diff --git a/.circleci/config.yml b/.circleci/config.yml
index dc357101e79fd..6133037bf3b7d 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -4,15 +4,16 @@ jobs:
   test-arm:
     machine:
       image: ubuntu-2004:202101-01
-    resource_class: arm.medium
+    resource_class: arm.large
     environment:
       ENV_FILE: ci/deps/circle-38-arm64.yaml
       PYTEST_WORKERS: auto
-      PATTERN: "not slow and not network and not clipboard and not arm_slow"
+      PATTERN: "not single_cpu and not slow and not network and not clipboard and not arm_slow and not db"
       PYTEST_TARGET: "pandas"
+      PANDAS_CI: "1"
     steps:
       - checkout
-      - run: ci/setup_env.sh
+      - run: .circleci/setup_env.sh
       - run: PATH=$HOME/miniconda3/envs/pandas-dev/bin:$HOME/miniconda3/condabin:$PATH ci/run_tests.sh
 
 workflows:
diff --git a/.circleci/setup_env.sh b/.circleci/setup_env.sh
new file mode 100755
index 0000000000000..c03a7ff4be8b3
--- /dev/null
+++ b/.circleci/setup_env.sh
@@ -0,0 +1,106 @@
+#!/bin/bash -e
+
+# edit the locale file if needed
+if [[ "$(uname)" == "Linux" && -n "$LC_ALL" ]]; then
+    echo "Adding locale to the first line of pandas/__init__.py"
+    rm -f pandas/__init__.pyc
+    SEDC="3iimport locale\nlocale.setlocale(locale.LC_ALL, '$LC_ALL')\n"
+    sed -i "$SEDC" pandas/__init__.py
+
+    echo "[head -4 pandas/__init__.py]"
+    head -4 pandas/__init__.py
+    echo
+fi
+
+
+MINICONDA_DIR=/usr/local/miniconda
+if [ -e $MINICONDA_DIR ] && [ "$BITS32" != yes ]; then
+    echo "Found Miniconda installation at $MINICONDA_DIR"
+else
+    echo "Install Miniconda"
+    DEFAULT_CONDA_URL="https://repo.continuum.io/miniconda/Miniconda3-latest"
+    if [[ "$(uname -m)" == 'aarch64' ]]; then
+        CONDA_URL="https://github.com/conda-forge/miniforge/releases/download/4.10.1-4/Miniforge3-4.10.1-4-Linux-aarch64.sh"
+    elif [[ "$(uname)" == 'Linux' ]]; then
+        if [[ "$BITS32" == "yes" ]]; then
+            CONDA_URL="$DEFAULT_CONDA_URL-Linux-x86.sh"
+        else
+            CONDA_URL="$DEFAULT_CONDA_URL-Linux-x86_64.sh"
+        fi
+    elif [[ "$(uname)" == 'Darwin' ]]; then
+        CONDA_URL="$DEFAULT_CONDA_URL-MacOSX-x86_64.sh"
+    else
+      echo "OS $(uname) not supported"
+      exit 1
+    fi
+    echo "Downloading $CONDA_URL"
+    wget -q $CONDA_URL -O miniconda.sh
+    chmod +x miniconda.sh
+
+    MINICONDA_DIR="$HOME/miniconda3"
+    rm -rf $MINICONDA_DIR
+    ./miniconda.sh -b -p $MINICONDA_DIR
+fi
+export PATH=$MINICONDA_DIR/bin:$PATH
+
+echo
+echo "which conda"
+which conda
+
+echo
+echo "update conda"
+conda config --set ssl_verify false
+conda config --set quiet true --set always_yes true --set changeps1 false
+conda install -y -c conda-forge -n base 'mamba>=0.21.2' pip setuptools
+
+echo "conda info -a"
+conda info -a
+
+echo "conda list (root environment)"
+conda list
+
+echo
+# Clean up any left-over from a previous build
+mamba env remove -n pandas-dev
+echo "mamba env update --file=${ENV_FILE}"
+# See https://github.com/mamba-org/mamba/issues/633
+mamba create -q -n pandas-dev
+time mamba env update -n pandas-dev --file="${ENV_FILE}"
+
+echo "conda list -n pandas-dev"
+conda list -n pandas-dev
+
+if [[ "$BITS32" == "yes" ]]; then
+    # activate 32-bit compiler
+    export CONDA_BUILD=1
+fi
+
+echo "activate pandas-dev"
+source activate pandas-dev
+
+# Explicitly set an environment variable indicating that this is pandas' CI environment.
+#
+# This allows us to enable things like -Werror that shouldn't be activated in
+# downstream CI jobs that may also build pandas from source.
+export PANDAS_CI=1
+
+if pip list | grep -q ^pandas; then
+    echo
+    echo "remove any installed pandas package w/o removing anything else"
+    pip uninstall -y pandas || true
+fi
+
+if [ "$(conda list -f qt --json)" != [] ]; then
+    echo
+    echo "remove qt"
+    echo "causes problems with the clipboard, we use xsel for that"
+    conda remove qt -y --force || true
+fi
+
+echo "Build extensions"
+python setup.py build_ext -q -j3
+
+echo "Install pandas"
+python -m pip install --no-build-isolation --no-use-pep517 -e .
+
+echo "done"
diff --git a/.devcontainer.json b/.devcontainer.json
index 8bea96aea29c1..7c5d009260c64 100644
--- a/.devcontainer.json
+++ b/.devcontainer.json
@@ -9,8 +9,7 @@
 	// You can edit these settings after create using File > Preferences > Settings > Remote.
 	"settings": {
 		"terminal.integrated.shell.linux": "/bin/bash",
-		"python.condaPath": "/opt/conda/bin/conda",
-		"python.pythonPath": "/opt/conda/bin/python",
+		"python.pythonPath": "/usr/local/bin/python",
 		"python.formatting.provider": "black",
 		"python.linting.enabled": true,
 		"python.linting.flake8Enabled": true,
diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md
deleted file mode 100644
index 87a5b7905fc6d..0000000000000
--- a/.github/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, we pledge to respect all people who
-contribute through reporting issues, posting feature requests, updating
-documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free
-experience for everyone, regardless of level of experience, gender, gender
-identity and expression, sexual orientation, disability, personal appearance,
-body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic
-  addresses, without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to
-fairly and consistently applying these principles to every aspect of managing
-this project. Project maintainers who do not follow or enforce the Code of
-Conduct may be permanently removed from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-A working group of community members is committed to promptly addressing any
-reported issues. The working group is made up of pandas contributors and users.
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the working group by e-mail (pandas-coc@googlegroups.com).
-Messages sent to this e-mail address will not be publicly visible but only to
-the working group members. The working group currently includes
-
-- Safia Abdalla
-- Tom Augspurger
-- Joris Van den Bossche
-- Camille Scott
-- Nathaniel Smith
-
-All complaints will be reviewed and investigated and will result in a response
-that is deemed necessary and appropriate to the circumstances. Maintainers are
-obligated to maintain confidentiality with regard to the reporter of an
-incident.
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 1.3.0, available at
-[https://www.contributor-covenant.org/version/1/3/0/][version],
-and the [Swift Code of Conduct][swift].
-
-[homepage]: https://www.contributor-covenant.org
-[version]: https://www.contributor-covenant.org/version/1/3/0/
-[swift]: https://swift.org/community/#code-of-conduct
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
deleted file mode 100644
index d27eab5b9c95c..0000000000000
--- a/.github/CONTRIBUTING.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Contributing to pandas
-
-A detailed overview on how to contribute can be found in the **[contributing guide](https://pandas.pydata.org/docs/dev/development/contributing.html)**.
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index 27dfded808b95..0000000000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-custom: https://pandas.pydata.org/donate.html
-github: [numfocus]
-tidelift: pypi/pandas
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
index 805413d79aae2..36bc8dcf02bae 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -17,7 +17,7 @@ body:
             [latest version](https://pandas.pydata.org/docs/whatsnew/index.html) of pandas.
           required: true
         - label: >
-            I have confirmed this bug exists on the master branch of pandas.
+            I have confirmed this bug exists on the main branch of pandas.
   - type: textarea
     id: example
     attributes:
diff --git a/.github/ISSUE_TEMPLATE/documentation_improvement.yaml b/.github/ISSUE_TEMPLATE/documentation_improvement.yaml
index 8486d6e3eebdc..b89600f8598e7 100644
--- a/.github/ISSUE_TEMPLATE/documentation_improvement.yaml
+++ b/.github/ISSUE_TEMPLATE/documentation_improvement.yaml
@@ -10,7 +10,7 @@ body:
       options:
         - label: >
             I have checked that the issue still exists on the latest versions of the docs
-            on `master` [here](https://pandas.pydata.org/docs/dev/)
+            on `main` [here](https://pandas.pydata.org/docs/dev/)
           required: true
   - type: textarea
     id: location
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
deleted file mode 100644
index 0c30b941bc520..0000000000000
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-
-name: Feature Request
-about: Suggest an idea for pandas
-title: "ENH:"
-labels: "Enhancement, Needs Triage"
-
----
-
-#### Is your feature request related to a problem?
-
-[this should provide a description of what the problem is, e.g. "I wish I could use pandas to do [...]"]
-
-#### Describe the solution you'd like
-
-[this should provide a description of the feature request, e.g. "`DataFrame.foo` should get a new parameter `bar` that [...]", try to write a docstring for the desired feature]
-
-#### API breaking implications
-
-[this should provide a description of how this feature will affect the API]
-
-#### Describe alternatives you've considered
-
-[this should provide a description of any alternative solutions or features you've considered]
-
-#### Additional context
-
-[add any other context, code examples, or references to existing implementations about the feature request here]
-
-```python
-# Your code here, if applicable
-
-```
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
new file mode 100644
index 0000000000000..f837eb1ca5bb7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
@@ -0,0 +1,72 @@
+name: Feature Request
+description: Suggest an idea for pandas
+title: "ENH: "
+labels: [Enhancement, Needs Triage]
+
+body:
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Feature Type
+      description: Please check what type of feature request you would like to propose.
+      options:
+        - label: >
+            Adding new functionality to pandas
+        - label: >
+            Changing existing functionality in pandas
+        - label: >
+            Removing existing functionality in pandas
+  - type: textarea
+    id: description
+    attributes:
+      label: Problem Description
+      description: >
+        Please describe what problem the feature would solve, e.g. "I wish I could use pandas to ..."
+      placeholder: >
+        I wish I could use pandas to return a Series from a DataFrame when possible.
+    validations:
+      required: true
+  - type: textarea
+    id: feature
+    attributes:
+      label: Feature Description
+      description: >
+        Please describe how the new feature would be implemented, using psudocode if relevant.
+      placeholder: >
+        Add a new parameter to DataFrame, to_series, to return a Series if possible.
+
+        def __init__(self, ..., to_series: bool=False):
+            """
+            Parameters
+            ----------
+            ...
+
+            to_series : bool, default False
+                Return a Series if possible
+            """
+            if to_series:
+                return Series(data)
+    validations:
+      required: true
+  - type: textarea
+    id: alternative
+    attributes:
+      label: Alternative Solutions
+      description: >
+        Please describe any alternative solution (existing functionality, 3rd party package, etc.)
+        that would satisfy the feature request.
+      placeholder: >
+        Write a custom function to return a Series when possible.
+
+        def to_series(...)
+           result = pd.DataFrame(...)
+           ...
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional Context
+      description: >
+        Please provide any relevant Github issues, code examples or references that help describe and support
+        the feature request.
diff --git a/.github/ISSUE_TEMPLATE/performance_issue.yaml b/.github/ISSUE_TEMPLATE/performance_issue.yaml
index 9cde5b6dca385..096e012f4ee0f 100644
--- a/.github/ISSUE_TEMPLATE/performance_issue.yaml
+++ b/.github/ISSUE_TEMPLATE/performance_issue.yaml
@@ -17,7 +17,7 @@ body:
             [latest version](https://pandas.pydata.org/docs/whatsnew/index.html) of pandas.
           required: true
         - label: >
-            I have confirmed this issue exists on the master branch of pandas.
+            I have confirmed this issue exists on the main branch of pandas.
   - type: textarea
     id: example
     attributes:
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 42017db8a05b1..876e5e2cfbb1e 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,4 +1,5 @@
-- [ ] closes #xxxx
-- [ ] tests added / passed
-- [ ] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
-- [ ] whatsnew entry
+- [ ] closes #xxxx (Replace xxxx with the Github issue number)
+- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
+- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
+- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
+- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
diff --git a/.github/SECURITY.md b/.github/SECURITY.md
deleted file mode 100644
index f3b059a5d4f13..0000000000000
--- a/.github/SECURITY.md
+++ /dev/null
@@ -1 +0,0 @@
-To report a security vulnerability to pandas, please go to https://tidelift.com/security and see the instructions there.
diff --git a/.github/actions/build_pandas/action.yml b/.github/actions/build_pandas/action.yml
index 2e4bfea165316..23bb988ef4d73 100644
--- a/.github/actions/build_pandas/action.yml
+++ b/.github/actions/build_pandas/action.yml
@@ -6,12 +6,17 @@ runs:
 
     - name: Environment Detail
       run: |
-        conda info
-        conda list
-      shell: bash -l {0}
+        micromamba info
+        micromamba list
+      shell: bash -el {0}
 
     - name: Build Pandas
       run: |
-        python setup.py build_ext -j 2
+        python setup.py build_ext -j $N_JOBS
         python -m pip install -e . --no-build-isolation --no-use-pep517 --no-index
-      shell: bash -l {0}
+      shell: bash -el {0}
+      env:
+        # Cannot use parallel compilation on Windows, see https://github.com/pandas-dev/pandas/issues/30873
+        # GH 47305: Parallel build causes flaky ImportError: /home/runner/work/pandas/pandas/pandas/_libs/tslibs/timestamps.cpython-38-x86_64-linux-gnu.so: undefined symbol: pandas_datetime_to_datetimestruct
+        N_JOBS: 1
+        #N_JOBS: ${{ runner.os == 'Windows' && 1 || 2 }}
diff --git a/.github/actions/run-tests/action.yml b/.github/actions/run-tests/action.yml
new file mode 100644
index 0000000000000..2a7601f196ec4
--- /dev/null
+++ b/.github/actions/run-tests/action.yml
@@ -0,0 +1,27 @@
+name: Run tests and report results
+runs:
+  using: composite
+  steps:
+    - name: Test
+      run: ci/run_tests.sh
+      shell: bash -el {0}
+
+    - name: Publish test results
+      uses: actions/upload-artifact@v2
+      with:
+        name: Test results
+        path: test-data.xml
+      if: failure()
+
+    - name: Report Coverage
+      run: coverage report -m
+      shell: bash -el {0}
+      if: failure()
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v2
+      with:
+        flags: unittests
+        name: codecov-pandas
+        fail_ci_if_error: false
+      if: failure()
diff --git a/.github/actions/setup-conda/action.yml b/.github/actions/setup-conda/action.yml
new file mode 100644
index 0000000000000..7d1e54052f938
--- /dev/null
+++ b/.github/actions/setup-conda/action.yml
@@ -0,0 +1,36 @@
+name: Set up Conda environment
+inputs:
+  environment-file:
+    description: Conda environment file to use.
+    default: environment.yml
+  environment-name:
+    description: Name to use for the Conda environment
+    default: test
+  extra-specs:
+    description: Extra packages to install
+    required: false
+  pyarrow-version:
+    description: If set, overrides the PyArrow version in the Conda environment to the given string.
+    required: false
+runs:
+  using: composite
+  steps:
+    - name: Set Arrow version in ${{ inputs.environment-file }} to ${{ inputs.pyarrow-version }}
+      run: |
+        grep -q '  - pyarrow' ${{ inputs.environment-file }}
+        sed -i"" -e "s/  - pyarrow<10/  - pyarrow=${{ inputs.pyarrow-version }}/" ${{ inputs.environment-file }}
+        cat ${{ inputs.environment-file }}
+      shell: bash
+      if: ${{ inputs.pyarrow-version }}
+
+    - name: Install ${{ inputs.environment-file }}
+      uses: mamba-org/provision-with-micromamba@v12
+      with:
+        environment-file: ${{ inputs.environment-file }}
+        environment-name: ${{ inputs.environment-name }}
+        extra-specs: ${{ inputs.extra-specs }}
+        channels: conda-forge
+        channel-priority: ${{ runner.os == 'macOS' && 'flexible' || 'strict' }}
+        condarc-file: ci/condarc.yml
+        cache-env: true
+        cache-downloads: true
diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml
deleted file mode 100644
index 9ef00e7a85a6f..0000000000000
--- a/.github/actions/setup/action.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-name: Set up pandas
-description: Runs all the setup steps required to have a built pandas ready to use
-runs:
-  using: composite
-  steps:
-    - name: Setting conda path
-      run: echo "${HOME}/miniconda3/bin" >> $GITHUB_PATH
-      shell: bash -l {0}
-
-    - name: Setup environment and build pandas
-      run: ci/setup_env.sh
-      shell: bash -l {0}
diff --git a/.github/workflows/32-bit-linux.yml b/.github/workflows/32-bit-linux.yml
new file mode 100644
index 0000000000000..49df3a077cfe7
--- /dev/null
+++ b/.github/workflows/32-bit-linux.yml
@@ -0,0 +1,53 @@
+name: 32 Bit Linux
+
+on:
+  push:
+    branches:
+      - main
+      - 1.5.x
+  pull_request:
+    branches:
+      - main
+      - 1.5.x
+    paths-ignore:
+      - "doc/**"
+
+permissions:
+  contents: read
+
+jobs:
+  pytest:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Run 32-bit manylinux2014 Docker Build / Tests
+        run: |
+          # Without this (line 34), versioneer will not be able to determine the pandas version.
+          # This is because of a security update to git that blocks it from reading the config folder if
+          # it is not owned by the current user. We hit this since the "mounted" folder is not hit by the
+          # Docker container.
+          # xref https://github.com/pypa/manylinux/issues/1309
+          docker pull quay.io/pypa/manylinux2014_i686
+          docker run --platform linux/386 -v $(pwd):/pandas quay.io/pypa/manylinux2014_i686 \
+          /bin/bash -xc "cd pandas && \
+          git config --global --add safe.directory /pandas && \
+          /opt/python/cp38-cp38/bin/python -m venv ~/virtualenvs/pandas-dev && \
+          . ~/virtualenvs/pandas-dev/bin/activate && \
+          python -m pip install --no-deps -U pip wheel 'setuptools<60.0.0' && \
+          pip install cython numpy python-dateutil pytz pytest pytest-xdist pytest-asyncio>=0.17 hypothesis && \
+          python setup.py build_ext -q -j1 && \
+          python -m pip install --no-build-isolation --no-use-pep517 -e . && \
+          python -m pip list && \
+          export PANDAS_CI=1 && \
+          pytest -m 'not slow and not network and not clipboard and not single_cpu' pandas --junitxml=test-data.xml"
+
+      - name: Publish test results for Python 3.8-32 bit full Linux
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test results
+          path: test-data.xml
+        if: failure()
diff --git a/.github/workflows/assign.yml b/.github/workflows/assign.yml
index a6d3f1f383751..b3331060823a9 100644
--- a/.github/workflows/assign.yml
+++ b/.github/workflows/assign.yml
@@ -3,12 +3,17 @@ on:
   issue_comment:
     types: created
 
+permissions:
+  contents: read
+
 jobs:
-  one:
-    runs-on: ubuntu-latest
+  issue_assign:
+    permissions:
+      issues: write
+      pull-requests: write
+    runs-on: ubuntu-22.04
     steps:
     - if: github.event.comment.body == 'take'
-      name:
       run: |
         echo "Assigning issue ${{ github.event.issue.number }} to ${{ github.event.comment.user.login }}"
         curl -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" -d '{"assignees": ["${{ github.event.comment.user.login }}"]}' https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees
diff --git a/.github/workflows/asv-bot.yml b/.github/workflows/asv-bot.yml
index c2a49dd96c1c1..d264698e60485 100644
--- a/.github/workflows/asv-bot.yml
+++ b/.github/workflows/asv-bot.yml
@@ -9,15 +9,22 @@ env:
   ENV_FILE: environment.yml
   COMMENT: ${{github.event.comment.body}}
 
+permissions:
+  contents: read
+
 jobs:
   autotune:
+    permissions:
+      contents: read
+      issues: write
+      pull-requests: write
     name: "Run benchmarks"
     # TODO: Support more benchmarking options later, against different branches, against self, etc
     if: startsWith(github.event.comment.body, '@github-actions benchmark')
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     defaults:
       run:
-        shell: bash -l {0}
+        shell: bash -el {0}
 
     concurrency:
       # Set concurrency to prevent abuse(full runs are ~5.5 hours !!!)
@@ -29,24 +36,14 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - name: Cache conda
-        uses: actions/cache@v2
-        with:
-          path: ~/conda_pkgs_dir
-          key: ${{ runner.os }}-conda-${{ hashFiles('${{ env.ENV_FILE }}') }}
-
         # Although asv sets up its own env, deps are still needed
         # during discovery process
-      - uses: conda-incubator/setup-miniconda@v2
-        with:
-          activate-environment: pandas-dev
-          channel-priority: strict
-          environment-file: ${{ env.ENV_FILE }}
-          use-only-tar-bz2: true
+      - name: Set up Conda
+        uses: ./.github/actions/setup-conda
 
       - name: Run benchmarks
         id: bench
@@ -59,13 +56,13 @@ jobs:
           git remote add upstream https://github.com/pandas-dev/pandas.git
           git fetch upstream
           asv machine --yes
-          asv continuous -f 1.1 -b $REGEX upstream/master HEAD
+          asv continuous -f 1.1 -b $REGEX upstream/main HEAD
           echo 'BENCH_OUTPUT<<EOF' >> $GITHUB_ENV
-          asv compare -f 1.1 upstream/master HEAD >> $GITHUB_ENV
+          asv compare -f 1.1 upstream/main HEAD >> $GITHUB_ENV
           echo 'EOF' >> $GITHUB_ENV
           echo "REGEX=$REGEX" >> $GITHUB_ENV
 
-      - uses: actions/github-script@v4
+      - uses: actions/github-script@v6
         env:
           BENCH_OUTPUT: ${{env.BENCH_OUTPUT}}
           REGEX: ${{env.REGEX}}
@@ -73,7 +70,7 @@ jobs:
           script: |
             const ENV_VARS = process.env
             const run_url = `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
-            github.issues.createComment({
+            github.rest.issues.createComment({
               issue_number: context.issue.number,
               owner: context.repo.owner,
               repo: context.repo.repo,
diff --git a/.github/workflows/autoupdate-pre-commit-config.yml b/.github/workflows/autoupdate-pre-commit-config.yml
index 3696cba8cf2e6..376aa8343c571 100644
--- a/.github/workflows/autoupdate-pre-commit-config.yml
+++ b/.github/workflows/autoupdate-pre-commit-config.yml
@@ -5,16 +5,22 @@ on:
     - cron: "0 7 1 * *" # At 07:00 on 1st of every month.
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   update-pre-commit:
+    permissions:
+      contents: write  # for technote-space/create-pr-action to push code
+      pull-requests: write  # for technote-space/create-pr-action to create a PR
     if: github.repository_owner == 'pandas-dev'
     name: Autoupdate pre-commit config
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Set up Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
       - name: Cache multiple paths
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/pre-commit
diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index 634688d65e117..cb95b224ba677 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -3,43 +3,46 @@ name: Code Checks
 on:
   push:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
   pull_request:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
 
 env:
   ENV_FILE: environment.yml
   PANDAS_CI: 1
 
+permissions:
+  contents: read
+
 jobs:
   pre_commit:
     name: pre-commit
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     concurrency:
       # https://github.community/t/concurrecy-not-work-for-push/183068/7
       group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-pre-commit
       cancel-in-progress: true
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Install Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
-        python-version: '3.9.7'
+        python-version: '3.9'
 
     - name: Run pre-commit
       uses: pre-commit/action@v2.0.3
 
   typing_and_docstring_validation:
     name: Docstring and typing validation
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     defaults:
       run:
-        shell: bash -l {0}
+        shell: bash -el {0}
 
     concurrency:
       # https://github.community/t/concurrecy-not-work-for-push/183068/7
@@ -48,64 +51,57 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
-    - name: Cache conda
-      uses: actions/cache@v2
-      with:
-        path: ~/conda_pkgs_dir
-        key: ${{ runner.os }}-conda-${{ hashFiles('${{ env.ENV_FILE }}') }}
-
-    - uses: conda-incubator/setup-miniconda@v2
-      with:
-        mamba-version: "*"
-        channels: conda-forge
-        activate-environment: pandas-dev
-        channel-priority: strict
-        environment-file: ${{ env.ENV_FILE }}
-        use-only-tar-bz2: true
-
-    - name: Install node.js (for pyright)
-      uses: actions/setup-node@v2
-      with:
-        node-version: "16"
-
-    - name: Install pyright
-      # note: keep version in sync with .pre-commit-config.yaml
-      run: npm install -g pyright@1.1.202
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
 
     - name: Build Pandas
       id: build
       uses: ./.github/actions/build_pandas
 
+    # The following checks are independent of each other and should still be run if one fails
+    - name: Check for no warnings when building single-page docs
+      run: ci/code_checks.sh single-docs
+      if: ${{ steps.build.outcome == 'success' && always() }}
+
     - name: Run checks on imported code
       run: ci/code_checks.sh code
-      if: ${{ steps.build.outcome == 'success' }}
+      if: ${{ steps.build.outcome == 'success' && always() }}
 
     - name: Run doctests
       run: ci/code_checks.sh doctests
-      if: ${{ steps.build.outcome == 'success' }}
+      if: ${{ steps.build.outcome == 'success' && always() }}
 
     - name: Run docstring validation
       run: ci/code_checks.sh docstrings
-      if: ${{ steps.build.outcome == 'success' }}
+      if: ${{ steps.build.outcome == 'success' && always() }}
 
-    - name: Run typing validation
-      run: ci/code_checks.sh typing
-      if: ${{ steps.build.outcome == 'success' }}
+    - name: Use existing environment for type checking
+      run: |
+        echo $PATH >> $GITHUB_PATH
+        echo "PYTHONHOME=$PYTHONHOME" >> $GITHUB_ENV
+        echo "PYTHONPATH=$PYTHONPATH" >> $GITHUB_ENV
+      if: ${{ steps.build.outcome == 'success' && always() }}
+
+    - name: Typing
+      uses: pre-commit/action@v2.0.3
+      with:
+        extra_args: --hook-stage manual --all-files
+      if: ${{ steps.build.outcome == 'success' && always() }}
 
     - name: Run docstring validation script tests
       run: pytest scripts
-      if: ${{ steps.build.outcome == 'success' }}
+      if: ${{ steps.build.outcome == 'success' && always() }}
 
   asv-benchmarks:
     name: ASV Benchmarks
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     defaults:
       run:
-        shell: bash -l {0}
+        shell: bash -el {0}
 
     concurrency:
       # https://github.community/t/concurrecy-not-work-for-push/183068/7
@@ -114,24 +110,12 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
-    - name: Cache conda
-      uses: actions/cache@v2
-      with:
-        path: ~/conda_pkgs_dir
-        key: ${{ runner.os }}-conda-${{ hashFiles('${{ env.ENV_FILE }}') }}
-
-    - uses: conda-incubator/setup-miniconda@v2
-      with:
-        mamba-version: "*"
-        channels: conda-forge
-        activate-environment: pandas-dev
-        channel-priority: strict
-        environment-file: ${{ env.ENV_FILE }}
-        use-only-tar-bz2: true
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
 
     - name: Build Pandas
       id: build
@@ -140,19 +124,61 @@ jobs:
     - name: Run ASV benchmarks
       run: |
         cd asv_bench
-        asv check -E existing
-        git remote add upstream https://github.com/pandas-dev/pandas.git
-        git fetch upstream
         asv machine --yes
-        asv dev | sed "/failed$/ s/^/##[error]/" | tee benchmarks.log
-        if grep "failed" benchmarks.log > /dev/null ; then
-            exit 1
-        fi
-      if: ${{ steps.build.outcome == 'success' }}
-
-    - name: Publish benchmarks artifact
-      uses: actions/upload-artifact@master
-      with:
-        name: Benchmarks log
-        path: asv_bench/benchmarks.log
-      if: failure()
+        asv run --quick --dry-run --strict --durations=30 --python=same
+
+  build_docker_dev_environment:
+    name: Build Docker Dev Environment
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        shell: bash -el {0}
+
+    concurrency:
+      # https://github.community/t/concurrecy-not-work-for-push/183068/7
+      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-build_docker_dev_environment
+      cancel-in-progress: true
+
+    steps:
+      - name: Clean up dangling images
+        run: docker image prune -f
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Build image
+        run: docker build --pull --no-cache --tag pandas-dev-env .
+
+      - name: Show environment
+        run: docker run --rm pandas-dev-env python -c "import pandas as pd; print(pd.show_versions())"
+
+  requirements-dev-text-installable:
+    name: Test install requirements-dev.txt
+    runs-on: ubuntu-22.04
+
+    concurrency:
+      # https://github.community/t/concurrecy-not-work-for-push/183068/7
+      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-requirements-dev-text-installable
+      cancel-in-progress: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        id: setup_python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+          cache: 'pip'
+          cache-dependency-path: 'requirements-dev.txt'
+
+      - name: Install requirements-dev.txt
+        run: pip install -r requirements-dev.txt
+
+      - name: Check Pip Cache Hit
+        run: echo ${{ steps.setup_python.outputs.cache-hit }}
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 0000000000000..05a5d003c1dd1
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,31 @@
+name: CodeQL
+on:
+  schedule:
+    # every day at midnight
+    - cron: "0 0 * * *"
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    runs-on: ubuntu-22.04
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language:
+          - python
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+      - uses: github/codeql-action/autobuild@v2
+      - uses: github/codeql-action/analyze@v2
diff --git a/.github/workflows/comment_bot.yml b/.github/workflows/comment_bot.yml
deleted file mode 100644
index dc396be753269..0000000000000
--- a/.github/workflows/comment_bot.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-name: Comment-bot
-
-on:
-  issue_comment:
-    types:
-      - created
-      - edited
-
-jobs:
-  autotune:
-    name: "Fixup pre-commit formatting"
-    if: startsWith(github.event.comment.body, '@github-actions pre-commit')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: r-lib/actions/pr-fetch@master
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Cache multiple paths
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cache/pre-commit
-            ~/.cache/pip
-          key: pre-commit-dispatched-${{ runner.os }}-build
-      - uses: actions/setup-python@v2
-        with:
-          python-version: 3.8
-      - name: Install-pre-commit
-        run: python -m pip install --upgrade pre-commit
-      - name: Run pre-commit
-        run: pre-commit run --from-ref=origin/master --to-ref=HEAD --all-files || (exit 0)
-      - name: Commit results
-        run: |
-          git config user.name "$(git log -1 --pretty=format:%an)"
-          git config user.email "$(git log -1 --pretty=format:%ae)"
-          git commit -a -m 'Fixes from pre-commit [automated commit]' || echo "No changes to commit"
-      - uses: r-lib/actions/pr-push@master
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/datamanger.yml b/.github/workflows/datamanger.yml
deleted file mode 100644
index d6c96926d0d92..0000000000000
--- a/.github/workflows/datamanger.yml
+++ /dev/null
@@ -1,57 +0,0 @@
-name: Data Manager
-
-on:
-  push:
-    branches:
-      - master
-      - 1.3.x
-  pull_request:
-    branches:
-      - master
-      - 1.3.x
-
-env:
-  ENV_FILE: environment.yml
-  PANDAS_CI: 1
-
-jobs:
-  data_manager:
-    name: Test experimental data manager
-    runs-on: ubuntu-latest
-    services:
-      moto:
-        image: motoserver/moto
-        env:
-          AWS_ACCESS_KEY_ID: foobar_key
-          AWS_SECRET_ACCESS_KEY: foobar_secret
-        ports:
-          - 5000:5000
-    strategy:
-      matrix:
-        pattern: ["not slow and not network and not clipboard", "slow"]
-    concurrency:
-      # https://github.community/t/concurrecy-not-work-for-push/183068/7
-      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-data_manager-${{ matrix.pattern }}
-      cancel-in-progress: true
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-
-    - name: Set up pandas
-      uses: ./.github/actions/setup
-
-    - name: Run tests
-      env:
-        PANDAS_DATA_MANAGER: array
-        PATTERN: ${{ matrix.pattern }}
-        PYTEST_WORKERS: "auto"
-        PYTEST_TARGET: pandas
-      run: |
-        source activate pandas-dev
-        ci/run_tests.sh
-
-    - name: Print skipped tests
-      run: python ci/print_skipped.py
diff --git a/.github/workflows/docbuild-and-upload.yml b/.github/workflows/docbuild-and-upload.yml
index 7f830b59251d1..13da56806de6e 100644
--- a/.github/workflows/docbuild-and-upload.yml
+++ b/.github/workflows/docbuild-and-upload.yml
@@ -3,74 +3,90 @@ name: Doc Build and Upload
 on:
   push:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
+    tags:
+      - '*'
   pull_request:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
 
 env:
   ENV_FILE: environment.yml
   PANDAS_CI: 1
 
+permissions:
+  contents: read
+
 jobs:
   web_and_docs:
     name: Doc Build and Upload
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     concurrency:
       # https://github.community/t/concurrecy-not-work-for-push/183068/7
       group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-web-docs
       cancel-in-progress: true
 
+    defaults:
+      run:
+        shell: bash -el {0}
+
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
-    - name: Set up pandas
-      uses: ./.github/actions/setup
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
+
+    - name: Build Pandas
+      uses: ./.github/actions/build_pandas
 
     - name: Build website
-      run: |
-        source activate pandas-dev
-        python web/pandas_web.py web/pandas --target-path=web/build
+      run: python web/pandas_web.py web/pandas --target-path=web/build
+
     - name: Build documentation
-      run: |
-        source activate pandas-dev
-        doc/make.py --warnings-are-errors | tee sphinx.log ; exit ${PIPESTATUS[0]}
+      run: doc/make.py --warnings-are-errors
+
+    - name: Build documentation zip
+      run: doc/make.py zip_html
 
-    # This can be removed when the ipython directive fails when there are errors,
-    # including the `tee sphinx.log` in te previous step (https://github.com/ipython/ipython/issues/11547)
-    - name: Check ipython directive errors
-      run: "! grep -B10 \"^<<<-------------------------------------------------------------------------$\" sphinx.log"
+    - name: Build the interactive terminal
+      run: |
+        cd web/interactive_terminal
+        jupyter lite build
 
     - name: Install ssh key
       run: |
         mkdir -m 700 -p ~/.ssh
         echo "${{ secrets.server_ssh_key }}" > ~/.ssh/id_rsa
         chmod 600 ~/.ssh/id_rsa
-        echo "${{ secrets.server_ip }} ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBE1Kkopomm7FHG5enATf7SgnpICZ4W2bw+Ho+afqin+w7sMcrsa0je7sbztFAV8YchDkiBKnWTG4cRT+KZgZCaY=" > ~/.ssh/known_hosts
-      if: ${{github.event_name == 'push' && github.ref == 'refs/heads/master'}}
+        echo "${{ secrets.server_ip }} ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBFjYkJBk7sos+r7yATODogQc3jUdW1aascGpyOD4bohj8dWjzwLJv/OJ/fyOQ5lmj81WKDk67tGtqNJYGL9acII=" > ~/.ssh/known_hosts
+      if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))
 
     - name: Copy cheatsheets into site directory
       run: cp doc/cheatsheet/Pandas_Cheat_Sheet* web/build/
 
     - name: Upload web
-      run: rsync -az --delete --exclude='pandas-docs' --exclude='docs' web/build/ docs@${{ secrets.server_ip }}:/usr/share/nginx/pandas
-      if: ${{github.event_name == 'push' && github.ref == 'refs/heads/master'}}
+      run: rsync -az --delete --exclude='pandas-docs' --exclude='docs' web/build/ web@${{ secrets.server_ip }}:/var/www/html
+      if: github.event_name == 'push' && github.ref == 'refs/heads/main'
 
     - name: Upload dev docs
-      run: rsync -az --delete doc/build/html/ docs@${{ secrets.server_ip }}:/usr/share/nginx/pandas/pandas-docs/dev
-      if: ${{github.event_name == 'push' && github.ref == 'refs/heads/master'}}
+      run: rsync -az --delete doc/build/html/ web@${{ secrets.server_ip }}:/var/www/html/pandas-docs/dev
+      if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+
+    - name: Upload prod docs
+      run: rsync -az --delete doc/build/html/ web@${{ secrets.server_ip }}:/var/www/html/pandas-docs/version/${GITHUB_REF_NAME:1}
+      if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
 
     - name: Move docs into site directory
       run: mv doc/build/html web/build/docs
 
     - name: Save website as an artifact
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
       with:
         name: website
         path: web/build
diff --git a/.github/workflows/macos-windows.yml b/.github/workflows/macos-windows.yml
new file mode 100644
index 0000000000000..5da2d0d281edd
--- /dev/null
+++ b/.github/workflows/macos-windows.yml
@@ -0,0 +1,61 @@
+name: Windows-MacOS
+
+on:
+  push:
+    branches:
+      - main
+      - 1.5.x
+  pull_request:
+    branches:
+      - main
+      - 1.5.x
+    paths-ignore:
+      - "doc/**"
+
+env:
+  PANDAS_CI: 1
+  PYTEST_TARGET: pandas
+  PATTERN: "not slow and not db and not network and not single_cpu"
+
+
+permissions:
+  contents: read
+
+jobs:
+  pytest:
+    defaults:
+      run:
+        shell: bash -el {0}
+    timeout-minutes: 180
+    strategy:
+      matrix:
+        os: [macos-latest, windows-latest]
+        env_file: [actions-38.yaml, actions-39.yaml, actions-310.yaml]
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    name: ${{ format('{0} {1}', matrix.os, matrix.env_file) }}
+    concurrency:
+      # https://github.community/t/concurrecy-not-work-for-push/183068/7
+      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-${{ matrix.env_file }}-${{ matrix.os }}
+      cancel-in-progress: true
+    env:
+      # GH 47443: PYTEST_WORKERS > 1 crashes Windows builds with memory related errors
+      PYTEST_WORKERS: ${{ matrix.os == 'macos-latest' && 'auto' || '1' }}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
+      with:
+        environment-file: ci/deps/${{ matrix.env_file }}
+        pyarrow-version: ${{ matrix.os == 'macos-latest' && '6' || '' }}
+
+    - name: Build Pandas
+      uses: ./.github/actions/build_pandas
+
+    - name: Test
+      uses: ./.github/actions/run-tests
diff --git a/.github/workflows/posix.yml b/.github/workflows/posix.yml
deleted file mode 100644
index bc3ee2e500d22..0000000000000
--- a/.github/workflows/posix.yml
+++ /dev/null
@@ -1,163 +0,0 @@
-name: Posix
-
-on:
-  push:
-    branches:
-      - master
-      - 1.3.x
-  pull_request:
-    branches:
-      - master
-      - 1.3.x
-    paths-ignore:
-      - "doc/**"
-
-env:
-  PYTEST_WORKERS: "auto"
-  PANDAS_CI: 1
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -l {0}
-    strategy:
-      matrix:
-        settings: [
-          [actions-38-downstream_compat.yaml, "not slow and not network and not clipboard", "", "", "", "", ""],
-          [actions-38-minimum_versions.yaml, "slow", "", "", "", "", ""],
-          [actions-38-minimum_versions.yaml, "not slow and not network and not clipboard", "", "", "", "", ""],
-          [actions-38-locale_slow.yaml, "slow", "language-pack-it xsel", "it_IT.utf8", "it_IT.utf8", "", ""],
-          [actions-38.yaml, "not slow and not clipboard", "", "", "", "", ""],
-          [actions-38-slow.yaml, "slow", "", "", "", "", ""],
-          [actions-38-locale.yaml, "not slow and not network", "language-pack-zh-hans xsel", "zh_CN.utf8", "zh_CN.utf8", "", ""],
-          [actions-39-slow.yaml, "slow", "", "", "", "", ""],
-          [actions-pypy-38.yaml, "not slow and not clipboard", "", "", "", "", "--max-worker-restart 0"],
-          [actions-39-numpydev.yaml, "not slow and not network", "xsel", "", "", "deprecate", "-W error"],
-          [actions-39.yaml, "not slow and not clipboard", "", "", "", "", ""]
-        ]
-      fail-fast: false
-    env:
-      ENV_FILE: ci/deps/${{ matrix.settings[0] }}
-      PATTERN: ${{ matrix.settings[1] }}
-      EXTRA_APT: ${{ matrix.settings[2] }}
-      LANG: ${{ matrix.settings[3] }}
-      LC_ALL: ${{ matrix.settings[4] }}
-      PANDAS_TESTING_MODE: ${{ matrix.settings[5] }}
-      TEST_ARGS: ${{ matrix.settings[6] }}
-      PYTEST_TARGET:  pandas
-      IS_PYPY: ${{ contains(matrix.settings[0], 'pypy') }}
-      # TODO: re-enable coverage on pypy, its slow
-      COVERAGE: ${{ !contains(matrix.settings[0], 'pypy') }}
-    concurrency:
-      # https://github.community/t/concurrecy-not-work-for-push/183068/7
-      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-${{ matrix.settings[0] }}
-      cancel-in-progress: true
-
-    services:
-      mysql:
-        image: mysql
-        env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: yes
-          MYSQL_DATABASE: pandas
-        options: >-
-          --health-cmd "mysqladmin ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 3306:3306
-
-      postgres:
-        image: postgres
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: pandas
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 5432:5432
-
-      moto:
-        image: motoserver/moto
-        env:
-          AWS_ACCESS_KEY_ID: foobar_key
-          AWS_SECRET_ACCESS_KEY: foobar_secret
-        ports:
-          - 5000:5000
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-
-    - name: Cache conda
-      uses: actions/cache@v2
-      env:
-        CACHE_NUMBER: 0
-      with:
-        path: ~/conda_pkgs_dir
-        key: ${{ runner.os }}-conda-${{ env.CACHE_NUMBER }}-${{
-          hashFiles('${{ env.ENV_FILE }}') }}
-
-    - name: Extra installs
-      run: sudo apt-get update && sudo apt-get install -y libc6-dev-i386 ${{ env.EXTRA_APT }}
-
-    - uses: conda-incubator/setup-miniconda@v2
-      with:
-        mamba-version: "*"
-        channels: conda-forge
-        activate-environment: pandas-dev
-        channel-priority: flexible
-        environment-file: ${{ env.ENV_FILE }}
-        use-only-tar-bz2: true
-      if: ${{ env.IS_PYPY == 'false' }} # No pypy3.8 support
-
-    - name: Setup PyPy
-      uses: actions/setup-python@v2.3.1
-      with:
-        python-version: "pypy-3.8"
-      if: ${{ env.IS_PYPY == 'true' }}
-
-    - name: Setup PyPy dependencies
-      shell: bash
-      run: |
-        # TODO: re-enable cov, its slowing the tests down though
-        # TODO: Unpin Cython, the new Cython 0.29.26 is causing compilation errors
-        pip install Cython==0.29.25 numpy python-dateutil pytz pytest>=6.0 pytest-xdist>=1.31.0 hypothesis>=5.5.3
-      if: ${{ env.IS_PYPY == 'true' }}
-
-    - name: Build Pandas
-      uses: ./.github/actions/build_pandas
-
-    - name: Test
-      run: ci/run_tests.sh
-      # TODO: Don't continue on error for PyPy
-      continue-on-error: ${{ env.IS_PYPY == 'true' }}
-      if: always()
-
-    - name: Build Version
-      run: pushd /tmp && python -c "import pandas; pandas.show_versions();" && popd
-
-    - name: Publish test results
-      uses: actions/upload-artifact@master
-      with:
-        name: Test results
-        path: test-data.xml
-      if: failure()
-
-    - name: Print skipped tests
-      run: python ci/print_skipped.py
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v2
-      with:
-        flags: unittests
-        name: codecov-pandas
-        fail_ci_if_error: false
diff --git a/.github/workflows/python-dev.yml b/.github/workflows/python-dev.yml
index a7c7f3b739f65..0d265182b3924 100644
--- a/.github/workflows/python-dev.yml
+++ b/.github/workflows/python-dev.yml
@@ -1,34 +1,58 @@
+# This workflow may or may not run depending on the state of the next
+# unreleased Python version. DO NOT DELETE IT.
+#
+# In general, this file will remain frozen(present, but not running) until:
+#    - The next unreleased Python version has released beta 1
+#      - This version should be available on Github Actions.
+#    - Our required build/runtime dependencies(numpy, pytz, Cython, python-dateutil)
+#      support that unreleased Python version.
+#    To unfreeze, comment out the ``if: false`` condition, and make sure you update
+#    the name of the workflow and Python version in actions/setup-python to: '3.12-dev'
+#
+# After it has been unfrozen, this file should remain unfrozen(present, and running) until:
+#    - The next Python version has been officially released.
+#    OR
+#    - Most/All of our optional dependencies support Python 3.11 AND
+#    - The next Python version has released a rc(we are guaranteed a stable ABI).
+#    To freeze this file, uncomment out the ``if: false`` condition, and migrate the jobs
+#    to the corresponding posix/windows-macos/sdist etc. workflows.
+# Feel free to modify this comment as necessary.
+
 name: Python Dev
 
 on:
   push:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
   pull_request:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
     paths-ignore:
       - "doc/**"
 
 env:
   PYTEST_WORKERS: "auto"
   PANDAS_CI: 1
-  PATTERN: "not slow and not network and not clipboard"
+  PATTERN: "not slow and not network and not clipboard and not single_cpu"
   COVERAGE: true
   PYTEST_TARGET: pandas
 
+permissions:
+  contents: read
+
 jobs:
   build:
+    # if: false # Uncomment this to freeze the workflow, comment it to unfreeze
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macOS-latest, windows-latest]
+        os: [ubuntu-22.04, macOS-latest, windows-latest]
 
-    name: actions-310-dev
-    timeout-minutes: 80
+    name: actions-311-dev
+    timeout-minutes: 120
 
     concurrency:
       #https://github.community/t/concurrecy-not-work-for-push/183068/7
@@ -36,57 +60,33 @@ jobs:
       cancel-in-progress: true
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
     - name: Set up Python Dev Version
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
-        python-version: '3.10-dev'
+        python-version: '3.11-dev'
 
-    # TODO: GH#44980 https://github.com/pypa/setuptools/issues/2941
     - name: Install dependencies
-      shell: bash
       run: |
-        python -m pip install --upgrade pip "setuptools<60.0.0" wheel
-        pip install -i https://pypi.anaconda.org/scipy-wheels-nightly/simple numpy
-        pip install git+https://github.com/nedbat/coveragepy.git
-        pip install cython python-dateutil pytz hypothesis pytest>=6.2.5 pytest-xdist pytest-cov
-        pip list
+        python --version
+        python -m pip install --upgrade pip setuptools wheel
+        python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple numpy
+        python -m pip install git+https://github.com/nedbat/coveragepy.git
+        python -m pip install python-dateutil pytz cython hypothesis==6.52.1 pytest>=6.2.5 pytest-xdist pytest-cov pytest-asyncio>=0.17
+        python -m pip list
 
+    # GH 47305: Parallel build can cause flaky ImportError from pandas/_libs/tslibs
     - name: Build Pandas
       run: |
-        python setup.py build_ext -q -j2
-        python -m pip install -e . --no-build-isolation --no-use-pep517
+        python setup.py build_ext -q -j1
+        python -m pip install -e . --no-build-isolation --no-use-pep517 --no-index
 
     - name: Build Version
       run: |
         python -c "import pandas; pandas.show_versions();"
 
-    - name: Test with pytest
-      shell: bash
-      run: |
-        ci/run_tests.sh
-
-    - name: Publish test results
-      uses: actions/upload-artifact@master
-      with:
-        name: Test results
-        path: test-data.xml
-      if: failure()
-
-    - name: Print skipped tests
-      run: |
-        python ci/print_skipped.py
-
-    - name: Report Coverage
-      run: |
-        coverage report -m
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v2
-      with:
-        flags: unittests
-        name: codecov-pandas
-        fail_ci_if_error: true
+    - name: Test
+      uses: ./.github/actions/run-tests
diff --git a/.github/workflows/sdist.yml b/.github/workflows/sdist.yml
index 9ce3cc5d59208..46b453532ad0b 100644
--- a/.github/workflows/sdist.yml
+++ b/.github/workflows/sdist.yml
@@ -3,46 +3,50 @@ name: sdist
 on:
   push:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
   pull_request:
     branches:
-      - master
-      - 1.3.x
+      - main
+      - 1.5.x
+    types: [labeled, opened, synchronize, reopened]
     paths-ignore:
       - "doc/**"
 
+permissions:
+  contents: read
+
 jobs:
   build:
-    runs-on: ubuntu-latest
+    if: ${{ github.event.label.name == 'Build' || contains(github.event.pull_request.labels.*.name, 'Build') || github.event_name == 'push'}}
+    runs-on: ubuntu-22.04
     timeout-minutes: 60
     defaults:
       run:
-        shell: bash -l {0}
+        shell: bash -el {0}
 
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
     concurrency:
       # https://github.community/t/concurrecy-not-work-for-push/183068/7
       group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-${{matrix.python-version}}-sdist
       cancel-in-progress: true
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
 
-    # TODO: GH#44980 https://github.com/pypa/setuptools/issues/2941
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip "setuptools<60.0.0" wheel
+        python -m pip install --upgrade pip setuptools wheel
 
         # GH 39416
         pip install numpy
@@ -52,16 +56,22 @@ jobs:
         pip list
         python setup.py sdist --formats=gztar
 
-    - uses: conda-incubator/setup-miniconda@v2
+    - name: Upload sdist artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: ${{matrix.python-version}}-sdist.gz
+        path: dist/*.gz
+
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
       with:
-        activate-environment: pandas-sdist
-        channels: conda-forge
-        python-version: '${{ matrix.python-version }}'
+        environment-file: false
+        environment-name: pandas-sdist
+        extra-specs: |
+          python =${{ matrix.python-version }}
 
-    # TODO: GH#44980 https://github.com/pypa/setuptools/issues/2941
     - name: Install pandas from sdist
       run: |
-        python -m pip install --upgrade "setuptools<60.0.0"
         pip list
         python -m pip install dist/*.gz
 
@@ -69,11 +79,13 @@ jobs:
       run: |
         case "${{matrix.python-version}}" in
         3.8)
-          pip install numpy==1.18.5 ;;
+          pip install numpy==1.20.3 ;;
         3.9)
-          pip install numpy==1.19.3 ;;
+          pip install numpy==1.20.3 ;;
         3.10)
           pip install numpy==1.21.2 ;;
+        3.11)
+          pip install numpy==1.23.2 ;;
         esac
 
     - name: Import pandas
diff --git a/.github/workflows/stale-pr.yml b/.github/workflows/stale-pr.yml
index 2f55a180bc88c..c47745e097d17 100644
--- a/.github/workflows/stale-pr.yml
+++ b/.github/workflows/stale-pr.yml
@@ -4,18 +4,23 @@ on:
   # * is a special character in YAML so you have to quote this string
   - cron: "0 0 * * *"
 
+permissions:
+  contents: read
+
 jobs:
   stale:
-    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/stale@v3
+    - uses: actions/stale@v4
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-pr-message: "This pull request is stale because it has been open for thirty days with no activity. Please update or respond to this comment if you're still interested in working on this."
-        skip-stale-pr-message: false
+        stale-pr-message: "This pull request is stale because it has been open for thirty days with no activity. Please [update](https://pandas.pydata.org/pandas-docs/stable/development/contributing.html#updating-your-pull-request) and respond to this comment if you're still interested in working on this."
         stale-pr-label: "Stale"
         exempt-pr-labels: "Needs Review,Blocked,Needs Discussion"
-        days-before-stale: 30
+        days-before-issue-stale: -1
+        days-before-pr-stale: 30
         days-before-close: -1
         remove-stale-when-updated: false
         debug-only: false
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
new file mode 100644
index 0000000000000..4602d12d8505e
--- /dev/null
+++ b/.github/workflows/ubuntu.yml
@@ -0,0 +1,161 @@
+name: Ubuntu
+
+on:
+  push:
+    branches:
+      - main
+      - 1.5.x
+  pull_request:
+    branches:
+      - main
+      - 1.5.x
+    paths-ignore:
+      - "doc/**"
+
+env:
+  PANDAS_CI: 1
+
+permissions:
+  contents: read
+
+jobs:
+  pytest:
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        shell: bash -el {0}
+    timeout-minutes: 180
+    strategy:
+      matrix:
+        env_file: [actions-38.yaml, actions-39.yaml, actions-310.yaml]
+        pattern: ["not single_cpu", "single_cpu"]
+        # Don't test pyarrow v2/3: Causes timeouts in read_csv engine
+        # even if tests are skipped/xfailed
+        pyarrow_version: ["5", "6", "7"]
+        include:
+          - name: "Downstream Compat"
+            env_file: actions-38-downstream_compat.yaml
+            pattern: "not slow and not network and not single_cpu"
+            pytest_target: "pandas/tests/test_downstream.py"
+          - name: "Minimum Versions"
+            env_file: actions-38-minimum_versions.yaml
+            pattern: "not slow and not network and not single_cpu"
+          - name: "Locale: it_IT.utf8"
+            env_file: actions-38.yaml
+            pattern: "not slow and not network and not single_cpu"
+            extra_apt: "language-pack-it"
+            lang: "it_IT.utf8"
+            lc_all: "it_IT.utf8"
+          - name: "Locale: zh_CN.utf8"
+            env_file: actions-38.yaml
+            pattern: "not slow and not network and not single_cpu"
+            extra_apt: "language-pack-zh-hans"
+            lang: "zh_CN.utf8"
+            lc_all: "zh_CN.utf8"
+          - name: "Copy-on-Write"
+            env_file: actions-310.yaml
+            pattern: "not slow and not network and not single_cpu"
+            pandas_copy_on_write: "1"
+          - name: "Data Manager"
+            env_file: actions-38.yaml
+            pattern: "not slow and not network and not single_cpu"
+            pandas_data_manager: "array"
+          - name: "Pypy"
+            env_file: actions-pypy-38.yaml
+            pattern: "not slow and not network and not single_cpu"
+            test_args: "--max-worker-restart 0"
+          - name: "Numpy Dev"
+            env_file: actions-310-numpydev.yaml
+            pattern: "not slow and not network and not single_cpu"
+            pandas_testing_mode: "deprecate"
+            test_args: "-W error::DeprecationWarning:numpy -W error::FutureWarning:numpy"
+        exclude:
+          - env_file: actions-39.yaml
+            pyarrow_version: "6"
+          - env_file: actions-39.yaml
+            pyarrow_version: "7"
+          - env_file: actions-310.yaml
+            pyarrow_version: "6"
+          - env_file: actions-310.yaml
+            pyarrow_version: "7"
+      fail-fast: false
+    name: ${{ matrix.name || format('{0} pyarrow={1} {2}', matrix.env_file, matrix.pyarrow_version, matrix.pattern) }}
+    env:
+      ENV_FILE: ci/deps/${{ matrix.env_file }}
+      PATTERN: ${{ matrix.pattern }}
+      EXTRA_APT: ${{ matrix.extra_apt || '' }}
+      LANG: ${{ matrix.lang || '' }}
+      LC_ALL: ${{ matrix.lc_all || '' }}
+      PANDAS_TESTING_MODE: ${{ matrix.pandas_testing_mode || '' }}
+      PANDAS_DATA_MANAGER: ${{ matrix.pandas_data_manager || 'block' }}
+      PANDAS_COPY_ON_WRITE: ${{ matrix.pandas_copy_on_write || '0' }}
+      TEST_ARGS: ${{ matrix.test_args || '' }}
+      PYTEST_WORKERS: ${{ contains(matrix.pattern, 'not single_cpu') && 'auto' || '1' }}
+      PYTEST_TARGET: ${{ matrix.pytest_target || 'pandas' }}
+      IS_PYPY: ${{ contains(matrix.env_file, 'pypy') }}
+      # TODO: re-enable coverage on pypy, its slow
+      COVERAGE: ${{ !contains(matrix.env_file, 'pypy') }}
+    concurrency:
+      # https://github.community/t/concurrecy-not-work-for-push/183068/7
+      group: ${{ github.event_name == 'push' && github.run_number || github.ref }}-${{ matrix.env_file }}-${{ matrix.pattern }}-${{ matrix.pyarrow_version || '' }}-${{ matrix.extra_apt || '' }}-${{ matrix.pandas_data_manager || '' }}
+      cancel-in-progress: true
+
+    services:
+      mysql:
+        image: mysql
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: yes
+          MYSQL_DATABASE: pandas
+        options: >-
+          --health-cmd "mysqladmin ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 3306:3306
+
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: pandas
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+      moto:
+        image: motoserver/moto
+        env:
+          AWS_ACCESS_KEY_ID: foobar_key
+          AWS_SECRET_ACCESS_KEY: foobar_secret
+        ports:
+          - 5000:5000
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Extra installs
+      # xsel for clipboard tests
+      run: sudo apt-get update && sudo apt-get install -y xsel ${{ env.EXTRA_APT }}
+
+    - name: Set up Conda
+      uses: ./.github/actions/setup-conda
+      with:
+        environment-file: ${{ env.ENV_FILE }}
+        pyarrow-version: ${{ matrix.pyarrow_version }}
+
+    - name: Build Pandas
+      uses: ./.github/actions/build_pandas
+
+    - name: Test
+      uses: ./.github/actions/run-tests
+      # TODO: Don't continue on error for PyPy
+      continue-on-error: ${{ env.IS_PYPY == 'true' }}
diff --git a/.gitignore b/.gitignore
index 87224f1d6060f..07b1f056d511b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -122,3 +122,7 @@ doc/build/html/index.html
 doc/tmp.sv
 env/
 doc/source/savefig/
+
+# Interactive terminal generated files #
+########################################
+.jupyterlite.doit.db
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 854b7b2e4fe63..2ca5b5c9b896b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,15 +1,24 @@
-minimum_pre_commit_version: 2.9.2
+minimum_pre_commit_version: 2.15.0
 exclude: ^LICENSES/|\.(html|csv|svg)$
+# reserve "manual" for mypy and pyright
+default_stages: [commit, merge-commit, push, prepare-commit-msg, commit-msg, post-checkout, post-commit, post-merge, post-rewrite]
 ci:
     autofix_prs: false
 repos:
 -   repo: https://github.com/MarcoGorelli/absolufy-imports
-    rev: v0.3.0
+    rev: v0.3.1
     hooks:
     -   id: absolufy-imports
         files: ^pandas/
+-   repo: https://github.com/jendrikseipp/vulture
+    rev: 'v2.5'
+    hooks:
+      - id: vulture
+        entry: python scripts/run_vulture.py
+        pass_filenames: true
+        require_serial: false
 -   repo: https://github.com/python/black
-    rev: 21.12b0
+    rev: 22.6.0
     hooks:
     -   id: black
 -   repo: https://github.com/codespell-project/codespell
@@ -17,16 +26,17 @@ repos:
     hooks:
     -   id: codespell
         types_or: [python, rst, markdown]
-        files: ^(pandas|doc)/
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.1.0
+    rev: v4.3.0
     hooks:
     -   id: debug-statements
     -   id: end-of-file-fixer
         exclude: \.txt$
+        stages: [commit, merge-commit, push, prepare-commit-msg, commit-msg, post-checkout, post-commit, post-merge, post-rewrite]
     -   id: trailing-whitespace
+        stages: [commit, merge-commit, push, prepare-commit-msg, commit-msg, post-checkout, post-commit, post-merge, post-rewrite]
 -   repo: https://github.com/cpplint/cpplint
-    rev: 1.5.5
+    rev: 1.6.0
     hooks:
     -   id: cpplint
         # We don't lint all C files because we don't want to lint any that are built
@@ -36,20 +46,19 @@ repos:
         exclude: ^pandas/_libs/src/(klib|headers)/
         args: [--quiet, '--extensions=c,h', '--headers=h', --recursive, '--filter=-readability/casting,-runtime/int,-build/include_subdir']
 -   repo: https://github.com/PyCQA/flake8
-    rev: 4.0.1
+    rev: 5.0.4
     hooks:
     -   id: flake8
         additional_dependencies: &flake8_dependencies
-        - flake8==4.0.1
-        - flake8-comprehensions==3.7.0
-        - flake8-bugbear==21.3.2
-        - pandas-dev-flaker==0.2.0
+        - flake8==5.0.4
+        - flake8-bugbear==22.7.1
+        - pandas-dev-flaker==0.5.0
 -   repo: https://github.com/PyCQA/isort
     rev: 5.10.1
     hooks:
     -   id: isort
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v2.31.0
+    rev: v2.37.3
     hooks:
     -   id: pyupgrade
         args: [--py38-plus]
@@ -63,6 +72,10 @@ repos:
       - id: rst-inline-touching-normal
         types: [text]  # overwrite types: [rst]
         types_or: [python, rst]
+-   repo: https://github.com/sphinx-contrib/sphinx-lint
+    rev: v0.6.1
+    hooks:
+    - id: sphinx-lint
 -   repo: https://github.com/asottile/yesqa
     rev: v1.3.0
     hooks:
@@ -71,16 +84,42 @@ repos:
 -   repo: local
     hooks:
     -   id: pyright
+        # note: assumes python env is setup and activated
         name: pyright
         entry: pyright
         language: node
         pass_filenames: false
         types: [python]
         stages: [manual]
-        # note: keep version in sync with .github/workflows/ci.yml
-        additional_dependencies: ['pyright@1.1.202']
--   repo: local
-    hooks:
+        additional_dependencies: &pyright_dependencies
+        - pyright@1.1.264
+    -   id: pyright_reportGeneralTypeIssues
+        # note: assumes python env is setup and activated
+        name: pyright reportGeneralTypeIssues
+        entry: pyright --skipunannotated -p pyright_reportGeneralTypeIssues.json
+        language: node
+        pass_filenames: false
+        types: [python]
+        stages: [manual]
+        additional_dependencies: *pyright_dependencies
+    -   id: mypy
+        # note: assumes python env is setup and activated
+        name: mypy
+        entry: mypy
+        language: system
+        pass_filenames: false
+        types: [python]
+        stages: [manual]
+    -   id: stubtest
+        # note: assumes python env is setup and activated
+        # note: requires pandas dev to be installed
+        name: mypy (stubtest)
+        entry: python
+        language: system
+        pass_filenames: false
+        types: [pyi]
+        args: [scripts/run_stubtest.py]
+        stages: [manual]
     -   id: flake8-rst
         name: flake8-rst
         description: Run flake8 on code snippets in docstrings or RST files
@@ -165,13 +204,20 @@ repos:
         files: ^pandas/core/
         exclude: ^pandas/core/api\.py$
         types: [python]
+    -   id: use-io-common-urlopen
+        name: Use pandas.io.common.urlopen instead of urllib.request.urlopen
+        language: python
+        entry: python scripts/use_io_common_urlopen.py
+        files: ^pandas/
+        exclude: ^pandas/tests/
+        types: [python]
     -   id: no-bool-in-core-generic
         name: Use bool_t instead of bool in pandas/core/generic.py
         entry: python scripts/no_bool_in_generic.py
         language: python
         files: ^pandas/core/generic\.py$
     -   id: pandas-errors-documented
-        name: Ensure pandas errors are documented in doc/source/reference/general_utility_functions.rst
+        name: Ensure pandas errors are documented in doc/source/reference/testing.rst
         entry: python scripts/pandas_errors_documented.py
         language: python
         files: ^pandas/errors/__init__.py$
@@ -181,3 +227,28 @@ repos:
         entry: 'pg8000'
         files: ^ci/deps
         types: [yaml]
+    -   id: validate-min-versions-in-sync
+        name: Check minimum version of dependencies are aligned
+        entry: python scripts/validate_min_versions_in_sync.py
+        language: python
+        files: ^(ci/deps/actions-.*-minimum_versions\.yaml|pandas/compat/_optional\.py)$
+    -   id: flake8-pyi
+        name: flake8-pyi
+        entry: flake8 --extend-ignore=E301,E302,E305,E701,E704
+        types: [pyi]
+        language: python
+        additional_dependencies:
+        - flake8==5.0.4
+        - flake8-pyi==22.8.1
+    -   id: future-annotations
+        name: import annotations from __future__
+        entry: 'from __future__ import annotations'
+        language: pygrep
+        args: [--negate]
+        files: ^pandas/
+        types: [python]
+        exclude: |
+            (?x)
+            /(__init__\.py)|(api\.py)|(_version\.py)|(testing\.py)|(conftest\.py)$
+            |/tests/
+            |/_testing/
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000000000..0161dfa92fdef
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,10 @@
+cff-version: 1.2.0
+title: 'pandas-dev/pandas: Pandas'
+message: 'If you use this software, please cite it as below.'
+authors:
+  - name: "The pandas development team"
+license: BSD-3-Clause
+license-url: "https://github.com/pandas-dev/pandas/blob/main/LICENSE"
+repository-code: "https://github.com/pandas-dev/pandas"
+type: software
+url: "https://github.com/pandas-dev/pandas"
diff --git a/Dockerfile b/Dockerfile
index de1c564921de9..7230dcab20f6e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,48 +1,13 @@
-FROM quay.io/condaforge/miniforge3
+FROM python:3.10.8
+WORKDIR /home/pandas
 
-# if you forked pandas, you can pass in your own GitHub username to use your fork
-# i.e. gh_username=myname
-ARG gh_username=pandas-dev
-ARG pandas_home="/home/pandas"
+RUN apt-get update && apt-get -y upgrade
+RUN apt-get install -y build-essential
 
-# Avoid warnings by switching to noninteractive
-ENV DEBIAN_FRONTEND=noninteractive
+# hdf5 needed for pytables installation
+RUN apt-get install -y libhdf5-dev
 
-# Configure apt and install packages
-RUN apt-get update \
-    && apt-get -y install --no-install-recommends apt-utils dialog 2>&1 \
-    #
-    # Verify git, process tools, lsb-release (common in install instructions for CLIs) installed
-    && apt-get -y install git iproute2 procps iproute2 lsb-release \
-    #
-    # cleanup
-    && apt-get autoremove -y \
-    && apt-get clean -y \
-    && rm -rf /var/lib/apt/lists/*
-
-# Switch back to dialog for any ad-hoc use of apt-get
-ENV DEBIAN_FRONTEND=dialog
-
-# Clone pandas repo
-RUN mkdir "$pandas_home" \
-    && git clone "https://github.com/$gh_username/pandas.git" "$pandas_home" \
-    && cd "$pandas_home" \
-    && git remote add upstream "https://github.com/pandas-dev/pandas.git" \
-    && git pull upstream master
-
-# Because it is surprisingly difficult to activate a conda environment inside a DockerFile
-# (from personal experience and per https://github.com/ContinuumIO/docker-images/issues/89),
-# we just update the base/root one from the 'environment.yml' file instead of creating a new one.
-#
-# Set up environment
-RUN conda install -y mamba
-RUN mamba env update -n base -f "$pandas_home/environment.yml"
-
-# Build C extensions and pandas
-SHELL ["/bin/bash", "-c"]
-RUN . /opt/conda/etc/profile.d/conda.sh \
-    && conda activate base \
-    && cd "$pandas_home" \
-    && export \
-    && python setup.py build_ext -j 4 \
-    && python -m pip install -e .
+RUN python -m pip install --upgrade pip
+RUN python -m pip install \
+    -r https://raw.githubusercontent.com/pandas-dev/pandas/main/requirements-dev.txt
+CMD ["/bin/bash"]
diff --git a/LICENSE b/LICENSE
index a0cc369f725b8..d4e49a140f1cb 100644
--- a/LICENSE
+++ b/LICENSE
@@ -3,7 +3,7 @@ BSD 3-Clause License
 Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
 All rights reserved.
 
-Copyright (c) 2011-2021, Open source contributors.
+Copyright (c) 2011-2022, Open source contributors.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
diff --git a/LICENSES/KLIB_LICENSE b/LICENSES/KLIB_LICENSE
new file mode 100644
index 0000000000000..0a996fae3360f
--- /dev/null
+++ b/LICENSES/KLIB_LICENSE
@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2008-     Attractive Chaos <attractor@live.co.uk>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/LICENSES/OTHER b/LICENSES/OTHER
index f0550b4ee208a..7446d68eb43a6 100644
--- a/LICENSES/OTHER
+++ b/LICENSES/OTHER
@@ -1,8 +1,3 @@
-numpydoc license
-----------------
-
-The numpydoc license is in pandas/doc/sphinxext/LICENSE.txt
-
 Bottleneck license
 ------------------
 
@@ -77,4 +72,4 @@ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/LICENSES/ULTRAJSON_LICENSE b/LICENSES/ULTRAJSON_LICENSE
index 3b2886eb9cfae..a905fb017d813 100644
--- a/LICENSES/ULTRAJSON_LICENSE
+++ b/LICENSES/ULTRAJSON_LICENSE
@@ -28,7 +28,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 https://github.com/client9/stringencoders
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/MANIFEST.in b/MANIFEST.in
index 78464c9aaedc8..d2b1b8cb887bc 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,4 +1,5 @@
 include RELEASE.md
+include versioneer.py
 
 graft doc
 prune doc/build
@@ -54,9 +55,6 @@ global-exclude *.pxi
 # exclude the whole directory to avoid running related tests in sdist
 prune pandas/tests/io/parser/data
 
-include versioneer.py
-include pandas/_version.py
-include pandas/io/formats/templates/*.tpl
-
+# Selectively re-add *.cxx files that were excluded above
 graft pandas/_libs/src
 graft pandas/_libs/tslibs/src
diff --git a/Makefile b/Makefile
index 1fdd3cfdcf027..c0aa685ed47ac 100644
--- a/Makefile
+++ b/Makefile
@@ -12,7 +12,7 @@ build: clean_pyc
 	python setup.py build_ext
 
 lint-diff:
-	git diff upstream/master --name-only -- "*.py" | xargs flake8
+	git diff upstream/main --name-only -- "*.py" | xargs flake8
 
 black:
 	black .
diff --git a/README.md b/README.md
index bde815939239d..aaf63ead9c416 100644
--- a/README.md
+++ b/README.md
@@ -9,9 +9,8 @@
 [![Conda Latest Release](https://anaconda.org/conda-forge/pandas/badges/version.svg)](https://anaconda.org/anaconda/pandas/)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3509134.svg)](https://doi.org/10.5281/zenodo.3509134)
 [![Package Status](https://img.shields.io/pypi/status/pandas.svg)](https://pypi.org/project/pandas/)
-[![License](https://img.shields.io/pypi/l/pandas.svg)](https://github.com/pandas-dev/pandas/blob/master/LICENSE)
-[![Azure Build Status](https://dev.azure.com/pandas-dev/pandas/_apis/build/status/pandas-dev.pandas?branch=master)](https://dev.azure.com/pandas-dev/pandas/_build/latest?definitionId=1&branch=master)
-[![Coverage](https://codecov.io/github/pandas-dev/pandas/coverage.svg?branch=master)](https://codecov.io/gh/pandas-dev/pandas)
+[![License](https://img.shields.io/pypi/l/pandas.svg)](https://github.com/pandas-dev/pandas/blob/main/LICENSE)
+[![Coverage](https://codecov.io/github/pandas-dev/pandas/coverage.svg?branch=main)](https://codecov.io/gh/pandas-dev/pandas)
 [![Downloads](https://static.pepy.tech/personalized-badge/pandas?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/pandas)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/pydata/pandas)
 [![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
@@ -136,7 +135,7 @@ or alternatively
 python setup.py develop
 ```
 
-See the full instructions for [installing from source](https://pandas.pydata.org/pandas-docs/stable/install.html#installing-from-source).
+See the full instructions for [installing from source](https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html#installing-from-source).
 
 ## License
 [BSD 3](LICENSE)
@@ -170,4 +169,4 @@ Or maybe through using pandas you have an idea of your own or are looking for so
 
 Feel free to ask questions on the [mailing list](https://groups.google.com/forum/?fromgroups#!forum/pydata) or on [Gitter](https://gitter.im/pydata/pandas).
 
-As contributors and maintainers to this project, you are expected to abide by pandas' code of conduct. More information can be found at: [Contributor Code of Conduct](https://github.com/pandas-dev/pandas/blob/master/.github/CODE_OF_CONDUCT.md)
+As contributors and maintainers to this project, you are expected to abide by pandas' code of conduct. More information can be found at: [Contributor Code of Conduct](https://github.com/pandas-dev/.github/blob/master/CODE_OF_CONDUCT.md)
diff --git a/RELEASE.md b/RELEASE.md
index 42cb82dfcf020..344a097a3e81e 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,6 +1,6 @@
 Release Notes
 =============
 
-The list of changes to Pandas between each release can be found
+The list of changes to pandas between each release can be found
 [here](https://pandas.pydata.org/pandas-docs/stable/whatsnew/index.html). For full
 details, see the commit logs at https://github.com/pandas-dev/pandas.
diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json
index 9ad856d5d03ed..b1ea2682b7ea7 100644
--- a/asv_bench/asv.conf.json
+++ b/asv_bench/asv.conf.json
@@ -13,6 +13,10 @@
     // benchmarked
     "repo": "..",
 
+    // List of branches to benchmark. If not provided, defaults to "master"
+    // (for git) or "default" (for mercurial).
+    "branches": ["main"],
+
     // The tool to use to create environments.  May be "conda",
     // "virtualenv" or other value depending on the plugins in use.
     // If missing or the empty string, the tool will be automatically
@@ -25,7 +29,6 @@
 
     // The Pythons you'd like to test against.  If not provided, defaults
     // to the current version of Python used to run `asv`.
-    // "pythons": ["2.7", "3.4"],
     "pythons": ["3.8"],
 
     // The matrix of dependencies to test.  Each key is the name of a
@@ -39,7 +42,7 @@
     // followed by the pip installed packages).
     "matrix": {
         "numpy": [],
-        "Cython": ["0.29.24"],
+        "Cython": ["0.29.32"],
         "matplotlib": [],
         "sqlalchemy": [],
         "scipy": [],
diff --git a/asv_bench/benchmarks/algorithms.py b/asv_bench/benchmarks/algorithms.py
index 2e43827232ae5..0008a589ca71f 100644
--- a/asv_bench/benchmarks/algorithms.py
+++ b/asv_bench/benchmarks/algorithms.py
@@ -34,7 +34,7 @@ class Factorize:
     param_names = ["unique", "sort", "dtype"]
 
     def setup(self, unique, sort, dtype):
-        N = 10 ** 5
+        N = 10**5
         string_index = tm.makeStringIndex(N)
         string_arrow = None
         if dtype == "string[pyarrow]":
@@ -74,7 +74,7 @@ class Duplicated:
     param_names = ["unique", "keep", "dtype"]
 
     def setup(self, unique, keep, dtype):
-        N = 10 ** 5
+        N = 10**5
         data = {
             "int": pd.Index(np.arange(N), dtype="int64"),
             "uint": pd.Index(np.arange(N), dtype="uint64"),
@@ -97,7 +97,7 @@ def time_duplicated(self, unique, keep, dtype):
 
 class Hashing:
     def setup_cache(self):
-        N = 10 ** 5
+        N = 10**5
 
         df = pd.DataFrame(
             {
@@ -145,7 +145,7 @@ class Quantile:
     param_names = ["quantile", "interpolation", "dtype"]
 
     def setup(self, quantile, interpolation, dtype):
-        N = 10 ** 5
+        N = 10**5
         data = {
             "int": np.arange(N),
             "uint": np.arange(N).astype(np.uint64),
@@ -158,7 +158,7 @@ def time_quantile(self, quantile, interpolation, dtype):
 
 
 class SortIntegerArray:
-    params = [10 ** 3, 10 ** 5]
+    params = [10**3, 10**5]
 
     def setup(self, N):
         data = np.arange(N, dtype=float)
diff --git a/asv_bench/benchmarks/algos/isin.py b/asv_bench/benchmarks/algos/isin.py
index 37fa0b490bd9e..16d90b9d23741 100644
--- a/asv_bench/benchmarks/algos/isin.py
+++ b/asv_bench/benchmarks/algos/isin.py
@@ -49,7 +49,7 @@ def setup(self, dtype):
 
         elif dtype in ["category[object]", "category[int]"]:
             # Note: sizes are different in this case than others
-            n = 5 * 10 ** 5
+            n = 5 * 10**5
             sample_size = 100
 
             arr = list(np.random.randint(0, n // 10, size=n))
@@ -174,7 +174,7 @@ class IsinWithArange:
 
     def setup(self, dtype, M, offset_factor):
         offset = int(M * offset_factor)
-        tmp = Series(np.random.randint(offset, M + offset, 10 ** 6))
+        tmp = Series(np.random.randint(offset, M + offset, 10**6))
         self.series = tmp.astype(dtype)
         self.values = np.arange(M).astype(dtype)
 
@@ -191,8 +191,8 @@ class IsInFloat64:
     param_names = ["dtype", "title"]
 
     def setup(self, dtype, title):
-        N_many = 10 ** 5
-        N_few = 10 ** 6
+        N_many = 10**5
+        N_few = 10**6
         self.series = Series([1, 2], dtype=dtype)
 
         if title == "many_different_values":
@@ -240,10 +240,10 @@ class IsInForObjects:
     param_names = ["series_type", "vals_type"]
 
     def setup(self, series_type, vals_type):
-        N_many = 10 ** 5
+        N_many = 10**5
 
         if series_type == "nans":
-            ser_vals = np.full(10 ** 4, np.nan)
+            ser_vals = np.full(10**4, np.nan)
         elif series_type == "short":
             ser_vals = np.arange(2)
         elif series_type == "long":
@@ -254,7 +254,7 @@ def setup(self, series_type, vals_type):
         self.series = Series(ser_vals).astype(object)
 
         if vals_type == "nans":
-            values = np.full(10 ** 4, np.nan)
+            values = np.full(10**4, np.nan)
         elif vals_type == "short":
             values = np.arange(2)
         elif vals_type == "long":
@@ -277,7 +277,7 @@ class IsInLongSeriesLookUpDominates:
     param_names = ["dtype", "MaxNumber", "series_type"]
 
     def setup(self, dtype, MaxNumber, series_type):
-        N = 10 ** 7
+        N = 10**7
 
         if series_type == "random_hits":
             array = np.random.randint(0, MaxNumber, N)
@@ -304,7 +304,7 @@ class IsInLongSeriesValuesDominate:
     param_names = ["dtype", "series_type"]
 
     def setup(self, dtype, series_type):
-        N = 10 ** 7
+        N = 10**7
 
         if series_type == "random":
             vals = np.random.randint(0, 10 * N, N)
@@ -312,7 +312,7 @@ def setup(self, dtype, series_type):
             vals = np.arange(N)
 
         self.values = vals.astype(dtype.lower())
-        M = 10 ** 6 + 1
+        M = 10**6 + 1
         self.series = Series(np.arange(M)).astype(dtype)
 
     def time_isin(self, dtypes, series_type):
diff --git a/asv_bench/benchmarks/arithmetic.py b/asv_bench/benchmarks/arithmetic.py
index edd1132116f76..496db66c78569 100644
--- a/asv_bench/benchmarks/arithmetic.py
+++ b/asv_bench/benchmarks/arithmetic.py
@@ -59,7 +59,7 @@ def time_frame_op_with_scalar(self, dtype, scalar, op):
 class OpWithFillValue:
     def setup(self):
         # GH#31300
-        arr = np.arange(10 ** 6)
+        arr = np.arange(10**6)
         df = DataFrame({"A": arr})
         ser = df["A"]
 
@@ -93,7 +93,7 @@ class MixedFrameWithSeriesAxis:
     param_names = ["opname"]
 
     def setup(self, opname):
-        arr = np.arange(10 ** 6).reshape(1000, -1)
+        arr = np.arange(10**6).reshape(1000, -1)
         df = DataFrame(arr)
         df["C"] = 1.0
         self.df = df
@@ -201,7 +201,7 @@ def teardown(self, use_numexpr, threads):
 
 class Ops2:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.df = DataFrame(np.random.randn(N, N))
         self.df2 = DataFrame(np.random.randn(N, N))
 
@@ -258,7 +258,7 @@ class Timeseries:
     param_names = ["tz"]
 
     def setup(self, tz):
-        N = 10 ** 6
+        N = 10**6
         halfway = (N // 2) - 1
         self.s = Series(date_range("20010101", periods=N, freq="T", tz=tz))
         self.ts = self.s[halfway]
@@ -280,7 +280,7 @@ def time_timestamp_ops_diff_with_shift(self, tz):
 
 class IrregularOps:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         idx = date_range(start="1/1/2000", periods=N, freq="s")
         s = Series(np.random.randn(N), index=idx)
         self.left = s.sample(frac=1)
@@ -304,7 +304,7 @@ class CategoricalComparisons:
     param_names = ["op"]
 
     def setup(self, op):
-        N = 10 ** 5
+        N = 10**5
         self.cat = pd.Categorical(list("aabbcd") * N, ordered=True)
 
     def time_categorical_op(self, op):
@@ -317,7 +317,7 @@ class IndexArithmetic:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        N = 10 ** 6
+        N = 10**6
         indexes = {"int": "makeIntIndex", "float": "makeFloatIndex"}
         self.index = getattr(tm, indexes[dtype])(N)
 
@@ -343,7 +343,7 @@ class NumericInferOps:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        N = 5 * 10 ** 5
+        N = 5 * 10**5
         self.df = DataFrame(
             {"A": np.arange(N).astype(dtype), "B": np.arange(N).astype(dtype)}
         )
@@ -367,7 +367,7 @@ def time_modulo(self, dtype):
 class DateInferOps:
     # from GH 7332
     def setup_cache(self):
-        N = 5 * 10 ** 5
+        N = 5 * 10**5
         df = DataFrame({"datetime64": np.arange(N).astype("datetime64[ms]")})
         df["timedelta"] = df["datetime64"] - df["datetime64"]
         return df
@@ -388,7 +388,7 @@ class AddOverflowScalar:
     param_names = ["scalar"]
 
     def setup(self, scalar):
-        N = 10 ** 6
+        N = 10**6
         self.arr = np.arange(N)
 
     def time_add_overflow_scalar(self, scalar):
@@ -397,7 +397,7 @@ def time_add_overflow_scalar(self, scalar):
 
 class AddOverflowArray:
     def setup(self):
-        N = 10 ** 6
+        N = 10**6
         self.arr = np.arange(N)
         self.arr_rev = np.arange(-N, 0)
         self.arr_mixed = np.array([1, -1]).repeat(N / 2)
@@ -420,7 +420,7 @@ def time_add_overflow_both_arg_nan(self):
 
 
 hcal = pd.tseries.holiday.USFederalHolidayCalendar()
-# These offsets currently raise a NotImplimentedError with .apply_index()
+# These offsets currently raise a NotImplementedError with .apply_index()
 non_apply = [
     pd.offsets.Day(),
     pd.offsets.BYearEnd(),
diff --git a/asv_bench/benchmarks/array.py b/asv_bench/benchmarks/array.py
index 103df0fd94847..b58200911749e 100644
--- a/asv_bench/benchmarks/array.py
+++ b/asv_bench/benchmarks/array.py
@@ -2,6 +2,8 @@
 
 import pandas as pd
 
+from .pandas_vb_common import tm
+
 
 class BooleanArray:
     def setup(self):
@@ -39,3 +41,32 @@ def time_constructor(self):
 
     def time_from_integer_array(self):
         pd.array(self.values_integer, dtype="Int64")
+
+
+class ArrowStringArray:
+
+    params = [False, True]
+    param_names = ["multiple_chunks"]
+
+    def setup(self, multiple_chunks):
+        try:
+            import pyarrow as pa
+        except ImportError:
+            raise NotImplementedError
+        strings = tm.rands_array(3, 10_000)
+        if multiple_chunks:
+            chunks = [strings[i : i + 100] for i in range(0, len(strings), 100)]
+            self.array = pd.arrays.ArrowStringArray(pa.chunked_array(chunks))
+        else:
+            self.array = pd.arrays.ArrowStringArray(pa.array(strings))
+
+    def time_setitem(self, multiple_chunks):
+        for i in range(200):
+            self.array[i] = "foo"
+
+    def time_setitem_list(self, multiple_chunks):
+        indexer = list(range(0, 50)) + list(range(-50, 0))
+        self.array[indexer] = ["foo"] * len(indexer)
+
+    def time_setitem_slice(self, multiple_chunks):
+        self.array[::10] = "foo"
diff --git a/asv_bench/benchmarks/categoricals.py b/asv_bench/benchmarks/categoricals.py
index 268f25c3d12e3..ff0b3b2fb651d 100644
--- a/asv_bench/benchmarks/categoricals.py
+++ b/asv_bench/benchmarks/categoricals.py
@@ -19,7 +19,7 @@
 
 class Constructor:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         self.categories = list("abcde")
         self.cat_idx = pd.Index(self.categories)
         self.values = np.tile(self.categories, N)
@@ -71,16 +71,16 @@ def time_existing_series(self):
 
 class AsType:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
 
         random_pick = np.random.default_rng().choice
 
         categories = {
             "str": list(string.ascii_letters),
-            "int": np.random.randint(2 ** 16, size=154),
+            "int": np.random.randint(2**16, size=154),
             "float": sys.maxsize * np.random.random((38,)),
             "timestamp": [
-                pd.Timestamp(x, unit="s") for x in np.random.randint(2 ** 18, size=578)
+                pd.Timestamp(x, unit="s") for x in np.random.randint(2**18, size=578)
             ],
         }
 
@@ -112,7 +112,7 @@ def astype_datetime(self):
 
 class Concat:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         self.s = pd.Series(list("aabbcd") * N).astype("category")
 
         self.a = pd.Categorical(list("aabbcd") * N)
@@ -148,7 +148,7 @@ class ValueCounts:
     param_names = ["dropna"]
 
     def setup(self, dropna):
-        n = 5 * 10 ** 5
+        n = 5 * 10**5
         arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
@@ -166,7 +166,7 @@ def time_rendering(self):
 
 class SetCategories:
     def setup(self):
-        n = 5 * 10 ** 5
+        n = 5 * 10**5
         arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
@@ -176,7 +176,7 @@ def time_set_categories(self):
 
 class RemoveCategories:
     def setup(self):
-        n = 5 * 10 ** 5
+        n = 5 * 10**5
         arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
@@ -186,8 +186,8 @@ def time_remove_categories(self):
 
 class Rank:
     def setup(self):
-        N = 10 ** 5
-        ncats = 100
+        N = 10**5
+        ncats = 15
 
         self.s_str = pd.Series(tm.makeCategoricalIndex(N, ncats)).astype(str)
         self.s_str_cat = pd.Series(self.s_str, dtype="category")
@@ -241,7 +241,7 @@ def time_categorical_series_is_monotonic_decreasing(self):
 
 class Contains:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         self.ci = tm.makeCategoricalIndex(N)
         self.c = self.ci.values
         self.key = self.ci.categories[0]
@@ -259,7 +259,7 @@ class CategoricalSlicing:
     param_names = ["index"]
 
     def setup(self, index):
-        N = 10 ** 6
+        N = 10**6
         categories = ["a", "b", "c"]
         values = [0] * N + [1] * N + [2] * N
         if index == "monotonic_incr":
@@ -295,7 +295,7 @@ def time_getitem_bool_array(self, index):
 
 class Indexing:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         self.index = pd.CategoricalIndex(range(N), range(N))
         self.series = pd.Series(range(N), index=self.index).sort_index()
         self.category = self.index[500]
@@ -327,7 +327,7 @@ def time_sort_values(self):
 
 class SearchSorted:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         self.ci = tm.makeCategoricalIndex(N).sort_values()
         self.c = self.ci.values
         self.key = self.ci.categories[1]
diff --git a/asv_bench/benchmarks/ctors.py b/asv_bench/benchmarks/ctors.py
index 5993b068feadf..ef8b16f376d6a 100644
--- a/asv_bench/benchmarks/ctors.py
+++ b/asv_bench/benchmarks/ctors.py
@@ -76,7 +76,7 @@ def setup(self, data_fmt, with_index, dtype):
             raise NotImplementedError(
                 "Series constructors do not support using generators with indexes"
             )
-        N = 10 ** 4
+        N = 10**4
         if dtype == "float":
             arr = np.random.randn(N)
         else:
@@ -90,7 +90,7 @@ def time_series_constructor(self, data_fmt, with_index, dtype):
 
 class SeriesDtypesConstructors:
     def setup(self):
-        N = 10 ** 4
+        N = 10**4
         self.arr = np.random.randn(N)
         self.arr_str = np.array(["foo", "bar", "baz"], dtype=object)
         self.s = Series(
@@ -114,7 +114,7 @@ def time_dtindex_from_index_with_series(self):
 
 class MultiIndexConstructor:
     def setup(self):
-        N = 10 ** 4
+        N = 10**4
         self.iterables = [tm.makeStringIndex(N), range(20)]
 
     def time_multiindex_from_iterables(self):
diff --git a/asv_bench/benchmarks/eval.py b/asv_bench/benchmarks/eval.py
index cbab9fdc9c0ba..b5442531e748a 100644
--- a/asv_bench/benchmarks/eval.py
+++ b/asv_bench/benchmarks/eval.py
@@ -43,7 +43,7 @@ def teardown(self, engine, threads):
 
 class Query:
     def setup(self):
-        N = 10 ** 6
+        N = 10**6
         halfway = (N // 2) - 1
         index = pd.date_range("20010101", periods=N, freq="T")
         s = pd.Series(index)
diff --git a/asv_bench/benchmarks/frame_ctor.py b/asv_bench/benchmarks/frame_ctor.py
index eace665ba0bac..20c0c0ea2f6fe 100644
--- a/asv_bench/benchmarks/frame_ctor.py
+++ b/asv_bench/benchmarks/frame_ctor.py
@@ -2,8 +2,10 @@
 
 import pandas as pd
 from pandas import (
+    NA,
     Categorical,
     DataFrame,
+    Float64Dtype,
     MultiIndex,
     Series,
     Timestamp,
@@ -35,7 +37,7 @@ def setup(self):
         self.dict_list = frame.to_dict(orient="records")
         self.data2 = {i: {j: float(j) for j in range(100)} for i in range(2000)}
 
-        # arrays which we wont consolidate
+        # arrays which we won't consolidate
         self.dict_of_categoricals = {i: Categorical(np.arange(N)) for i in range(K)}
 
     def time_list_of_dict(self):
@@ -58,7 +60,7 @@ def time_nested_dict_int64(self):
         DataFrame(self.data2)
 
     def time_dict_of_categoricals(self):
-        # dict of arrays that we wont consolidate
+        # dict of arrays that we won't consolidate
         DataFrame(self.dict_of_categoricals)
 
 
@@ -77,7 +79,7 @@ class FromDictwithTimestamp:
     param_names = ["offset"]
 
     def setup(self, offset):
-        N = 10 ** 3
+        N = 10**3
         idx = date_range(Timestamp("1/1/1900"), freq=offset, periods=N)
         df = DataFrame(np.random.randn(N, 10), index=idx)
         self.d = df.to_dict()
@@ -138,6 +140,27 @@ def time_frame_from_range(self):
         self.df = DataFrame(self.data)
 
 
+class FromScalar:
+    def setup(self):
+        self.nrows = 100_000
+
+    def time_frame_from_scalar_ea_float64(self):
+        DataFrame(
+            1.0,
+            index=range(self.nrows),
+            columns=list("abc"),
+            dtype=Float64Dtype(),
+        )
+
+    def time_frame_from_scalar_ea_float64_na(self):
+        DataFrame(
+            NA,
+            index=range(self.nrows),
+            columns=list("abc"),
+            dtype=Float64Dtype(),
+        )
+
+
 class FromArrays:
 
     goal_time = 0.2
diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index 16925b7959e6a..a28e20a636ce2 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -50,7 +50,7 @@ def time_frame_fancy_lookup_all(self):
 
 class Reindex:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.df = DataFrame(np.random.randn(N * 10, N))
         self.idx = np.arange(4 * N, 7 * N)
         self.idx_cols = np.random.randint(0, N, N)
@@ -84,7 +84,7 @@ def time_reindex_upcast(self):
 
 class Rename:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.df = DataFrame(np.random.randn(N * 10, N))
         self.idx = np.arange(4 * N, 7 * N)
         self.dict_idx = {k: k for k in self.idx}
@@ -288,6 +288,26 @@ def time_values_mixed_wide(self):
         self.df_mixed_wide.values
 
 
+class ToRecords:
+    def setup(self):
+        N = 100_000
+        data = np.random.randn(N, 2)
+        mi = MultiIndex.from_arrays(
+            [
+                np.arange(N),
+                date_range("1970-01-01", periods=N, freq="ms"),
+            ]
+        )
+        self.df = DataFrame(data)
+        self.df_mi = DataFrame(data, index=mi)
+
+    def time_to_records(self):
+        self.df.to_records(index=True)
+
+    def time_to_records_multiindex(self):
+        self.df_mi.to_records(index=True)
+
+
 class Repr:
     def setup(self):
         nrows = 10000
@@ -329,7 +349,7 @@ def time_frame_mask_floats(self):
 
 class Isnull:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.df_no_null = DataFrame(np.random.randn(N, N))
 
         sample = np.array([np.nan, 1.0])
@@ -497,7 +517,7 @@ def time_frame_dtypes(self):
 
 class Equals:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.float_df = DataFrame(np.random.randn(N, N))
         self.float_df_nan = self.float_df.copy()
         self.float_df_nan.iloc[-1, -1] = np.nan
@@ -611,6 +631,9 @@ def time_frame_duplicated(self):
     def time_frame_duplicated_wide(self):
         self.df2.duplicated()
 
+    def time_frame_duplicated_subset(self):
+        self.df.duplicated(subset=["a"])
+
 
 class XS:
 
@@ -618,7 +641,7 @@ class XS:
     param_names = ["axis"]
 
     def setup(self, axis):
-        self.N = 10 ** 4
+        self.N = 10**4
         self.df = DataFrame(np.random.randn(self.N, self.N))
 
     def time_frame_xs(self, axis):
@@ -718,9 +741,9 @@ class Describe:
     def setup(self):
         self.df = DataFrame(
             {
-                "a": np.random.randint(0, 100, 10 ** 6),
-                "b": np.random.randint(0, 100, 10 ** 6),
-                "c": np.random.randint(0, 100, 10 ** 6),
+                "a": np.random.randint(0, 100, 10**6),
+                "b": np.random.randint(0, 100, 10**6),
+                "c": np.random.randint(0, 100, 10**6),
             }
         )
 
diff --git a/asv_bench/benchmarks/gil.py b/asv_bench/benchmarks/gil.py
index ac7cd87c846d5..31654a5c75617 100644
--- a/asv_bench/benchmarks/gil.py
+++ b/asv_bench/benchmarks/gil.py
@@ -1,3 +1,6 @@
+from functools import wraps
+import threading
+
 import numpy as np
 
 from pandas import (
@@ -30,21 +33,57 @@
     from pandas._libs import algos
 except ImportError:
     from pandas import algos
-try:
-    from pandas._testing import test_parallel  # noqa: PDF014
 
-    have_real_test_parallel = True
-except ImportError:
-    have_real_test_parallel = False
 
-    def test_parallel(num_threads=1):
-        def wrapper(fname):
-            return fname
+from .pandas_vb_common import BaseIO  # isort:skip
 
-        return wrapper
 
+def test_parallel(num_threads=2, kwargs_list=None):
+    """
+    Decorator to run the same function multiple times in parallel.
 
-from .pandas_vb_common import BaseIO  # isort:skip
+    Parameters
+    ----------
+    num_threads : int, optional
+        The number of times the function is run in parallel.
+    kwargs_list : list of dicts, optional
+        The list of kwargs to update original
+        function kwargs on different threads.
+
+    Notes
+    -----
+    This decorator does not pass the return value of the decorated function.
+
+    Original from scikit-image:
+
+    https://github.com/scikit-image/scikit-image/pull/1519
+
+    """
+    assert num_threads > 0
+    has_kwargs_list = kwargs_list is not None
+    if has_kwargs_list:
+        assert len(kwargs_list) == num_threads
+
+    def wrapper(func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            if has_kwargs_list:
+                update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
+            else:
+                update_kwargs = lambda i: kwargs
+            threads = []
+            for i in range(num_threads):
+                updated_kwargs = update_kwargs(i)
+                thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
+                threads.append(thread)
+            for thread in threads:
+                thread.start()
+            for thread in threads:
+                thread.join()
+
+        return inner
+
+    return wrapper
 
 
 class ParallelGroupbyMethods:
@@ -53,10 +92,9 @@ class ParallelGroupbyMethods:
     param_names = ["threads", "method"]
 
     def setup(self, threads, method):
-        if not have_real_test_parallel:
-            raise NotImplementedError
-        N = 10 ** 6
-        ngroups = 10 ** 3
+
+        N = 10**6
+        ngroups = 10**3
         df = DataFrame(
             {"key": np.random.randint(0, ngroups, size=N), "data": np.random.randn(N)}
         )
@@ -86,10 +124,9 @@ class ParallelGroups:
     param_names = ["threads"]
 
     def setup(self, threads):
-        if not have_real_test_parallel:
-            raise NotImplementedError
-        size = 2 ** 22
-        ngroups = 10 ** 3
+
+        size = 2**22
+        ngroups = 10**3
         data = Series(np.random.randint(0, ngroups, size=size))
 
         @test_parallel(num_threads=threads)
@@ -108,9 +145,8 @@ class ParallelTake1D:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        if not have_real_test_parallel:
-            raise NotImplementedError
-        N = 10 ** 6
+
+        N = 10**6
         df = DataFrame({"col": np.arange(N, dtype=dtype)})
         indexer = np.arange(100, len(df) - 100)
 
@@ -131,10 +167,9 @@ class ParallelKth:
     repeat = 5
 
     def setup(self):
-        if not have_real_test_parallel:
-            raise NotImplementedError
-        N = 10 ** 7
-        k = 5 * 10 ** 5
+
+        N = 10**7
+        k = 5 * 10**5
         kwargs_list = [{"arr": np.random.randn(N)}, {"arr": np.random.randn(N)}]
 
         @test_parallel(num_threads=2, kwargs_list=kwargs_list)
@@ -149,9 +184,8 @@ def time_kth_smallest(self):
 
 class ParallelDatetimeFields:
     def setup(self):
-        if not have_real_test_parallel:
-            raise NotImplementedError
-        N = 10 ** 6
+
+        N = 10**6
         self.dti = date_range("1900-01-01", periods=N, freq="T")
         self.period = self.dti.to_period("D")
 
@@ -204,8 +238,7 @@ class ParallelRolling:
     param_names = ["method"]
 
     def setup(self, method):
-        if not have_real_test_parallel:
-            raise NotImplementedError
+
         win = 100
         arr = np.random.rand(100000)
         if hasattr(DataFrame, "rolling"):
@@ -248,8 +281,7 @@ class ParallelReadCSV(BaseIO):
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        if not have_real_test_parallel:
-            raise NotImplementedError
+
         rows = 10000
         cols = 50
         data = {
@@ -284,8 +316,6 @@ class ParallelFactorize:
     param_names = ["threads"]
 
     def setup(self, threads):
-        if not have_real_test_parallel:
-            raise NotImplementedError
 
         strings = tm.makeStringIndex(100000)
 
diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index ff58e382a9ba2..2de1f25fceace 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -7,6 +7,7 @@
 from pandas import (
     Categorical,
     DataFrame,
+    Index,
     MultiIndex,
     Series,
     Timestamp,
@@ -18,6 +19,7 @@
 
 method_blocklist = {
     "object": {
+        "diff",
         "median",
         "prod",
         "sem",
@@ -73,7 +75,7 @@ class Apply:
     params = [4, 5]
 
     def setup(self, factor):
-        N = 10 ** factor
+        N = 10**factor
         # two cases:
         # - small groups: small data (N**4) + many labels (2000) -> average group
         #   size of 5 (-> larger overhead of slicing method)
@@ -110,13 +112,25 @@ def time_copy_overhead_single_col(self, factor):
         self.df.groupby("key").apply(self.df_copy_function)
 
 
+class ApplyNonUniqueUnsortedIndex:
+    def setup(self):
+        # GH 46527
+        # unsorted and non-unique index
+        idx = np.arange(100)[::-1]
+        idx = Index(np.repeat(idx, 200), name="key")
+        self.df = DataFrame(np.random.randn(len(idx), 10), index=idx)
+
+    def time_groupby_apply_non_unique_unsorted_index(self):
+        self.df.groupby("key", group_keys=False).apply(lambda x: x)
+
+
 class Groups:
 
     param_names = ["key"]
     params = ["int64_small", "int64_large", "object_small", "object_large"]
 
     def setup_cache(self):
-        size = 10 ** 6
+        size = 10**6
         data = {
             "int64_small": Series(np.random.randint(0, 100, size=size)),
             "int64_large": Series(np.random.randint(0, 10000, size=size)),
@@ -160,7 +174,7 @@ class Nth:
     params = ["float32", "float64", "datetime", "object"]
 
     def setup(self, dtype):
-        N = 10 ** 5
+        N = 10**5
         # with datetimes (GH7555)
         if dtype == "datetime":
             values = date_range("1/1/2011", periods=N, freq="s")
@@ -268,7 +282,7 @@ def time_multi_int_nunique(self, df):
 
 class AggFunctions:
     def setup_cache(self):
-        N = 10 ** 5
+        N = 10**5
         fac1 = np.array(["A", "B", "C"], dtype="O")
         fac2 = np.array(["one", "two"], dtype="O")
         df = DataFrame(
@@ -301,7 +315,7 @@ def time_different_python_functions_singlecol(self, df):
 
 class GroupStrings:
     def setup(self):
-        n = 2 * 10 ** 5
+        n = 2 * 10**5
         alpha = list(map("".join, product(ascii_letters, repeat=4)))
         data = np.random.choice(alpha, (n // 5, 4), replace=False)
         data = np.repeat(data, 5, axis=0)
@@ -315,7 +329,7 @@ def time_multi_columns(self):
 
 class MultiColumn:
     def setup_cache(self):
-        N = 10 ** 5
+        N = 10**5
         key1 = np.tile(np.arange(100, dtype=object), 1000)
         key2 = key1.copy()
         np.random.shuffle(key1)
@@ -345,7 +359,7 @@ def time_col_select_numpy_sum(self, df):
 
 class Size:
     def setup(self):
-        n = 10 ** 5
+        n = 10**5
         offsets = np.random.randint(n, size=n).astype("timedelta64[ns]")
         dates = np.datetime64("now") + offsets
         self.df = DataFrame(
@@ -405,7 +419,7 @@ class GroupByMethods:
 
     param_names = ["dtype", "method", "application", "ncols"]
     params = [
-        ["int", "float", "object", "datetime", "uint"],
+        ["int", "int16", "float", "object", "datetime", "uint"],
         [
             "all",
             "any",
@@ -417,6 +431,7 @@ class GroupByMethods:
             "cumprod",
             "cumsum",
             "describe",
+            "diff",
             "ffill",
             "first",
             "head",
@@ -478,7 +493,7 @@ def setup(self, dtype, method, application, ncols):
         values = rng.take(taker, axis=0)
         if dtype == "int":
             key = np.random.randint(0, size, size=size)
-        elif dtype == "uint":
+        elif dtype in ("int16", "uint"):
             key = np.random.randint(0, size, size=size, dtype=dtype)
         elif dtype == "float":
             key = np.concatenate(
@@ -512,7 +527,7 @@ def time_dtype_as_field(self, dtype, method, application, ncols):
 
 class GroupByCythonAgg:
     """
-    Benchmarks specifically targetting our cython aggregation algorithms
+    Benchmarks specifically targeting our cython aggregation algorithms
     (using a big enough dataframe with simple key, so a large part of the
     time is actually spent in the grouped aggregation).
     """
@@ -582,7 +597,7 @@ class RankWithTies:
     ]
 
     def setup(self, dtype, tie_method):
-        N = 10 ** 4
+        N = 10**4
         if dtype == "datetime64":
             data = np.array([Timestamp("2011/01/01")] * N, dtype=dtype)
         else:
@@ -640,7 +655,7 @@ def time_str_func(self, dtype, method):
 
 class Categories:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         arr = np.random.random(N)
         data = {"a": Categorical(np.random.randint(10000, size=N)), "b": arr}
         self.df = DataFrame(data)
@@ -682,14 +697,14 @@ class Datelike:
     param_names = ["grouper"]
 
     def setup(self, grouper):
-        N = 10 ** 4
+        N = 10**4
         rng_map = {
             "period_range": period_range,
             "date_range": date_range,
             "date_range_tz": partial(date_range, tz="US/Central"),
         }
         self.grouper = rng_map[grouper]("1900-01-01", freq="D", periods=N)
-        self.df = DataFrame(np.random.randn(10 ** 4, 2))
+        self.df = DataFrame(np.random.randn(10**4, 2))
 
     def time_sum(self, grouper):
         self.df.groupby(self.grouper).sum()
@@ -735,6 +750,18 @@ def setup(self):
         data = DataFrame(arr, index=index, columns=["col1", "col20", "col3"])
         self.df = data
 
+        n = 1000
+        self.df_wide = DataFrame(
+            np.random.randn(n, n),
+            index=np.random.choice(range(10), n),
+        )
+
+        n = 1_000_000
+        self.df_tall = DataFrame(
+            np.random.randn(n, 3),
+            index=np.random.randint(0, 5, n),
+        )
+
         n = 20000
         self.df1 = DataFrame(
             np.random.randint(1, n, (n, 3)), columns=["jim", "joe", "jolie"]
@@ -754,6 +781,12 @@ def time_transform_lambda_max(self):
     def time_transform_ufunc_max(self):
         self.df.groupby(level="lev1").transform(np.max)
 
+    def time_transform_lambda_max_tall(self):
+        self.df_tall.groupby(level=0).transform(lambda x: np.max(x, axis=0))
+
+    def time_transform_lambda_max_wide(self):
+        self.df_wide.groupby(level=0).transform(lambda x: np.max(x, axis=0))
+
     def time_transform_multi_key1(self):
         self.df1.groupby(["jim", "joe"])["jolie"].transform("max")
 
@@ -798,7 +831,7 @@ class TransformEngine:
     params = [[True, False]]
 
     def setup(self, parallel):
-        N = 10 ** 3
+        N = 10**3
         data = DataFrame(
             {0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
             columns=[0, 1],
@@ -841,7 +874,7 @@ class AggEngine:
     params = [[True, False]]
 
     def setup(self, parallel):
-        N = 10 ** 3
+        N = 10**3
         data = DataFrame(
             {0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
             columns=[0, 1],
@@ -904,7 +937,7 @@ def function(values):
 
 class Sample:
     def setup(self):
-        N = 10 ** 3
+        N = 10**3
         self.df = DataFrame({"a": np.zeros(N)})
         self.groups = np.arange(0, N)
         self.weights = np.ones(N)
diff --git a/asv_bench/benchmarks/hash_functions.py b/asv_bench/benchmarks/hash_functions.py
index 6703cc791493a..da752b902b4fd 100644
--- a/asv_bench/benchmarks/hash_functions.py
+++ b/asv_bench/benchmarks/hash_functions.py
@@ -16,9 +16,9 @@ class Float64GroupIndex:
     # GH28303
     def setup(self):
         self.df = pd.date_range(
-            start="1/1/2018", end="1/2/2018", periods=10 ** 6
+            start="1/1/2018", end="1/2/2018", periods=10**6
         ).to_frame()
-        self.group_index = np.round(self.df.index.astype(int) / 10 ** 9)
+        self.group_index = np.round(self.df.index.astype(int) / 10**9)
 
     def time_groupby(self):
         self.df.groupby(self.group_index).last()
@@ -29,8 +29,8 @@ class UniqueAndFactorizeArange:
     param_names = ["exponent"]
 
     def setup(self, exponent):
-        a = np.arange(10 ** 4, dtype="float64")
-        self.a2 = (a + 10 ** exponent).repeat(100)
+        a = np.arange(10**4, dtype="float64")
+        self.a2 = (a + 10**exponent).repeat(100)
 
     def time_factorize(self, exponent):
         pd.factorize(self.a2)
@@ -39,11 +39,26 @@ def time_unique(self, exponent):
         pd.unique(self.a2)
 
 
+class Unique:
+    params = ["Int64", "Float64"]
+    param_names = ["dtype"]
+
+    def setup(self, dtype):
+        self.ser = pd.Series(([1, pd.NA, 2] + list(range(100_000))) * 3, dtype=dtype)
+        self.ser_unique = pd.Series(list(range(300_000)) + [pd.NA], dtype=dtype)
+
+    def time_unique_with_duplicates(self, exponent):
+        pd.unique(self.ser)
+
+    def time_unique(self, exponent):
+        pd.unique(self.ser_unique)
+
+
 class NumericSeriesIndexing:
 
     params = [
         (pd.Int64Index, pd.UInt64Index, pd.Float64Index),
-        (10 ** 4, 10 ** 5, 5 * 10 ** 5, 10 ** 6, 5 * 10 ** 6),
+        (10**4, 10**5, 5 * 10**5, 10**6, 5 * 10**6),
     ]
     param_names = ["index_dtype", "N"]
 
@@ -61,7 +76,7 @@ class NumericSeriesIndexingShuffled:
 
     params = [
         (pd.Int64Index, pd.UInt64Index, pd.Float64Index),
-        (10 ** 4, 10 ** 5, 5 * 10 ** 5, 10 ** 6, 5 * 10 ** 6),
+        (10**4, 10**5, 5 * 10**5, 10**6, 5 * 10**6),
     ]
     param_names = ["index_dtype", "N"]
 
diff --git a/asv_bench/benchmarks/index_cached_properties.py b/asv_bench/benchmarks/index_cached_properties.py
index 16fbc741775e4..1a88bb7eef37a 100644
--- a/asv_bench/benchmarks/index_cached_properties.py
+++ b/asv_bench/benchmarks/index_cached_properties.py
@@ -22,7 +22,7 @@ class IndexCache:
     param_names = ["index_type"]
 
     def setup(self, index_type):
-        N = 10 ** 5
+        N = 10**5
         if index_type == "MultiIndex":
             self.idx = pd.MultiIndex.from_product(
                 [pd.date_range("1/1/2000", freq="T", periods=N // 2), ["a", "b"]]
@@ -56,9 +56,6 @@ def time_values(self, index_type):
     def time_shape(self, index_type):
         self.idx.shape
 
-    def time_is_monotonic(self, index_type):
-        self.idx.is_monotonic
-
     def time_is_monotonic_decreasing(self, index_type):
         self.idx.is_monotonic_decreasing
 
diff --git a/asv_bench/benchmarks/index_object.py b/asv_bench/benchmarks/index_object.py
index 2b2302a796730..dab33f02c2cd9 100644
--- a/asv_bench/benchmarks/index_object.py
+++ b/asv_bench/benchmarks/index_object.py
@@ -25,7 +25,7 @@ class SetOperations:
     param_names = ["dtype", "method"]
 
     def setup(self, dtype, method):
-        N = 10 ** 5
+        N = 10**5
         dates_left = date_range("1/1/2000", periods=N, freq="T")
         fmt = "%Y-%m-%d %H:%M:%S"
         date_str_left = Index(dates_left.strftime(fmt))
@@ -46,7 +46,7 @@ def time_operation(self, dtype, method):
 
 class SetDisjoint:
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         B = N + 20000
         self.datetime_left = DatetimeIndex(range(N))
         self.datetime_right = DatetimeIndex(range(N, B))
@@ -57,8 +57,8 @@ def time_datetime_difference_disjoint(self):
 
 class Range:
     def setup(self):
-        self.idx_inc = RangeIndex(start=0, stop=10 ** 6, step=3)
-        self.idx_dec = RangeIndex(start=10 ** 6, stop=-1, step=-3)
+        self.idx_inc = RangeIndex(start=0, stop=10**6, step=3)
+        self.idx_dec = RangeIndex(start=10**6, stop=-1, step=-3)
 
     def time_max(self):
         self.idx_inc.max()
@@ -139,7 +139,7 @@ class Indexing:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        N = 10 ** 6
+        N = 10**6
         self.idx = getattr(tm, f"make{dtype}Index")(N)
         self.array_mask = (np.arange(N) % 3) == 0
         self.series_mask = Series(self.array_mask)
@@ -192,7 +192,7 @@ def time_get_loc(self):
 
 class IntervalIndexMethod:
     # GH 24813
-    params = [10 ** 3, 10 ** 5]
+    params = [10**3, 10**5]
 
     def setup(self, N):
         left = np.append(np.arange(N), np.array(0))
diff --git a/asv_bench/benchmarks/indexing.py b/asv_bench/benchmarks/indexing.py
index 58f2a73d82842..54da7c109e02a 100644
--- a/asv_bench/benchmarks/indexing.py
+++ b/asv_bench/benchmarks/indexing.py
@@ -13,7 +13,6 @@
     CategoricalIndex,
     DataFrame,
     Float64Index,
-    IndexSlice,
     Int64Index,
     IntervalIndex,
     MultiIndex,
@@ -37,7 +36,7 @@ class NumericSeriesIndexing:
     param_names = ["index_dtype", "index_structure"]
 
     def setup(self, index, index_structure):
-        N = 10 ** 6
+        N = 10**6
         indices = {
             "unique_monotonic_inc": index(range(N)),
             "nonunique_monotonic_inc": index(
@@ -97,7 +96,7 @@ class NonNumericSeriesIndexing:
     param_names = ["index_dtype", "index_structure"]
 
     def setup(self, index, index_structure):
-        N = 10 ** 6
+        N = 10**6
         if index == "string":
             index = tm.makeStringIndex(N)
         elif index == "datetime":
@@ -144,6 +143,12 @@ def setup(self):
     def time_loc(self):
         self.df.loc[self.idx_scalar, self.col_scalar]
 
+    def time_at(self):
+        self.df.at[self.idx_scalar, self.col_scalar]
+
+    def time_at_setitem(self):
+        self.df.at[self.idx_scalar, self.col_scalar] = 0.0
+
     def time_getitem_scalar(self):
         self.df[self.col_scalar][self.idx_scalar]
 
@@ -158,25 +163,39 @@ def time_boolean_rows_boolean(self):
 
 
 class DataFrameNumericIndexing:
-    def setup(self):
+
+    params = [
+        (Int64Index, UInt64Index, Float64Index),
+        ("unique_monotonic_inc", "nonunique_monotonic_inc"),
+    ]
+    param_names = ["index_dtype", "index_structure"]
+
+    def setup(self, index, index_structure):
+        N = 10**5
+        indices = {
+            "unique_monotonic_inc": index(range(N)),
+            "nonunique_monotonic_inc": index(
+                list(range(55)) + [54] + list(range(55, N - 1))
+            ),
+        }
         self.idx_dupe = np.array(range(30)) * 99
-        self.df = DataFrame(np.random.randn(100000, 5))
+        self.df = DataFrame(np.random.randn(N, 5), index=indices[index_structure])
         self.df_dup = concat([self.df, 2 * self.df, 3 * self.df])
-        self.bool_indexer = [True] * 50000 + [False] * 50000
+        self.bool_indexer = [True] * (N // 2) + [False] * (N - N // 2)
 
-    def time_iloc_dups(self):
+    def time_iloc_dups(self, index, index_structure):
         self.df_dup.iloc[self.idx_dupe]
 
-    def time_loc_dups(self):
+    def time_loc_dups(self, index, index_structure):
         self.df_dup.loc[self.idx_dupe]
 
-    def time_iloc(self):
+    def time_iloc(self, index, index_structure):
         self.df.iloc[:100, 0]
 
-    def time_loc(self):
+    def time_loc(self, index, index_structure):
         self.df.loc[:100, 0]
 
-    def time_bool_indexer(self):
+    def time_bool_indexer(self, index, index_structure):
         self.df[self.bool_indexer]
 
 
@@ -200,28 +219,81 @@ def time_take(self, index):
 
 
 class MultiIndexing:
-    def setup(self):
-        mi = MultiIndex.from_product([range(1000), range(1000)])
-        self.s = Series(np.random.randn(1000000), index=mi)
-        self.df = DataFrame(self.s)
 
-        n = 100000
-        with warnings.catch_warnings(record=True):
-            self.mdt = DataFrame(
-                {
-                    "A": np.random.choice(range(10000, 45000, 1000), n),
-                    "B": np.random.choice(range(10, 400), n),
-                    "C": np.random.choice(range(1, 150), n),
-                    "D": np.random.choice(range(10000, 45000), n),
-                    "x": np.random.choice(range(400), n),
-                    "y": np.random.choice(range(25), n),
-                }
-            )
-        self.idx = IndexSlice[20000:30000, 20:30, 35:45, 30000:40000]
-        self.mdt = self.mdt.set_index(["A", "B", "C", "D"]).sort_index()
+    params = [True, False]
+    param_names = ["unique_levels"]
+
+    def setup(self, unique_levels):
+        self.nlevels = 2
+        if unique_levels:
+            mi = MultiIndex.from_arrays([range(1000000)] * self.nlevels)
+        else:
+            mi = MultiIndex.from_product([range(1000)] * self.nlevels)
+        self.df = DataFrame(np.random.randn(len(mi)), index=mi)
+
+        self.tgt_slice = slice(200, 800)
+        self.tgt_null_slice = slice(None)
+        self.tgt_list = list(range(0, 1000, 10))
+        self.tgt_scalar = 500
 
-    def time_index_slice(self):
-        self.mdt.loc[self.idx, :]
+        bool_indexer = np.zeros(len(mi), dtype=np.bool_)
+        bool_indexer[slice(0, len(mi), 100)] = True
+        self.tgt_bool_indexer = bool_indexer
+
+    def time_loc_partial_key_slice(self, unique_levels):
+        self.df.loc[self.tgt_slice, :]
+
+    def time_loc_partial_key_null_slice(self, unique_levels):
+        self.df.loc[self.tgt_null_slice, :]
+
+    def time_loc_partial_key_list(self, unique_levels):
+        self.df.loc[self.tgt_list, :]
+
+    def time_loc_partial_key_scalar(self, unique_levels):
+        self.df.loc[self.tgt_scalar, :]
+
+    def time_loc_partial_key_bool_indexer(self, unique_levels):
+        self.df.loc[self.tgt_bool_indexer, :]
+
+    def time_loc_all_slices(self, unique_levels):
+        target = tuple([self.tgt_slice] * self.nlevels)
+        self.df.loc[target, :]
+
+    def time_loc_all_null_slices(self, unique_levels):
+        target = tuple([self.tgt_null_slice] * self.nlevels)
+        self.df.loc[target, :]
+
+    def time_loc_all_lists(self, unique_levels):
+        target = tuple([self.tgt_list] * self.nlevels)
+        self.df.loc[target, :]
+
+    def time_loc_all_scalars(self, unique_levels):
+        target = tuple([self.tgt_scalar] * self.nlevels)
+        self.df.loc[target, :]
+
+    def time_loc_all_bool_indexers(self, unique_levels):
+        target = tuple([self.tgt_bool_indexer] * self.nlevels)
+        self.df.loc[target, :]
+
+    def time_loc_slice_plus_null_slice(self, unique_levels):
+        target = (self.tgt_slice, self.tgt_null_slice)
+        self.df.loc[target, :]
+
+    def time_loc_null_slice_plus_slice(self, unique_levels):
+        target = (self.tgt_null_slice, self.tgt_slice)
+        self.df.loc[target, :]
+
+    def time_xs_level_0(self, unique_levels):
+        target = self.tgt_scalar
+        self.df.xs(target, level=0)
+
+    def time_xs_level_1(self, unique_levels):
+        target = self.tgt_scalar
+        self.df.xs(target, level=1)
+
+    def time_xs_full_key(self, unique_levels):
+        target = tuple([self.tgt_scalar] * self.nlevels)
+        self.df.xs(target)
 
 
 class IntervalIndexing:
@@ -257,13 +329,31 @@ def time_get_indexer_mismatched_tz(self):
         self.dti.get_indexer(self.dti2)
 
 
+class SortedAndUnsortedDatetimeIndexLoc:
+    def setup(self):
+        dti = date_range("2016-01-01", periods=10000, tz="US/Pacific")
+        index = np.array(dti)
+
+        unsorted_index = index.copy()
+        unsorted_index[10] = unsorted_index[20]
+
+        self.df_unsorted = DataFrame(index=unsorted_index, data={"a": 1})
+        self.df_sort = DataFrame(index=index, data={"a": 1})
+
+    def time_loc_unsorted(self):
+        self.df_unsorted.loc["2016-6-11"]
+
+    def time_loc_sorted(self):
+        self.df_sort.loc["2016-6-11"]
+
+
 class CategoricalIndexIndexing:
 
     params = ["monotonic_incr", "monotonic_decr", "non_monotonic"]
     param_names = ["index"]
 
     def setup(self, index):
-        N = 10 ** 5
+        N = 10**5
         values = list("a" * N + "b" * N + "c" * N)
         indices = {
             "monotonic_incr": CategoricalIndex(values),
@@ -332,7 +422,7 @@ class IndexSingleRow:
     param_names = ["unique_cols"]
 
     def setup(self, unique_cols):
-        arr = np.arange(10 ** 7).reshape(-1, 10)
+        arr = np.arange(10**7).reshape(-1, 10)
         df = DataFrame(arr)
         dtypes = ["u1", "u2", "u4", "u8", "i1", "i2", "i4", "i8", "f8", "f4"]
         for i, d in enumerate(dtypes):
@@ -364,7 +454,7 @@ def time_frame_assign_timeseries_index(self):
 
 class InsertColumns:
     def setup(self):
-        self.N = 10 ** 3
+        self.N = 10**3
         self.df = DataFrame(index=range(self.N))
         self.df2 = DataFrame(np.random.randn(self.N, 2))
 
diff --git a/asv_bench/benchmarks/indexing_engines.py b/asv_bench/benchmarks/indexing_engines.py
index 60e07a9d1469c..0c6cb89f49da1 100644
--- a/asv_bench/benchmarks/indexing_engines.py
+++ b/asv_bench/benchmarks/indexing_engines.py
@@ -36,7 +36,7 @@ class NumericEngineIndexing:
         _get_numeric_engines(),
         ["monotonic_incr", "monotonic_decr", "non_monotonic"],
         [True, False],
-        [10 ** 5, 2 * 10 ** 6],  # 2e6 is above SIZE_CUTOFF
+        [10**5, 2 * 10**6],  # 2e6 is above SIZE_CUTOFF
     ]
     param_names = ["engine_and_dtype", "index_type", "unique", "N"]
 
@@ -86,7 +86,7 @@ class ObjectEngineIndexing:
     param_names = ["index_type"]
 
     def setup(self, index_type):
-        N = 10 ** 5
+        N = 10**5
         values = list("a" * N + "b" * N + "c" * N)
         arr = {
             "monotonic_incr": np.array(values, dtype=object),
diff --git a/asv_bench/benchmarks/inference.py b/asv_bench/benchmarks/inference.py
index a5a7bc5b5c8bd..0bbb599f2b045 100644
--- a/asv_bench/benchmarks/inference.py
+++ b/asv_bench/benchmarks/inference.py
@@ -85,8 +85,8 @@ class MaybeConvertNumeric:
     #  go in benchmarks/libs.py
 
     def setup_cache(self):
-        N = 10 ** 6
-        arr = np.repeat([2 ** 63], N) + np.arange(N).astype("uint64")
+        N = 10**6
+        arr = np.repeat([2**63], N) + np.arange(N).astype("uint64")
         data = arr.astype(object)
         data[1::2] = arr[1::2].astype(str)
         data[-1] = -1
@@ -101,7 +101,7 @@ class MaybeConvertObjects:
     #  does have some run-time imports from outside of _libs
 
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
 
         data = list(range(N))
         data[0] = NaT
diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index 0b443b29116a2..10aef954a3475 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -266,8 +266,8 @@ def time_skipprows(self, skiprows, engine):
 
 class ReadUint64Integers(StringIORewind):
     def setup(self):
-        self.na_values = [2 ** 63 + 500]
-        arr = np.arange(10000).astype("uint64") + 2 ** 63
+        self.na_values = [2**63 + 500]
+        arr = np.arange(10000).astype("uint64") + 2**63
         self.data1 = StringIO("\n".join(arr.astype(str).tolist()))
         arr = arr.astype(object)
         arr[500] = -1
diff --git a/asv_bench/benchmarks/io/excel.py b/asv_bench/benchmarks/io/excel.py
index 3363b43f29b78..a88c4374b7030 100644
--- a/asv_bench/benchmarks/io/excel.py
+++ b/asv_bench/benchmarks/io/excel.py
@@ -47,6 +47,25 @@ def time_write_excel(self, engine):
         writer.save()
 
 
+class WriteExcelStyled:
+    params = ["openpyxl", "xlsxwriter"]
+    param_names = ["engine"]
+
+    def setup(self, engine):
+        self.df = _generate_dataframe()
+
+    def time_write_excel_style(self, engine):
+        bio = BytesIO()
+        bio.seek(0)
+        writer = ExcelWriter(bio, engine=engine)
+        df_style = self.df.style
+        df_style.applymap(lambda x: "border: red 1px solid;")
+        df_style.applymap(lambda x: "color: blue")
+        df_style.applymap(lambda x: "border-color: green black", subset=["float1"])
+        df_style.to_excel(writer, sheet_name="Sheet1")
+        writer.save()
+
+
 class ReadExcel:
 
     params = ["xlrd", "openpyxl", "odf"]
@@ -86,4 +105,15 @@ def time_read_excel(self, engine):
         read_excel(fname, engine=engine)
 
 
+class ReadExcelNRows(ReadExcel):
+    def time_read_excel(self, engine):
+        if engine == "xlrd":
+            fname = self.fname_excel_xls
+        elif engine == "odf":
+            fname = self.fname_odf
+        else:
+            fname = self.fname_excel
+        read_excel(fname, engine=engine, nrows=10)
+
+
 from ..pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/io/json.py b/asv_bench/benchmarks/io/json.py
index d1468a238c491..bb09fe0ff634d 100644
--- a/asv_bench/benchmarks/io/json.py
+++ b/asv_bench/benchmarks/io/json.py
@@ -109,7 +109,7 @@ class ToJSON(BaseIO):
     param_names = ["orient", "frame"]
 
     def setup(self, orient, frame):
-        N = 10 ** 5
+        N = 10**5
         ncols = 5
         index = date_range("20000101", periods=N, freq="H")
         timedeltas = timedelta_range(start=1, periods=N, freq="s")
@@ -193,7 +193,7 @@ class ToJSONISO(BaseIO):
     param_names = ["orient"]
 
     def setup(self, orient):
-        N = 10 ** 5
+        N = 10**5
         index = date_range("20000101", periods=N, freq="H")
         timedeltas = timedelta_range(start=1, periods=N, freq="s")
         datetimes = date_range(start=1, periods=N, freq="s")
@@ -216,7 +216,7 @@ class ToJSONLines(BaseIO):
     fname = "__test__.json"
 
     def setup(self):
-        N = 10 ** 5
+        N = 10**5
         ncols = 5
         index = date_range("20000101", periods=N, freq="H")
         timedeltas = timedelta_range(start=1, periods=N, freq="s")
diff --git a/asv_bench/benchmarks/io/sql.py b/asv_bench/benchmarks/io/sql.py
index 3cfa28de78c90..fb8b7dafa0ade 100644
--- a/asv_bench/benchmarks/io/sql.py
+++ b/asv_bench/benchmarks/io/sql.py
@@ -39,6 +39,8 @@ def setup(self, connection):
             index=tm.makeStringIndex(N),
         )
         self.df.loc[1000:3000, "float_with_nan"] = np.nan
+        self.df["date"] = self.df["datetime"].dt.date
+        self.df["time"] = self.df["datetime"].dt.time
         self.df["datetime_string"] = self.df["datetime"].astype(str)
         self.df.to_sql(self.table_name, self.con, if_exists="replace")
 
@@ -53,7 +55,16 @@ class WriteSQLDtypes:
 
     params = (
         ["sqlalchemy", "sqlite"],
-        ["float", "float_with_nan", "string", "bool", "int", "datetime"],
+        [
+            "float",
+            "float_with_nan",
+            "string",
+            "bool",
+            "int",
+            "date",
+            "time",
+            "datetime",
+        ],
     )
     param_names = ["connection", "dtype"]
 
@@ -78,6 +89,8 @@ def setup(self, connection, dtype):
             index=tm.makeStringIndex(N),
         )
         self.df.loc[1000:3000, "float_with_nan"] = np.nan
+        self.df["date"] = self.df["datetime"].dt.date
+        self.df["time"] = self.df["datetime"].dt.time
         self.df["datetime_string"] = self.df["datetime"].astype(str)
         self.df.to_sql(self.table_name, self.con, if_exists="replace")
 
@@ -105,6 +118,8 @@ def setup(self):
             index=tm.makeStringIndex(N),
         )
         self.df.loc[1000:3000, "float_with_nan"] = np.nan
+        self.df["date"] = self.df["datetime"].dt.date
+        self.df["time"] = self.df["datetime"].dt.time
         self.df["datetime_string"] = self.df["datetime"].astype(str)
         self.df.to_sql(self.table_name, self.con, if_exists="replace")
 
@@ -122,7 +137,16 @@ def time_read_sql_table_parse_dates(self):
 
 class ReadSQLTableDtypes:
 
-    params = ["float", "float_with_nan", "string", "bool", "int", "datetime"]
+    params = [
+        "float",
+        "float_with_nan",
+        "string",
+        "bool",
+        "int",
+        "date",
+        "time",
+        "datetime",
+    ]
     param_names = ["dtype"]
 
     def setup(self, dtype):
@@ -141,6 +165,8 @@ def setup(self, dtype):
             index=tm.makeStringIndex(N),
         )
         self.df.loc[1000:3000, "float_with_nan"] = np.nan
+        self.df["date"] = self.df["datetime"].dt.date
+        self.df["time"] = self.df["datetime"].dt.time
         self.df["datetime_string"] = self.df["datetime"].astype(str)
         self.df.to_sql(self.table_name, self.con, if_exists="replace")
 
diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py
index ad40adc75c567..e3c6bf9bd4e07 100644
--- a/asv_bench/benchmarks/join_merge.py
+++ b/asv_bench/benchmarks/join_merge.py
@@ -158,6 +158,19 @@ def time_left_outer_join_index(self):
         self.left.join(self.right, on="jim")
 
 
+class JoinEmpty:
+    def setup(self):
+        N = 100_000
+        self.df = DataFrame({"A": np.arange(N)})
+        self.df_empty = DataFrame(columns=["B", "C"], dtype="int64")
+
+    def time_inner_join_left_empty(self):
+        self.df_empty.join(self.df, how="inner")
+
+    def time_inner_join_right_empty(self):
+        self.df.join(self.df_empty, how="inner")
+
+
 class JoinNonUnique:
     # outer join of non-unique
     # GH 6329
@@ -216,6 +229,12 @@ def time_merge_dataframe_integer_2key(self, sort):
     def time_merge_dataframe_integer_key(self, sort):
         merge(self.df, self.df2, on="key1", sort=sort)
 
+    def time_merge_dataframe_empty_right(self, sort):
+        merge(self.left, self.right.iloc[:0], sort=sort)
+
+    def time_merge_dataframe_empty_left(self, sort):
+        merge(self.left.iloc[:0], self.right, sort=sort)
+
     def time_merge_dataframes_cross(self, sort):
         merge(self.left.loc[:2000], self.right.loc[:2000], how="cross", sort=sort)
 
@@ -226,7 +245,7 @@ class I8Merge:
     param_names = ["how"]
 
     def setup(self, how):
-        low, high, n = -1000, 1000, 10 ** 6
+        low, high, n = -1000, 1000, 10**6
         self.left = DataFrame(
             np.random.randint(low, high, (n, 7)), columns=list("ABCDEFG")
         )
@@ -394,8 +413,8 @@ def time_multiby(self, direction, tolerance):
 
 class Align:
     def setup(self):
-        size = 5 * 10 ** 5
-        rng = np.arange(0, 10 ** 13, 10 ** 7)
+        size = 5 * 10**5
+        rng = np.arange(0, 10**13, 10**7)
         stamps = np.datetime64("now").view("i8") + rng
         idx1 = np.sort(np.random.choice(stamps, size, replace=False))
         idx2 = np.sort(np.random.choice(stamps, size, replace=False))
diff --git a/asv_bench/benchmarks/libs.py b/asv_bench/benchmarks/libs.py
index 4e3f938a33eb1..f041499c9c622 100644
--- a/asv_bench/benchmarks/libs.py
+++ b/asv_bench/benchmarks/libs.py
@@ -2,7 +2,7 @@
 Benchmarks for code in pandas/_libs, excluding pandas/_libs/tslibs,
 which has its own directory.
 
-If a PR does not edit anything in _libs/, then it is unlikely that thes
+If a PR does not edit anything in _libs/, then it is unlikely that the
 benchmarks will be affected.
 """
 import numpy as np
diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index 25df5b0214959..a498c6b2e4944 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -47,6 +47,29 @@ def time_small_get_loc_warm(self):
             self.mi_small.get_loc((99, "A", "A"))
 
 
+class GetLocs:
+    def setup(self):
+        self.mi_large = MultiIndex.from_product(
+            [np.arange(1000), np.arange(20), list(string.ascii_letters)],
+            names=["one", "two", "three"],
+        )
+        self.mi_med = MultiIndex.from_product(
+            [np.arange(1000), np.arange(10), list("A")], names=["one", "two", "three"]
+        )
+        self.mi_small = MultiIndex.from_product(
+            [np.arange(100), list("A"), list("A")], names=["one", "two", "three"]
+        )
+
+    def time_large_get_locs(self):
+        self.mi_large.get_locs([999, 19, "Z"])
+
+    def time_med_get_locs(self):
+        self.mi_med.get_locs([999, 9, "A"])
+
+    def time_small_get_locs(self):
+        self.mi_small.get_locs([99, "A", "A"])
+
+
 class Duplicates:
     def setup(self):
         size = 65536
@@ -112,7 +135,7 @@ def time_get_indexer_and_pad(self):
         self.mi_int.get_indexer(self.other_mi_many_mismatches, method="pad")
 
     def time_is_monotonic(self):
-        self.mi_int.is_monotonic
+        self.mi_int.is_monotonic_increasing
 
 
 class Duplicated:
@@ -203,7 +226,7 @@ class SetOperations:
     param_names = ["index_structure", "dtype", "method"]
 
     def setup(self, index_structure, dtype, method):
-        N = 10 ** 5
+        N = 10**5
         level1 = range(1000)
 
         level2 = date_range(start="1/1/2000", periods=N // 1000)
diff --git a/asv_bench/benchmarks/plotting.py b/asv_bench/benchmarks/plotting.py
index 249a8f3f556a1..789bb8d8533b1 100644
--- a/asv_bench/benchmarks/plotting.py
+++ b/asv_bench/benchmarks/plotting.py
@@ -1,9 +1,14 @@
-import importlib
+import contextlib
+import importlib.machinery
+import importlib.util
+import os
+import pathlib
 import sys
+import tempfile
+from unittest import mock
 
 import matplotlib
 import numpy as np
-import pkg_resources
 
 from pandas import (
     DataFrame,
@@ -111,22 +116,49 @@ class BackendLoading:
     warmup_time = 0
 
     def setup(self):
-        dist = pkg_resources.get_distribution("pandas")
-        spec = importlib.machinery.ModuleSpec("my_backend", None)
-        mod = importlib.util.module_from_spec(spec)
+        mod = importlib.util.module_from_spec(
+            importlib.machinery.ModuleSpec("pandas_dummy_backend", None)
+        )
         mod.plot = lambda *args, **kwargs: 1
 
-        backends = pkg_resources.get_entry_map("pandas")
-        my_entrypoint = pkg_resources.EntryPoint(
-            "pandas_plotting_backend", mod.__name__, dist=dist
-        )
-        backends["pandas_plotting_backends"][mod.__name__] = my_entrypoint
-        for i in range(10):
-            backends["pandas_plotting_backends"][str(i)] = my_entrypoint
-        sys.modules["my_backend"] = mod
+        with contextlib.ExitStack() as stack:
+            stack.enter_context(
+                mock.patch.dict(sys.modules, {"pandas_dummy_backend": mod})
+            )
+            tmp_path = pathlib.Path(stack.enter_context(tempfile.TemporaryDirectory()))
+
+            sys.path.insert(0, os.fsdecode(tmp_path))
+            stack.callback(sys.path.remove, os.fsdecode(tmp_path))
+
+            dist_info = tmp_path / "my_backend-0.0.0.dist-info"
+            dist_info.mkdir()
+            (dist_info / "entry_points.txt").write_bytes(
+                b"[pandas_plotting_backends]\n"
+                b"my_ep_backend = pandas_dummy_backend\n"
+                b"my_ep_backend0 = pandas_dummy_backend\n"
+                b"my_ep_backend1 = pandas_dummy_backend\n"
+                b"my_ep_backend2 = pandas_dummy_backend\n"
+                b"my_ep_backend3 = pandas_dummy_backend\n"
+                b"my_ep_backend4 = pandas_dummy_backend\n"
+                b"my_ep_backend5 = pandas_dummy_backend\n"
+                b"my_ep_backend6 = pandas_dummy_backend\n"
+                b"my_ep_backend7 = pandas_dummy_backend\n"
+                b"my_ep_backend8 = pandas_dummy_backend\n"
+                b"my_ep_backend9 = pandas_dummy_backend\n"
+            )
+            self.stack = stack.pop_all()
+
+    def teardown(self):
+        self.stack.close()
 
     def time_get_plot_backend(self):
-        _get_plot_backend("my_backend")
+        # finds the first my_ep_backend
+        _get_plot_backend("my_ep_backend")
+
+    def time_get_plot_backend_fallback(self):
+        # iterates through all the my_ep_backend[0-9] before falling back
+        # to importlib.import_module
+        _get_plot_backend("pandas_dummy_backend")
 
 
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/reindex.py b/asv_bench/benchmarks/reindex.py
index 5181b983c9f7a..29d2831be1522 100644
--- a/asv_bench/benchmarks/reindex.py
+++ b/asv_bench/benchmarks/reindex.py
@@ -28,6 +28,11 @@ def setup(self):
         index = MultiIndex.from_arrays([level1, level2])
         self.s = Series(np.random.randn(N * K), index=index)
         self.s_subset = self.s[::2]
+        self.s_subset_no_cache = self.s[::2].copy()
+
+        mi = MultiIndex.from_product([rng, range(100)])
+        self.s2 = Series(np.random.randn(len(mi)), index=mi)
+        self.s2_subset = self.s2[::2].copy()
 
     def time_reindex_dates(self):
         self.df.reindex(self.rng_subset)
@@ -35,9 +40,18 @@ def time_reindex_dates(self):
     def time_reindex_columns(self):
         self.df2.reindex(columns=self.df.columns[1:5])
 
-    def time_reindex_multiindex(self):
+    def time_reindex_multiindex_with_cache(self):
+        # MultiIndex._values gets cached
         self.s.reindex(self.s_subset.index)
 
+    def time_reindex_multiindex_no_cache(self):
+        # Copy to avoid MultiIndex._values getting cached
+        self.s.reindex(self.s_subset_no_cache.index.copy())
+
+    def time_reindex_multiindex_no_cache_dates(self):
+        # Copy to avoid MultiIndex._values getting cached
+        self.s2_subset.reindex(self.s2.index.copy())
+
 
 class ReindexMethod:
 
diff --git a/asv_bench/benchmarks/replace.py b/asv_bench/benchmarks/replace.py
index 2a115fb0b4fe3..8d4fc0240f2cc 100644
--- a/asv_bench/benchmarks/replace.py
+++ b/asv_bench/benchmarks/replace.py
@@ -9,7 +9,7 @@ class FillNa:
     param_names = ["inplace"]
 
     def setup(self, inplace):
-        N = 10 ** 6
+        N = 10**6
         rng = pd.date_range("1/1/2000", periods=N, freq="min")
         data = np.random.randn(N)
         data[::2] = np.nan
@@ -28,10 +28,10 @@ class ReplaceDict:
     param_names = ["inplace"]
 
     def setup(self, inplace):
-        N = 10 ** 5
-        start_value = 10 ** 5
+        N = 10**5
+        start_value = 10**5
         self.to_rep = dict(enumerate(np.arange(N) + start_value))
-        self.s = pd.Series(np.random.randint(N, size=10 ** 3))
+        self.s = pd.Series(np.random.randint(N, size=10**3))
 
     def time_replace_series(self, inplace):
         self.s.replace(self.to_rep, inplace=inplace)
@@ -44,13 +44,13 @@ class ReplaceList:
     param_names = ["inplace"]
 
     def setup(self, inplace):
-        self.df = pd.DataFrame({"A": 0, "B": 0}, index=range(4 * 10 ** 7))
+        self.df = pd.DataFrame({"A": 0, "B": 0}, index=range(4 * 10**7))
 
     def time_replace_list(self, inplace):
         self.df.replace([np.inf, -np.inf], np.nan, inplace=inplace)
 
     def time_replace_list_one_match(self, inplace):
-        # the 1 can be held in self._df.blocks[0], while the inf and -inf cant
+        # the 1 can be held in self._df.blocks[0], while the inf and -inf can't
         self.df.replace([np.inf, -np.inf, 1], np.nan, inplace=inplace)
 
 
@@ -60,7 +60,7 @@ class Convert:
     param_names = ["constructor", "replace_data"]
 
     def setup(self, constructor, replace_data):
-        N = 10 ** 3
+        N = 10**3
         data = {
             "Series": pd.Series(np.random.randint(N, size=N)),
             "DataFrame": pd.DataFrame(
diff --git a/asv_bench/benchmarks/reshape.py b/asv_bench/benchmarks/reshape.py
index c83cd9a925f6d..05e12630d7540 100644
--- a/asv_bench/benchmarks/reshape.py
+++ b/asv_bench/benchmarks/reshape.py
@@ -78,7 +78,7 @@ def time_stack(self, dtype):
         self.df.stack()
 
     def time_unstack_fast(self, dtype):
-        # last level -> doesnt have to make copies
+        # last level -> doesn't have to make copies
         self.ser.unstack("bar")
 
     def time_unstack_slow(self, dtype):
@@ -259,7 +259,7 @@ class Cut:
     param_names = ["bins"]
 
     def setup(self, bins):
-        N = 10 ** 5
+        N = 10**5
         self.int_series = pd.Series(np.arange(N).repeat(5))
         self.float_series = pd.Series(np.random.randn(N).repeat(5))
         self.timedelta_series = pd.Series(
diff --git a/asv_bench/benchmarks/rolling.py b/asv_bench/benchmarks/rolling.py
index 1c53d4adc8c25..d65a1a39e8bc7 100644
--- a/asv_bench/benchmarks/rolling.py
+++ b/asv_bench/benchmarks/rolling.py
@@ -16,7 +16,7 @@ class Methods:
     param_names = ["constructor", "window_kwargs", "dtype", "method"]
 
     def setup(self, constructor, window_kwargs, dtype, method):
-        N = 10 ** 5
+        N = 10**5
         window, kwargs = window_kwargs
         arr = (100 * np.random.random(N)).astype(dtype)
         obj = getattr(pd, constructor)(arr)
@@ -40,7 +40,7 @@ class Apply:
     param_names = ["constructor", "window", "dtype", "function", "raw"]
 
     def setup(self, constructor, window, dtype, function, raw):
-        N = 10 ** 3
+        N = 10**3
         arr = (100 * np.random.random(N)).astype(dtype)
         self.roll = getattr(pd, constructor)(arr).rolling(window)
 
@@ -67,7 +67,7 @@ class NumbaEngineMethods:
     ]
 
     def setup(self, constructor, dtype, window_kwargs, method, parallel, cols):
-        N = 10 ** 3
+        N = 10**3
         window, kwargs = window_kwargs
         shape = (N, cols) if cols is not None and constructor != "Series" else N
         arr = (100 * np.random.random(shape)).astype(dtype)
@@ -107,7 +107,7 @@ class NumbaEngineApply:
     ]
 
     def setup(self, constructor, dtype, window_kwargs, function, parallel, cols):
-        N = 10 ** 3
+        N = 10**3
         window, kwargs = window_kwargs
         shape = (N, cols) if cols is not None and constructor != "Series" else N
         arr = (100 * np.random.random(shape)).astype(dtype)
@@ -140,7 +140,7 @@ class EWMMethods:
             (
                 {
                     "halflife": "1 Day",
-                    "times": pd.date_range("1900", periods=10 ** 5, freq="23s"),
+                    "times": pd.date_range("1900", periods=10**5, freq="23s"),
                 },
                 "mean",
             ),
@@ -150,7 +150,7 @@ class EWMMethods:
     param_names = ["constructor", "kwargs_method", "dtype"]
 
     def setup(self, constructor, kwargs_method, dtype):
-        N = 10 ** 5
+        N = 10**5
         kwargs, method = kwargs_method
         arr = (100 * np.random.random(N)).astype(dtype)
         self.method = method
@@ -170,7 +170,7 @@ class VariableWindowMethods(Methods):
     param_names = ["constructor", "window", "dtype", "method"]
 
     def setup(self, constructor, window, dtype, method):
-        N = 10 ** 5
+        N = 10**5
         arr = (100 * np.random.random(N)).astype(dtype)
         index = pd.date_range("2017-01-01", periods=N, freq="5s")
         self.window = getattr(pd, constructor)(arr, index=index).rolling(window)
@@ -186,7 +186,7 @@ class Pairwise:
     param_names = ["window_kwargs", "method", "pairwise"]
 
     def setup(self, kwargs_window, method, pairwise):
-        N = 10 ** 4
+        N = 10**4
         n_groups = 20
         kwargs, window = kwargs_window
         groups = [i for _ in range(N // n_groups) for i in range(n_groups)]
@@ -215,7 +215,7 @@ class Quantile:
     param_names = ["constructor", "window", "dtype", "percentile"]
 
     def setup(self, constructor, window, dtype, percentile, interpolation):
-        N = 10 ** 5
+        N = 10**5
         arr = np.random.random(N).astype(dtype)
         self.roll = getattr(pd, constructor)(arr).rolling(window)
 
@@ -242,7 +242,7 @@ class Rank:
     ]
 
     def setup(self, constructor, window, dtype, percentile, ascending, method):
-        N = 10 ** 5
+        N = 10**5
         arr = np.random.random(N).astype(dtype)
         self.roll = getattr(pd, constructor)(arr).rolling(window)
 
@@ -255,7 +255,7 @@ class PeakMemFixedWindowMinMax:
     params = ["min", "max"]
 
     def setup(self, operation):
-        N = 10 ** 6
+        N = 10**6
         arr = np.random.random(N)
         self.roll = pd.Series(arr).rolling(2)
 
@@ -274,7 +274,7 @@ class ForwardWindowMethods:
     param_names = ["constructor", "window_size", "dtype", "method"]
 
     def setup(self, constructor, window_size, dtype, method):
-        N = 10 ** 5
+        N = 10**5
         arr = np.random.random(N).astype(dtype)
         indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=window_size)
         self.roll = getattr(pd, constructor)(arr).rolling(window=indexer)
diff --git a/asv_bench/benchmarks/series_methods.py b/asv_bench/benchmarks/series_methods.py
index d8578ed604ae3..09c318af76159 100644
--- a/asv_bench/benchmarks/series_methods.py
+++ b/asv_bench/benchmarks/series_methods.py
@@ -3,6 +3,7 @@
 import numpy as np
 
 from pandas import (
+    Index,
     NaT,
     Series,
     date_range,
@@ -12,27 +13,30 @@
 
 
 class SeriesConstructor:
-
-    params = [None, "dict"]
-    param_names = ["data"]
-
-    def setup(self, data):
+    def setup(self):
         self.idx = date_range(
             start=datetime(2015, 10, 26), end=datetime(2016, 1, 1), freq="50s"
         )
-        dict_data = dict(zip(self.idx, range(len(self.idx))))
-        self.data = None if data is None else dict_data
+        self.data = dict(zip(self.idx, range(len(self.idx))))
+        self.array = np.array([1, 2, 3])
+        self.idx2 = Index(["a", "b", "c"])
 
-    def time_constructor(self, data):
+    def time_constructor_dict(self):
         Series(data=self.data, index=self.idx)
 
+    def time_constructor_no_data(self):
+        Series(data=None, index=self.idx)
+
+    def time_constructor_fastpath(self):
+        Series(self.array, index=self.idx2, name="name", fastpath=True)
+
 
 class ToFrame:
     params = [["int64", "datetime64[ns]", "category", "Int64"], [None, "foo"]]
     param_names = ["dtype", "name"]
 
     def setup(self, dtype, name):
-        arr = np.arange(10 ** 5)
+        arr = np.arange(10**5)
         ser = Series(arr, dtype=dtype)
         self.ser = ser
 
@@ -61,7 +65,7 @@ class Dropna:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        N = 10 ** 6
+        N = 10**6
         data = {
             "int": np.random.randint(1, 10, N),
             "datetime": date_range("2000-01-01", freq="S", periods=N),
@@ -94,7 +98,7 @@ class SearchSorted:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        N = 10 ** 5
+        N = 10**5
         data = np.array([1] * N + [2] * N + [3] * N).astype(dtype)
         self.s = Series(data)
 
@@ -130,7 +134,7 @@ def time_map(self, mapper, *args, **kwargs):
 
 
 class Clip:
-    params = [50, 1000, 10 ** 5]
+    params = [50, 1000, 10**5]
     param_names = ["n"]
 
     def setup(self, n):
@@ -140,9 +144,19 @@ def time_clip(self, n):
         self.s.clip(0, 1)
 
 
+class ClipDt:
+    def setup(self):
+        dr = date_range("20220101", periods=100_000, freq="s", tz="UTC")
+        self.clipper_dt = dr[0:1_000].repeat(100)
+        self.s = Series(dr)
+
+    def time_clip(self):
+        self.s.clip(upper=self.clipper_dt)
+
+
 class ValueCounts:
 
-    params = [[10 ** 3, 10 ** 4, 10 ** 5], ["int", "uint", "float", "object"]]
+    params = [[10**3, 10**4, 10**5], ["int", "uint", "float", "object"]]
     param_names = ["N", "dtype"]
 
     def setup(self, N, dtype):
@@ -154,7 +168,7 @@ def time_value_counts(self, N, dtype):
 
 class ValueCountsObjectDropNAFalse:
 
-    params = [10 ** 3, 10 ** 4, 10 ** 5]
+    params = [10**3, 10**4, 10**5]
     param_names = ["N"]
 
     def setup(self, N):
@@ -166,7 +180,7 @@ def time_value_counts(self, N):
 
 class Mode:
 
-    params = [[10 ** 3, 10 ** 4, 10 ** 5], ["int", "uint", "float", "object"]]
+    params = [[10**3, 10**4, 10**5], ["int", "uint", "float", "object"]]
     param_names = ["N", "dtype"]
 
     def setup(self, N, dtype):
@@ -178,7 +192,7 @@ def time_mode(self, N, dtype):
 
 class ModeObjectDropNAFalse:
 
-    params = [10 ** 3, 10 ** 4, 10 ** 5]
+    params = [10**3, 10**4, 10**5]
     param_names = ["N"]
 
     def setup(self, N):
@@ -199,7 +213,7 @@ def time_dir_strings(self):
 class SeriesGetattr:
     # https://github.com/pandas-dev/pandas/issues/19764
     def setup(self):
-        self.s = Series(1, index=date_range("2012-01-01", freq="s", periods=10 ** 6))
+        self.s = Series(1, index=date_range("2012-01-01", freq="s", periods=10**6))
 
     def time_series_datetimeindex_repr(self):
         getattr(self.s, "a", None)
@@ -207,7 +221,7 @@ def time_series_datetimeindex_repr(self):
 
 class All:
 
-    params = [[10 ** 3, 10 ** 6], ["fast", "slow"], ["bool", "boolean"]]
+    params = [[10**3, 10**6], ["fast", "slow"], ["bool", "boolean"]]
     param_names = ["N", "case", "dtype"]
 
     def setup(self, N, case, dtype):
@@ -220,7 +234,7 @@ def time_all(self, N, case, dtype):
 
 class Any:
 
-    params = [[10 ** 3, 10 ** 6], ["fast", "slow"], ["bool", "boolean"]]
+    params = [[10**3, 10**6], ["fast", "slow"], ["bool", "boolean"]]
     param_names = ["N", "case", "dtype"]
 
     def setup(self, N, case, dtype):
@@ -248,7 +262,7 @@ class NanOps:
             "kurt",
             "prod",
         ],
-        [10 ** 3, 10 ** 6],
+        [10**3, 10**6],
         ["int8", "int32", "int64", "float64", "Int64", "boolean"],
     ]
     param_names = ["func", "N", "dtype"]
diff --git a/asv_bench/benchmarks/sparse.py b/asv_bench/benchmarks/sparse.py
index ec704896f5726..10390cb4493cd 100644
--- a/asv_bench/benchmarks/sparse.py
+++ b/asv_bench/benchmarks/sparse.py
@@ -40,7 +40,7 @@ class SparseArrayConstructor:
     param_names = ["dense_proportion", "fill_value", "dtype"]
 
     def setup(self, dense_proportion, fill_value, dtype):
-        N = 10 ** 6
+        N = 10**6
         self.array = make_array(N, dense_proportion, fill_value, dtype)
 
     def time_sparse_array(self, dense_proportion, fill_value, dtype):
@@ -111,7 +111,7 @@ class Arithmetic:
     param_names = ["dense_proportion", "fill_value"]
 
     def setup(self, dense_proportion, fill_value):
-        N = 10 ** 6
+        N = 10**6
         arr1 = make_array(N, dense_proportion, fill_value, np.int64)
         self.array1 = SparseArray(arr1, fill_value=fill_value)
         arr2 = make_array(N, dense_proportion, fill_value, np.int64)
@@ -136,7 +136,7 @@ class ArithmeticBlock:
     param_names = ["fill_value"]
 
     def setup(self, fill_value):
-        N = 10 ** 6
+        N = 10**6
         self.arr1 = self.make_block_array(
             length=N, num_blocks=1000, block_size=10, fill_value=fill_value
         )
@@ -146,10 +146,10 @@ def setup(self, fill_value):
 
     def make_block_array(self, length, num_blocks, block_size, fill_value):
         arr = np.full(length, fill_value)
-        indicies = np.random.choice(
+        indices = np.random.choice(
             np.arange(0, length, block_size), num_blocks, replace=False
         )
-        for ind in indicies:
+        for ind in indices:
             arr[ind : ind + block_size] = np.random.randint(0, 100, block_size)
         return SparseArray(arr, fill_value=fill_value)
 
@@ -219,12 +219,12 @@ def setup(self, fill_value):
         d = 1e-5
         arr = make_array(N, d, np.nan, np.float64)
         self.sp_arr = SparseArray(arr)
-        b_arr = np.full(shape=N, fill_value=fill_value, dtype=np.bool8)
+        b_arr = np.full(shape=N, fill_value=fill_value, dtype=np.bool_)
         fv_inds = np.unique(
             np.random.randint(low=0, high=N - 1, size=int(N * d), dtype=np.int32)
         )
         b_arr[fv_inds] = True if pd.isna(fill_value) else not fill_value
-        self.sp_b_arr = SparseArray(b_arr, dtype=np.bool8, fill_value=fill_value)
+        self.sp_b_arr = SparseArray(b_arr, dtype=np.bool_, fill_value=fill_value)
 
     def time_mask(self, fill_value):
         self.sp_arr[self.sp_b_arr]
diff --git a/asv_bench/benchmarks/stat_ops.py b/asv_bench/benchmarks/stat_ops.py
index 5639d6702a92c..92a78b7c2f63d 100644
--- a/asv_bench/benchmarks/stat_ops.py
+++ b/asv_bench/benchmarks/stat_ops.py
@@ -83,7 +83,7 @@ class Rank:
     param_names = ["constructor", "pct"]
 
     def setup(self, constructor, pct):
-        values = np.random.randn(10 ** 5)
+        values = np.random.randn(10**5)
         self.data = getattr(pd, constructor)(values)
 
     def time_rank(self, constructor, pct):
diff --git a/asv_bench/benchmarks/strftime.py b/asv_bench/benchmarks/strftime.py
new file mode 100644
index 0000000000000..ac1b7f65d2d90
--- /dev/null
+++ b/asv_bench/benchmarks/strftime.py
@@ -0,0 +1,64 @@
+import numpy as np
+
+import pandas as pd
+from pandas import offsets
+
+
+class DatetimeStrftime:
+    timeout = 1500
+    params = [1000, 10000]
+    param_names = ["obs"]
+
+    def setup(self, obs):
+        d = "2018-11-29"
+        dt = "2018-11-26 11:18:27.0"
+        self.data = pd.DataFrame(
+            {
+                "dt": [np.datetime64(dt)] * obs,
+                "d": [np.datetime64(d)] * obs,
+                "r": [np.random.uniform()] * obs,
+            }
+        )
+
+    def time_frame_date_to_str(self, obs):
+        self.data["d"].astype(str)
+
+    def time_frame_date_formatting_default(self, obs):
+        self.data["d"].dt.strftime(date_format="%Y-%m-%d")
+
+    def time_frame_date_formatting_custom(self, obs):
+        self.data["d"].dt.strftime(date_format="%Y---%m---%d")
+
+    def time_frame_datetime_to_str(self, obs):
+        self.data["dt"].astype(str)
+
+    def time_frame_datetime_formatting_default_date_only(self, obs):
+        self.data["dt"].dt.strftime(date_format="%Y-%m-%d")
+
+    def time_frame_datetime_formatting_default(self, obs):
+        self.data["dt"].dt.strftime(date_format="%Y-%m-%d %H:%M:%S")
+
+    def time_frame_datetime_formatting_default_with_float(self, obs):
+        self.data["dt"].dt.strftime(date_format="%Y-%m-%d %H:%M:%S.%f")
+
+    def time_frame_datetime_formatting_custom(self, obs):
+        self.data["dt"].dt.strftime(date_format="%Y-%m-%d --- %H:%M:%S")
+
+
+class BusinessHourStrftime:
+    timeout = 1500
+    params = [1000, 10000]
+    param_names = ["obs"]
+
+    def setup(self, obs):
+        self.data = pd.DataFrame(
+            {
+                "off": [offsets.BusinessHour()] * obs,
+            }
+        )
+
+    def time_frame_offset_str(self, obs):
+        self.data["off"].apply(str)
+
+    def time_frame_offset_repr(self, obs):
+        self.data["off"].apply(repr)
diff --git a/asv_bench/benchmarks/strings.py b/asv_bench/benchmarks/strings.py
index 32fbf4e6c7de3..eec722c9f167b 100644
--- a/asv_bench/benchmarks/strings.py
+++ b/asv_bench/benchmarks/strings.py
@@ -3,10 +3,12 @@
 import numpy as np
 
 from pandas import (
+    NA,
     Categorical,
     DataFrame,
     Series,
 )
+from pandas.arrays import StringArray
 
 from .pandas_vb_common import tm
 
@@ -17,7 +19,7 @@ class Dtypes:
 
     def setup(self, dtype):
         try:
-            self.s = Series(tm.makeStringIndex(10 ** 5), dtype=dtype)
+            self.s = Series(tm.makeStringIndex(10**5), dtype=dtype)
         except ImportError:
             raise NotImplementedError
 
@@ -28,7 +30,7 @@ class Construction:
     param_names = ["dtype"]
 
     def setup(self, dtype):
-        self.series_arr = tm.rands_array(nchars=10, size=10 ** 5)
+        self.series_arr = tm.rands_array(nchars=10, size=10**5)
         self.frame_arr = self.series_arr.reshape((50_000, 2)).copy()
 
         # GH37371. Testing construction of string series/frames from ExtensionArrays
@@ -180,7 +182,7 @@ class Repeat:
     param_names = ["repeats"]
 
     def setup(self, repeats):
-        N = 10 ** 5
+        N = 10**5
         self.s = Series(tm.makeStringIndex(N))
         repeat = {"int": 1, "array": np.random.randint(1, 3, N)}
         self.values = repeat[repeats]
@@ -195,7 +197,7 @@ class Cat:
     param_names = ["other_cols", "sep", "na_rep", "na_frac"]
 
     def setup(self, other_cols, sep, na_rep, na_frac):
-        N = 10 ** 5
+        N = 10**5
         mask_gen = lambda: np.random.choice([True, False], N, p=[1 - na_frac, na_frac])
         self.s = Series(tm.makeStringIndex(N)).where(mask_gen())
         if other_cols == 0:
@@ -266,7 +268,7 @@ def time_get_dummies(self, dtype):
 
 class Encode:
     def setup(self):
-        self.ser = Series(tm.makeUnicodeIndex())
+        self.ser = Series(tm.makeStringIndex())
 
     def time_encode_decode(self):
         self.ser.str.encode("utf-8").str.decode("utf-8")
@@ -285,3 +287,18 @@ class Iter(Dtypes):
     def time_iter(self, dtype):
         for i in self.s:
             pass
+
+
+class StringArrayConstruction:
+    def setup(self):
+        self.series_arr = tm.rands_array(nchars=10, size=10**5)
+        self.series_arr_nan = np.concatenate([self.series_arr, np.array([NA] * 1000)])
+
+    def time_string_array_construction(self):
+        StringArray(self.series_arr)
+
+    def time_string_array_with_nan_construction(self):
+        StringArray(self.series_arr_nan)
+
+    def peakmem_stringarray_construction(self):
+        StringArray(self.series_arr)
diff --git a/asv_bench/benchmarks/timeseries.py b/asv_bench/benchmarks/timeseries.py
index 5b123c7127c28..9373edadb8e90 100644
--- a/asv_bench/benchmarks/timeseries.py
+++ b/asv_bench/benchmarks/timeseries.py
@@ -131,7 +131,7 @@ class Iteration:
     param_names = ["time_index"]
 
     def setup(self, time_index):
-        N = 10 ** 6
+        N = 10**6
         if time_index is timedelta_range:
             self.idx = time_index(start=0, freq="T", periods=N)
         else:
@@ -247,7 +247,7 @@ class SortIndex:
     param_names = ["monotonic"]
 
     def setup(self, monotonic):
-        N = 10 ** 5
+        N = 10**5
         idx = date_range(start="1/1/2000", periods=N, freq="s")
         self.s = Series(np.random.randn(N), index=idx)
         if not monotonic:
diff --git a/asv_bench/benchmarks/tslibs/normalize.py b/asv_bench/benchmarks/tslibs/normalize.py
index f5f7adbf63995..b263ae21422b6 100644
--- a/asv_bench/benchmarks/tslibs/normalize.py
+++ b/asv_bench/benchmarks/tslibs/normalize.py
@@ -31,13 +31,15 @@ def setup(self, size, tz):
         dti = pd.date_range("2016-01-01", periods=10, tz=tz).repeat(size // 10)
         self.i8data = dti.asi8
 
-        if size == 10 ** 6 and tz is tzlocal_obj:
+        if size == 10**6 and tz is tzlocal_obj:
             # tzlocal is cumbersomely slow, so skip to keep runtime in check
             raise NotImplementedError
 
     def time_normalize_i8_timestamps(self, size, tz):
-        normalize_i8_timestamps(self.i8data, tz)
+        # 10 i.e. NPY_FR_ns
+        normalize_i8_timestamps(self.i8data, tz, 10)
 
     def time_is_date_array_normalized(self, size, tz):
         # TODO: cases with different levels of short-circuiting
-        is_date_array_normalized(self.i8data, tz)
+        # 10 i.e. NPY_FR_ns
+        is_date_array_normalized(self.i8data, tz, 10)
diff --git a/asv_bench/benchmarks/tslibs/offsets.py b/asv_bench/benchmarks/tslibs/offsets.py
index 0aea8332398b1..978a36e470cbb 100644
--- a/asv_bench/benchmarks/tslibs/offsets.py
+++ b/asv_bench/benchmarks/tslibs/offsets.py
@@ -14,7 +14,7 @@
     pass
 
 hcal = pandas.tseries.holiday.USFederalHolidayCalendar()
-# These offsets currently raise a NotImplimentedError with .apply_index()
+# These offsets currently raise a NotImplementedError with .apply_index()
 non_apply = [
     offsets.Day(),
     offsets.BYearEnd(),
diff --git a/asv_bench/benchmarks/tslibs/period.py b/asv_bench/benchmarks/tslibs/period.py
index 15a922da7ee76..af10102749627 100644
--- a/asv_bench/benchmarks/tslibs/period.py
+++ b/asv_bench/benchmarks/tslibs/period.py
@@ -1,6 +1,6 @@
 """
-Period benchmarks that rely only on tslibs.  See benchmarks.period for
-Period benchmarks that rely on other parts fo pandas.
+Period benchmarks that rely only on tslibs. See benchmarks.period for
+Period benchmarks that rely on other parts of pandas.
 """
 
 import numpy as np
@@ -130,7 +130,7 @@ class TimeDT64ArrToPeriodArr:
     param_names = ["size", "freq", "tz"]
 
     def setup(self, size, freq, tz):
-        if size == 10 ** 6 and tz is tzlocal_obj:
+        if size == 10**6 and tz is tzlocal_obj:
             # tzlocal is cumbersomely slow, so skip to keep runtime in check
             raise NotImplementedError
 
diff --git a/asv_bench/benchmarks/tslibs/resolution.py b/asv_bench/benchmarks/tslibs/resolution.py
index 4b52efc188bf4..44f288c7de216 100644
--- a/asv_bench/benchmarks/tslibs/resolution.py
+++ b/asv_bench/benchmarks/tslibs/resolution.py
@@ -40,7 +40,7 @@ class TimeResolution:
     param_names = ["unit", "size", "tz"]
 
     def setup(self, unit, size, tz):
-        if size == 10 ** 6 and tz is tzlocal_obj:
+        if size == 10**6 and tz is tzlocal_obj:
             # tzlocal is cumbersomely slow, so skip to keep runtime in check
             raise NotImplementedError
 
diff --git a/asv_bench/benchmarks/tslibs/timedelta.py b/asv_bench/benchmarks/tslibs/timedelta.py
index 6ed273281569b..2daf1861eb80a 100644
--- a/asv_bench/benchmarks/tslibs/timedelta.py
+++ b/asv_bench/benchmarks/tslibs/timedelta.py
@@ -1,6 +1,6 @@
 """
-Timedelta benchmarks that rely only on tslibs.  See benchmarks.timedeltas for
-Timedelta benchmarks that rely on other parts fo pandas.
+Timedelta benchmarks that rely only on tslibs. See benchmarks.timedeltas for
+Timedelta benchmarks that rely on other parts of pandas.
 """
 import datetime
 
diff --git a/asv_bench/benchmarks/tslibs/tslib.py b/asv_bench/benchmarks/tslibs/tslib.py
index 180f95e7fbda5..f93ef1cef841f 100644
--- a/asv_bench/benchmarks/tslibs/tslib.py
+++ b/asv_bench/benchmarks/tslibs/tslib.py
@@ -41,7 +41,7 @@
     gettz("Asia/Tokyo"),
     tzlocal_obj,
 ]
-_sizes = [0, 1, 100, 10 ** 4, 10 ** 6]
+_sizes = [0, 1, 100, 10**4, 10**6]
 
 
 class TimeIntsToPydatetime:
@@ -57,7 +57,7 @@ def setup(self, box, size, tz):
         if box == "date" and tz is not None:
             # tz is ignored, so avoid running redundant benchmarks
             raise NotImplementedError  # skip benchmark
-        if size == 10 ** 6 and tz is _tzs[-1]:
+        if size == 10**6 and tz is _tzs[-1]:
             # This is cumbersomely-slow, so skip to trim runtime
             raise NotImplementedError  # skip benchmark
 
diff --git a/asv_bench/benchmarks/tslibs/tz_convert.py b/asv_bench/benchmarks/tslibs/tz_convert.py
index 793f43e9bbe35..c6b510efdca69 100644
--- a/asv_bench/benchmarks/tslibs/tz_convert.py
+++ b/asv_bench/benchmarks/tslibs/tz_convert.py
@@ -11,10 +11,14 @@
 
 try:
     old_sig = False
-    from pandas._libs.tslibs.tzconversion import tz_convert_from_utc
+    from pandas._libs.tslibs import tz_convert_from_utc
 except ImportError:
-    old_sig = True
-    from pandas._libs.tslibs.tzconversion import tz_convert as tz_convert_from_utc
+    try:
+        old_sig = False
+        from pandas._libs.tslibs.tzconversion import tz_convert_from_utc
+    except ImportError:
+        old_sig = True
+        from pandas._libs.tslibs.tzconversion import tz_convert as tz_convert_from_utc
 
 
 class TimeTZConvert:
@@ -25,7 +29,7 @@ class TimeTZConvert:
     param_names = ["size", "tz"]
 
     def setup(self, size, tz):
-        if size == 10 ** 6 and tz is tzlocal_obj:
+        if size == 10**6 and tz is tzlocal_obj:
             # tzlocal is cumbersomely slow, so skip to keep runtime in check
             raise NotImplementedError
 
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
deleted file mode 100644
index ac91dcac4d2d8..0000000000000
--- a/azure-pipelines.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-# Adapted from https://github.com/numba/numba/blob/master/azure-pipelines.yml
-trigger:
-  branches:
-    include:
-    - master
-    - 1.3.x
-  paths:
-    exclude:
-    - 'doc/*'
-
-pr:
-  autoCancel: true
-  branches:
-    include:
-    - master
-    - 1.3.x
-
-variables:
-  PYTEST_WORKERS: auto
-  PYTEST_TARGET:  pandas
-
-jobs:
-# Mac and Linux use the same template
-- template: ci/azure/posix.yml
-  parameters:
-    name: macOS
-    vmImage: macOS-10.15
-
-- template: ci/azure/windows.yml
-  parameters:
-    name: Windows
-    vmImage: windows-2019
-
-- job: py38_32bit
-  pool:
-    vmImage: ubuntu-18.04
-
-  steps:
-    # TODO: GH#44980 https://github.com/pypa/setuptools/issues/2941
-    - script: |
-        docker pull quay.io/pypa/manylinux2014_i686
-        docker run -v $(pwd):/pandas quay.io/pypa/manylinux2014_i686 \
-        /bin/bash -xc "cd pandas && \
-        /opt/python/cp38-cp38/bin/python -m venv ~/virtualenvs/pandas-dev && \
-        . ~/virtualenvs/pandas-dev/bin/activate && \
-        python -m pip install --no-deps -U pip wheel 'setuptools<60.0.0' && \
-        pip install cython numpy python-dateutil pytz pytest pytest-xdist hypothesis pytest-azurepipelines && \
-        python setup.py build_ext -q -j2 && \
-        python -m pip install --no-build-isolation -e . && \
-        pytest -m 'not slow and not network and not clipboard' pandas --junitxml=test-data.xml"
-      displayName: 'Run 32-bit manylinux2014 Docker Build / Tests'
-
-    - task: PublishTestResults@2
-      condition: succeededOrFailed()
-      inputs:
-        testResultsFiles: '**/test-*.xml'
-        failTaskOnFailedTests: true
-        testRunTitle: 'Publish test results for Python 3.8-32 bit full Linux'
diff --git a/ci/azure/posix.yml b/ci/azure/posix.yml
deleted file mode 100644
index b7c36bb87353b..0000000000000
--- a/ci/azure/posix.yml
+++ /dev/null
@@ -1,48 +0,0 @@
-parameters:
-  name: ''
-  vmImage: ''
-
-jobs:
-- job: ${{ parameters.name }}
-  pool:
-    vmImage: ${{ parameters.vmImage }}
-  strategy:
-    matrix:
-      py38_macos_1:
-        ENV_FILE: ci/deps/azure-macos-38.yaml
-        CONDA_PY: "38"
-        PATTERN: "not slow"
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-      py38_macos_2:
-        ENV_FILE: ci/deps/azure-macos-38.yaml
-        CONDA_PY: "38"
-        PATTERN: "not slow"
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
-
-  steps:
-    - script: echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
-      displayName: 'Set conda path'
-
-    - script: ci/setup_env.sh
-      displayName: 'Setup environment and build pandas'
-
-    - script: |
-        source activate pandas-dev
-        ci/run_tests.sh
-      displayName: 'Test'
-
-    - script: source activate pandas-dev && pushd /tmp && python -c "import pandas; pandas.show_versions();" && popd
-      displayName: 'Build versions'
-
-    - task: PublishTestResults@2
-      condition: succeededOrFailed()
-      inputs:
-        failTaskOnFailedTests: true
-        testResultsFiles: 'test-data.xml'
-        testRunTitle: ${{ format('{0}-$(CONDA_PY)', parameters.name) }}
-      displayName: 'Publish test results'
-
-    - script: |
-        source activate pandas-dev
-        python ci/print_skipped.py
-      displayName: 'Print skipped tests'
diff --git a/ci/azure/windows.yml b/ci/azure/windows.yml
deleted file mode 100644
index 7f3efb5a4dbf3..0000000000000
--- a/ci/azure/windows.yml
+++ /dev/null
@@ -1,72 +0,0 @@
-parameters:
-  name: ''
-  vmImage: ''
-
-jobs:
-- job: ${{ parameters.name }}
-  pool:
-    vmImage: ${{ parameters.vmImage }}
-  strategy:
-    matrix:
-      py38_np18_1:
-        ENV_FILE: ci/deps/azure-windows-38.yaml
-        CONDA_PY: "38"
-        PATTERN: "not slow"
-        PYTEST_WORKERS: 2  # GH-42236
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-
-      py38_np18_2:
-        ENV_FILE: ci/deps/azure-windows-38.yaml
-        CONDA_PY: "38"
-        PATTERN: "not slow"
-        PYTEST_WORKERS: 2  # GH-42236
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
-
-      py39_1:
-        ENV_FILE: ci/deps/azure-windows-39.yaml
-        CONDA_PY: "39"
-        PATTERN: "not slow and not high_memory"
-        PYTEST_WORKERS: 2  # GH-42236
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-
-      py39_2:
-        ENV_FILE: ci/deps/azure-windows-39.yaml
-        CONDA_PY: "39"
-        PATTERN: "not slow and not high_memory"
-        PYTEST_WORKERS: 2  # GH-42236
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
-
-  steps:
-    - powershell: |
-        Write-Host "##vso[task.prependpath]$env:CONDA\Scripts"
-        Write-Host "##vso[task.prependpath]$HOME/miniconda3/bin"
-      displayName: 'Add conda to PATH'
-    - script: conda update -q -n base conda
-      displayName: 'Update conda'
-
-    - bash: |
-        conda env create -q --file ci\\deps\\azure-windows-$(CONDA_PY).yaml
-      displayName: 'Create anaconda environment'
-    - bash: |
-        source activate pandas-dev
-        conda list
-        python setup.py build_ext -q -j 4
-        python -m pip install --no-build-isolation -e .
-      displayName: 'Build'
-    - bash: |
-        source activate pandas-dev
-        wmic.exe cpu get caption, deviceid, name, numberofcores, maxclockspeed
-        ci/run_tests.sh
-      displayName: 'Test'
-    - task: PublishTestResults@2
-      condition: succeededOrFailed()
-      inputs:
-        failTaskOnFailedTests: true
-        testResultsFiles: 'test-data.xml'
-        testRunTitle: ${{ format('{0}-$(CONDA_PY)', parameters.name) }}
-      displayName: 'Publish test results'
-
-    - bash: |
-        source activate pandas-dev
-        python ci/print_skipped.py
-      displayName: 'Print skipped tests'
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 4498585e36ce5..113186c746157 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -11,10 +11,10 @@
 #   $ ./ci/code_checks.sh code          # checks on imported code
 #   $ ./ci/code_checks.sh doctests      # run doctests
 #   $ ./ci/code_checks.sh docstrings    # validate docstring errors
-#   $ ./ci/code_checks.sh typing        # run static type analysis
+#   $ ./ci/code_checks.sh single-docs   # check single-page docs build warning-free
 
-[[ -z "$1" || "$1" == "code" || "$1" == "doctests" || "$1" == "docstrings" || "$1" == "typing" ]] || \
-    { echo "Unknown command $1. Usage: $0 [code|doctests|docstrings|typing]"; exit 9999; }
+[[ -z "$1" || "$1" == "code" || "$1" == "doctests" || "$1" == "docstrings" || "$1" == "single-docs" ]] || \
+    { echo "Unknown command $1. Usage: $0 [code|doctests|docstrings]"; exit 9999; }
 
 BASE_DIR="$(dirname $0)/.."
 RET=0
@@ -78,28 +78,17 @@ fi
 ### DOCSTRINGS ###
 if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
 
-    MSG='Validate docstrings (GL01, GL02, GL03, GL04, GL05, GL06, GL07, GL09, GL10, SS01, SS02, SS03, SS04, SS05, PR03, PR04, PR05, PR06, PR08, PR09, PR10, EX04, RT01, RT04, RT05, SA02, SA03)' ; echo $MSG
-    $BASE_DIR/scripts/validate_docstrings.py --format=actions --errors=GL01,GL02,GL03,GL04,GL05,GL06,GL07,GL09,GL10,SS02,SS03,SS04,SS05,PR03,PR04,PR05,PR06,PR08,PR09,PR10,EX04,RT01,RT04,RT05,SA02,SA03
+    MSG='Validate docstrings (EX04, GL01, GL02, GL03, GL04, GL05, GL06, GL07, GL09, GL10, PR03, PR04, PR05, PR06, PR08, PR09, PR10, RT01, RT04, RT05, SA02, SA03, SA04, SS01, SS02, SS03, SS04, SS05, SS06)' ; echo $MSG
+    $BASE_DIR/scripts/validate_docstrings.py --format=actions --errors=EX04,GL01,GL02,GL03,GL04,GL05,GL06,GL07,GL09,GL10,PR03,PR04,PR05,PR06,PR08,PR09,PR10,RT01,RT04,RT05,SA02,SA03,SA04,SS01,SS02,SS03,SS04,SS05,SS06
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
 fi
 
-### TYPING ###
-if [[ -z "$CHECK" || "$CHECK" == "typing" ]]; then
-
-    echo "mypy --version"
-    mypy --version
-
-    MSG='Performing static analysis using mypy' ; echo $MSG
-    mypy
-    RET=$(($RET + $?)) ; echo $MSG "DONE"
-
-    # run pyright, if it is installed
-    if command -v pyright &> /dev/null ; then
-        MSG='Performing static analysis using pyright' ; echo $MSG
-        pyright
-        RET=$(($RET + $?)) ; echo $MSG "DONE"
-    fi
+### SINGLE-PAGE DOCS ###
+if [[ -z "$CHECK" || "$CHECK" == "single-docs" ]]; then
+    python doc/make.py --warnings-are-errors --single pandas.Series.value_counts
+    python doc/make.py --warnings-are-errors --single pandas.Series.str.split
+    python doc/make.py clean
 fi
 
 exit $RET
diff --git a/ci/condarc.yml b/ci/condarc.yml
new file mode 100644
index 0000000000000..9d750b7102c39
--- /dev/null
+++ b/ci/condarc.yml
@@ -0,0 +1,32 @@
+# https://docs.conda.io/projects/conda/en/latest/configuration.html
+
+# always_yes (NoneType, bool)
+#   aliases: yes
+#   Automatically choose the 'yes' option whenever asked to proceed with a
+#   conda operation, such as when running `conda install`.
+#
+always_yes: true
+
+# remote_connect_timeout_secs (float)
+#   The number seconds conda will wait for your client to establish a
+#   connection to a remote url resource.
+#
+remote_connect_timeout_secs: 30.0
+
+# remote_max_retries (int)
+#   The maximum number of retries each HTTP connection should attempt.
+#
+remote_max_retries: 10
+
+# remote_backoff_factor (int)
+#   The factor determines the time HTTP connection should wait for
+#   attempt.
+#
+remote_backoff_factor: 3
+
+# remote_read_timeout_secs (float)
+#   Once conda has connected to a remote resource and sent an HTTP
+#   request, the read timeout is the number of seconds conda will wait for
+#   the server to send a response.
+#
+remote_read_timeout_secs: 60.0
diff --git a/ci/deps/actions-39-numpydev.yaml b/ci/deps/actions-310-numpydev.yaml
similarity index 85%
rename from ci/deps/actions-39-numpydev.yaml
rename to ci/deps/actions-310-numpydev.yaml
index 4a6acf55e265f..ef20c2aa889b9 100644
--- a/ci/deps/actions-39-numpydev.yaml
+++ b/ci/deps/actions-310-numpydev.yaml
@@ -2,20 +2,21 @@ name: pandas-dev
 channels:
   - defaults
 dependencies:
-  - python=3.9
+  - python=3.10
 
   # tools
   - pytest>=6.0
   - pytest-cov
   - pytest-xdist>=1.31
   - hypothesis>=5.5.3
+  - pytest-asyncio>=0.17
 
   # pandas dependencies
   - python-dateutil
   - pytz
   - pip
   - pip:
-    - cython==0.29.24 # GH#34014
+    - "cython"
     - "--extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple"
     - "--pre"
     - "numpy"
diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
new file mode 100644
index 0000000000000..deb23d435bddf
--- /dev/null
+++ b/ci/deps/actions-310.yaml
@@ -0,0 +1,55 @@
+name: pandas-dev
+channels:
+  - conda-forge
+dependencies:
+  - python=3.10
+
+  # test dependencies
+  - cython>=0.29.32
+  - pytest>=6.0
+  - pytest-cov
+  - pytest-xdist>=1.31
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
+
+  # required dependencies
+  - python-dateutil
+  - numpy
+  - pytz
+
+  # optional dependencies
+  - beautifulsoup4
+  - blosc
+  - bottleneck
+  - brotlipy
+  - fastparquet
+  - fsspec
+  - html5lib
+  - hypothesis
+  - gcsfs
+  - jinja2
+  - lxml
+  - matplotlib>=3.6.1
+  - numba
+  - numexpr
+  - openpyxl
+  - odfpy
+  - pandas-gbq
+  - psycopg2
+  - pymysql
+  - pytables
+  - pyarrow<10
+  - pyreadstat
+  - python-snappy
+  - pyxlsb
+  - s3fs>=2021.08.0
+  - scipy
+  - sqlalchemy<1.4.46
+  - tabulate
+  - tzdata>=2022a
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - zstandard
diff --git a/ci/deps/actions-38-downstream_compat.yaml b/ci/deps/actions-38-downstream_compat.yaml
index af4f7dee851d5..06ffafeb70570 100644
--- a/ci/deps/actions-38-downstream_compat.yaml
+++ b/ci/deps/actions-38-downstream_compat.yaml
@@ -4,63 +4,68 @@ channels:
   - conda-forge
 dependencies:
   - python=3.8
-  - pip
 
   # test dependencies
-  - cython>=0.29.24
+  - cython>=0.29.32
   - pytest>=6.0
+  - pytest-cov
   - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-  - pytest-cov>=2.10.1  # this is only needed in the coverage build, ref: GH 35737
-  - nomkl
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
 
   # required dependencies
-  - numpy
   - python-dateutil
+  - numpy
   - pytz
 
   # optional dependencies
   - beautifulsoup4
   - blosc
-  - fastparquet>=0.4.0
-  - fsspec>=0.7.4
-  - gcsfs
+  - brotlipy
+  - bottleneck
+  - fastparquet
+  - fsspec
   - html5lib
+  - hypothesis
+  - gcsfs
   - jinja2
   - lxml
-  - matplotlib
+  - matplotlib>=3.6.1
+  - numba
   - numexpr
-  - odfpy
   - openpyxl
+  - odfpy
   - pandas-gbq
   - psycopg2
-  - pyarrow>=1.0.1
+  - pyarrow<10
   - pymysql
+  - pyreadstat
   - pytables
+  - python-snappy
   - pyxlsb
-  - s3fs>=0.4.0
+  - s3fs>=2021.08.0
   - scipy
-  - sqlalchemy
+  - sqlalchemy<1.4.46
+  - tabulate
   - xarray
   - xlrd
   - xlsxwriter
   - xlwt
+  - zstandard
 
   # downstream packages
-  - aiobotocore<2.0.0  # GH#44311 pinned to fix docbuild
-  - boto3
-  - botocore>=1.11
+  - aiobotocore
+  - botocore
+  - cftime
   - dask
   - ipython
-  - geopandas
-  - python-snappy
+  - geopandas-base
   - seaborn
   - scikit-learn
   - statsmodels
-  - brotlipy
   - coverage
   - pandas-datareader
   - pyyaml
   - py
-  - pip:
-    - torch
+  - pytorch
diff --git a/ci/deps/actions-38-locale.yaml b/ci/deps/actions-38-locale.yaml
deleted file mode 100644
index ef2288e2a24a6..0000000000000
--- a/ci/deps/actions-38-locale.yaml
+++ /dev/null
@@ -1,36 +0,0 @@
-name: pandas-dev
-channels:
-  - conda-forge
-dependencies:
-  - python=3.8
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-cov
-  - pytest-xdist>=1.31
-  - pytest-asyncio>=0.12.0
-  - hypothesis>=5.5.3
-
-  # pandas dependencies
-  - beautifulsoup4
-  - html5lib
-  - ipython
-  - jinja2
-  - jedi
-  - lxml
-  - matplotlib
-  - nomkl
-  - numexpr
-  - numpy<1.20  # GH#39541 compat with pyarrow<3
-  - openpyxl
-  - pytables
-  - python-dateutil
-  - pytz
-  - scipy
-  - xarray
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - pyarrow=1.0.1
-  - pyxlsb
diff --git a/ci/deps/actions-38-locale_slow.yaml b/ci/deps/actions-38-locale_slow.yaml
deleted file mode 100644
index b16153398163b..0000000000000
--- a/ci/deps/actions-38-locale_slow.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-name: pandas-dev
-channels:
-  - defaults
-  - conda-forge
-dependencies:
-  - python=3.8
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-cov
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-
-  # pandas dependencies
-  - beautifulsoup4
-  - bottleneck
-  - lxml
-  - matplotlib
-  - numpy
-  - openpyxl
-  - python-dateutil
-  - python-blosc
-  - pytz=2020.1
-  - scipy
-  - sqlalchemy
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - html5lib
diff --git a/ci/deps/actions-38-minimum_versions.yaml b/ci/deps/actions-38-minimum_versions.yaml
index 8505dad542239..fd23080c2ab04 100644
--- a/ci/deps/actions-38-minimum_versions.yaml
+++ b/ci/deps/actions-38-minimum_versions.yaml
@@ -7,46 +7,51 @@ dependencies:
   - python=3.8.0
 
   # test dependencies
-  - cython=0.29.24
+  - cython>=0.29.32
   - pytest>=6.0
   - pytest-cov
   - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
   - psutil
+  - pytest-asyncio>=0.17
+  - boto3
 
   # required dependencies
   - python-dateutil=2.8.1
-  - numpy=1.18.5
+  - numpy=1.20.3
   - pytz=2020.1
 
   # optional dependencies
-  - beautifulsoup4=4.8.2
-  - blosc=1.20.1
-  - bottleneck=1.3.1
+  - beautifulsoup4=4.9.3
+  - blosc=1.21.0
+  - bottleneck=1.3.2
+  - brotlipy=0.7.0
   - fastparquet=0.4.0
-  - fsspec=0.7.4
+  - fsspec=2021.07.0
   - html5lib=1.1
-  - gcsfs=0.6.0
-  - jinja2=2.11
-  - lxml=4.5.0
+  - hypothesis=6.13.0
+  - gcsfs=2021.07.0
+  - jinja2=3.0.0
+  - lxml=4.6.3
   - matplotlib=3.3.2
-  - numba=0.50.1
-  - numexpr=2.7.1
-  - openpyxl=3.0.3
+  - numba=0.53.1
+  - numexpr=2.7.3
   - odfpy=1.4.1
-  - pandas-gbq=0.14.0
-  - psycopg2=2.8.4
-  - pymysql=0.10.1
-  - pytables=3.6.1
+  - openpyxl=3.0.7
+  - pandas-gbq=0.15.0
+  - psycopg2=2.8.6
   - pyarrow=1.0.1
-  - pyreadstat
-  - pyxlsb=1.0.6
-  - s3fs=0.4.0
-  - scipy=1.4.1
-  - sqlalchemy=1.4.0
-  - tabulate=0.8.7
-  - xarray=0.15.1
+  - pymysql=1.0.2
+  - pyreadstat=1.1.2
+  - pytables=3.6.1
+  - python-snappy=0.6.0
+  - pyxlsb=1.0.8
+  - s3fs=2021.08.0
+  - scipy=1.7.1
+  - sqlalchemy=1.4.16
+  - tabulate=0.8.9
+  - tzdata=2022a
+  - xarray=0.19.0
   - xlrd=2.0.1
-  - xlsxwriter=1.2.2
+  - xlsxwriter=1.4.3
   - xlwt=1.3.0
   - zstandard=0.15.2
diff --git a/ci/deps/actions-38-slow.yaml b/ci/deps/actions-38-slow.yaml
deleted file mode 100644
index 5b3ff947aef8a..0000000000000
--- a/ci/deps/actions-38-slow.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-name: pandas-dev
-channels:
-  - conda-forge
-dependencies:
-  - python=3.8
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-cov
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-
-  # pandas dependencies
-  - beautifulsoup4
-  - boto3
-  - fsspec>=0.7.4
-  - html5lib
-  - lxml
-  - matplotlib
-  - numexpr
-  - numpy
-  - openpyxl
-  - patsy
-  - psycopg2
-  - pymysql
-  - pytables
-  - python-dateutil
-  - pytz
-  - s3fs>=0.4.0
-  - scipy
-  - sqlalchemy
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - numba
-  - zstandard
diff --git a/ci/deps/actions-38.yaml b/ci/deps/actions-38.yaml
index 2ad31ce82b855..222da40ea9eea 100644
--- a/ci/deps/actions-38.yaml
+++ b/ci/deps/actions-38.yaml
@@ -1,20 +1,54 @@
 name: pandas-dev
 channels:
-  - defaults
   - conda-forge
 dependencies:
   - python=3.8
 
-  # tools
-  - cython>=0.29.24
+  # test dependencies
+  - cython>=0.29.32
   - pytest>=6.0
   - pytest-cov
   - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
 
-  # pandas dependencies
-  - numpy
+  # required dependencies
   - python-dateutil
-  - nomkl
+  - numpy
   - pytz
+
+  # optional dependencies
+  - beautifulsoup4
+  - blosc
+  - bottleneck
+  - brotlipy
+  - fastparquet
+  - fsspec
+  - html5lib
+  - hypothesis
+  - gcsfs
+  - jinja2
+  - lxml
+  - matplotlib>=3.6.1
+  - numba
+  - numexpr
+  - openpyxl
+  - odfpy
+  - pandas-gbq
+  - psycopg2
+  - pyarrow<10
+  - pymysql
+  - pyreadstat
+  - pytables
+  - python-snappy
+  - pyxlsb
+  - s3fs>=2021.08.0
+  - scipy
+  - sqlalchemy<1.4.46
   - tabulate
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - zstandard
diff --git a/ci/deps/actions-39-slow.yaml b/ci/deps/actions-39-slow.yaml
deleted file mode 100644
index e0b85b0331933..0000000000000
--- a/ci/deps/actions-39-slow.yaml
+++ /dev/null
@@ -1,41 +0,0 @@
-name: pandas-dev
-channels:
-  - defaults
-  - conda-forge
-dependencies:
-  - python=3.9
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-cov
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-
-  # pandas dependencies
-  - beautifulsoup4
-  - bottleneck
-  - boto3
-  - fsspec>=0.8.0
-  - gcsfs
-  - html5lib
-  - jinja2
-  - lxml
-  - matplotlib
-  - numba
-  - numexpr
-  - numpy
-  - openpyxl
-  - pyarrow>2.0.1
-  - pytables
-  - python-dateutil
-  - pytz
-  - s3fs>=0.4.2
-  - scipy
-  - sqlalchemy
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - pyreadstat
-  - pyxlsb
-  - zstandard
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index f62520ea1da9e..1c60e8ad6d78a 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -4,37 +4,52 @@ channels:
 dependencies:
   - python=3.9
 
-  # tools
-  - cython>=0.29.24
+  # test dependencies
+  - cython>=0.29.32
   - pytest>=6.0
   - pytest-cov
   - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
+
+  # required dependencies
+  - python-dateutil
+  - numpy
+  - pytz
 
-  # pandas dependencies
+  # optional dependencies
   - beautifulsoup4
+  - blosc
   - bottleneck
-  - boto3
-  - fsspec>=0.8.0
-  - gcsfs
+  - brotlipy
+  - fastparquet
+  - fsspec
   - html5lib
+  - hypothesis
+  - gcsfs
   - jinja2
   - lxml
-  - matplotlib
-  - numpy  # move up to solve before numba
+  - matplotlib>=3.6.1
   - numba
   - numexpr
   - openpyxl
-  - pyarrow>2.0.1
+  - odfpy
+  - pandas-gbq
+  - psycopg2
+  - pymysql
+  - pyarrow<10
+  - pyreadstat
   - pytables
-  - python-dateutil
-  - pytz
-  - s3fs>=0.4.2
+  - python-snappy
+  - pyxlsb
+  - s3fs>=2021.08.0
   - scipy
-  - sqlalchemy
+  - sqlalchemy<1.4.46
+  - tabulate
+  - tzdata>=2022a
+  - xarray
   - xlrd
   - xlsxwriter
   - xlwt
-  - pyreadstat
-  - pyxlsb
   - zstandard
diff --git a/ci/deps/actions-pypy-38.yaml b/ci/deps/actions-pypy-38.yaml
index ad05d2ab2dacc..e06b992acc191 100644
--- a/ci/deps/actions-pypy-38.yaml
+++ b/ci/deps/actions-pypy-38.yaml
@@ -8,9 +8,10 @@ dependencies:
   - python=3.8[build=*_pypy] # TODO: use this once pypy3.8 is available
 
   # tools
-  - cython>=0.29.24
+  - cython>=0.29.32
   - pytest>=6.0
   - pytest-cov
+  - pytest-asyncio
   - pytest-xdist>=1.31
   - hypothesis>=5.5.3
 
diff --git a/ci/deps/azure-macos-38.yaml b/ci/deps/azure-macos-38.yaml
deleted file mode 100644
index 472dc8754d13e..0000000000000
--- a/ci/deps/azure-macos-38.yaml
+++ /dev/null
@@ -1,38 +0,0 @@
-name: pandas-dev
-channels:
-  - defaults
-  - conda-forge
-dependencies:
-  - python=3.8
-
-  # tools
-  - pytest>=6.0
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-  - pytest-azurepipelines
-
-  # pandas dependencies
-  - beautifulsoup4
-  - bottleneck
-  - html5lib
-  - jinja2
-  - lxml
-  - matplotlib=3.3.2
-  - nomkl
-  - numexpr
-  - numpy=1.18.5
-  - openpyxl
-  - pyarrow=1.0.1
-  - pyreadstat
-  - pytables
-  - python-dateutil==2.8.1
-  - pytz
-  - pyxlsb
-  - xarray
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - zstandard
-  - pip
-  - pip:
-    - cython>=0.29.24
diff --git a/ci/deps/azure-windows-38.yaml b/ci/deps/azure-windows-38.yaml
deleted file mode 100644
index aa2921ca7e496..0000000000000
--- a/ci/deps/azure-windows-38.yaml
+++ /dev/null
@@ -1,35 +0,0 @@
-name: pandas-dev
-channels:
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.8
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-  - pytest-azurepipelines
-
-  # pandas dependencies
-  - blosc
-  - bottleneck
-  - fastparquet>=0.4.0
-  - fsspec>=0.8.0
-  - matplotlib=3.3.2
-  - numba
-  - numexpr
-  - numpy=1.18
-  - openpyxl
-  - jinja2
-  - pyarrow=1.0.1
-  - pytables
-  - python-dateutil
-  - pytz
-  - s3fs>=0.4.0
-  - scipy
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - zstandard
diff --git a/ci/deps/azure-windows-39.yaml b/ci/deps/azure-windows-39.yaml
deleted file mode 100644
index 3d8fe05e2fce5..0000000000000
--- a/ci/deps/azure-windows-39.yaml
+++ /dev/null
@@ -1,40 +0,0 @@
-name: pandas-dev
-channels:
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.9
-
-  # tools
-  - cython>=0.29.24
-  - pytest>=6.0
-  - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
-  - pytest-azurepipelines
-
-  # pandas dependencies
-  - beautifulsoup4
-  - bottleneck
-  - fsspec>=0.8.0
-  - gcsfs
-  - html5lib
-  - jinja2
-  - lxml
-  - matplotlib
-  - numba
-  - numexpr
-  - numpy
-  - openpyxl
-  - pyarrow
-  - pytables
-  - python-dateutil
-  - pytz
-  - s3fs>=0.4.2
-  - scipy
-  - sqlalchemy
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - pyreadstat
-  - pyxlsb
-  - zstandard
diff --git a/ci/deps/circle-38-arm64.yaml b/ci/deps/circle-38-arm64.yaml
index 60608c3ee1a86..263521fb74879 100644
--- a/ci/deps/circle-38-arm64.yaml
+++ b/ci/deps/circle-38-arm64.yaml
@@ -4,18 +4,52 @@ channels:
 dependencies:
   - python=3.8
 
-  # tools
-  - cython>=0.29.24
+  # test dependencies
+  - cython>=0.29.32
   - pytest>=6.0
+  - pytest-cov
   - pytest-xdist>=1.31
-  - hypothesis>=5.5.3
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
 
-  # pandas dependencies
-  - botocore>=1.11
-  - flask
-  - moto
-  - numpy
+  # required dependencies
   - python-dateutil
+  - numpy
   - pytz
+
+  # optional dependencies
+  - beautifulsoup4
+  - blosc
+  - bottleneck
+  - brotlipy
+  - fastparquet
+  - fsspec
+  - html5lib
+  - hypothesis
+  - gcsfs
+  - jinja2
+  - lxml
+  - matplotlib>=3.6.1
+  - numba
+  - numexpr
+  - openpyxl
+  - odfpy
+  - pandas-gbq
+  - psycopg2
+  - pyarrow<10
+  - pymysql
+  # Not provided on ARM
+  #- pyreadstat
+  - pytables
+  - python-snappy
+  - pyxlsb
+  - s3fs>=2021.08.0
+  - scipy
+  - sqlalchemy<1.4.46
+  - tabulate
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
   - zstandard
-  - pip
diff --git a/ci/print_skipped.py b/ci/print_skipped.py
deleted file mode 100755
index 60e2f047235e6..0000000000000
--- a/ci/print_skipped.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-import os
-import xml.etree.ElementTree as et
-
-
-def main(filename):
-    if not os.path.isfile(filename):
-        raise RuntimeError(f"Could not find junit file {repr(filename)}")
-
-    tree = et.parse(filename)
-    root = tree.getroot()
-    current_class = ""
-    for el in root.iter("testcase"):
-        cn = el.attrib["classname"]
-        for sk in el.findall("skipped"):
-            old_class = current_class
-            current_class = cn
-            if old_class != current_class:
-                yield None
-            yield {
-                "class_name": current_class,
-                "test_name": el.attrib["name"],
-                "message": sk.attrib["message"],
-            }
-
-
-if __name__ == "__main__":
-    print("SKIPPED TESTS:")
-    i = 1
-    for test_data in main("test-data.xml"):
-        if test_data is None:
-            print("-" * 80)
-        else:
-            print(
-                f"#{i} {test_data['class_name']}."
-                f"{test_data['test_name']}: {test_data['message']}"
-            )
-            i += 1
diff --git a/ci/run_tests.sh b/ci/run_tests.sh
index 203f8fe293a06..e6de5caf955fc 100755
--- a/ci/run_tests.sh
+++ b/ci/run_tests.sh
@@ -24,18 +24,25 @@ if [[ $(uname) == "Linux" && -z $DISPLAY ]]; then
     XVFB="xvfb-run "
 fi
 
-PYTEST_CMD="${XVFB}pytest -m \"$PATTERN\" -n $PYTEST_WORKERS --dist=loadfile $TEST_ARGS $COVERAGE $PYTEST_TARGET"
+PYTEST_CMD="${XVFB}pytest -r fEs -n $PYTEST_WORKERS --dist=loadfile $TEST_ARGS $COVERAGE $PYTEST_TARGET"
 
-if [[ $(uname) != "Linux"  && $(uname) != "Darwin" ]]; then
-    PYTEST_CMD="$PYTEST_CMD --ignore=pandas/tests/plotting/"
+if [[ "$PATTERN" ]]; then
+  PYTEST_CMD="$PYTEST_CMD -m \"$PATTERN\""
 fi
 
 echo $PYTEST_CMD
 sh -c "$PYTEST_CMD"
 
-if [[ "$PANDAS_DATA_MANAGER" != "array" ]]; then
+if [[ "$PANDAS_DATA_MANAGER" != "array" && "$PYTEST_TARGET" == "pandas" ]]; then
     # The ArrayManager tests should have already been run by PYTEST_CMD if PANDAS_DATA_MANAGER was already set to array
-    PYTEST_AM_CMD="PANDAS_DATA_MANAGER=array pytest -m \"$PATTERN and arraymanager\" -n $PYTEST_WORKERS  --dist=loadfile $TEST_ARGS $COVERAGE pandas"
+    # If we're targeting specific files, e.g. test_downstream.py, don't run.
+    PYTEST_AM_CMD="PANDAS_DATA_MANAGER=array pytest -n $PYTEST_WORKERS --dist=loadfile $TEST_ARGS $COVERAGE pandas"
+
+    if [[ "$PATTERN" ]]; then
+      PYTEST_AM_CMD="$PYTEST_AM_CMD -m \"$PATTERN and arraymanager\""
+    else
+      PYTEST_AM_CMD="$PYTEST_AM_CMD -m \"arraymanager\""
+    fi
 
     echo $PYTEST_AM_CMD
     sh -c "$PYTEST_AM_CMD"
diff --git a/ci/setup_env.sh b/ci/setup_env.sh
deleted file mode 100755
index d51ff98b241a6..0000000000000
--- a/ci/setup_env.sh
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/bin/bash -e
-
-# edit the locale file if needed
-if [[ "$(uname)" == "Linux" && -n "$LC_ALL" ]]; then
-    echo "Adding locale to the first line of pandas/__init__.py"
-    rm -f pandas/__init__.pyc
-    SEDC="3iimport locale\nlocale.setlocale(locale.LC_ALL, '$LC_ALL')\n"
-    sed -i "$SEDC" pandas/__init__.py
-
-    echo "[head -4 pandas/__init__.py]"
-    head -4 pandas/__init__.py
-    echo
-fi
-
-
-echo "Install Miniconda"
-DEFAULT_CONDA_URL="https://repo.continuum.io/miniconda/Miniconda3-latest"
-if [[ "$(uname -m)" == 'aarch64' ]]; then
-    CONDA_URL="https://github.com/conda-forge/miniforge/releases/download/4.10.1-4/Miniforge3-4.10.1-4-Linux-aarch64.sh"
-elif [[ "$(uname)" == 'Linux' ]]; then
-    if [[ "$BITS32" == "yes" ]]; then
-        CONDA_URL="$DEFAULT_CONDA_URL-Linux-x86.sh"
-    else
-        CONDA_URL="$DEFAULT_CONDA_URL-Linux-x86_64.sh"
-    fi
-elif [[ "$(uname)" == 'Darwin' ]]; then
-    CONDA_URL="$DEFAULT_CONDA_URL-MacOSX-x86_64.sh"
-else
-  echo "OS $(uname) not supported"
-  exit 1
-fi
-echo "Downloading $CONDA_URL"
-wget -q $CONDA_URL -O miniconda.sh
-chmod +x miniconda.sh
-
-MINICONDA_DIR="$HOME/miniconda3"
-rm -rf $MINICONDA_DIR
-./miniconda.sh -b -p $MINICONDA_DIR
-export PATH=$MINICONDA_DIR/bin:$PATH
-
-echo
-echo "which conda"
-which conda
-
-echo
-echo "update conda"
-conda config --set ssl_verify false
-conda config --set quiet true --set always_yes true --set changeps1 false
-conda install pip conda  # create conda to create a historical artifact for pip & setuptools
-conda update -n base conda
-conda install -y -c conda-forge mamba
-
-echo "conda info -a"
-conda info -a
-
-echo "source deactivate"
-source deactivate
-
-echo "conda list (root environment)"
-conda list
-
-# Clean up any left-over from a previous build
-conda remove --all -q -y -n pandas-dev
-
-echo
-echo "mamba env create -q --file=${ENV_FILE}"
-time mamba env create -q --file="${ENV_FILE}"
-
-
-if [[ "$BITS32" == "yes" ]]; then
-    # activate 32-bit compiler
-    export CONDA_BUILD=1
-fi
-
-echo "activate pandas-dev"
-source activate pandas-dev
-
-# Explicitly set an environment variable indicating that this is pandas' CI environment.
-#
-# This allows us to enable things like -Werror that shouldn't be activated in
-# downstream CI jobs that may also build pandas from source.
-export PANDAS_CI=1
-
-echo
-echo "remove any installed pandas package"
-echo "w/o removing anything else"
-conda remove pandas -y --force || true
-pip uninstall -y pandas || true
-
-echo
-echo "remove qt"
-echo "causes problems with the clipboard, we use xsel for that"
-conda remove qt -y --force || true
-
-echo
-echo "conda list pandas"
-conda list pandas
-
-# Make sure any error below is reported as such
-
-echo "[Build extensions]"
-python setup.py build_ext -q -j2
-
-echo "[Updating pip]"
-# TODO: GH#44980 https://github.com/pypa/setuptools/issues/2941
-python -m pip install --no-deps -U pip wheel "setuptools<60.0.0"
-
-echo "[Install pandas]"
-python -m pip install --no-build-isolation -e .
-
-echo
-echo "conda list"
-conda list
-
-echo "done"
diff --git a/codecov.yml b/codecov.yml
index 883f9fbb20729..d893bdbdc9298 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -1,5 +1,5 @@
 codecov:
-  branch: master
+  branch: main
   notify:
     after_n_builds: 10
 comment: false
diff --git a/doc/_templates/pandas_footer.html b/doc/_templates/pandas_footer.html
new file mode 100644
index 0000000000000..6d8caa4d6c741
--- /dev/null
+++ b/doc/_templates/pandas_footer.html
@@ -0,0 +1,3 @@
+<p class="copyright">
+    &copy {{copyright}} pandas via <a href="https://numfocus.org/">NumFOCUS, Inc.</a> Hosted by <a href="https://www.ovhcloud.com/">OVHcloud</a>.
+</p>
diff --git a/doc/_templates/sidebar-nav-bs.html b/doc/_templates/sidebar-nav-bs.html
index 7e0043e771e72..8298b66568e20 100644
--- a/doc/_templates/sidebar-nav-bs.html
+++ b/doc/_templates/sidebar-nav-bs.html
@@ -1,9 +1,9 @@
 <nav class="bd-links" id="bd-docs-nav" aria-label="Main navigation">
-  <div class="bd-toc-item active">
+  <div class="bd-toc-item navbar-nav">
     {% if pagename.startswith("reference") %}
-    {{ generate_nav_html("sidebar", maxdepth=4, collapse=True, includehidden=True, titles_only=True) }}
+    {{ generate_toctree_html("sidebar", maxdepth=4, collapse=True, includehidden=True, titles_only=True) }}
     {% else %}
-    {{ generate_nav_html("sidebar", maxdepth=4, collapse=False, includehidden=True, titles_only=True) }}
+    {{ generate_toctree_html("sidebar", maxdepth=4, collapse=False, includehidden=True, titles_only=True) }}
     {% endif %}
   </div>
 </nav>
diff --git a/doc/data/fx_prices b/doc/data/fx_prices
deleted file mode 100644
index 38cadf26909a3..0000000000000
Binary files a/doc/data/fx_prices and /dev/null differ
diff --git a/doc/data/mindex_ex.csv b/doc/data/mindex_ex.csv
deleted file mode 100644
index 935ff936cd842..0000000000000
--- a/doc/data/mindex_ex.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-year,indiv,zit,xit
-1977,"A",1.2,.6
-1977,"B",1.5,.5
-1977,"C",1.7,.8
-1978,"A",.2,.06
-1978,"B",.7,.2
-1978,"C",.8,.3
-1978,"D",.9,.5
-1978,"E",1.4,.9
-1979,"C",.2,.15
-1979,"D",.14,.05
-1979,"E",.5,.15
-1979,"F",1.2,.5
-1979,"G",3.4,1.9
-1979,"H",5.4,2.7
-1979,"I",6.4,1.2
diff --git a/doc/data/test.xls b/doc/data/test.xls
deleted file mode 100644
index db0f9dec7d5e4..0000000000000
Binary files a/doc/data/test.xls and /dev/null differ
diff --git a/doc/make.py b/doc/make.py
index 5d2476fcdca8d..c758c7fc84bbb 100755
--- a/doc/make.py
+++ b/doc/make.py
@@ -45,7 +45,7 @@ def __init__(
         single_doc=None,
         verbosity=0,
         warnings_are_errors=False,
-    ):
+    ) -> None:
         self.num_jobs = num_jobs
         self.include_api = include_api
         self.whatsnew = whatsnew
diff --git a/doc/redirects.csv b/doc/redirects.csv
index 9b8a5a73dedff..fda09d7644a49 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -45,6 +45,7 @@ contributing_docstring,development/contributing_docstring
 developer,development/developer
 extending,development/extending
 internals,development/internals
+development/meeting,community
 
 # api moved function
 reference/api/pandas.io.json.json_normalize,pandas.json_normalize
diff --git a/doc/source/_static/css/getting_started.css b/doc/source/_static/css/getting_started.css
index 84eafa308175c..2a348e5b84e6e 100644
--- a/doc/source/_static/css/getting_started.css
+++ b/doc/source/_static/css/getting_started.css
@@ -154,7 +154,7 @@ ul.task-bullet > li > p:first-child {
 
 .comparison-card .card-footer {
   border: none;
-  background-color:white;
+  background-color: transparent;
 }
 
 .install-block {
@@ -163,19 +163,18 @@ ul.task-bullet > li > p:first-child {
 
 .install-card .card-header {
   border: none;
-  background-color:white;
+  background-color: transparent;
   padding: 1rem 1rem 0rem 1rem;
 }
 
 .install-card .card-header p.card-text {
-  color: #150458;
   font-size: 1.1rem;
   font-weight: bold;
 }
 
 .install-card .card-footer {
   border: none;
-  background-color:white;
+  background-color: transparent;
 }
 
 .install-card pre {
diff --git a/doc/source/_static/css/pandas.css b/doc/source/_static/css/pandas.css
index 452c7d20ff5df..a08be3301edda 100644
--- a/doc/source/_static/css/pandas.css
+++ b/doc/source/_static/css/pandas.css
@@ -5,6 +5,10 @@
   --pst-color-info: 23, 162, 184;
 }
 
+table {
+  width: auto; /* Override fit-content which breaks Styler user guide ipynb */
+}
+
 /* Main index page overview cards */
 
 .intro-card {
@@ -25,7 +29,7 @@
 
 .intro-card .card-header {
   border: none;
-  background-color:white;
+  background-color: transparent;
   color: #150458 !important;
   font-size: var(--pst-font-size-h5);
   font-weight: bold;
@@ -34,7 +38,7 @@
 
 .intro-card .card-footer {
   border: none;
-  background-color:white;
+  background-color: transparent;
 }
 
 .intro-card .card-footer p.card-text{
@@ -42,3 +46,7 @@
   margin-left: auto;
   margin-right: auto;
 }
+
+.card, .card img {
+  background-color: transparent !important;
+}
diff --git a/doc/source/_static/index_api.svg b/doc/source/_static/index_api.svg
index 70bf0d3504b1a..69f7ba1d2d114 100644
--- a/doc/source/_static/index_api.svg
+++ b/doc/source/_static/index_api.svg
@@ -64,29 +64,29 @@
          inkscape:connector-curvature="0"
          id="path899"
          d="M 324.96812,187.09499 H 303.0455 v 72.1639 h 22.67969"
-         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+         style="fill:none;stroke:#459DB9;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
       <path
          inkscape:connector-curvature="0"
          id="path899-3"
          d="m 361.58921,187.09499 h 21.92262 v 72.1639 h -22.67969"
-         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+         style="fill:none;stroke:#459DB9;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
       <g
          transform="translate(415.87139,46.162126)"
          id="g944">
         <circle
-           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           style="fill:#459DB9;fill-opacity:1;stroke:#459DB9;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
            id="path918"
            cx="-84.40152"
            cy="189.84375"
            r="2.2293637" />
         <circle
-           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           style="fill:#459DB9;fill-opacity:1;stroke:#459DB9;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
            id="path918-5"
            cx="-72.949402"
            cy="189.84375"
            r="2.2293637" />
         <circle
-           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           style="fill:#459DB9;fill-opacity:1;stroke:#459DB9;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
            id="path918-6"
            cx="-61.497284"
            cy="189.84375"
diff --git a/doc/source/_static/index_contribute.svg b/doc/source/_static/index_contribute.svg
index e86c3e9fd0b3e..de3d902379383 100644
--- a/doc/source/_static/index_contribute.svg
+++ b/doc/source/_static/index_contribute.svg
@@ -65,12 +65,12 @@
          inkscape:connector-curvature="0"
          id="path869"
          d="m -97.139881,161.26069 47.247024,40.25446 -47.247024,40.25446"
-         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+         style="fill:none;stroke:#459DB9;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
       <path
          inkscape:connector-curvature="0"
          id="path871"
          d="m -49.514879,241.81547 h 32.505951"
-         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+         style="fill:none;stroke:#459DB9;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
     </g>
   </g>
 </svg>
diff --git a/doc/source/_static/index_getting_started.svg b/doc/source/_static/index_getting_started.svg
index d00e462427193..2d36622cb7e55 100644
--- a/doc/source/_static/index_getting_started.svg
+++ b/doc/source/_static/index_getting_started.svg
@@ -58,7 +58,7 @@
      id="layer1"
      transform="translate(2.9219487,-8.5995374)">
     <path
-       style="fill:#150458;fill-opacity:1;stroke-width:0.20233451"
+       style="fill:#459DB9;fill-opacity:1;stroke-width:0.20233451"
        d="M 37.270955,98.335591 C 33.358064,97.07991 31.237736,92.52319 32.964256,89.08022 c 0.18139,-0.361738 4.757999,-5.096629 10.17021,-10.521968 l 9.84041,-9.864254 -4.03738,-4.041175 -4.037391,-4.041172 -4.96415,4.916665 c -3.61569,3.581096 -5.238959,5.04997 -5.975818,5.407377 l -1.011682,0.490718 H 17.267525 1.5866055 L 0.65034544,70.96512 C -2.2506745,69.535833 -3.5952145,66.18561 -2.5925745,62.884631 c 0.53525,-1.762217 1.61699004,-3.050074 3.22528014,-3.839847 l 1.15623996,-0.56778 13.2591094,-0.05613 13.259111,-0.05613 11.5262,-11.527539 11.526199,-11.527528 H 40.622647 c -12.145542,0 -12.189222,-0.0046 -13.752801,-1.445851 -2.229871,-2.055423 -2.162799,-5.970551 0.135998,-7.938238 1.475193,-1.262712 1.111351,-1.238469 18.588522,-1.238469 12.899229,0 16.035311,0.05193 16.692589,0.276494 0.641832,0.219264 2.590731,2.051402 9.416301,8.852134 l 8.606941,8.575638 h 6.848168 c 4.837422,0 7.092281,0.07311 7.679571,0.249094 0.48064,0.144008 1.22985,0.634863 1.77578,1.163429 2.383085,2.307333 1.968685,6.539886 -0.804989,8.221882 -0.571871,0.346781 -1.38284,0.687226 -1.80217,0.756523 -0.41933,0.06928 -4.2741,0.127016 -8.56615,0.128238 -6.56998,0.0016 -7.977492,-0.04901 -8.902732,-0.321921 -0.975569,-0.287742 -1.400468,-0.622236 -3.783999,-2.978832 l -2.685021,-2.654679 -5.05411,5.051071 -5.0541,5.051081 3.926292,3.947202 c 2.365399,2.378001 4.114289,4.309171 4.399158,4.857713 0.39266,0.75606 0.47311,1.219412 0.474321,2.731516 0.003,3.083647 0.620779,2.331942 -13.598011,16.531349 -10.273768,10.259761 -12.679778,12.563171 -13.500979,12.92519 -1.267042,0.55857 -3.156169,0.681342 -4.390271,0.285321 z m 40.130741,-65.45839 c -2.212909,-0.579748 -3.782711,-1.498393 -5.51275,-3.226063 -2.522111,-2.518633 -3.633121,-5.181304 -3.633121,-8.707194 0,-3.530699 1.11238,-6.197124 3.631161,-8.704043 4.866751,-4.8438383 12.324781,-4.8550953 17.211791,-0.026 3.908758,3.862461 4.818578,9.377999 2.372188,14.380771 -0.846209,1.730481 -3.39493,4.326384 -5.143839,5.239072 -2.69708,1.407492 -6.042829,1.798628 -8.92543,1.043434 z"
        id="path1000"
        inkscape:connector-curvature="0" />
diff --git a/doc/source/_static/index_user_guide.svg b/doc/source/_static/index_user_guide.svg
index a567103af5918..bd170535170a3 100644
--- a/doc/source/_static/index_user_guide.svg
+++ b/doc/source/_static/index_user_guide.svg
@@ -58,7 +58,7 @@
      id="layer1"
      transform="translate(141.8903,-20.32143)">
     <path
-       style="fill:#150458;fill-opacity:1;stroke-width:0.20483544"
+       style="fill:#459DB9;fill-opacity:1;stroke-width:0.20483544"
        d="m -139.53374,110.1657 c -0.80428,-0.24884 -1.71513,-1.11296 -2.07107,-1.96486 -0.23905,-0.57214 -0.28453,-6.28104 -0.28453,-35.720988 0,-38.274546 -0.079,-35.840728 1.19849,-36.91568 0.58869,-0.495345 4.63766,-2.187548 8.47998,-3.544073 l 1.58749,-0.560453 v -3.309822 c 0,-3.025538 0.0396,-3.388179 0.46086,-4.222122 0.68808,-1.362003 1.38671,-1.714455 4.60319,-2.322195 4.12797,-0.779966 5.13304,-0.912766 8.81544,-1.16476 11.80964,-0.808168 22.80911,2.509277 30.965439,9.3392 1.750401,1.465747 3.840861,3.5635 5.0903,5.108065 l 0.659122,0.814805 0.659109,-0.814805 c 1.249431,-1.544565 3.33988,-3.642318 5.09029,-5.108065 8.156331,-6.829923 19.155791,-10.147368 30.965441,-9.3392 3.682389,0.251994 4.68748,0.384794 8.81544,1.16476 3.21647,0.60774 3.91511,0.960192 4.60318,2.322195 0.4213,0.833943 0.46087,1.196584 0.46087,4.222122 v 3.309822 l 1.58748,0.560453 c 4.10165,1.448077 7.98852,3.072753 8.5259,3.563743 1.22643,1.120567 1.15258,-1.245868 1.15258,36.927177 0,34.567591 -0.005,35.083151 -0.40663,35.903991 -0.22365,0.45804 -0.73729,1.05665 -1.14143,1.33024 -1.22281,0.82783 -2.17721,0.70485 -5.86813,-0.7561 -9.19595,-3.63998 -18.956011,-6.38443 -26.791332,-7.53353 -3.02827,-0.44412 -9.26189,-0.61543 -11.77821,-0.3237 -5.19357,0.60212 -8.736108,2.05527 -11.700039,4.79936 -0.684501,0.63371 -1.466141,1.23646 -1.736979,1.33942 -0.63859,0.2428 -4.236521,0.2428 -4.875112,0 -0.27083,-0.10296 -1.05247,-0.70571 -1.73696,-1.33942 -2.96395,-2.74409 -6.50648,-4.19724 -11.700058,-4.79936 -2.516312,-0.29173 -8.749941,-0.12042 -11.778201,0.3237 -7.78194,1.14127 -17.39965,3.83907 -26.73341,7.49883 -3.38325,1.32658 -4.15525,1.50926 -5.11851,1.21125 z m 4.2107,-5.34052 c 5.86759,-2.29858 14.40398,-4.922695 20.2018,-6.210065 6.31584,-1.402418 8.5236,-1.646248 14.91592,-1.647338 4.68699,-7.94e-4 6.013661,0.0632 7.257809,0.3497 0.837332,0.19286 1.561052,0.312028 1.60828,0.264819 0.147111,-0.147119 -1.803289,-1.307431 -4.154879,-2.471801 -8.12511,-4.023029 -18.27311,-4.986568 -29.0861,-2.761718 -1.09536,0.22538 -2.32708,0.40827 -2.73715,0.406418 -1.12787,-0.005 -2.3054,-0.76382 -2.84516,-1.8332 l -0.46086,-0.913098 V 62.99179 35.97471 l -0.56331,0.138329 c -0.30981,0.07608 -1.89985,0.665075 -3.5334,1.308881 -2.27551,0.896801 -2.96414,1.252878 -2.94452,1.522563 0.014,0.193604 0.0372,15.284513 0.0512,33.535345 0.014,18.250839 0.0538,33.183322 0.0884,33.183322 0.0346,0 1.02543,-0.3771 2.20198,-0.83801 z m 113.006991,-32.697216 -0.0518,-33.535203 -3.17495,-1.272156 c -1.74623,-0.699685 -3.33627,-1.278755 -3.53341,-1.286819 -0.33966,-0.01389 -0.35847,1.401778 -0.35847,26.980216 v 26.994863 l -0.46087,0.913112 c -0.53976,1.06939 -1.71729,1.828088 -2.84515,1.833189 -0.41008,0.0021 -1.6418,-0.181031 -2.73716,-0.406421 -11.888201,-2.446089 -22.84337,-1.046438 -31.491022,4.02332 -1.68175,0.985941 -2.216748,1.467501 -1.36534,1.228942 1.575181,-0.441362 4.990592,-0.73864 8.524862,-0.742011 5.954408,-0.005 11.43046,0.791951 19.10874,2.78333 3.9516,1.024874 12.1555,3.687454 15.6699,5.085704 1.23926,0.49306 2.36869,0.90517 2.50985,0.9158 0.20489,0.0155 0.2462,-6.745894 0.20483,-33.515866 z m -59.76135,-2.233777 V 40.065438 l -0.95972,-1.357442 c -1.380522,-1.952627 -5.376262,-5.847994 -7.64336,-7.45136 -3.778692,-2.672401 -9.063392,-4.943324 -13.672511,-5.875304 -3.19731,-0.646503 -5.23069,-0.833103 -9.05886,-0.831312 -4.37716,0.0021 -7.70223,0.349169 -11.83461,1.235469 l -1.07538,0.230645 v 31.242342 c 0,26.565778 0.0426,31.226011 0.28429,31.133261 0.15637,-0.06 1.42379,-0.297169 2.81648,-0.527026 12.37657,-2.042634 23.21658,-0.346861 32.521639,5.087596 2.10018,1.226558 5.20202,3.618878 6.880942,5.30692 0.788609,0.792909 1.502978,1.446609 1.587468,1.452679 0.0845,0.006 0.153622,-13.411893 0.153622,-29.817719 z m 5.80221,28.3766 c 6.21476,-6.141601 15.08488,-10.061509 25.025529,-11.05933 4.262419,-0.427849 11.579921,-0.0054 16.017661,0.924912 0.75932,0.15916 1.45259,0.244888 1.54058,0.190498 0.088,-0.05434 0.16003,-14.060382 0.16003,-31.124436 V 26.176883 l -0.52136,-0.198219 c -0.66893,-0.254325 -4.77649,-0.95482 -7.159981,-1.221048 -2.41372,-0.269605 -8.559851,-0.266589 -10.759229,0.0052 -6.458111,0.798299 -12.584091,3.083792 -17.405651,6.49374 -2.267091,1.603366 -6.262831,5.498733 -7.64336,7.45136 l -0.959721,1.357438 v 29.828747 c 0,16.405812 0.0532,29.828746 0.11802,29.828746 0.065,0 0.77928,-0.65347 1.587482,-1.452149 z"
        id="path845"
        inkscape:connector-curvature="0"
diff --git a/doc/source/_static/logo_sas_white.svg b/doc/source/_static/logo_sas_white.svg
new file mode 100644
index 0000000000000..8f023fa831b6b
--- /dev/null
+++ b/doc/source/_static/logo_sas_white.svg
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) by Marsupilami -->
+<svg xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" version="1.0" width="1024" height="420" viewBox="0 0 129.24898 53.067852" id="svg2320">
+  <defs id="defs2322"/>
+  <g transform="translate(-310.37551,-505.82825)" id="layer1">
+    <path d="M 18.46875,0 C 16.638866,-0.041377236 14.748438,0.1725 12.8125,0.65625 C 3.86,2.8925 -6.16125,14.40875 4.78125,27.6875 L 11.3125,35.59375 L 13.15625,37.84375 C 14.39375,39.315 16.41875,39.28875 17.90625,38.0625 C 19.40125,36.829998 19.82625,34.80875 18.59375,33.3125 C 18.592173,33.310397 18.071121,32.679752 17.84375,32.40625 L 17.875,32.40625 C 17.402936,31.838361 17.300473,31.743127 16.8125,31.15625 C 14.448752,28.313409 11.75,25.03125 11.75,25.03125 C 6.9987503,19.265 9.11875,12.14125 15.5625,8.09375 C 21.24,4.5275001 31.65875,5.80125 35.25,11.65625 C 32.988202,4.9805465 26.398246,0.17930136 18.46875,0 z M 19.78125,13.9375 C 18.937031,13.90875 18.055625,14.230625 17.3125,14.84375 C 15.815001,16.0775 15.39375,18.10125 16.625,19.59375 C 16.627499,19.597501 16.77625,19.7825 17.03125,20.09375 C 19.863614,23.496657 23.625,28.0625 23.625,28.0625 C 28.3775,33.82875 26.25625,40.92125 19.8125,44.96875 C 14.136251,48.53375 3.71625,47.2575 0.125,41.40625 C 2.90875,49.618751 12.23875,54.9875 22.5625,52.40625 C 31.5175,50.166248 41.53625,38.6825 30.59375,25.40625 L 22.9375,16.15625 L 22.0625,15.0625 C 21.44375,14.326875 20.625469,13.96625 19.78125,13.9375 z " transform="translate(310.37551,505.82825)" style="fill:#007cc2;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path2440"/>
+    <path d="M 53.53125,6.3125 C 47.8625,6.3125 41.374998,9.2362506 41.375,16.28125 C 41.375,22.9875 46.708752,24.869999 52,26.15625 C 57.355,27.4425 62.656249,28.187498 62.65625,32.65625 C 62.65625,37.05875 58.121251,37.875002 54.78125,37.875 C 50.3725,37.875 46.218751,36.27125 46.03125,31.125 L 40.6875,31.125 C 41,39.79375 47.161249,42.968749 54.46875,42.96875 C 61.085,42.96875 68.343749,40.27125 68.34375,31.9375 C 68.34375,25.16375 63.041251,23.25625 57.6875,21.96875 C 52.7125,20.6825 47.031249,20.00625 47.03125,15.875 C 47.03125,12.3525 50.75625,11.40625 53.96875,11.40625 C 57.49875,11.40625 61.151251,12.810001 61.53125,17.28125 L 66.875,17.28125 C 66.435,8.74625 60.712498,6.3125001 53.53125,6.3125 z M 84.40625,6.3125 C 77.159998,6.3125001 70.90625,9.3625 70.59375,18.03125 L 75.9375,18.03125 C 76.190003,12.883749 79.5275,11.40625 84.0625,11.40625 C 87.466253,11.40625 91.3125,12.20625 91.3125,17.21875 C 91.312501,21.553749 86.2975,21.155 80.375,22.375 C 74.833751,23.526251 69.34375,25.23 69.34375,33.15625 C 69.343748,40.133748 74.20125,42.96875 80.125,42.96875 C 84.656249,42.968749 88.6025,41.255 91.5625,37.53125 C 91.562499,41.322498 93.3525,42.96875 96.125,42.96875 C 97.823751,42.968749 98.9925,42.60875 99.9375,42 L 99.9375,37.53125 C 99.244997,37.802498 98.7525,37.875 98.3125,37.875 C 96.612501,37.875002 96.625,36.68 96.625,33.96875 L 96.625,15.9375 C 96.624998,7.7424996 90.265,6.3125 84.40625,6.3125 z M 112.40625,6.3125 C 106.7375,6.3125 100.25,9.2362506 100.25,16.28125 C 100.25,22.9875 105.61625,24.869999 110.90625,26.15625 C 116.2625,27.4425 121.5625,28.187498 121.5625,32.65625 C 121.5625,37.05875 117.02625,37.875002 113.6875,37.875 C 109.2775,37.875 105.125,36.27125 104.9375,31.125 L 99.5625,31.125 C 99.87625,39.79375 106.06875,42.968749 113.375,42.96875 C 119.9875,42.96875 127.21875,40.27125 127.21875,31.9375 C 127.21875,25.16375 121.91625,23.25625 116.5625,21.96875 C 111.58875,20.6825 105.9375,20.00625 105.9375,15.875 C 105.9375,12.3525 109.63125,11.40625 112.84375,11.40625 C 116.37,11.40625 120.025,12.810001 120.40625,17.28125 L 125.78125,17.28125 C 125.3425,8.74625 119.59,6.3125001 112.40625,6.3125 z M 91.25,24.0625 L 91.25,29.96875 C 91.25,33.1525 88.36875,37.875 81.3125,37.875 C 78.040002,37.875002 75,36.51375 75,32.71875 C 75.000003,28.452501 78.0375,27.115 81.5625,26.4375 C 85.15375,25.761251 89.1725,25.6875 91.25,24.0625 z M 38.21875,39.40625 C 37.088748,39.406249 36.125,40.28375 36.125,41.46875 C 36.125001,42.658749 37.08875,43.53125 38.21875,43.53125 C 39.338748,43.53125 40.28125,42.65875 40.28125,41.46875 C 40.281252,40.283749 39.33875,39.40625 38.21875,39.40625 z M 127.15625,39.40625 C 126.0225,39.406249 125.0625,40.285 125.0625,41.46875 C 125.0625,42.66 126.0225,43.53125 127.15625,43.53125 C 128.275,43.53125 129.25,42.66 129.25,41.46875 C 129.25,40.285 128.275,39.40625 127.15625,39.40625 z M 38.21875,39.75 C 39.146248,39.750002 39.875,40.49 39.875,41.46875 C 39.875,42.456249 39.14625,43.1875 38.21875,43.1875 C 37.273748,43.187501 36.53125,42.45625 36.53125,41.46875 C 36.53125,40.489999 37.27375,39.75 38.21875,39.75 z M 127.15625,39.75 C 128.08375,39.750002 128.84375,40.49125 128.84375,41.46875 C 128.84375,42.4575 128.08375,43.1875 127.15625,43.1875 C 126.21,43.187499 125.5,42.4575 125.5,41.46875 C 125.5,40.49125 126.21,39.75 127.15625,39.75 z M 37.40625,40.28125 L 37.40625,42.65625 L 37.78125,42.65625 L 37.78125,41.625 L 38.1875,41.625 L 38.8125,42.65625 L 39.21875,42.65625 L 38.53125,41.59375 C 38.88375,41.553751 39.15625,41.395 39.15625,40.96875 C 39.156251,40.49875 38.8775,40.28125 38.3125,40.28125 L 37.40625,40.28125 z M 126.375,40.28125 L 126.375,42.65625 L 126.71875,42.65625 L 126.71875,41.625 L 127.15625,41.625 L 127.78125,42.65625 L 128.1875,42.65625 L 127.5,41.59375 C 127.84625,41.554998 128.125,41.395 128.125,40.96875 C 128.125,40.49875 127.8425,40.28125 127.28125,40.28125 L 126.375,40.28125 z M 37.78125,40.59375 L 38.28125,40.59375 C 38.528749,40.593749 38.78125,40.6425 38.78125,40.9375 C 38.78125,41.300001 38.5275,41.3125 38.21875,41.3125 L 37.78125,41.3125 L 37.78125,40.59375 z M 126.71875,40.59375 L 127.21875,40.59375 C 127.47125,40.593749 127.75,40.64125 127.75,40.9375 C 127.75,41.300001 127.4625,41.3125 127.15625,41.3125 L 126.71875,41.3125 L 126.71875,40.59375 z " transform="translate(310.37551,505.82825)" style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path2448"/>
+  </g>
+<head xmlns=""/></svg>
\ No newline at end of file
diff --git a/doc/source/_static/logo_sql.svg b/doc/source/_static/logo_sql.svg
index 4a5b7d0b1b943..38b3b2c726214 100644
--- a/doc/source/_static/logo_sql.svg
+++ b/doc/source/_static/logo_sql.svg
@@ -58,10 +58,10 @@
      d="m 18.846017,1.608 c -0.497,-0.326 -1.193,-0.615 -2.069,-0.858 -1.742,-0.484 -4.05,-0.75 -6.498,-0.75 -2.4480004,0 -4.7560004,0.267 -6.4980004,0.75 -0.877,0.243 -1.573,0.532 -2.069,0.858 -0.619,0.407 -0.93299996,0.874 -0.93299996,1.391 v 12 c 0,0.517 0.31399996,0.985 0.93299996,1.391 0.497,0.326 1.193,0.615 2.069,0.858 1.742,0.484 4.05,0.75 6.4980004,0.75 2.448,0 4.756,-0.267 6.498,-0.751 0.877,-0.243 1.573,-0.532 2.069,-0.858 0.619,-0.406 0.933,-0.874 0.933,-1.391 v -12 c 0,-0.517 -0.314,-0.985 -0.933,-1.391 z M 4.0490166,1.713 c 1.658,-0.46 3.87,-0.714 6.2300004,-0.714 2.36,0 4.573,0.254 6.23,0.714 1.795,0.499 2.27,1.059 2.27,1.286 0,0.227 -0.474,0.787 -2.27,1.286 -1.658,0.46 -3.87,0.714 -6.23,0.714 -2.3600004,0 -4.5730004,-0.254 -6.2300004,-0.714 -1.795,-0.499 -2.27,-1.059 -2.27,-1.286 0,-0.227 0.474,-0.787 2.27,-1.286 z M 16.509017,16.285 c -1.658,0.46 -3.87,0.714 -6.23,0.714 -2.3600004,0 -4.5730004,-0.254 -6.2300004,-0.714 -1.795,-0.499 -2.27,-1.059 -2.27,-1.286 v -2.566 c 0.492,0.309 1.164,0.583 2.002,0.816 1.742,0.484 4.05,0.75 6.4980004,0.75 2.448,0 4.756,-0.267 6.498,-0.751 0.838,-0.233 1.511,-0.507 2.002,-0.816 v 2.566 c 0,0.227 -0.474,0.787 -2.27,1.286 z m 0,-4 c -1.658,0.46 -3.87,0.714 -6.23,0.714 -2.3600004,0 -4.5730004,-0.254 -6.2300004,-0.714 -1.795,-0.499 -2.27,-1.059 -2.27,-1.286 V 8.433 c 0.492,0.309 1.164,0.583 2.002,0.816 1.742,0.484 4.05,0.75 6.4980004,0.75 2.448,0 4.756,-0.267 6.498,-0.75 0.838,-0.233 1.511,-0.507 2.002,-0.816 v 2.566 c 0,0.227 -0.474,0.787 -2.27,1.286 z m 0,-4 c -1.658,0.46 -3.87,0.714 -6.23,0.714 -2.3600004,0 -4.5730004,-0.254 -6.2300004,-0.714 -1.795,-0.499 -2.27,-1.059 -2.27,-1.286 V 4.433 c 0.492,0.309 1.164,0.583 2.002,0.816 1.742,0.484 4.05,0.75 6.4980004,0.75 2.448,0 4.756,-0.267 6.498,-0.75 0.838,-0.233 1.511,-0.507 2.002,-0.816 v 2.566 c 0,0.227 -0.474,0.787 -2.27,1.286 z"
      id="path2"
      inkscape:connector-curvature="0"
-     style="fill:#000000" />
+     style="fill:#888888" />
   <text
      xml:space="preserve"
-     style="font-style:normal;font-weight:normal;font-size:32.32878494px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.99999994"
+     style="font-style:normal;font-weight:normal;font-size:32.32878494px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#888888;fill-opacity:1;stroke:none;stroke-width:0.99999994"
      x="-0.71034926"
      y="27.875254"
      id="text819"><tspan
diff --git a/doc/source/_static/option_unicode01.png b/doc/source/_static/option_unicode01.png
deleted file mode 100644
index d7168de126c5b..0000000000000
Binary files a/doc/source/_static/option_unicode01.png and /dev/null differ
diff --git a/doc/source/_static/option_unicode02.png b/doc/source/_static/option_unicode02.png
deleted file mode 100644
index 89e81e4f5f0ed..0000000000000
Binary files a/doc/source/_static/option_unicode02.png and /dev/null differ
diff --git a/doc/source/_static/option_unicode03.png b/doc/source/_static/option_unicode03.png
deleted file mode 100644
index 0b4ee876e17fe..0000000000000
Binary files a/doc/source/_static/option_unicode03.png and /dev/null differ
diff --git a/doc/source/_static/option_unicode04.png b/doc/source/_static/option_unicode04.png
deleted file mode 100644
index 1b839a44422b3..0000000000000
Binary files a/doc/source/_static/option_unicode04.png and /dev/null differ
diff --git a/doc/source/_static/style/df_pipe_applydata.png b/doc/source/_static/style/df_pipe_applydata.png
new file mode 100644
index 0000000000000..a2d5aa514e311
Binary files /dev/null and b/doc/source/_static/style/df_pipe_applydata.png differ
diff --git a/doc/source/_static/style/df_pipe_applymap.png b/doc/source/_static/style/df_pipe_applymap.png
new file mode 100644
index 0000000000000..cd493c78452ef
Binary files /dev/null and b/doc/source/_static/style/df_pipe_applymap.png differ
diff --git a/doc/source/_static/style/df_pipe_hl.png b/doc/source/_static/style/df_pipe_hl.png
new file mode 100644
index 0000000000000..2238a55ab1ce3
Binary files /dev/null and b/doc/source/_static/style/df_pipe_hl.png differ
diff --git a/doc/source/_static/style/df_pipe_hl2.png b/doc/source/_static/style/df_pipe_hl2.png
new file mode 100644
index 0000000000000..7025a7c373d92
Binary files /dev/null and b/doc/source/_static/style/df_pipe_hl2.png differ
diff --git a/doc/source/_static/style/footer_extended.png b/doc/source/_static/style/footer_extended.png
new file mode 100644
index 0000000000000..3699d61ad4346
Binary files /dev/null and b/doc/source/_static/style/footer_extended.png differ
diff --git a/doc/source/_static/style/footer_simple.png b/doc/source/_static/style/footer_simple.png
new file mode 100644
index 0000000000000..56dc3c09cc700
Binary files /dev/null and b/doc/source/_static/style/footer_simple.png differ
diff --git a/doc/source/_static/style/format_excel_css.png b/doc/source/_static/style/format_excel_css.png
new file mode 100644
index 0000000000000..0bd4662c3f2d0
Binary files /dev/null and b/doc/source/_static/style/format_excel_css.png differ
diff --git a/doc/source/_static/style/latex_stocks.png b/doc/source/_static/style/latex_stocks.png
new file mode 100644
index 0000000000000..c8906c33b810b
Binary files /dev/null and b/doc/source/_static/style/latex_stocks.png differ
diff --git a/doc/source/_static/style/latex_stocks_html.png b/doc/source/_static/style/latex_stocks_html.png
new file mode 100644
index 0000000000000..11b30faddf47c
Binary files /dev/null and b/doc/source/_static/style/latex_stocks_html.png differ
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 0096b3337e19a..252670565ebff 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -9,13 +9,13 @@
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
-
 from datetime import datetime
 import importlib
 import inspect
 import logging
 import os
 import sys
+import warnings
 
 import jinja2
 from numpydoc.docscrape import NumpyDocString
@@ -50,23 +50,25 @@
 # sphinxext.
 
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.autosummary",
-    "sphinx.ext.doctest",
-    "sphinx.ext.extlinks",
-    "sphinx.ext.todo",
-    "numpydoc",  # handle NumPy documentation formatted docstrings
+    "contributors",  # custom pandas extension
     "IPython.sphinxext.ipython_directive",
     "IPython.sphinxext.ipython_console_highlighting",
     "matplotlib.sphinxext.plot_directive",
-    "sphinx.ext.intersphinx",
+    "numpydoc",
+    "sphinx_copybutton",
+    "sphinx_panels",
+    "sphinx_toggleprompt",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
     "sphinx.ext.coverage",
-    "sphinx.ext.mathjax",
+    "sphinx.ext.doctest",
+    "sphinx.ext.extlinks",
     "sphinx.ext.ifconfig",
+    "sphinx.ext.intersphinx",
     "sphinx.ext.linkcode",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.todo",
     "nbsphinx",
-    "sphinx_panels",
-    "contributors",  # custom pandas extension
 ]
 
 exclude_patterns = [
@@ -144,6 +146,9 @@
 # already loads it
 panels_add_bootstrap_css = False
 
+# https://sphinx-toggleprompt.readthedocs.io/en/stable/#offset
+toggleprompt_offset_right = 35
+
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["../_templates"]
 
@@ -158,7 +163,8 @@
 
 # General information about the project.
 project = "pandas"
-copyright = f"2008-{datetime.now().year}, the pandas development team"
+# We have our custom "pandas_footer.html" template, using copyright for the current year
+copyright = f"{datetime.now().year}"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -225,11 +231,25 @@
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
+
+switcher_version = version
+if ".dev" in version:
+    switcher_version = "dev"
+elif "rc" in version:
+    switcher_version = version.split("rc")[0] + " (rc)"
+
 html_theme_options = {
     "external_links": [],
+    "footer_items": ["pandas_footer", "sphinx-version"],
     "github_url": "https://github.com/pandas-dev/pandas",
     "twitter_url": "https://twitter.com/pandas_dev",
     "google_analytics_id": "UA-27880019-2",
+    "logo": {"image_dark": "https://pandas.pydata.org/static/img/pandas_white.svg"},
+    "navbar_end": ["version-switcher", "theme-switcher", "navbar-icon-links"],
+    "switcher": {
+        "json_url": "/versions.json",
+        "version_match": switcher_version,
+    },
 }
 
 # Add any paths that contain custom themes here, relative to this directory.
@@ -433,15 +453,13 @@
         "pandas-gbq": ("https://pandas-gbq.readthedocs.io/en/latest/", None),
         "py": ("https://pylib.readthedocs.io/en/latest/", None),
         "python": ("https://docs.python.org/3/", None),
-        "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None),
-        "statsmodels": ("https://www.statsmodels.org/devel/", None),
+        "scipy": ("https://docs.scipy.org/doc/scipy/", None),
         "pyarrow": ("https://arrow.apache.org/docs/", None),
     }
 
 # extlinks alias
 extlinks = {
     "issue": ("https://github.com/pandas-dev/pandas/issues/%s", "GH"),
-    "wiki": ("https://github.com/pandas-dev/pandas/wiki/%s", "wiki "),
 }
 
 
@@ -627,19 +645,30 @@ def linkcode_resolve(domain, info):
     obj = submod
     for part in fullname.split("."):
         try:
-            obj = getattr(obj, part)
+            with warnings.catch_warnings():
+                # Accessing deprecated objects will generate noisy warnings
+                warnings.simplefilter("ignore", FutureWarning)
+                obj = getattr(obj, part)
         except AttributeError:
             return None
 
     try:
         fn = inspect.getsourcefile(inspect.unwrap(obj))
     except TypeError:
-        fn = None
+        try:  # property
+            fn = inspect.getsourcefile(inspect.unwrap(obj.fget))
+        except (AttributeError, TypeError):
+            fn = None
     if not fn:
         return None
 
     try:
         source, lineno = inspect.getsourcelines(obj)
+    except TypeError:
+        try:  # property
+            source, lineno = inspect.getsourcelines(obj.fget)
+        except (AttributeError, TypeError):
+            lineno = None
     except OSError:
         lineno = None
 
@@ -651,7 +680,7 @@ def linkcode_resolve(domain, info):
     fn = os.path.relpath(fn, start=os.path.dirname(pandas.__file__))
 
     if "+" in pandas.__version__:
-        return f"https://github.com/pandas-dev/pandas/blob/master/pandas/%7Bfn%7D%7Blinespec%7D"
+        return f"https://github.com/pandas-dev/pandas/blob/main/pandas/%7Bfn%7D%7Blinespec%7D"
     else:
         return (
             f"https://github.com/pandas-dev/pandas/blob/"
diff --git a/doc/source/development/code_style.rst b/doc/source/development/code_style.rst
deleted file mode 100644
index 77c8d56765e5e..0000000000000
--- a/doc/source/development/code_style.rst
+++ /dev/null
@@ -1,80 +0,0 @@
-.. _code_style:
-
-{{ header }}
-
-=======================
-pandas code style guide
-=======================
-
-.. contents:: Table of contents:
-   :local:
-
-pandas follows the `PEP8 <https://www.python.org/dev/peps/pep-0008/>`_
-standard and uses `Black <https://black.readthedocs.io/en/stable/>`_
-and `Flake8 <https://flake8.pycqa.org/en/latest/>`_ to ensure a
-consistent code format throughout the project. We encourage you to use
-:ref:`pre-commit <contributing.pre-commit>` to automatically run ``black``,
-``flake8``, ``isort``, and related code checks when you make a git commit.
-
-Patterns
-========
-
-We use a ``flake8`` plugin, `pandas-dev-flaker <https://github.com/pandas-dev/pandas-dev-flaker>`_, to
-check our codebase for unwanted patterns. See its ``README`` for the up-to-date list of rules we enforce.
-
-Testing
-=======
-
-Failing tests
---------------
-
-See https://docs.pytest.org/en/latest/skipping.html for background.
-
-Do not use ``pytest.xfail``
----------------------------
-
-Do not use this method. It has the same behavior as ``pytest.skip``, namely
-it immediately stops the test and does not check if the test will fail. If
-this is the behavior you desire, use ``pytest.skip`` instead.
-
-Using ``pytest.mark.xfail``
----------------------------
-
-Use this method if a test is known to fail but the manner in which it fails
-is not meant to be captured. It is common to use this method for a test that
-exhibits buggy behavior or a non-implemented feature. If
-the failing test has flaky behavior, use the argument ``strict=False``. This
-will make it so pytest does not fail if the test happens to pass.
-
-Prefer the decorator ``@pytest.mark.xfail`` and the argument ``pytest.param``
-over usage within a test so that the test is appropriately marked during the
-collection phase of pytest. For xfailing a test that involves multiple
-parameters, a fixture, or a combination of these, it is only possible to
-xfail during the testing phase. To do so, use the ``request`` fixture:
-
-.. code-block:: python
-
-    import pytest
-
-    def test_xfail(request):
-        mark = pytest.mark.xfail(raises=TypeError, reason="Indicate why here")
-        request.node.add_marker(mark)
-
-xfail is not to be used for tests involving failure due to invalid user arguments.
-For these tests, we need to verify the correct exception type and error message
-is being raised, using ``pytest.raises`` instead.
-
-Miscellaneous
-=============
-
-Reading from a url
-------------------
-
-**Good:**
-
-.. code-block:: python
-
-    from pandas.io.common import urlopen
-
-    with urlopen("http://www.google.com/") as url:
-        raw_text = url.read()
diff --git a/doc/source/development/community.rst b/doc/source/development/community.rst
new file mode 100644
index 0000000000000..59689a2cf51d1
--- /dev/null
+++ b/doc/source/development/community.rst
@@ -0,0 +1,119 @@
+.. _community:
+
+=====================
+Contributor community
+=====================
+
+pandas is a community-driven open source project developed by a large group
+of `contributors <https://github.com/pandas-dev/pandas/graphs/contributors>`_
+and a smaller group of `maintainers <https://pandas.pydata.org/about/team.html>`_.
+The pandas leadership has made a strong commitment to creating an open,
+inclusive, and positive community. Please read the pandas `Code of Conduct
+<https://pandas.pydata.org/community/coc.html>`_ for guidance on how to
+interact with others in a way that makes the community thrive.
+
+We offer several meetings and communication channels to share knowledge and
+connect with others within the pandas community.
+
+Community meeting
+-----------------
+
+The pandas Community Meeting is a regular sync meeting for the project's
+maintainers which is open to the community. Everyone is welcome to attend and
+contribute to conversations.
+
+The meetings take place on the second Wednesday of each month at 18:00 UTC.
+
+The minutes of past meetings are available in `this Google Document <https://docs.google.com/document/d/1tGbTiYORHiSPgVMXawiweGJlBw5dOkVJLY-licoBmBU/edit?usp=sharing>`__.
+
+
+New contributor meeting
+-----------------------
+
+On the third Wednesday of the month, we hold meetings to welcome and support
+new contributors in our community.
+
+| 👋 you all are invited
+| 💬 everyone can present (add yourself to the hackMD agenda)
+| 👀 anyone can sit in and listen
+
+Attendees are new and experienced contributors, as well as a few maintainers.
+We aim to answer questions about getting started, or help with work in
+progress when possible, as well as get to know each other and share our
+learnings and experiences.
+
+The agenda for the next meeting and minutes of past meetings are available in
+`this HackMD <https://hackmd.io/@pandas-dev/HJgQt1Tei>`__.
+
+Calendar
+--------
+
+This calendar shows all the community meetings. Our community meetings are
+ideal for anyone wanting to contribute to pandas, or just curious to know how
+current development is going.
+
+.. raw:: html
+
+   <iframe src="https://calendar.google.com/calendar/embed?src=pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com" style="border: 0" width="800" height="600" frameborder="0" scrolling="no"></iframe>
+
+You can subscribe to this calendar with the following links:
+
+* `iCal <https://calendar.google.com/calendar/ical/pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com/public/basic.ics>`__
+* `Google calendar <https://calendar.google.com/calendar/r?cid=pgbn14p6poja8a1cf2dv2jhrmg@group.calendar.google.com>`__
+
+Additionally, we'll sometimes have one-off meetings on specific topics.
+These will be published on the same calendar.
+
+`GitHub issue tracker <https://github.com/pandas-dev/pandas/issues>`_
+----------------------------------------------------------------------
+
+The pandas contributor community conducts conversations mainly via this channel.
+Any community member can open issues to:
+
+- Report bugs, e.g. "I noticed the behavior of a certain function is
+  incorrect"
+- Request features, e.g. "I would like this error message to be more readable"
+- Request documentation improvements, e.g. "I found this section unclear"
+- Ask questions, e.g. "I noticed the behavior of a certain function
+  changed between versions. Is this expected?".
+
+    Ideally your questions should be related to how pandas work rather
+    than how you use pandas. `StackOverflow <https://stackoverflow.com/>`_ is
+    better suited for answering usage questions, and we ask that all usage
+    questions are first asked on StackOverflow. Thank you for respecting are
+    time and wishes. 🙇
+
+Maintainers and frequent contributors might also open issues to discuss the
+ongoing development of the project. For example:
+
+- Report issues with the CI, GitHub Actions, or the performance of pandas
+- Open issues relating to the internals
+- Start roadmap discussion aligning on proposals what to do in future
+  releases or changes to the API.
+- Open issues relating to the project's website, logo, or governance
+
+The developer mailing list
+--------------------------
+
+The pandas mailing list `pandas-dev@python.org <mailto://pandas-dev@python
+.org>`_ is used for long form
+conversations and to engages people in the wider community who might not
+be active on the issue tracker but we would like to include in discussions.
+
+.. _community.slack:
+
+Community slack
+---------------
+
+We have a chat platform for contributors, maintainers and potential
+contributors. This is not a space for user questions, rather for questions about
+contributing to pandas. The slack is a private space, specifically meant for
+people who are hesitant to bring up their questions or ideas on a large public
+mailing list or GitHub.
+
+If this sounds like the right place for you, you are welcome to join! Email us
+at `slack@pandas.pydata.org <mailto://slack@pandas.pydata.org>`_ and let us
+know that you read and agree to our `Code of Conduct <https://pandas.pydata.org/community/coc.html>`_
+😉 to get an invite. And please remember the slack is not meant to replace the
+mailing list or issue tracker - all important announcements and conversations
+should still happen there.
diff --git a/doc/source/development/contributing.rst b/doc/source/development/contributing.rst
index 9b3d50069b077..faa3d29a628f9 100644
--- a/doc/source/development/contributing.rst
+++ b/doc/source/development/contributing.rst
@@ -45,8 +45,13 @@ assigned issues, since people may not be working in them anymore. If you want to
 that is assigned, feel free to kindly ask the current assignee if you can take it
 (please allow at least a week of inactivity before considering work in the issue discontinued).
 
-Feel free to ask questions on the `mailing list
-<https://groups.google.com/forum/?fromgroups#!forum/pydata>`_ or on `Gitter`_.
+We have several :ref:`contributor community <community>` communication channels, which you are
+welcome to join, and ask questions as you figure things out. Among them are regular meetings for
+new contributors, dev meetings, a dev mailing list, and a slack for the contributor community.
+All pandas contributors are welcome to these spaces, where they can connect with each other. Even
+maintainers who have been with us for a long time felt just like you when they started out, and
+are happy to welcome you and support you as you get to know how we work, and where things are.
+Take a look at the next sections to learn more.
 
 .. _contributing.bug_reports:
 
@@ -59,7 +64,7 @@ will allow others to reproduce the bug and provide insight into fixing. See
 `this blogpost <https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports>`_
 for tips on writing a good bug report.
 
-Trying the bug-producing code out on the *master* branch is often a worthwhile exercise
+Trying the bug-producing code out on the *main* branch is often a worthwhile exercise
 to confirm the bug still exists. It is also worth searching existing bug reports and pull requests
 to see if the issue has already been reported and/or fixed.
 
@@ -143,7 +148,7 @@ as the version number cannot be computed anymore.
 Creating a branch
 -----------------
 
-You want your master branch to reflect only production-ready code, so create a
+You want your main branch to reflect only production-ready code, so create a
 feature branch for making your changes. For example::
 
     git branch shiny-new-feature
@@ -158,14 +163,14 @@ changes in this branch specific to one bug or feature so it is clear
 what the branch brings to pandas. You can have many shiny-new-features
 and switch in between them using the git checkout command.
 
-When creating this branch, make sure your master branch is up to date with
-the latest upstream master version. To update your local master branch, you
+When creating this branch, make sure your main branch is up to date with
+the latest upstream main version. To update your local main branch, you
 can do::
 
-    git checkout master
-    git pull upstream master --ff-only
+    git checkout main
+    git pull upstream main --ff-only
 
-When you want to update the feature branch with changes in master after
+When you want to update the feature branch with changes in main after
 you created the branch, check the section on
 :ref:`updating a PR <contributing.update-pr>`.
 
@@ -256,7 +261,7 @@ double check your branch changes against the branch it was based on:
 #. Navigate to your repository on GitHub -- https://github.com/your-user-name/pandas
 #. Click on ``Branches``
 #. Click on the ``Compare`` button for your feature branch
-#. Select the ``base`` and ``compare`` branches, if necessary. This will be ``master`` and
+#. Select the ``base`` and ``compare`` branches, if necessary. This will be ``main`` and
    ``shiny-new-feature``, respectively.
 
 Finally, make the pull request
@@ -264,8 +269,8 @@ Finally, make the pull request
 
 If everything looks good, you are ready to make a pull request.  A pull request is how
 code from a local repository becomes available to the GitHub community and can be looked
-at and eventually merged into the master version.  This pull request and its associated
-changes will eventually be committed to the master branch and available in the next
+at and eventually merged into the main version.  This pull request and its associated
+changes will eventually be committed to the main branch and available in the next
 release.  To submit a pull request:
 
 #. Navigate to your repository on GitHub
@@ -294,14 +299,14 @@ This will automatically update your pull request with the latest code and restar
 :any:`Continuous Integration <contributing.ci>` tests.
 
 Another reason you might need to update your pull request is to solve conflicts
-with changes that have been merged into the master branch since you opened your
+with changes that have been merged into the main branch since you opened your
 pull request.
 
-To do this, you need to "merge upstream master" in your branch::
+To do this, you need to "merge upstream main" in your branch::
 
     git checkout shiny-new-feature
     git fetch upstream
-    git merge upstream/master
+    git merge upstream/main
 
 If there are no conflicts (or they could be fixed automatically), a file with a
 default commit message will open, and you can simply save and quit this file.
@@ -313,7 +318,7 @@ Once the conflicts are merged and the files where the conflicts were solved are
 added, you can run ``git commit`` to save those fixes.
 
 If you have uncommitted changes at the moment you want to update the branch with
-master, you will need to ``stash`` them prior to updating (see the
+main, you will need to ``stash`` them prior to updating (see the
 `stash docs <https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning>`__).
 This will effectively store your changes and they can be reapplied after updating.
 
@@ -326,13 +331,7 @@ Autofixing formatting errors
 ----------------------------
 
 We use several styling checks (e.g. ``black``, ``flake8``, ``isort``) which are run after
-you make a pull request. If there is a scenario where any of these checks fail then you
-can comment::
-
-    @github-actions pre-commit
-
-on that pull request. This will trigger a workflow which will autofix formatting
-errors.
+you make a pull request.
 
 To automatically fix formatting errors on each commit you make, you can
 set up pre-commit yourself. First, create a Python :ref:`environment
@@ -342,12 +341,12 @@ Delete your merged branch (optional)
 ------------------------------------
 
 Once your feature branch is accepted into upstream, you'll probably want to get rid of
-the branch. First, merge upstream master into your branch so git knows it is safe to
+the branch. First, merge upstream main into your branch so git knows it is safe to
 delete your branch::
 
     git fetch upstream
-    git checkout master
-    git merge upstream/master
+    git checkout main
+    git merge upstream/main
 
 Then you can do::
 
@@ -360,8 +359,6 @@ The branch will still exist on GitHub, so to delete it there do::
 
     git push origin --delete shiny-new-feature
 
-.. _Gitter: https://gitter.im/pydata/pandas
-
 
 Tips for a successful pull request
 ==================================
diff --git a/doc/source/development/contributing_codebase.rst b/doc/source/development/contributing_codebase.rst
index 41fe88e02318a..26692057f3e23 100644
--- a/doc/source/development/contributing_codebase.rst
+++ b/doc/source/development/contributing_codebase.rst
@@ -23,9 +23,9 @@ contributing them to the project::
 
    ./ci/code_checks.sh
 
-The script validates the doctests, formatting in docstrings, static typing, and
+The script validates the doctests, formatting in docstrings, and
 imported modules. It is possible to run the checks independently by using the
-parameters ``docstring``, ``code``, ``typing``, and ``doctests``
+parameters ``docstring``, ``code``, and ``doctests``
 (e.g. ``./ci/code_checks.sh doctests``).
 
 In addition, because a lot of people use our library, it is important that we
@@ -33,20 +33,20 @@ do not make sudden changes to the code that could have the potential to break
 a lot of user code as a result, that is, we need it to be as *backwards compatible*
 as possible to avoid mass breakages.
 
-In addition to ``./ci/code_checks.sh``, some extra checks are run by
-``pre-commit`` - see :ref:`here <contributing.pre-commit>` for how to
-run them.
-
-Additional standards are outlined on the :ref:`pandas code style guide <code_style>`.
+In addition to ``./ci/code_checks.sh``, some extra checks (including static type
+checking) are run by ``pre-commit`` - see :ref:`here <contributing.pre-commit>`
+for how to run them.
 
 .. _contributing.pre-commit:
 
 Pre-commit
 ----------
 
-You can run many of these styling checks manually as we have described above. However,
-we encourage you to use `pre-commit hooks <https://pre-commit.com/>`_ instead
-to automatically run ``black``, ``flake8``, ``isort`` when you make a git commit. This
+Additionally, :ref:`Continuous Integration <contributing.ci>` will run code formatting checks
+like ``black``, ``flake8`` (including a `pandas-dev-flaker <https://github.com/pandas-dev/pandas-dev-flaker>`_ plugin),
+``isort``, and ``cpplint`` and more using `pre-commit hooks <https://pre-commit.com/>`_
+Any warnings from these checks will cause the :ref:`Continuous Integration <contributing.ci>` to fail; therefore,
+it is helpful to run the check yourself before submitting code. This
 can be done by installing ``pre-commit``::
 
     pip install pre-commit
@@ -69,12 +69,17 @@ to run its checks with::
 
 without needing to have done ``pre-commit install`` beforehand.
 
-If you want to run checks on all recently committed files on upstream/master you can use::
+If you want to run checks on all recently committed files on upstream/main you can use::
 
-    pre-commit run --from-ref=upstream/master --to-ref=HEAD --all-files
+    pre-commit run --from-ref=upstream/main --to-ref=HEAD --all-files
 
 without needing to have done ``pre-commit install`` beforehand.
 
+.. note::
+
+    You may want to periodically run ``pre-commit gc``, to clean up repos
+    which are no longer used.
+
 .. note::
 
     If you have conflicting installations of ``virtualenv``, then you may get an
@@ -99,157 +104,8 @@ All optional dependencies should be documented in
 :ref:`install.optional_dependencies` and the minimum required version should be
 set in the ``pandas.compat._optional.VERSIONS`` dict.
 
-C (cpplint)
-~~~~~~~~~~~
-
-pandas uses the `Google <https://google.github.io/styleguide/cppguide.html>`_
-standard. Google provides an open source style checker called ``cpplint``, but we
-use a fork of it that can be found `here <https://github.com/cpplint/cpplint>`__.
-Here are *some* of the more common ``cpplint`` issues:
-
-* we restrict line-length to 80 characters to promote readability
-* every header file must include a header guard to avoid name collisions if re-included
-
-:ref:`Continuous Integration <contributing.ci>` will run the
-`cpplint <https://pypi.org/project/cpplint>`_ tool
-and report any stylistic errors in your code. Therefore, it is helpful before
-submitting code to run the check yourself::
-
-   cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir modified-c-file
-
-You can also run this command on an entire directory if necessary::
-
-   cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir --recursive modified-c-directory
-
-To make your commits compliant with this standard, you can install the
-`ClangFormat <https://clang.llvm.org/docs/ClangFormat.html>`_ tool, which can be
-downloaded `here <https://llvm.org/builds/>`__. To configure, in your home directory,
-run the following command::
-
-    clang-format style=google -dump-config  > .clang-format
-
-Then modify the file to ensure that any indentation width parameters are at least four.
-Once configured, you can run the tool as follows::
-
-    clang-format modified-c-file
-
-This will output what your file will look like if the changes are made, and to apply
-them, run the following command::
-
-    clang-format -i modified-c-file
-
-To run the tool on an entire directory, you can run the following analogous commands::
-
-    clang-format modified-c-directory/*.c modified-c-directory/*.h
-    clang-format -i modified-c-directory/*.c modified-c-directory/*.h
-
-Do note that this tool is best-effort, meaning that it will try to correct as
-many errors as possible, but it may not correct *all* of them. Thus, it is
-recommended that you run ``cpplint`` to double check and make any other style
-fixes manually.
-
-.. _contributing.code-formatting:
-
-Python (PEP8 / black)
-~~~~~~~~~~~~~~~~~~~~~
-
-pandas follows the `PEP8 <https://www.python.org/dev/peps/pep-0008/>`_ standard
-and uses `Black <https://black.readthedocs.io/en/stable/>`_ and
-`Flake8 <http://flake8.pycqa.org/en/latest/>`_ to ensure a consistent code
-format throughout the project. We encourage you to use :ref:`pre-commit <contributing.pre-commit>`.
-
-:ref:`Continuous Integration <contributing.ci>` will run those tools and
-report any stylistic errors in your code. Therefore, it is helpful before
-submitting code to run the check yourself::
-
-   black pandas
-   git diff upstream/master -u -- "*.py" | flake8 --diff
-
-to auto-format your code. Additionally, many editors have plugins that will
-apply ``black`` as you edit files.
-
-You should use a ``black`` version 21.5b2 as previous versions are not compatible
-with the pandas codebase.
-
-One caveat about ``git diff upstream/master -u -- "*.py" | flake8 --diff``: this
-command will catch any stylistic errors in your changes specifically, but
-be beware it may not catch all of them. For example, if you delete the only
-usage of an imported function, it is stylistically incorrect to import an
-unused function. However, style-checking the diff will not catch this because
-the actual import is not part of the diff. Thus, for completeness, you should
-run this command, though it may take longer::
-
-   git diff upstream/master --name-only -- "*.py" | xargs -r flake8
-
-Note that on macOS, the ``-r`` flag is not available, so you have to omit it and
-run this slightly modified command::
-
-   git diff upstream/master --name-only -- "*.py" | xargs flake8
-
-Windows does not support the ``xargs`` command (unless installed for example
-via the `MinGW <http://www.mingw.org/>`__ toolchain), but one can imitate the
-behaviour as follows::
-
-    for /f %i in ('git diff upstream/master --name-only -- "*.py"') do flake8 %i
-
-This will get all the files being changed by the PR (and ending with ``.py``),
-and run ``flake8`` on them, one after the other.
-
-Note that these commands can be run analogously with ``black``.
-
-.. _contributing.import-formatting:
-
-Import formatting
-~~~~~~~~~~~~~~~~~
-pandas uses `isort <https://pypi.org/project/isort/>`__ to standardise import
-formatting across the codebase.
-
-A guide to import layout as per pep8 can be found `here <https://www.python.org/dev/peps/pep-0008/#imports/>`__.
-
-A summary of our current import sections ( in order ):
-
-* Future
-* Python Standard Library
-* Third Party
-* ``pandas._libs``, ``pandas.compat``, ``pandas.util._*``, ``pandas.errors`` (largely not dependent on ``pandas.core``)
-* ``pandas.core.dtypes`` (largely not dependent on the rest of ``pandas.core``)
-* Rest of ``pandas.core.*``
-* Non-core ``pandas.io``, ``pandas.plotting``, ``pandas.tseries``
-* Local application/library specific imports
-
-Imports are alphabetically sorted within these sections.
-
-As part of :ref:`Continuous Integration <contributing.ci>` checks we run::
-
-    isort --check-only pandas
-
-to check that imports are correctly formatted as per the ``setup.cfg``.
-
-If you see output like the below in :ref:`Continuous Integration <contributing.ci>` checks:
-
-.. code-block:: shell
-
-   Check import format using isort
-   ERROR: /home/travis/build/pandas-dev/pandas/pandas/io/pytables.py Imports are incorrectly sorted
-   Check import format using isort DONE
-   The command "ci/code_checks.sh" exited with 1
-
-You should run::
-
-    isort pandas/io/pytables.py
-
-to automatically format imports correctly. This will modify your local copy of the files.
-
-Alternatively, you can run a command similar to what was suggested for ``black`` and ``flake8`` :ref:`right above <contributing.code-formatting>`::
-
-    git diff upstream/master --name-only -- "*.py" | xargs -r isort
-
-Where similar caveats apply if you are on macOS or Windows.
-
-You can then verify the changes look ok, then git :any:`commit <contributing.commit-code>` and :any:`push <contributing.push-code>`.
-
 Backwards compatibility
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 Please try to maintain backward compatibility. pandas has lots of users with lots of
 existing code, so don't break it if at all possible.  If you think breakage is required,
@@ -271,6 +127,7 @@ Otherwise, you need to do it manually:
 .. code-block:: python
 
     import warnings
+    from pandas.util._exceptions import find_stack_level
 
 
     def old_func():
@@ -279,7 +136,11 @@ Otherwise, you need to do it manually:
         .. deprecated:: 1.1.0
            Use new_func instead.
         """
-        warnings.warn('Use new_func instead.', FutureWarning, stacklevel=2)
+        warnings.warn(
+            'Use new_func instead.',
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
         new_func()
 
 
@@ -371,7 +232,7 @@ In some cases you may be tempted to use ``cast`` from the typing module when you
            ...
        else:  # Reasonably only str objects would reach this but...
            obj = cast(str, obj)  # Mypy complains without this!
-	   return obj.upper()
+           return obj.upper()
 
 The limitation here is that while a human can reasonably understand that ``is_number`` would catch the ``int`` and ``float`` types mypy cannot make that same inference just yet (see `mypy #5206 <https://github.com/python/mypy/issues/5206>`_. While the above works, the use of ``cast`` is **strongly discouraged**. Where applicable a refactor of the code to appease static analysis is preferable
 
@@ -389,7 +250,7 @@ With custom types and inference this is not always possible so exceptions are ma
 pandas-specific types
 ~~~~~~~~~~~~~~~~~~~~~
 
-Commonly used types specific to pandas will appear in `pandas._typing <https://github.com/pandas-dev/pandas/blob/master/pandas/_typing.py>`_ and you should use these where applicable. This module is private for now but ultimately this should be exposed to third party libraries who want to implement type checking against pandas.
+Commonly used types specific to pandas will appear in `pandas._typing <https://github.com/pandas-dev/pandas/blob/main/pandas/_typing.py>`_ and you should use these where applicable. This module is private for now but ultimately this should be exposed to third party libraries who want to implement type checking against pandas.
 
 For example, quite a few functions in pandas accept a ``dtype`` argument. This can be expressed as a string like ``"object"``, a ``numpy.dtype`` like ``np.int64`` or even a pandas ``ExtensionDtype`` like ``pd.CategoricalDtype``. Rather than burden the user with having to constantly annotate all of those options, this can simply be imported and reused from the pandas._typing module
 
@@ -409,14 +270,13 @@ pandas uses `mypy <http://mypy-lang.org>`_ and `pyright <https://github.com/micr
 
 .. code-block:: shell
 
-   mypy
+    # the following might fail if the installed pandas version does not correspond to your local git version
+    pre-commit run --hook-stage manual --all-files
 
-   # let pre-commit setup and run pyright
-   pre-commit run --hook-stage manual --all-files pyright
-   # or if pyright is installed (requires node.js)
-   pyright
+    # if the above fails due to stubtest
+    SKIP=stubtest pre-commit run --hook-stage manual --all-files
 
-A recent version of ``numpy`` (>=1.21.0) is required for type validation.
+in your activated python environment. A recent version of ``numpy`` (>=1.22.0) is required for type validation.
 
 .. _contributing.ci:
 
@@ -443,13 +303,11 @@ library. This makes type checkers aware of the type annotations shipped with pan
 Testing with continuous integration
 -----------------------------------
 
-The pandas test suite will run automatically on `GitHub Actions <https://github.com/features/actions/>`__ and
-`Azure Pipelines <https://azure.microsoft.com/en-us/services/devops/pipelines/>`__
+The pandas test suite will run automatically on `GitHub Actions <https://github.com/features/actions/>`__
 continuous integration services, once your pull request is submitted.
 However, if you wish to run the test suite on a branch prior to submitting the pull request,
 then the continuous integration services need to be hooked to your GitHub repository. Instructions are here
-for `GitHub Actions <https://docs.github.com/en/actions/>`__ and
-`Azure Pipelines <https://docs.microsoft.com/en-us/azure/devops/pipelines/>`__.
+for `GitHub Actions <https://docs.github.com/en/actions/>`__.
 
 A pull-request will be considered for merging when you have an all 'green' build. If any tests are failing,
 then you will get a red 'X', where you can click through to see the individual failed tests.
@@ -460,8 +318,8 @@ This is an example of a green build.
 .. _contributing.tdd:
 
 
-Test-driven development/code writing
-------------------------------------
+Test-driven development
+-----------------------
 
 pandas is serious about testing and strongly encourages contributors to embrace
 `test-driven development (TDD) <https://en.wikipedia.org/wiki/Test-driven_development>`_.
@@ -475,61 +333,190 @@ use cases and writing corresponding tests.
 Adding tests is one of the most common requests after code is pushed to pandas.  Therefore,
 it is worth getting in the habit of writing tests ahead of time so this is never an issue.
 
-Like many packages, pandas uses `pytest
-<https://docs.pytest.org/en/latest/>`_ and the convenient
-extensions in `numpy.testing
-<https://numpy.org/doc/stable/reference/routines.testing.html>`_.
-
-.. note::
-
-   The earliest supported pytest version is 5.0.1.
-
 Writing tests
 ~~~~~~~~~~~~~
 
 All tests should go into the ``tests`` subdirectory of the specific package.
 This folder contains many current examples of tests, and we suggest looking to these for
-inspiration.  If your test requires working with files or
-network connectivity, there is more information on the `testing page
-<https://github.com/pandas-dev/pandas/wiki/Testing>`_ of the wiki.
+inspiration. Ideally, there should be one, and only one, obvious place for a test to reside.
+Until we reach that ideal, these are some rules of thumb for where a test should
+be located.
+
+1. Does your test depend only on code in ``pd._libs.tslibs``?
+   This test likely belongs in one of:
+
+   - tests.tslibs
+
+     .. note::
+
+          No file in ``tests.tslibs`` should import from any pandas modules
+          outside of ``pd._libs.tslibs``
+
+   - tests.scalar
+   - tests.tseries.offsets
+
+2. Does your test depend only on code in pd._libs?
+   This test likely belongs in one of:
+
+   - tests.libs
+   - tests.groupby.test_libgroupby
+
+3. Is your test for an arithmetic or comparison method?
+   This test likely belongs in one of:
+
+   - tests.arithmetic
+
+     .. note::
+
+         These are intended for tests that can be shared to test the behavior
+         of DataFrame/Series/Index/ExtensionArray using the ``box_with_array``
+         fixture.
+
+   - tests.frame.test_arithmetic
+   - tests.series.test_arithmetic
+
+4. Is your test for a reduction method (min, max, sum, prod, ...)?
+   This test likely belongs in one of:
+
+   - tests.reductions
+
+     .. note::
+
+         These are intended for tests that can be shared to test the behavior
+         of DataFrame/Series/Index/ExtensionArray.
+
+   - tests.frame.test_reductions
+   - tests.series.test_reductions
+   - tests.test_nanops
+
+5. Is your test for an indexing method?
+   This is the most difficult case for deciding where a test belongs, because
+   there are many of these tests, and many of them test more than one method
+   (e.g. both ``Series.__getitem__`` and ``Series.loc.__getitem__``)
+
+   A) Is the test specifically testing an Index method (e.g. ``Index.get_loc``,
+      ``Index.get_indexer``)?
+      This test likely belongs in one of:
+
+      - tests.indexes.test_indexing
+      - tests.indexes.fooindex.test_indexing
+
+      Within that files there should be a method-specific test class e.g.
+      ``TestGetLoc``.
+
+      In most cases, neither ``Series`` nor ``DataFrame`` objects should be
+      needed in these tests.
+
+   B) Is the test for a Series or DataFrame indexing method *other* than
+      ``__getitem__`` or ``__setitem__``, e.g. ``xs``, ``where``, ``take``,
+      ``mask``, ``lookup``, or ``insert``?
+      This test likely belongs in one of:
+
+      - tests.frame.indexing.test_methodname
+      - tests.series.indexing.test_methodname
+
+   C) Is the test for any of ``loc``, ``iloc``, ``at``, or ``iat``?
+      This test likely belongs in one of:
+
+      - tests.indexing.test_loc
+      - tests.indexing.test_iloc
+      - tests.indexing.test_at
+      - tests.indexing.test_iat
+
+      Within the appropriate file, test classes correspond to either types of
+      indexers (e.g. ``TestLocBooleanMask``) or major use cases
+      (e.g. ``TestLocSetitemWithExpansion``).
+
+      See the note in section D) about tests that test multiple indexing methods.
+
+   D) Is the test for ``Series.__getitem__``, ``Series.__setitem__``,
+      ``DataFrame.__getitem__``, or ``DataFrame.__setitem__``?
+      This test likely belongs in one of:
+
+      - tests.series.test_getitem
+      - tests.series.test_setitem
+      - tests.frame.test_getitem
+      - tests.frame.test_setitem
+
+      If many cases such a test may test multiple similar methods, e.g.
+
+      .. code-block:: python
+
+           import pandas as pd
+           import pandas._testing as tm
+
+           def test_getitem_listlike_of_ints():
+               ser = pd.Series(range(5))
+
+               result = ser[[3, 4]]
+               expected = pd.Series([2, 3])
+               tm.assert_series_equal(result, expected)
+
+               result = ser.loc[[3, 4]]
+               tm.assert_series_equal(result, expected)
+
+    In cases like this, the test location should be based on the *underlying*
+    method being tested.  Or in the case of a test for a bugfix, the location
+    of the actual bug.  So in this example, we know that ``Series.__getitem__``
+    calls ``Series.loc.__getitem__``, so this is *really* a test for
+    ``loc.__getitem__``.  So this test belongs in ``tests.indexing.test_loc``.
+
+6. Is your test for a DataFrame or Series method?
 
-The ``pandas._testing`` module has many special ``assert`` functions that
-make it easier to make statements about whether Series or DataFrame objects are
-equivalent. The easiest way to verify that your code is correct is to
-explicitly construct the result you expect, then compare the actual result to
-the expected correct result::
+   A) Is the method a plotting method?
+      This test likely belongs in one of:
 
-    def test_pivot(self):
-        data = {
-            'index' : ['A', 'B', 'C', 'C', 'B', 'A'],
-            'columns' : ['One', 'One', 'One', 'Two', 'Two', 'Two'],
-            'values' : [1., 2., 3., 3., 2., 1.]
-        }
+      - tests.plotting
 
-        frame = DataFrame(data)
-        pivoted = frame.pivot(index='index', columns='columns', values='values')
+   B) Is the method an IO method?
+      This test likely belongs in one of:
 
-        expected = DataFrame({
-            'One' : {'A' : 1., 'B' : 2., 'C' : 3.},
-            'Two' : {'A' : 1., 'B' : 2., 'C' : 3.}
-        })
+      - tests.io
 
-        assert_frame_equal(pivoted, expected)
+   C) Otherwise
+      This test likely belongs in one of:
 
-Please remember to add the Github Issue Number as a comment to a new test.
-E.g. "# brief comment, see GH#28907"
+      - tests.series.methods.test_mymethod
+      - tests.frame.methods.test_mymethod
 
-Transitioning to ``pytest``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        .. note::
+
+            If a test can be shared between DataFrame/Series using the
+            ``frame_or_series`` fixture, by convention it goes in the
+            ``tests.frame`` file.
+
+7. Is your test for an Index method, not depending on Series/DataFrame?
+   This test likely belongs in one of:
+
+   - tests.indexes
+
+8) Is your test for one of the pandas-provided ExtensionArrays (``Categorical``,
+   ``DatetimeArray``, ``TimedeltaArray``, ``PeriodArray``, ``IntervalArray``,
+   ``PandasArray``, ``FloatArray``, ``BoolArray``, ``StringArray``)?
+   This test likely belongs in one of:
+
+   - tests.arrays
+
+9) Is your test for *all* ExtensionArray subclasses (the "EA Interface")?
+   This test likely belongs in one of:
+
+   - tests.extension
+
+Using ``pytest``
+~~~~~~~~~~~~~~~~
+
+Test structure
+^^^^^^^^^^^^^^
 
 pandas existing test structure is *mostly* class-based, meaning that you will typically find tests wrapped in a class.
 
 .. code-block:: python
 
-    class TestReallyCoolFeature:
-        pass
+   class TestReallyCoolFeature:
+       def test_cool_feature_aspect(self):
+           pass
 
-Going forward, we are moving to a more *functional* style using the `pytest <https://docs.pytest.org/en/latest/>`__ framework, which offers a richer testing
+We prefer a more *functional* style using the `pytest <https://docs.pytest.org/en/latest/>`__ framework, which offers a richer testing
 framework that will facilitate testing and developing. Thus, instead of writing test classes, we will write test functions like this:
 
 .. code-block:: python
@@ -537,21 +524,135 @@ framework that will facilitate testing and developing. Thus, instead of writing
     def test_really_cool_feature():
         pass
 
-Using ``pytest``
-~~~~~~~~~~~~~~~~
+Preferred ``pytest`` idioms
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+* Functional tests named ``def test_*`` and *only* take arguments that are either fixtures or parameters.
+* Use a bare ``assert`` for testing scalars and truth-testing
+* Use ``tm.assert_series_equal(result, expected)`` and ``tm.assert_frame_equal(result, expected)`` for comparing :class:`Series` and :class:`DataFrame` results respectively.
+* Use `@pytest.mark.parameterize <https://docs.pytest.org/en/latest/how-to/parametrize.html>`__ when testing multiple cases.
+* Use `pytest.mark.xfail <https://docs.pytest.org/en/latest/reference/reference.html?#pytest.mark.xfail>`__ when a test case is expected to fail.
+* Use `pytest.mark.skip <https://docs.pytest.org/en/latest/reference/reference.html?#pytest.mark.skip>`__ when a test case is never expected to pass.
+* Use `pytest.param <https://docs.pytest.org/en/latest/reference/reference.html?#pytest-param>`__ when a test case needs a particular mark.
+* Use `@pytest.fixture <https://docs.pytest.org/en/latest/reference/reference.html?#pytest-fixture>`__ if multiple tests can share a setup object.
+
+.. warning::
+
+    Do not use ``pytest.xfail`` (which is different than ``pytest.mark.xfail``) since it immediately stops the
+    test and does not check if the test will fail. If this is the behavior you desire, use ``pytest.skip`` instead.
+
+If a test is known to fail but the manner in which it fails
+is not meant to be captured, use ``pytest.mark.xfail`` It is common to use this method for a test that
+exhibits buggy behavior or a non-implemented feature. If
+the failing test has flaky behavior, use the argument ``strict=False``. This
+will make it so pytest does not fail if the test happens to pass.
+
+Prefer the decorator ``@pytest.mark.xfail`` and the argument ``pytest.param``
+over usage within a test so that the test is appropriately marked during the
+collection phase of pytest. For xfailing a test that involves multiple
+parameters, a fixture, or a combination of these, it is only possible to
+xfail during the testing phase. To do so, use the ``request`` fixture:
+
+.. code-block:: python
+
+    def test_xfail(request):
+        mark = pytest.mark.xfail(raises=TypeError, reason="Indicate why here")
+        request.node.add_marker(mark)
+
+xfail is not to be used for tests involving failure due to invalid user arguments.
+For these tests, we need to verify the correct exception type and error message
+is being raised, using ``pytest.raises`` instead.
+
+.. _contributing.warnings:
+
+Testing a warning
+^^^^^^^^^^^^^^^^^
+
+Use ``tm.assert_produces_warning`` as a context manager to check that a block of code raises a warning.
+
+.. code-block:: python
+
+    with tm.assert_produces_warning(DeprecationWarning):
+        pd.deprecated_function()
+
+If a warning should specifically not happen in a block of code, pass ``False`` into the context manager.
+
+.. code-block:: python
+
+    with tm.assert_produces_warning(False):
+        pd.no_warning_function()
+
+If you have a test that would emit a warning, but you aren't actually testing the
+warning itself (say because it's going to be removed in the future, or because we're
+matching a 3rd-party library's behavior), then use ``pytest.mark.filterwarnings`` to
+ignore the error.
+
+.. code-block:: python
+
+    @pytest.mark.filterwarnings("ignore:msg:category")
+    def test_thing(self):
+        pass
+
+If you need finer-grained control, you can use Python's
+`warnings module <https://docs.python.org/3/library/warnings.html>`__
+to control whether a warning is ignored or raised at different places within
+a single test.
+
+.. code-block:: python
 
-Here is an example of a self-contained set of tests that illustrate multiple features that we like to use.
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", FutureWarning)
 
-* functional style: tests are like ``test_*`` and *only* take arguments that are either fixtures or parameters
-* ``pytest.mark`` can be used to set metadata on test functions, e.g. ``skip`` or ``xfail``.
-* using ``parametrize``: allow testing of multiple cases
-* to set a mark on a parameter, ``pytest.param(..., marks=...)`` syntax should be used
-* ``fixture``, code for object construction, on a per-test basis
-* using bare ``assert`` for scalars and truth-testing
-* ``tm.assert_series_equal`` (and its counter part ``tm.assert_frame_equal``), for pandas object comparisons.
-* the typical pattern of constructing an ``expected`` and comparing versus the ``result``
+Testing an exception
+^^^^^^^^^^^^^^^^^^^^
 
-We would name this file ``test_cool_feature.py`` and put in an appropriate place in the ``pandas/tests/`` structure.
+Use `pytest.raises <https://docs.pytest.org/en/latest/reference/reference.html#pytest-raises>`_ as a context manager
+with the specific exception subclass (i.e. never use :py:class:`Exception`) and the exception message in ``match``.
+
+.. code-block:: python
+
+    with pytest.raises(ValueError, match="an error"):
+        raise ValueError("an error")
+
+Testing involving files
+^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``tm.ensure_clean`` context manager creates a temporary file for testing,
+with a generated filename (or your filename if provided), that is automatically
+deleted when the context block is exited.
+
+.. code-block:: python
+
+    with tm.ensure_clean('my_file_path') as path:
+        # do something with the path
+
+Testing involving network connectivity
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+It is highly discouraged to add a test that connects to the internet due to flakiness of network connections and
+lack of ownership of the server that is being connected to. If network connectivity is absolutely required, use the
+``tm.network`` decorator.
+
+.. code-block:: python
+
+    @tm.network   # noqa
+    def test_network():
+        result = package.call_to_internet()
+
+If the test requires data from a specific website, specify ``check_before_test=True`` and the site in the decorator.
+
+.. code-block:: python
+
+    @tm.network("https://www.somespecificsite.com/", check_before_test=True)
+    def test_network():
+        result = pd.read_html("https://www.somespecificsite.com/")
+
+Example
+^^^^^^^
+
+Here is an example of a self-contained set of tests in a file ``pandas/tests/test_cool_feature.py``
+that illustrate multiple features that we like to use. Please remember to add the Github Issue Number
+as a comment to a new test.
 
 .. code-block:: python
 
@@ -584,6 +685,7 @@ We would name this file ``test_cool_feature.py`` and put in an appropriate place
 
 
    def test_series(series, dtype):
+       # GH <issue_number>
        result = series.astype(dtype)
        assert result.dtype == dtype
 
@@ -631,7 +733,7 @@ Tests that we have ``parametrized`` are now accessible via the test name, for ex
 Using ``hypothesis``
 ~~~~~~~~~~~~~~~~~~~~
 
-Hypothesis is a library for property-based testing.  Instead of explicitly
+Hypothesis is a library for property-based testing. Instead of explicitly
 parametrizing a test, you can describe *all* valid inputs and let Hypothesis
 try to find a failing input.  Even better, no matter how many random examples
 it tries, Hypothesis always reports a single minimal counterexample to your
@@ -666,59 +768,6 @@ preferred if the inputs or logic are simple, with Hypothesis tests reserved
 for cases with complex logic or where there are too many combinations of
 options or subtle interactions to test (or think of!) all of them.
 
-.. _contributing.warnings:
-
-Testing warnings
-~~~~~~~~~~~~~~~~
-
-By default, one of pandas CI workers will fail if any unhandled warnings are emitted.
-
-If your change involves checking that a warning is actually emitted, use
-``tm.assert_produces_warning(ExpectedWarning)``.
-
-
-.. code-block:: python
-
-   import pandas._testing as tm
-
-
-   df = pd.DataFrame()
-   with tm.assert_produces_warning(FutureWarning):
-       df.some_operation()
-
-We prefer this to the ``pytest.warns`` context manager because ours checks that the warning's
-stacklevel is set correctly. The stacklevel is what ensure the *user's* file name and line number
-is printed in the warning, rather than something internal to pandas. It represents the number of
-function calls from user code (e.g. ``df.some_operation()``) to the function that actually emits
-the warning. Our linter will fail the build if you use ``pytest.warns`` in a test.
-
-If you have a test that would emit a warning, but you aren't actually testing the
-warning itself (say because it's going to be removed in the future, or because we're
-matching a 3rd-party library's behavior), then use ``pytest.mark.filterwarnings`` to
-ignore the error.
-
-.. code-block:: python
-
-   @pytest.mark.filterwarnings("ignore:msg:category")
-   def test_thing(self):
-       ...
-
-If the test generates a warning of class ``category`` whose message starts
-with ``msg``, the warning will be ignored and the test will pass.
-
-If you need finer-grained control, you can use Python's usual
-`warnings module <https://docs.python.org/3/library/warnings.html>`__
-to control whether a warning is ignored / raised at different places within
-a single test.
-
-.. code-block:: python
-
-   with warnings.catch_warnings():
-       warnings.simplefilter("ignore", FutureWarning)
-       # Or use warnings.filterwarnings(...)
-
-Alternatively, consider breaking up the unit test.
-
 
 Running the test suite
 ----------------------
@@ -728,8 +777,7 @@ install pandas) by typing::
 
     pytest pandas
 
-The tests suite is exhaustive and takes around 20 minutes to run.  Often it is
-worth running only a subset of tests first around your changes before running the
+Often it is worth running only a subset of tests first around your changes before running the
 entire suite.
 
 The easiest way to do this is with::
@@ -777,10 +825,10 @@ Running the performance test suite
 
 Performance matters and it is worth considering whether your code has introduced
 performance regressions. pandas is in the process of migrating to
-`asv benchmarks <https://github.com/spacetelescope/asv>`__
+`asv benchmarks <https://github.com/airspeed-velocity/asv>`__
 to enable easy monitoring of the performance of critical pandas operations.
 These benchmarks are all found in the ``pandas/asv_bench`` directory, and the
-test results can be found `here <https://pandas.pydata.org/speed/pandas/#/>`__.
+test results can be found `here <https://pandas.pydata.org/speed/pandas/>`__.
 
 To use all features of asv, you will need either ``conda`` or
 ``virtualenv``. For more details please check the `asv installation
@@ -788,18 +836,18 @@ webpage <https://asv.readthedocs.io/en/latest/installing.html>`_.
 
 To install asv::
 
-    pip install git+https://github.com/spacetelescope/asv
+    pip install git+https://github.com/airspeed-velocity/asv
 
 If you need to run a benchmark, change your directory to ``asv_bench/`` and run::
 
-    asv continuous -f 1.1 upstream/master HEAD
+    asv continuous -f 1.1 upstream/main HEAD
 
 You can replace ``HEAD`` with the name of the branch you are working on,
 and report benchmarks that changed by more than 10%.
 The command uses ``conda`` by default for creating the benchmark
 environments. If you want to use virtualenv instead, write::
 
-    asv continuous -f 1.1 -E virtualenv upstream/master HEAD
+    asv continuous -f 1.1 -E virtualenv upstream/main HEAD
 
 The ``-E virtualenv`` option should be added to all ``asv`` commands
 that run benchmarks. The default value is defined in ``asv.conf.json``.
@@ -811,12 +859,12 @@ do not cause unexpected performance regressions.  You can run specific benchmark
 using the ``-b`` flag, which takes a regular expression. For example, this will
 only run benchmarks from a ``pandas/asv_bench/benchmarks/groupby.py`` file::
 
-    asv continuous -f 1.1 upstream/master HEAD -b ^groupby
+    asv continuous -f 1.1 upstream/main HEAD -b ^groupby
 
 If you want to only run a specific group of benchmarks from a file, you can do it
 using ``.`` as a separator. For example::
 
-    asv continuous -f 1.1 upstream/master HEAD -b groupby.GroupByMethods
+    asv continuous -f 1.1 upstream/main HEAD -b groupby.GroupByMethods
 
 will only run the ``GroupByMethods`` benchmark defined in ``groupby.py``.
 
diff --git a/doc/source/development/contributing_docstring.rst b/doc/source/development/contributing_docstring.rst
index 623d1e8d45565..a87d8d5ad44bf 100644
--- a/doc/source/development/contributing_docstring.rst
+++ b/doc/source/development/contributing_docstring.rst
@@ -68,7 +68,7 @@ explained in this document:
 
 * `numpydoc docstring guide <https://numpydoc.readthedocs.io/en/latest/format.html>`_
   (which is based in the original `Guide to NumPy/SciPy documentation
-  <https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt>`_)
+  <https://github.com/numpy/numpy/blob/main/doc/HOWTO_DOCUMENT.rst.txt>`_)
 
 numpydoc is a Sphinx extension to support the NumPy docstring convention.
 
diff --git a/doc/source/development/contributing_documentation.rst b/doc/source/development/contributing_documentation.rst
index a4a4f781d9dad..fac6a91ce82f2 100644
--- a/doc/source/development/contributing_documentation.rst
+++ b/doc/source/development/contributing_documentation.rst
@@ -12,7 +12,11 @@ you don't have to be an expert on pandas to do so! In fact,
 there are sections of the docs that are worse off after being written by
 experts. If something in the docs doesn't make sense to you, updating the
 relevant section after you figure it out is a great way to ensure it will help
-the next person.
+the next person. Please visit the `issues page <https://github.com/pandas-dev/pandas/issues?page=1&q=is%3Aopen+sort%3Aupdated-desc+label%3ADocs>`__
+for a full list of issues that are currently open regarding the
+Pandas documentation.
+
+
 
 .. contents:: Documentation:
    :local:
@@ -89,16 +93,6 @@ Some other important things to know about the docs:
   ``doc/source/reference``, else Sphinx
   will emit a warning.
 
-.. note::
-
-    The ``.rst`` files are used to automatically generate Markdown and HTML versions
-    of the docs. For this reason, please do not edit ``CONTRIBUTING.md`` directly,
-    but instead make any changes to ``doc/source/development/contributing.rst``. Then, to
-    generate ``CONTRIBUTING.md``, use `pandoc <https://johnmacfarlane.net/pandoc/>`_
-    with the following command::
-
-      pandoc doc/source/development/contributing.rst -t markdown_github > CONTRIBUTING.md
-
 The utility script ``scripts/validate_docstrings.py`` can be used to get a csv
 summary of the API documentation. And also validate common errors in the docstring
 of a specific class, function or method. The summary also compares the list of
@@ -202,10 +196,10 @@ And you'll have the satisfaction of seeing your new and improved documentation!
 
 .. _contributing.dev_docs:
 
-Building master branch documentation
+Building main branch documentation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-When pull requests are merged into the pandas ``master`` branch, the main parts of
+When pull requests are merged into the pandas ``main`` branch, the main parts of
 the documentation are also built by Travis-CI. These docs are then hosted `here
 <https://pandas.pydata.org/docs/dev/>`__, see also
 the :any:`Continuous Integration <contributing.ci>` section.
diff --git a/doc/source/development/contributing_environment.rst b/doc/source/development/contributing_environment.rst
index 4ea3701dec029..942edd863a19a 100644
--- a/doc/source/development/contributing_environment.rst
+++ b/doc/source/development/contributing_environment.rst
@@ -10,104 +10,46 @@ To test out code changes, you'll need to build pandas from source, which
 requires a C/C++ compiler and Python environment. If you're making documentation
 changes, you can skip to :ref:`contributing to the documentation <contributing_documentation>` but if you skip
 creating the development environment you won't be able to build the documentation
-locally before pushing your changes.
+locally before pushing your changes. It's recommended to also install the :ref:`pre-commit hooks <contributing.pre-commit>`.
 
 .. contents:: Table of contents:
    :local:
 
+Step 1: install a C compiler
+----------------------------
 
-Creating an environment using Docker
---------------------------------------
-
-Instead of manually setting up a development environment, you can use `Docker
-<https://docs.docker.com/get-docker/>`_ to automatically create the environment with just several
-commands. pandas provides a ``DockerFile`` in the root directory to build a Docker image
-with a full pandas development environment.
-
-**Docker Commands**
-
-Pass your GitHub username in the ``DockerFile`` to use your own fork::
-
-    # Build the image pandas-yourname-env
-    docker build --tag pandas-yourname-env .
-    # Run a container and bind your local forked repo, pandas-yourname, to the container
-    docker run -it --rm -v path-to-pandas-yourname:/home/pandas-yourname pandas-yourname-env
-
-Even easier, you can integrate Docker with the following IDEs:
-
-**Visual Studio Code**
-
-You can use the DockerFile to launch a remote session with Visual Studio Code,
-a popular free IDE, using the ``.devcontainer.json`` file.
-See https://code.visualstudio.com/docs/remote/containers for details.
-
-**PyCharm (Professional)**
-
-Enable Docker support and use the Services tool window to build and manage images as well as
-run and interact with containers.
-See https://www.jetbrains.com/help/pycharm/docker.html for details.
-
-Note that you might need to rebuild the C extensions if/when you merge with upstream/master using::
-
-    python setup.py build_ext -j 4
-
-
-Creating an environment without Docker
----------------------------------------
-
-Installing a C compiler
-~~~~~~~~~~~~~~~~~~~~~~~
-
-pandas uses C extensions (mostly written using Cython) to speed up certain
-operations. To install pandas from source, you need to compile these C
-extensions, which means you need a C compiler. This process depends on which
-platform you're using.
-
-If you have setup your environment using ``conda``, the packages ``c-compiler``
-and ``cxx-compiler`` will install a fitting compiler for your platform that is
-compatible with the remaining conda packages. On Windows and macOS, you will
-also need to install the SDKs as they have to be distributed separately.
-These packages will automatically be installed by using the ``pandas``
-``environment.yml`` file.
+How to do this will depend on your platform. If you choose to user ``Docker``
+in the next step, then you can skip this step.
 
 **Windows**
 
-You will need `Build Tools for Visual Studio 2019
-<https://visualstudio.microsoft.com/downloads/>`_.
-
-.. warning::
-	You DO NOT need to install Visual Studio 2019.
-	You only need "Build Tools for Visual Studio 2019" found by
-	scrolling down to "All downloads" -> "Tools for Visual Studio 2019".
-	In the installer, select the "C++ build tools" workload.
+You will need `Build Tools for Visual Studio 2022
+<https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022>`_.
 
-You can install the necessary components on the commandline using
-`vs_buildtools.exe <https://aka.ms/vs/16/release/vs_buildtools.exe>`_:
+.. note::
+        You DO NOT need to install Visual Studio 2022.
+        You only need "Build Tools for Visual Studio 2022" found by
+        scrolling down to "All downloads" -> "Tools for Visual Studio".
+        In the installer, select the "Desktop development with C++" Workloads.
 
-.. code::
+Alternatively, you can install the necessary components on the commandline using
+`vs_BuildTools.exe <https://learn.microsoft.com/en-us/visualstudio/install/use-command-line-parameters-to-install-visual-studio?source=recommendations&view=vs-2022>`_
 
-    vs_buildtools.exe --quiet --wait --norestart --nocache ^
-        --installPath C:\BuildTools ^
-        --add "Microsoft.VisualStudio.Workload.VCTools;includeRecommended" ^
-        --add Microsoft.VisualStudio.Component.VC.v141 ^
-        --add Microsoft.VisualStudio.Component.VC.v141.x86.x64 ^
-        --add Microsoft.VisualStudio.Component.Windows10SDK.17763
-
-To setup the right paths on the commandline, call
-``"C:\BuildTools\VC\Auxiliary\Build\vcvars64.bat" -vcvars_ver=14.16 10.0.17763.0``.
+Alternatively, you could use the `WSL <https://learn.microsoft.com/en-us/windows/wsl/install>`_
+and consult the ``Linux`` instructions below.
 
 **macOS**
 
-To use the ``conda``-based compilers, you will need to install the
+To use the :ref:`mamba <contributing.mamba>`-based compilers, you will need to install the
 Developer Tools using ``xcode-select --install``. Otherwise
 information about compiler installation can be found here:
 https://devguide.python.org/setup/#macos
 
 **Linux**
 
-For Linux-based ``conda`` installations, you won't have to install any
-additional components outside of the conda environment. The instructions
-below are only needed if your setup isn't based on conda environments.
+For Linux-based :ref:`mamba <contributing.mamba>` installations, you won't have to install any
+additional components outside of the mamba environment. The instructions
+below are only needed if your setup isn't based on mamba environments.
 
 Some Linux distributions will come with a pre-installed C compiler. To find out
 which compilers (and versions) are installed on your system::
@@ -119,75 +61,40 @@ which compilers (and versions) are installed on your system::
 
 `GCC (GNU Compiler Collection) <https://gcc.gnu.org/>`_, is a widely used
 compiler, which supports C and a number of other languages. If GCC is listed
-as an installed compiler nothing more is required. If no C compiler is
-installed (or you wish to install a newer version) you can install a compiler
-(GCC in the example code below) with::
-
-    # for recent Debian/Ubuntu:
-    sudo apt install build-essential
-    # for Red Had/RHEL/CentOS/Fedora
-    yum groupinstall "Development Tools"
+as an installed compiler nothing more is required.
 
-For other Linux distributions, consult your favorite search engine for
-compiler installation instructions.
+If no C compiler is installed, or you wish to upgrade, or you're using a different
+Linux distribution, consult your favorite search engine for compiler installation/update
+instructions.
 
-Let us know if you have any difficulties by opening an issue or reaching out on `Gitter <https://gitter.im/pydata/pandas/>`_.
+Let us know if you have any difficulties by opening an issue or reaching out on our contributor
+community :ref:`Slack <community.slack>`.
 
-Creating a Python environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Step 2: create an isolated environment
+----------------------------------------
 
-Now create an isolated pandas development environment:
+Before we begin, please:
 
-* Install either `Anaconda <https://www.anaconda.com/download/>`_, `miniconda
-  <https://conda.io/miniconda.html>`_, or `miniforge <https://github.com/conda-forge/miniforge>`_
-* Make sure your conda is up to date (``conda update conda``)
 * Make sure that you have :any:`cloned the repository <contributing.forking>`
 * ``cd`` to the pandas source directory
 
-We'll now kick off a three-step process:
+.. _contributing.mamba:
+
+Option 1: using mamba (recommended)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-1. Install the build dependencies
-2. Build and install pandas
-3. Install the optional dependencies
+* Install `mamba <https://mamba.readthedocs.io/en/latest/installation.html>`_
+* Make sure your mamba is up to date (``mamba update mamba``)
 
 .. code-block:: none
 
    # Create and activate the build environment
-   conda env create -f environment.yml
-   conda activate pandas-dev
-
-   # or with older versions of Anaconda:
-   source activate pandas-dev
-
-   # Build and install pandas
-   python setup.py build_ext -j 4
-   python -m pip install -e . --no-build-isolation --no-use-pep517
-
-At this point you should be able to import pandas from your locally built version::
-
-   $ python
-   >>> import pandas
-   >>> print(pandas.__version__)
-   0.22.0.dev0+29.g4ad6d4d74
-
-This will create the new environment, and not touch any of your existing environments,
-nor any existing Python installation.
-
-To view your environments::
-
-      conda info -e
-
-To return to your root environment::
+   mamba env create --file environment.yml
+   mamba activate pandas-dev
 
-      conda deactivate
+Option 2: using pip
+~~~~~~~~~~~~~~~~~~~
 
-See the full conda docs `here <https://conda.pydata.org/docs>`__.
-
-
-Creating a Python environment (pip)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you aren't using conda for your development environment, follow these instructions.
 You'll need to have at least the :ref:`minimum Python version <install.version>` that pandas supports.
 You also need to have ``setuptools`` 51.0.0 or later to build pandas.
 
@@ -206,10 +113,6 @@ You also need to have ``setuptools`` 51.0.0 or later to build pandas.
    # Install the build dependencies
    python -m pip install -r requirements-dev.txt
 
-   # Build and install pandas
-   python setup.py build_ext -j 4
-   python -m pip install -e . --no-build-isolation --no-use-pep517
-
 **Unix**/**macOS with pyenv**
 
 Consult the docs for setting up pyenv `here <https://github.com/pyenv/pyenv>`__.
@@ -218,11 +121,10 @@ Consult the docs for setting up pyenv `here <https://github.com/pyenv/pyenv>`__.
 
    # Create a virtual environment
    # Use an ENV_DIR of your choice. We'll use ~/Users/<yourname>/.pyenv/versions/pandas-dev
-
    pyenv virtualenv <version> <name-to-give-it>
 
    # For instance:
-   pyenv virtualenv 3.7.6 pandas-dev
+   pyenv virtualenv 3.9.10 pandas-dev
 
    # Activate the virtualenv
    pyenv activate pandas-dev
@@ -230,19 +132,15 @@ Consult the docs for setting up pyenv `here <https://github.com/pyenv/pyenv>`__.
    # Now install the build dependencies in the cloned pandas repo
    python -m pip install -r requirements-dev.txt
 
-   # Build and install pandas
-   python setup.py build_ext -j 4
-   python -m pip install -e . --no-build-isolation --no-use-pep517
-
 **Windows**
 
 Below is a brief overview on how to set-up a virtual environment with Powershell
 under Windows. For details please refer to the
-`official virtualenv user guide <https://virtualenv.pypa.io/en/stable/userguide/#activate-script>`__
+`official virtualenv user guide <https://virtualenv.pypa.io/en/latest/user_guide.html#activators>`__.
 
-Use an ENV_DIR of your choice. We'll use ~\\virtualenvs\\pandas-dev where
-'~' is the folder pointed to by either $env:USERPROFILE (Powershell) or
-%USERPROFILE% (cmd.exe) environment variable. Any parent directories
+Use an ENV_DIR of your choice. We'll use ``~\\virtualenvs\\pandas-dev`` where
+``~`` is the folder pointed to by either ``$env:USERPROFILE`` (Powershell) or
+``%USERPROFILE%`` (cmd.exe) environment variable. Any parent directories
 should already exist.
 
 .. code-block:: powershell
@@ -256,6 +154,59 @@ should already exist.
    # Install the build dependencies
    python -m pip install -r requirements-dev.txt
 
+Option 3: using Docker
+~~~~~~~~~~~~~~~~~~~~~~
+
+pandas provides a ``DockerFile`` in the root directory to build a Docker image
+with a full pandas development environment.
+
+**Docker Commands**
+
+Build the Docker image::
+
+    # Build the image
+    docker build -t pandas-dev .
+
+Run Container::
+
+    # Run a container and bind your local repo to the container
+    # This command assumes you are running from your local repo
+    # but if not alter ${PWD} to match your local repo path
+    docker run -it --rm -v ${PWD}:/home/pandas pandas-dev
+
+*Even easier, you can integrate Docker with the following IDEs:*
+
+**Visual Studio Code**
+
+You can use the DockerFile to launch a remote session with Visual Studio Code,
+a popular free IDE, using the ``.devcontainer.json`` file.
+See https://code.visualstudio.com/docs/remote/containers for details.
+
+**PyCharm (Professional)**
+
+Enable Docker support and use the Services tool window to build and manage images as well as
+run and interact with containers.
+See https://www.jetbrains.com/help/pycharm/docker.html for details.
+
+Step 3: build and install pandas
+--------------------------------
+
+You can now run::
+
    # Build and install pandas
    python setup.py build_ext -j 4
    python -m pip install -e . --no-build-isolation --no-use-pep517
+
+At this point you should be able to import pandas from your locally built version::
+
+   $ python
+   >>> import pandas
+   >>> print(pandas.__version__)  # note: the exact output may differ
+   2.0.0.dev0+880.g2b9e661fbb.dirty
+
+This will create the new environment, and not touch any of your existing environments,
+nor any existing Python installation.
+
+.. note::
+   You will need to repeat this step each time the C extensions change, for example
+   if you modified any file in ``pandas/_libs`` or if you did a fetch and merge from ``upstream/main``.
diff --git a/doc/source/development/debugging_extensions.rst b/doc/source/development/debugging_extensions.rst
index 894277d304020..7ba2091e18853 100644
--- a/doc/source/development/debugging_extensions.rst
+++ b/doc/source/development/debugging_extensions.rst
@@ -80,7 +80,7 @@ Once the process launches, simply type ``run`` and the test suite will begin, st
 Checking memory leaks with valgrind
 ===================================
 
-You can use `Valgrind <https://www.valgrind.org>`_ to check for and log memory leaks in extensions. For instance, to check for a memory leak in a test from the suite you can run:
+You can use `Valgrind <https://valgrind.org/>`_ to check for and log memory leaks in extensions. For instance, to check for a memory leak in a test from the suite you can run:
 
 .. code-block:: sh
 
diff --git a/doc/source/development/extending.rst b/doc/source/development/extending.rst
index c10fcf6eacfc7..c7286616672b9 100644
--- a/doc/source/development/extending.rst
+++ b/doc/source/development/extending.rst
@@ -74,10 +74,11 @@ applies only to certain dtypes.
 Extension types
 ---------------
 
-.. warning::
+.. note::
 
-   The :class:`pandas.api.extensions.ExtensionDtype` and :class:`pandas.api.extensions.ExtensionArray` APIs are new and
-   experimental. They may change between versions without warning.
+   The :class:`pandas.api.extensions.ExtensionDtype` and :class:`pandas.api.extensions.ExtensionArray` APIs were
+   experimental prior to pandas 1.5. Starting with version 1.5, future changes will follow
+   the :ref:`pandas deprecation policy <policies.version>`.
 
 pandas defines an interface for implementing data types and arrays that *extend*
 NumPy's type system. pandas itself uses the extension system for some types
@@ -231,7 +232,7 @@ Testing extension arrays
 We provide a test suite for ensuring that your extension arrays satisfy the expected
 behavior. To use the test suite, you must provide several pytest fixtures and inherit
 from the base test class. The required fixtures are found in
-https://github.com/pandas-dev/pandas/blob/master/pandas/tests/extension/conftest.py.
+https://github.com/pandas-dev/pandas/blob/main/pandas/tests/extension/conftest.py.
 
 To use a test, subclass it:
 
@@ -244,7 +245,7 @@ To use a test, subclass it:
        pass
 
 
-See https://github.com/pandas-dev/pandas/blob/master/pandas/tests/extension/base/__init__.py
+See https://github.com/pandas-dev/pandas/blob/main/pandas/tests/extension/base/__init__.py
 for a list of all the tests available.
 
 .. _extending.extension.arrow:
@@ -290,9 +291,9 @@ See more in the `Arrow documentation <https://arrow.apache.org/docs/python/exten
 Those methods have been implemented for the nullable integer and string extension
 dtypes included in pandas, and ensure roundtrip to pyarrow and the Parquet file format.
 
-.. _extension dtype dtypes: https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/dtypes.py
-.. _extension dtype source: https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/base.py
-.. _extension array source: https://github.com/pandas-dev/pandas/blob/master/pandas/core/arrays/base.py
+.. _extension dtype dtypes: https://github.com/pandas-dev/pandas/blob/main/pandas/core/dtypes/dtypes.py
+.. _extension dtype source: https://github.com/pandas-dev/pandas/blob/main/pandas/core/dtypes/base.py
+.. _extension array source: https://github.com/pandas-dev/pandas/blob/main/pandas/core/arrays/base.py
 
 .. _extending.subclassing-pandas:
 
@@ -468,7 +469,7 @@ This would be more or less equivalent to:
 The backend module can then use other visualization tools (Bokeh, Altair,...)
 to generate the plots.
 
-Libraries implementing the plotting backend should use `entry points <https://setuptools.readthedocs.io/en/latest/setuptools.html#dynamic-discovery-of-services-and-plugins>`__
+Libraries implementing the plotting backend should use `entry points <https://setuptools.pypa.io/en/latest/userguide/entry_point.html>`__
 to make their backend discoverable to pandas. The key is ``"pandas_plotting_backends"``. For example, pandas
 registers the default "matplotlib" backend as follows.
 
@@ -486,4 +487,4 @@ registers the default "matplotlib" backend as follows.
 
 
 More information on how to implement a third-party plotting backend can be found at
-https://github.com/pandas-dev/pandas/blob/master/pandas/plotting/__init__.py#L1.
+https://github.com/pandas-dev/pandas/blob/main/pandas/plotting/__init__.py#L1.
diff --git a/doc/source/development/index.rst b/doc/source/development/index.rst
index fb50a88c6637f..c741441cf67a1 100644
--- a/doc/source/development/index.rst
+++ b/doc/source/development/index.rst
@@ -16,13 +16,11 @@ Development
     contributing_environment
     contributing_documentation
     contributing_codebase
-    code_style
     maintaining
     internals
-    test_writing
     debugging_extensions
     extending
     developer
     policies
     roadmap
-    meeting
+    community
diff --git a/doc/source/development/maintaining.rst b/doc/source/development/maintaining.rst
index a0e9ba53acd00..1bff2eccd3d27 100644
--- a/doc/source/development/maintaining.rst
+++ b/doc/source/development/maintaining.rst
@@ -138,7 +138,7 @@ Reviewing pull requests
 -----------------------
 
 Anybody can review a pull request: regular contributors, triagers, or core-team
-members. But only core-team members can merge pull requets when they're ready.
+members. But only core-team members can merge pull requests when they're ready.
 
 Here are some things to check when reviewing a pull request.
 
@@ -151,16 +151,37 @@ Here are some things to check when reviewing a pull request.
   for regression fixes and small bug fixes, the next minor milestone otherwise)
 * Changes should comply with our :ref:`policies.version`.
 
+
+.. _maintaining.backporting:
+
 Backporting
 -----------
 
-In the case you want to apply changes to a stable branch from a newer branch then you
-can comment::
+pandas supports point releases (e.g. ``1.4.3``) that aim to:
+
+1. Fix bugs in new features introduced in the first minor version release.
+
+  * e.g. If a new feature was added in ``1.4`` and contains a bug, a fix can be applied in ``1.4.3``
+
+2. Fix bugs that used to work in a few minor releases prior. There should be agreement between core team members that a backport is appropriate.
+
+  * e.g. If a feature worked in ``1.2`` and stopped working since ``1.3``, a fix can be applied in ``1.4.3``.
+
+Since pandas minor releases are based on Github branches (e.g. point release of ``1.4`` are based off the ``1.4.x`` branch),
+"backporting" means merging a pull request fix to the ``main`` branch and correct minor branch associated with the next point release.
+
+By default, if a pull request is assigned to the next point release milestone within the Github interface,
+the backporting process should happen automatically by the ``@meeseeksdev`` bot once the pull request is merged.
+A new pull request will be made backporting the pull request to the correct version branch.
+Sometimes due to merge conflicts, a manual pull request will need to be made addressing the code conflict.
+
+If the bot does not automatically start the backporting process, you can also write a Github comment in the merged pull request
+to trigger the backport::
 
     @meeseeksdev backport version-branch
 
 This will trigger a workflow which will backport a given change to a branch
-(e.g. @meeseeksdev backport 1.2.x)
+(e.g. @meeseeksdev backport 1.4.x)
 
 Cleaning up old issues
 ----------------------
@@ -204,6 +225,18 @@ The full process is outlined in our `governance documents`_. In summary,
 we're happy to give triage permissions to anyone who shows interest by
 being helpful on the issue tracker.
 
+The required steps for adding a maintainer are:
+
+1. Contact the contributor and ask their interest to join.
+2. Add the contributor to the appropriate `Github Team <https://github.com/orgs/pandas-dev/teams>`_ if accepted the invitation.
+
+  * ``pandas-core`` is for core team members
+  * ``pandas-triage`` is for pandas triage members
+
+3. Add the contributor to the pandas Google group.
+4. Create a pull request to add the contributor's Github handle to ``pandas-dev/pandas/web/pandas/config.yml``.
+5. Create a pull request to add the contributor's name/Github handle to the `governance document <https://github.com/pandas-dev/pandas-governance/blob/master/people.md>`_.
+
 The current list of core-team members is at
 https://github.com/pandas-dev/pandas-governance/blob/master/people.md
 
@@ -236,5 +269,40 @@ a milestone before tagging, you can request the bot to backport it with:
    @Meeseeksdev backport <branch>
 
 
+.. _maintaining.asv-machine:
+
+Benchmark machine
+-----------------
+
+The team currently owns dedicated hardware for hosting a website for pandas' ASV performance benchmark. The results
+are published to http://pandas.pydata.org/speed/pandas/
+
+Configuration
+`````````````
+
+The machine can be configured with the `Ansible <http://docs.ansible.com/ansible/latest/index.html>`_ playbook in https://github.com/tomaugspurger/asv-runner.
+
+Publishing
+``````````
+
+The results are published to another Github repository, https://github.com/tomaugspurger/asv-collection.
+Finally, we have a cron job on our docs server to pull from https://github.com/tomaugspurger/asv-collection, to serve them from ``/speed``.
+Ask Tom or Joris for access to the webserver.
+
+Debugging
+`````````
+
+The benchmarks are scheduled by Airflow. It has a dashboard for viewing and debugging the results. You'll need to setup an SSH tunnel to view them
+
+    ssh -L 8080:localhost:8080 pandas@panda.likescandy.com
+
+
+.. _maintaining.release:
+
+Release process
+---------------
+
+The process for releasing a new version of pandas can be found at https://github.com/pandas-dev/pandas-release
+
 .. _governance documents: https://github.com/pandas-dev/pandas-governance
-.. _list of permissions: https://help.github.com/en/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization
+.. _list of permissions: https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization
diff --git a/doc/source/development/meeting.rst b/doc/source/development/meeting.rst
deleted file mode 100644
index 35826af5912c2..0000000000000
--- a/doc/source/development/meeting.rst
+++ /dev/null
@@ -1,31 +0,0 @@
-.. _meeting:
-
-==================
-Developer meetings
-==================
-
-We hold regular developer meetings on the second Wednesday
-of each month at 18:00 UTC. These meetings and their minutes are open to
-the public. All are welcome to join.
-
-Minutes
--------
-
-The minutes of past meetings are available in `this Google Document <https://docs.google.com/document/d/1tGbTiYORHiSPgVMXawiweGJlBw5dOkVJLY-licoBmBU/edit?usp=sharing>`__.
-
-Calendar
---------
-
-This calendar shows all the developer meetings.
-
-.. raw:: html
-
-   <iframe src="https://calendar.google.com/calendar/embed?src=pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com" style="border: 0" width="800" height="600" frameborder="0" scrolling="no"></iframe>
-
-You can subscribe to this calendar with the following links:
-
-* `iCal <https://calendar.google.com/calendar/ical/pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com/public/basic.ics>`__
-* `Google calendar <https://calendar.google.com/calendar/r?cid=pgbn14p6poja8a1cf2dv2jhrmg@group.calendar.google.com>`__
-
-Additionally, we'll sometimes have one-off meetings on specific topics.
-These will be published on the same calendar.
diff --git a/doc/source/development/policies.rst b/doc/source/development/policies.rst
index f8e6bda2085d8..d75262c08dfd6 100644
--- a/doc/source/development/policies.rst
+++ b/doc/source/development/policies.rst
@@ -51,7 +51,7 @@ pandas may change the behavior of experimental features at any time.
 Python support
 ~~~~~~~~~~~~~~
 
-pandas will only drop support for specific Python versions (e.g. 3.6.x, 3.7.x) in
-pandas **major** or **minor** releases.
+pandas mirrors the `NumPy guidelines for Python support <https://numpy.org/neps/nep-0029-deprecation_policy.html#implementation>`__.
+
 
 .. _SemVer: https://semver.org
diff --git a/doc/source/development/roadmap.rst b/doc/source/development/roadmap.rst
index 37e45bf5a42b5..f935c27d9917d 100644
--- a/doc/source/development/roadmap.rst
+++ b/doc/source/development/roadmap.rst
@@ -74,8 +74,7 @@ types. This includes consistent behavior in all operations (indexing, arithmetic
 operations, comparisons, etc.). There has been discussion of eventually making
 the new semantics the default.
 
-This has been discussed at
-`github #28095 <https://github.com/pandas-dev/pandas/issues/28095>`__ (and
+This has been discussed at :issue:`28095` (and
 linked issues), and described in more detail in this
 `design doc <https://hackmd.io/@jorisvandenbossche/Sk0wMeAmB>`__.
 
@@ -129,8 +128,51 @@ We propose that it should only work with positional indexing, and the translatio
 to positions should be entirely done at a higher level.
 
 Indexing is a complicated API with many subtleties. This refactor will require care
-and attention. More details are discussed at
-https://github.com/pandas-dev/pandas/wiki/(Tentative)-rules-for-restructuring-indexing-code
+and attention. The following principles should inspire refactoring of indexing code and
+should result on cleaner, simpler, and more performant code.
+
+1. **Label indexing must never involve looking in an axis twice for the same label(s).**
+This implies that any validation step must either:
+
+  * limit validation to general features (e.g. dtype/structure of the key/index), or
+  * reuse the result for the actual indexing.
+
+2. **Indexers must never rely on an explicit call to other indexers.**
+For instance, it is OK to have some internal method of ``.loc`` call some
+internal method of ``__getitem__`` (or of their common base class),
+but never in the code flow of ``.loc`` should ``the_obj[something]`` appear.
+
+3. **Execution of positional indexing must never involve labels** (as currently, sadly, happens).
+That is, the code flow of a getter call (or a setter call in which the right hand side is non-indexed)
+to ``.iloc`` should never involve the axes of the object in any way.
+
+4. **Indexing must never involve accessing/modifying values** (i.e., act on ``._data`` or ``.values``) **more than once.**
+The following steps must hence be clearly decoupled:
+
+  * find positions we need to access/modify on each axis
+  * (if we are accessing) derive the type of object we need to return (dimensionality)
+  * actually access/modify the values
+  * (if we are accessing) construct the return object
+
+5. As a corollary to the decoupling between 4.i and 4.iii, **any code which deals on how data is stored**
+(including any combination of handling multiple dtypes, and sparse storage, categoricals, third-party types)
+**must be independent from code that deals with identifying affected rows/columns**,
+and take place only once step 4.i is completed.
+
+  * In particular, such code should most probably not live in ``pandas/core/indexing.py``
+  * ... and must not depend in any way on the type(s) of axes (e.g. no ``MultiIndex`` special cases)
+
+6. As a corollary to point 1.i, **``Index`` (sub)classes must provide separate methods for any desired validity check of label(s) which does not involve actual lookup**,
+on the one side, and for any required conversion/adaptation/lookup of label(s), on the other.
+
+7. **Use of trial and error should be limited**, and anyway restricted to catch only exceptions
+which are actually expected (typically ``KeyError``).
+
+  * In particular, code should never (intentionally) raise new exceptions in the ``except`` portion of a ``try... exception``
+
+8. **Any code portion which is not specific to setters and getters must be shared**,
+and when small differences in behavior are expected (e.g. getting with ``.loc`` raises for
+missing labels, setting still doesn't), they can be managed with a specific parameter.
 
 Numba-accelerated operations
 ----------------------------
@@ -205,4 +247,4 @@ We improved the pandas documentation
 * :ref:`getting_started` contains a number of resources intended for new
   pandas users coming from a variety of backgrounds (:issue:`26831`).
 
-.. _pydata-sphinx-theme: https://github.com/pandas-dev/pydata-sphinx-theme
+.. _pydata-sphinx-theme: https://github.com/pydata/pydata-sphinx-theme
diff --git a/doc/source/development/test_writing.rst b/doc/source/development/test_writing.rst
deleted file mode 100644
index 76eae505471b7..0000000000000
--- a/doc/source/development/test_writing.rst
+++ /dev/null
@@ -1,167 +0,0 @@
-.. _test_organization:
-
-Test organization
-=================
-Ideally, there should be one, and only one, obvious place for a test to reside.
-Until we reach that ideal, these are some rules of thumb for where a test should
-be located.
-
-1. Does your test depend only on code in ``pd._libs.tslibs``?
-   This test likely belongs in one of:
-
-   - tests.tslibs
-
-     .. note::
-
-          No file in ``tests.tslibs`` should import from any pandas modules
-          outside of ``pd._libs.tslibs``
-
-   - tests.scalar
-   - tests.tseries.offsets
-
-2. Does your test depend only on code in pd._libs?
-   This test likely belongs in one of:
-
-   - tests.libs
-   - tests.groupby.test_libgroupby
-
-3. Is your test for an arithmetic or comparison method?
-   This test likely belongs in one of:
-
-   - tests.arithmetic
-
-     .. note::
-
-         These are intended for tests that can be shared to test the behavior
-         of DataFrame/Series/Index/ExtensionArray using the ``box_with_array``
-         fixture.
-
-   - tests.frame.test_arithmetic
-   - tests.series.test_arithmetic
-
-4. Is your test for a reduction method (min, max, sum, prod, ...)?
-   This test likely belongs in one of:
-
-   - tests.reductions
-
-     .. note::
-
-         These are intended for tests that can be shared to test the behavior
-         of DataFrame/Series/Index/ExtensionArray.
-
-   - tests.frame.test_reductions
-   - tests.series.test_reductions
-   - tests.test_nanops
-
-5. Is your test for an indexing method?
-   This is the most difficult case for deciding where a test belongs, because
-   there are many of these tests, and many of them test more than one method
-   (e.g. both ``Series.__getitem__`` and ``Series.loc.__getitem__``)
-
-   A) Is the test specifically testing an Index method (e.g. ``Index.get_loc``,
-      ``Index.get_indexer``)?
-      This test likely belongs in one of:
-
-      - tests.indexes.test_indexing
-      - tests.indexes.fooindex.test_indexing
-
-      Within that files there should be a method-specific test class e.g.
-      ``TestGetLoc``.
-
-      In most cases, neither ``Series`` nor ``DataFrame`` objects should be
-      needed in these tests.
-
-   B) Is the test for a Series or DataFrame indexing method *other* than
-      ``__getitem__`` or ``__setitem__``, e.g. ``xs``, ``where``, ``take``,
-      ``mask``, ``lookup``, or ``insert``?
-      This test likely belongs in one of:
-
-      - tests.frame.indexing.test_methodname
-      - tests.series.indexing.test_methodname
-
-   C) Is the test for any of ``loc``, ``iloc``, ``at``, or ``iat``?
-      This test likely belongs in one of:
-
-      - tests.indexing.test_loc
-      - tests.indexing.test_iloc
-      - tests.indexing.test_at
-      - tests.indexing.test_iat
-
-      Within the appropriate file, test classes correspond to either types of
-      indexers (e.g. ``TestLocBooleanMask``) or major use cases
-      (e.g. ``TestLocSetitemWithExpansion``).
-
-      See the note in section D) about tests that test multiple indexing methods.
-
-   D) Is the test for ``Series.__getitem__``, ``Series.__setitem__``,
-      ``DataFrame.__getitem__``, or ``DataFrame.__setitem__``?
-      This test likely belongs in one of:
-
-      - tests.series.test_getitem
-      - tests.series.test_setitem
-      - tests.frame.test_getitem
-      - tests.frame.test_setitem
-
-      If many cases such a test may test multiple similar methods, e.g.
-
-      .. code-block:: python
-
-           import pandas as pd
-           import pandas._testing as tm
-
-           def test_getitem_listlike_of_ints():
-               ser = pd.Series(range(5))
-
-               result = ser[[3, 4]]
-               expected = pd.Series([2, 3])
-               tm.assert_series_equal(result, expected)
-
-               result = ser.loc[[3, 4]]
-               tm.assert_series_equal(result, expected)
-
-    In cases like this, the test location should be based on the *underlying*
-    method being tested.  Or in the case of a test for a bugfix, the location
-    of the actual bug.  So in this example, we know that ``Series.__getitem__``
-    calls ``Series.loc.__getitem__``, so this is *really* a test for
-    ``loc.__getitem__``.  So this test belongs in ``tests.indexing.test_loc``.
-
-6. Is your test for a DataFrame or Series method?
-
-   A) Is the method a plotting method?
-      This test likely belongs in one of:
-
-      - tests.plotting
-
-   B) Is the method an IO method?
-      This test likely belongs in one of:
-
-      - tests.io
-
-   C) Otherwise
-      This test likely belongs in one of:
-
-      - tests.series.methods.test_mymethod
-      - tests.frame.methods.test_mymethod
-
-        .. note::
-
-            If a test can be shared between DataFrame/Series using the
-            ``frame_or_series`` fixture, by convention it goes in the
-            ``tests.frame`` file.
-
-7. Is your test for an Index method, not depending on Series/DataFrame?
-   This test likely belongs in one of:
-
-   - tests.indexes
-
-8) Is your test for one of the pandas-provided ExtensionArrays (``Categorical``,
-   ``DatetimeArray``, ``TimedeltaArray``, ``PeriodArray``, ``IntervalArray``,
-   ``PandasArray``, ``FloatArray``, ``BoolArray``, ``StringArray``)?
-   This test likely belongs in one of:
-
-   - tests.arrays
-
-9) Is your test for *all* ExtensionArray subclasses (the "EA Interface")?
-   This test likely belongs in one of:
-
-   - tests.extension
diff --git a/doc/source/ecosystem.rst b/doc/source/ecosystem.rst
index 6ae923301fa07..166162a4763bf 100644
--- a/doc/source/ecosystem.rst
+++ b/doc/source/ecosystem.rst
@@ -19,7 +19,7 @@ development to remain focused around it's original requirements.
 This is an inexhaustive list of projects that build on pandas in order to provide
 tools in the PyData space. For a list of projects that depend on pandas,
 see the
-`libraries.io usage page for pandas <https://libraries.io/pypi/pandas/usage>`_
+`Github network dependents for pandas <https://github.com/pandas-dev/pandas/network/dependents>`_
 or `search pypi for pandas <https://pypi.org/search/?q=pandas>`_.
 
 We'd like to make it easier for users to find these projects, if you know of other
@@ -30,8 +30,8 @@ substantial projects that you feel should be on this list, please let us know.
 Data cleaning and validation
 ----------------------------
 
-`Pyjanitor <https://github.com/ericmjl/pyjanitor/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Pyjanitor <https://github.com/pyjanitor-devs/pyjanitor>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Pyjanitor provides a clean API for cleaning data, using method chaining.
 
@@ -71,19 +71,19 @@ a long-standing special relationship with pandas. Statsmodels provides powerful
 econometrics, analysis and modeling functionality that is out of pandas' scope.
 Statsmodels leverages pandas objects as the underlying data container for computation.
 
-`sklearn-pandas <https://github.com/paulgb/sklearn-pandas>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`sklearn-pandas <https://github.com/scikit-learn-contrib/sklearn-pandas>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Use pandas DataFrames in your `scikit-learn <https://scikit-learn.org/>`__
 ML pipeline.
 
 `Featuretools <https://github.com/alteryx/featuretools/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Featuretools is a Python library for automated feature engineering built on top of pandas. It excels at transforming temporal and relational datasets into feature matrices for machine learning using reusable feature engineering "primitives". Users can contribute their own primitives in Python and share them with the rest of the community.
 
 `Compose <https://github.com/alteryx/compose>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Compose is a machine learning tool for labeling data and prediction engineering. It allows you to structure the labeling process by parameterizing prediction problems and transforming time-driven relational data into target values with cutoff times that can be used for supervised learning.
 
@@ -115,8 +115,8 @@ simplicity produces beautiful and effective visualizations with a
 minimal amount of code. Altair works with pandas DataFrames.
 
 
-`Bokeh <https://bokeh.pydata.org>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Bokeh <https://docs.bokeh.org/en/latest/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Bokeh is a Python interactive visualization library for large datasets that natively uses
 the latest web technologies. Its goal is to provide elegant, concise construction of novel
@@ -147,7 +147,7 @@ estimation while plotting, aggregating across observations and visualizing the
 fit of statistical models to emphasize patterns in a dataset.
 
 `plotnine <https://github.com/has2k1/plotnine/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Hadley Wickham's `ggplot2 <https://ggplot2.tidyverse.org/>`__ is a foundational exploratory visualization package for the R language.
 Based on `"The Grammar of Graphics" <https://www.cs.uic.edu/~wilkinson/TheGrammarOfGraphics/GOG.html>`__ it
@@ -161,10 +161,10 @@ A good implementation for Python users is `has2k1/plotnine <https://github.com/h
 `IPython Vega <https://github.com/vega/ipyvega>`__ leverages `Vega
 <https://github.com/vega/vega>`__ to create plots within Jupyter Notebook.
 
-`Plotly <https://plot.ly/python>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Plotly <https://plotly.com/python>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`Plotly’s <https://plot.ly/>`__ `Python API <https://plot.ly/python/>`__ enables interactive figures and web shareability. Maps, 2D, 3D, and live-streaming graphs are rendered with WebGL and `D3.js <https://d3js.org/>`__. The library supports plotting directly from a pandas DataFrame and cloud-based collaboration. Users of `matplotlib, ggplot for Python, and Seaborn <https://plot.ly/python/matplotlib-to-plotly-tutorial/>`__ can convert figures into interactive web-based plots. Plots can be drawn in `IPython Notebooks <https://plot.ly/ipython-notebooks/>`__ , edited with R or MATLAB, modified in a GUI, or embedded in apps and dashboards. Plotly is free for unlimited sharing, and has `cloud <https://plot.ly/product/plans/>`__, `offline <https://plot.ly/python/offline/>`__, or `on-premise <https://plot.ly/product/enterprise/>`__ accounts for private use.
+`Plotly’s <https://plotly.com/>`__ `Python API <https://plotly.com/python/>`__ enables interactive figures and web shareability. Maps, 2D, 3D, and live-streaming graphs are rendered with WebGL and `D3.js <https://d3js.org/>`__. The library supports plotting directly from a pandas DataFrame and cloud-based collaboration. Users of `matplotlib, ggplot for Python, and Seaborn <https://plotly.com/python/matplotlib-to-plotly-tutorial/>`__ can convert figures into interactive web-based plots. Plots can be drawn in `IPython Notebooks <https://plotly.com/ipython-notebooks/>`__ , edited with R or MATLAB, modified in a GUI, or embedded in apps and dashboards. Plotly is free for unlimited sharing, and has `offline <https://plotly.com/python/offline/>`__, or `on-premise <https://plotly.com/product/enterprise/>`__ accounts for private use.
 
 `Lux <https://github.com/lux-org/lux>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -179,7 +179,7 @@ A good implementation for Python users is `has2k1/plotnine <https://github.com/h
     df = pd.read_csv("data.csv")
     df  # discover interesting insights!
 
-By printing out a dataframe, Lux automatically `recommends a set of visualizations <https://github.com/lux-org/lux-resources/blob/master/readme_img/demohighlight.gif?raw=true>`__ that highlights interesting trends and patterns in the dataframe. Users can leverage any existing pandas commands without modifying their code, while being able to visualize their pandas data structures (e.g., DataFrame, Series, Index) at the same time. Lux also offers a `powerful, intuitive language <https://lux-api.readthedocs.io/en/latest/source/guide/vis.html>`__ that allow users to create  `Altair <https://altair-viz.github.io/>`__, `matplotlib <https://matplotlib.org>`__, or `Vega-Lite <https://vega.github.io/vega-lite/>`__ visualizations without having to think at the level of code.
+By printing out a dataframe, Lux automatically `recommends a set of visualizations <https://raw.githubusercontent.com/lux-org/lux-resources/master/readme_img/demohighlight.gif>`__ that highlights interesting trends and patterns in the dataframe. Users can leverage any existing pandas commands without modifying their code, while being able to visualize their pandas data structures (e.g., DataFrame, Series, Index) at the same time. Lux also offers a `powerful, intuitive language <https://lux-api.readthedocs.io/en/latest/source/guide/vis.html>`__ that allow users to create  `Altair <https://altair-viz.github.io/>`__, `matplotlib <https://matplotlib.org>`__, or `Vega-Lite <https://vega.github.io/vega-lite/>`__ visualizations without having to think at the level of code.
 
 `Qtpandas <https://github.com/draperjames/qtpandas>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -204,8 +204,7 @@ invoked with the following command
     dtale.show(df)
 
 D-Tale integrates seamlessly with Jupyter notebooks, Python terminals, Kaggle
-& Google Colab. Here are some demos of the `grid <http://alphatechadmin.pythonanywhere.com/>`__
-and `chart-builder <http://alphatechadmin.pythonanywhere.com/charts/4?chart_type=surface&query=&x=date&z=Col0&agg=raw&cpg=false&y=%5B%22security_id%22%5D>`__.
+& Google Colab. Here are some demos of the `grid <http://alphatechadmin.pythonanywhere.com/dtale/main/1>`__.
 
 `hvplot <https://hvplot.holoviz.org/index.html>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -220,7 +219,7 @@ It can be loaded as a native pandas plotting backend via
 .. _ecosystem.ide:
 
 IDE
-------
+---
 
 `IPython <https://ipython.org/documentation.html>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -264,7 +263,7 @@ debugging and profiling functionality of a software development tool with the
 data exploration, interactive execution, deep inspection and rich visualization
 capabilities of a scientific environment like MATLAB or Rstudio.
 
-Its `Variable Explorer <https://docs.spyder-ide.org/variableexplorer.html>`__
+Its `Variable Explorer <https://docs.spyder-ide.org/current/panes/variableexplorer.html>`__
 allows users to view, manipulate and edit pandas ``Index``, ``Series``,
 and ``DataFrame`` objects like a "spreadsheet", including copying and modifying
 values, sorting, displaying a "heatmap", converting data types and more.
@@ -274,9 +273,9 @@ Spyder can also import data from a variety of plain text and binary files
 or the clipboard into a new pandas DataFrame via a sophisticated import wizard.
 
 Most pandas classes, methods and data attributes can be autocompleted in
-Spyder's `Editor <https://docs.spyder-ide.org/editor.html>`__ and
-`IPython Console <https://docs.spyder-ide.org/ipythonconsole.html>`__,
-and Spyder's `Help pane <https://docs.spyder-ide.org/help.html>`__ can retrieve
+Spyder's `Editor <https://docs.spyder-ide.org/current/panes/editor.html>`__ and
+`IPython Console <https://docs.spyder-ide.org/current/panes/ipythonconsole.html>`__,
+and Spyder's `Help pane <https://docs.spyder-ide.org/current/panes/help.html>`__ can retrieve
 and render Numpydoc documentation on pandas objects in rich text with Sphinx
 both automatically and on-demand.
 
@@ -312,8 +311,8 @@ The following data feeds are available:
  * Stooq Index Data
  * MOEX Data
 
-`Quandl/Python <https://github.com/quandl/Python>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Quandl/Python <https://github.com/quandl/quandl-python>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Quandl API for Python wraps the Quandl REST API to return
 pandas DataFrames with timeseries indexes.
 
@@ -324,8 +323,8 @@ PyDatastream is a Python interface to the
 REST API to return indexed pandas DataFrames with financial data.
 This package requires valid credentials for this API (non free).
 
-`pandaSDMX <https://pandasdmx.readthedocs.io>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`pandaSDMX <https://pandasdmx.readthedocs.io/en/v1.0/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 pandaSDMX is a library to retrieve and acquire statistical data
 and metadata disseminated in
 `SDMX <https://www.sdmx.org>`_ 2.1, an ISO-standard
@@ -357,13 +356,22 @@ with pandas.
 Domain specific
 ---------------
 
-`Geopandas <https://github.com/kjordahl/geopandas>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Geopandas <https://github.com/geopandas/geopandas>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Geopandas extends pandas data objects to include geographic information which support
 geometric operations. If your work entails maps and geographical coordinates, and
 you love pandas, you should take a close look at Geopandas.
 
+`staircase <https://github.com/staircase-dev/staircase>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+staircase is a data analysis package, built upon pandas and numpy, for modelling and
+manipulation of mathematical step functions. It provides a rich variety of arithmetic
+operations, relational operations, logical operations, statistical operations and
+aggregations for step functions defined over real numbers, datetime and timedelta domains.
+
+
 `xarray <https://github.com/pydata/xarray>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -398,7 +406,7 @@ any Delta table into Pandas dataframe.
 .. _ecosystem.out-of-core:
 
 Out-of-core
--------------
+-----------
 
 `Blaze <https://blaze.pydata.org/>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -436,8 +444,8 @@ can selectively scale parts of their pandas DataFrame applications.
 
     print(df3)
 
-`Dask <https://dask.readthedocs.io/en/latest/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Dask <https://docs.dask.org/en/latest/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Dask is a flexible parallel computing library for analytics. Dask
 provides a familiar ``DataFrame`` interface for out-of-core, parallel and distributed computing.
@@ -475,8 +483,8 @@ time-consuming tasks like ingesting data (``read_csv``, ``read_excel``,
 
     df = pd.read_csv("big.csv")  # use all your cores!
 
-`Odo <http://odo.pydata.org>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Odo <http://odo.pydata.org/en/latest/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Odo provides a uniform API for moving data between different formats. It uses
 pandas own ``read_csv`` for CSV IO and leverages many existing packages such as
@@ -500,8 +508,8 @@ If also displays progress bars.
     df.parallel_apply(func)
 
 
-`Vaex <https://docs.vaex.io/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Vaex <https://vaex.io/docs/index.html>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Increasingly, packages are being built on top of pandas to address specific needs in data preparation, analysis and visualization. Vaex is a Python library for Out-of-Core DataFrames (similar to pandas), to visualize and explore big tabular datasets. It can calculate statistics such as mean, sum, count, standard deviation etc, on an N-dimensional grid up to a billion (10\ :sup:`9`) objects/rows per second. Visualization is done using histograms, density plots and 3d volume rendering, allowing interactive exploration of big data. Vaex uses memory mapping, zero memory copy policy and lazy computations for best performance (no memory wasted).
 
@@ -532,7 +540,7 @@ Pandas-Genomics provides extension types, extension arrays, and extension access
 `Pint-Pandas`_
 ~~~~~~~~~~~~~~
 
-``Pint-Pandas <https://github.com/hgrecco/pint-pandas>`` provides an extension type for
+`Pint-Pandas <https://github.com/hgrecco/pint-pandas>`_ provides an extension type for
 storing numeric arrays with units. These arrays can be stored inside pandas'
 Series and DataFrame. Operations between Series and DataFrame columns which
 use pint's extension array are then units aware.
@@ -540,7 +548,7 @@ use pint's extension array are then units aware.
 `Text Extensions for Pandas`_
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-``Text Extensions for Pandas <https://ibm.biz/text-extensions-for-pandas>``
+`Text Extensions for Pandas <https://ibm.biz/text-extensions-for-pandas>`_
 provides extension types to cover common data structures for representing natural language
 data, plus library integrations that convert the outputs of popular natural language
 processing libraries into Pandas DataFrames.
@@ -565,6 +573,7 @@ Library            Accessor     Classes                              Description
 `composeml`_       ``slice``    ``DataFrame``                        Provides a generator for enhanced data slicing.
 `datatest`_        ``validate`` ``Series``, ``DataFrame``, ``Index`` Provides validation, differences, and acceptance managers.
 `woodwork`_        ``ww``       ``Series``, ``DataFrame``            Provides physical, logical, and semantic data typing information for Series and DataFrames.
+`staircase`_       ``sc``       ``Series``                           Provides methods for querying, aggregating and plotting step functions
 ================== ============ ==================================== ===============================================================================
 
 .. _cyberpandas: https://cyberpandas.readthedocs.io/en/latest
@@ -575,19 +584,19 @@ Library            Accessor     Classes                              Description
 .. _pathlib.Path: https://docs.python.org/3/library/pathlib.html
 .. _pint-pandas: https://github.com/hgrecco/pint-pandas
 .. _composeml: https://github.com/alteryx/compose
-.. _datatest: https://datatest.readthedocs.io/
+.. _datatest: https://datatest.readthedocs.io/en/stable/
 .. _woodwork: https://github.com/alteryx/woodwork
+.. _staircase: https://www.staircase.dev/
 
 Development tools
-----------------------------
+-----------------
 
-`pandas-stubs <https://github.com/VirtusLab/pandas-stubs>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`pandas-stubs <https://github.com/pandas-dev/pandas-stubs>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 While pandas repository is partially typed, the package itself doesn't expose this information for external use.
 Install pandas-stubs to enable basic type coverage of pandas API.
 
-Learn more by reading through these issues `14468 <https://github.com/pandas-dev/pandas/issues/14468>`_,
-`26766 <https://github.com/pandas-dev/pandas/issues/26766>`_, `28142 <https://github.com/pandas-dev/pandas/issues/28142>`_.
+Learn more by reading through :issue:`14468`, :issue:`26766`, :issue:`28142`.
 
-See installation and usage instructions on the `github page <https://github.com/VirtusLab/pandas-stubs>`__.
+See installation and usage instructions on the `github page <https://github.com/pandas-dev/pandas-stubs>`__.
diff --git a/doc/source/getting_started/comparison/comparison_with_r.rst b/doc/source/getting_started/comparison/comparison_with_r.rst
index 864081002086b..f91f4218c3429 100644
--- a/doc/source/getting_started/comparison/comparison_with_r.rst
+++ b/doc/source/getting_started/comparison/comparison_with_r.rst
@@ -31,7 +31,7 @@ Quick reference
 
 We'll start off with a quick reference guide pairing some common R
 operations using `dplyr
-<https://cran.r-project.org/package=dplyr>`__ with
+<https://cran.r-project.org/web/packages/dplyr/index.html>`__ with
 pandas equivalents.
 
 
@@ -326,8 +326,8 @@ table below shows how these data structures could be mapped in Python.
 | data.frame | dataframe                     |
 +------------+-------------------------------+
 
-|ddply|_
-~~~~~~~~
+ddply
+~~~~~
 
 An expression using a data.frame called ``df`` in R where you want to
 summarize ``x`` by ``month``:
@@ -372,8 +372,8 @@ For more details and examples see :ref:`the groupby documentation
 reshape / reshape2
 ------------------
 
-|meltarray|_
-~~~~~~~~~~~~~
+meltarray
+~~~~~~~~~
 
 An expression using a 3 dimensional array called ``a`` in R where you want to
 melt it into a data.frame:
@@ -390,8 +390,8 @@ In Python, since ``a`` is a list, you can simply use list comprehension.
    a = np.array(list(range(1, 24)) + [np.NAN]).reshape(2, 3, 4)
    pd.DataFrame([tuple(list(x) + [val]) for x, val in np.ndenumerate(a)])
 
-|meltlist|_
-~~~~~~~~~~~~
+meltlist
+~~~~~~~~
 
 An expression using a list called ``a`` in R where you want to melt it
 into a data.frame:
@@ -412,8 +412,8 @@ In Python, this list would be a list of tuples, so
 For more details and examples see :ref:`the Into to Data Structures
 documentation <dsintro>`.
 
-|meltdf|_
-~~~~~~~~~~~~~~~~
+meltdf
+~~~~~~
 
 An expression using a data.frame called ``cheese`` in R where you want to
 reshape the data.frame:
@@ -447,8 +447,8 @@ In Python, the :meth:`~pandas.melt` method is the R equivalent:
 For more details and examples see :ref:`the reshaping documentation
 <reshaping.melt>`.
 
-|cast|_
-~~~~~~~
+cast
+~~~~
 
 In R ``acast`` is an expression using a data.frame called ``df`` in R to cast
 into a higher dimensional array:
@@ -577,20 +577,5 @@ For more details and examples see :ref:`categorical introduction <categorical>`
 .. |subset| replace:: ``subset``
 .. _subset: https://stat.ethz.ch/R-manual/R-patched/library/base/html/subset.html
 
-.. |ddply| replace:: ``ddply``
-.. _ddply: https://cran.r-project.org/web/packages/plyr/plyr.pdf#Rfn.ddply.1
-
-.. |meltarray| replace:: ``melt.array``
-.. _meltarray: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.array.1
-
-.. |meltlist| replace:: ``melt.list``
-.. meltlist: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.list.1
-
-.. |meltdf| replace:: ``melt.data.frame``
-.. meltdf: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.data.frame.1
-
-.. |cast| replace:: ``cast``
-.. cast: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.cast.1
-
 .. |factor| replace:: ``factor``
 .. _factor: https://stat.ethz.ch/R-manual/R-devel/library/base/html/factor.html
diff --git a/doc/source/getting_started/comparison/comparison_with_sas.rst b/doc/source/getting_started/comparison/comparison_with_sas.rst
index 54b45dc20db20..595f3c85a9dc2 100644
--- a/doc/source/getting_started/comparison/comparison_with_sas.rst
+++ b/doc/source/getting_started/comparison/comparison_with_sas.rst
@@ -96,7 +96,7 @@ Reading external data
 
 Like SAS, pandas provides utilities for reading in data from
 many formats.  The ``tips`` dataset, found within the pandas
-tests (`csv <https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/tips.csv>`_)
+tests (`csv <https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/tips.csv>`_)
 will be used in many of the following examples.
 
 SAS provides ``PROC IMPORT`` to read csv data into a data set.
@@ -112,8 +112,8 @@ The pandas method is :func:`read_csv`, which works similarly.
 .. ipython:: python
 
    url = (
-       "https://raw.github.com/pandas-dev/"
-       "pandas/master/pandas/tests/io/data/csv/tips.csv"
+       "https://raw.githubusercontent.com/pandas-dev/"
+       "pandas/main/pandas/tests/io/data/csv/tips.csv"
    )
    tips = pd.read_csv(url)
    tips
@@ -335,7 +335,7 @@ Extracting substring by position
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 SAS extracts a substring from a string based on its position with the
-`SUBSTR <https://www2.sas.com/proceedings/sugi25/25/cc/25p088.pdf>`__ function.
+`SUBSTR <https://support.sas.com/documentation/cdl/en/imlug/66845/HTML/default/viewer.htm#imlug_langref_sect455.htm>`__ function.
 
 .. code-block:: sas
 
@@ -538,7 +538,7 @@ This means that the size of data able to be loaded in pandas is limited by your
 machine's memory, but also that the operations on that data may be faster.
 
 If out of core processing is needed, one possibility is the
-`dask.dataframe <https://dask.pydata.org/en/latest/dataframe.html>`_
+`dask.dataframe <https://docs.dask.org/en/latest/dataframe.html>`_
 library (currently in development) which
 provides a subset of pandas functionality for an on-disk ``DataFrame``
 
diff --git a/doc/source/getting_started/comparison/comparison_with_spreadsheets.rst b/doc/source/getting_started/comparison/comparison_with_spreadsheets.rst
index 19999be9b461f..d55b669d94a87 100644
--- a/doc/source/getting_started/comparison/comparison_with_spreadsheets.rst
+++ b/doc/source/getting_started/comparison/comparison_with_spreadsheets.rst
@@ -11,7 +11,7 @@ of how various spreadsheet operations would be performed using pandas. This page
 terminology and link to documentation for Excel, but much will be the same/similar in
 `Google Sheets <https://support.google.com/a/users/answer/9282959>`_,
 `LibreOffice Calc <https://help.libreoffice.org/latest/en-US/text/scalc/main0000.html?DbPAR=CALC>`_,
-`Apple Numbers <https://www.apple.com/mac/numbers/compatibility/functions.html>`_, and other
+`Apple Numbers <https://www.apple.com/numbers/compatibility/>`_, and other
 Excel-compatible spreadsheet software.
 
 .. include:: includes/introduction.rst
@@ -85,14 +85,14 @@ In a spreadsheet, `values can be typed directly into cells <https://support.micr
 Reading external data
 ~~~~~~~~~~~~~~~~~~~~~
 
-Both `Excel <https://support.microsoft.com/en-us/office/import-data-from-external-data-sources-power-query-be4330b3-5356-486c-a168-b68e9e616f5a>`__
+Both `Excel <https://support.microsoft.com/en-us/office/import-data-from-data-sources-power-query-be4330b3-5356-486c-a168-b68e9e616f5a>`__
 and :ref:`pandas <10min_tut_02_read_write>` can import data from various sources in various
 formats.
 
 CSV
 '''
 
-Let's load and display the `tips <https://github.com/pandas-dev/pandas/blob/master/pandas/tests/io/data/csv/tips.csv>`_
+Let's load and display the `tips <https://github.com/pandas-dev/pandas/blob/main/pandas/tests/io/data/csv/tips.csv>`_
 dataset from the pandas tests, which is a CSV file. In Excel, you would download and then
 `open the CSV <https://support.microsoft.com/en-us/office/import-or-export-text-txt-or-csv-files-5250ac4c-663c-47ce-937b-339e391393ba>`_.
 In pandas, you pass the URL or local path of the CSV file to :func:`~pandas.read_csv`:
@@ -100,8 +100,8 @@ In pandas, you pass the URL or local path of the CSV file to :func:`~pandas.read
 .. ipython:: python
 
    url = (
-       "https://raw.github.com/pandas-dev"
-       "/pandas/master/pandas/tests/io/data/csv/tips.csv"
+       "https://raw.githubusercontent.com/pandas-dev"
+       "/pandas/main/pandas/tests/io/data/csv/tips.csv"
    )
    tips = pd.read_csv(url)
    tips
diff --git a/doc/source/getting_started/comparison/comparison_with_sql.rst b/doc/source/getting_started/comparison/comparison_with_sql.rst
index 0596687b4d15e..a6d9d65e85645 100644
--- a/doc/source/getting_started/comparison/comparison_with_sql.rst
+++ b/doc/source/getting_started/comparison/comparison_with_sql.rst
@@ -17,8 +17,8 @@ structure.
 .. ipython:: python
 
     url = (
-        "https://raw.github.com/pandas-dev"
-        "/pandas/master/pandas/tests/io/data/csv/tips.csv"
+        "https://raw.githubusercontent.com/pandas-dev"
+        "/pandas/main/pandas/tests/io/data/csv/tips.csv"
     )
     tips = pd.read_csv(url)
     tips
diff --git a/doc/source/getting_started/comparison/comparison_with_stata.rst b/doc/source/getting_started/comparison/comparison_with_stata.rst
index 94c45adcccc82..b4b0c42d1db1d 100644
--- a/doc/source/getting_started/comparison/comparison_with_stata.rst
+++ b/doc/source/getting_started/comparison/comparison_with_stata.rst
@@ -92,7 +92,7 @@ Reading external data
 
 Like Stata, pandas provides utilities for reading in data from
 many formats.  The ``tips`` data set, found within the pandas
-tests (`csv <https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/tips.csv>`_)
+tests (`csv <https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/tips.csv>`_)
 will be used in many of the following examples.
 
 Stata provides ``import delimited`` to read csv data into a data set in memory.
@@ -108,8 +108,8 @@ the data set if presented with a url.
 .. ipython:: python
 
    url = (
-       "https://raw.github.com/pandas-dev"
-       "/pandas/master/pandas/tests/io/data/csv/tips.csv"
+       "https://raw.githubusercontent.com/pandas-dev"
+       "/pandas/main/pandas/tests/io/data/csv/tips.csv"
    )
    tips = pd.read_csv(url)
    tips
@@ -496,6 +496,6 @@ Disk vs memory
 pandas and Stata both operate exclusively in memory. This means that the size of
 data able to be loaded in pandas is limited by your machine's memory.
 If out of core processing is needed, one possibility is the
-`dask.dataframe <https://dask.pydata.org/en/latest/dataframe.html>`_
+`dask.dataframe <https://docs.dask.org/en/latest/dataframe.html>`_
 library, which provides a subset of pandas functionality for an
 on-disk ``DataFrame``.
diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 05c47d5cdf4f7..31eaa2367b683 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -12,7 +12,7 @@ cross platform distribution for data analysis and scientific computing.
 This is the recommended installation method for most users.
 
 Instructions for installing from source,
-`PyPI <https://pypi.org/project/pandas>`__, `ActivePython <https://www.activestate.com/products/python/downloads/>`__, various Linux distributions, or a
+`PyPI <https://pypi.org/project/pandas>`__, `ActivePython <https://www.activestate.com/products/python/>`__, various Linux distributions, or a
 `development version <https://github.com/pandas-dev/pandas>`__ are also provided.
 
 .. _install.version:
@@ -20,7 +20,7 @@ Instructions for installing from source,
 Python version support
 ----------------------
 
-Officially Python 3.8, and 3.9.
+Officially Python 3.8, 3.9, 3.10 and 3.11.
 
 Installing pandas
 -----------------
@@ -70,18 +70,18 @@ and involves downloading the installer which is a few hundred megabytes in size.
 
 If you want to have more control on which packages, or have a limited internet
 bandwidth, then installing pandas with
-`Miniconda <https://conda.pydata.org/miniconda.html>`__ may be a better solution.
+`Miniconda <https://docs.conda.io/en/latest/miniconda.html>`__ may be a better solution.
 
-`Conda <https://conda.pydata.org/docs/>`__ is the package manager that the
+`Conda <https://conda.io/en/latest/>`__ is the package manager that the
 `Anaconda <https://docs.continuum.io/anaconda/>`__ distribution is built upon.
 It is a package manager that is both cross-platform and language agnostic
 (it can play a similar role to a pip and virtualenv combination).
 
 `Miniconda <https://conda.pydata.org/miniconda.html>`__ allows you to create a
 minimal self contained Python installation, and then use the
-`Conda <https://conda.pydata.org/docs/>`__ command to install additional packages.
+`Conda <https://conda.io/en/latest/>`__ command to install additional packages.
 
-First you will need `Conda <https://conda.pydata.org/docs/>`__ to be installed and
+First you will need `Conda <https://conda.io/en/latest/>`__ to be installed and
 downloading and running the `Miniconda
 <https://conda.pydata.org/miniconda.html>`__
 will do this for you. The installer
@@ -143,8 +143,8 @@ Installing with ActivePython
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Installation instructions for
-`ActivePython <https://www.activestate.com/activepython>`__ can be found
-`here <https://www.activestate.com/activepython/downloads>`__. Versions
+`ActivePython <https://www.activestate.com/products/python/>`__ can be found
+`here <https://www.activestate.com/products/python/>`__. Versions
 2.7, 3.5 and 3.6 include pandas.
 
 Installing using your Linux distribution's package manager.
@@ -158,10 +158,10 @@ The commands in this table will install pandas for Python 3 from your distributi
 
 
     Debian, stable, `official Debian repository <https://packages.debian.org/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
-    Debian & Ubuntu, unstable (latest packages), `NeuroDebian <http://neuro.debian.net/index.html#how-to-use-this-repository>`__ , ``sudo apt-get install python3-pandas``
+    Debian & Ubuntu, unstable (latest packages), `NeuroDebian <https://neuro.debian.net/index.html#how-to-use-this-repository>`__ , ``sudo apt-get install python3-pandas``
     Ubuntu, stable, `official Ubuntu repository <https://packages.ubuntu.com/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
     OpenSuse, stable, `OpenSuse Repository  <https://software.opensuse.org/package/python-pandas?search_term=pandas>`__ , ``zypper in python3-pandas``
-    Fedora, stable, `official Fedora repository  <https://admin.fedoraproject.org/pkgdb/package/rpms/python-pandas/>`__ , ``dnf install python3-pandas``
+    Fedora, stable, `official Fedora repository  <https://src.fedoraproject.org/rpms/python-pandas>`__ , ``dnf install python3-pandas``
     Centos/RHEL, stable, `EPEL repository <https://admin.fedoraproject.org/pkgdb/package/rpms/python-pandas/>`__ , ``yum install python3-pandas``
 
 **However**, the packages in the linux package managers are often a few versions behind, so
@@ -199,22 +199,33 @@ the code base as of this writing. To run it on your machine to verify that
 everything is working (and that you have all of the dependencies, soft and hard,
 installed), make sure you have `pytest
 <https://docs.pytest.org/en/latest/>`__ >= 6.0 and `Hypothesis
-<https://hypothesis.readthedocs.io/>`__ >= 3.58, then run:
+<https://hypothesis.readthedocs.io/en/latest/>`__ >= 6.13.0, then run:
 
 ::
 
     >>> pd.test()
-    running: pytest --skip-slow --skip-network C:\Users\TP\Anaconda3\envs\py36\lib\site-packages\pandas
-    ============================= test session starts =============================
-    platform win32 -- Python 3.6.2, pytest-3.6.0, py-1.4.34, pluggy-0.4.0
-    rootdir: C:\Users\TP\Documents\Python\pandasdev\pandas, inifile: setup.cfg
-    collected 12145 items / 3 skipped
+    running: pytest --skip-slow --skip-network --skip-db /home/user/anaconda3/lib/python3.9/site-packages/pandas
 
-    ..................................................................S......
-    ........S................................................................
-    .........................................................................
+    ============================= test session starts ==============================
+    platform linux -- Python 3.9.7, pytest-6.2.5, py-1.11.0, pluggy-1.0.0
+    rootdir: /home/user
+    plugins: dash-1.19.0, anyio-3.5.0, hypothesis-6.29.3
+    collected 154975 items / 4 skipped / 154971 selected
+    ........................................................................ [  0%]
+    ........................................................................ [ 99%]
+    .......................................                                  [100%]
 
-    ==================== 12130 passed, 12 skipped in 368.339 seconds =====================
+    ==================================== ERRORS ====================================
+
+    =================================== FAILURES ===================================
+
+    =============================== warnings summary ===============================
+
+    =========================== short test summary info ============================
+
+    = 1 failed, 146194 passed, 7402 skipped, 1367 xfailed, 5 xpassed, 197 warnings, 10 errors in 1090.16s (0:18:10) =
+
+This is just an example of what information is shown. You might see a slightly different result as what is shown above.
 
 .. _install.dependencies:
 
@@ -224,7 +235,7 @@ Dependencies
 ================================================================ ==========================
 Package                                                          Minimum supported version
 ================================================================ ==========================
-`NumPy <https://numpy.org>`__                                    1.18.5
+`NumPy <https://numpy.org>`__                                    1.20.3
 `python-dateutil <https://dateutil.readthedocs.io/en/stable/>`__ 2.8.1
 `pytz <https://pypi.org/project/pytz/>`__                        2020.1
 ================================================================ ==========================
@@ -236,11 +247,11 @@ Recommended dependencies
 
 * `numexpr <https://github.com/pydata/numexpr>`__: for accelerating certain numerical operations.
   ``numexpr`` uses multiple cores as well as smart chunking and caching to achieve large speedups.
-  If installed, must be Version 2.7.1 or higher.
+  If installed, must be Version 2.7.3 or higher.
 
 * `bottleneck <https://github.com/pydata/bottleneck>`__: for accelerating certain types of ``nan``
   evaluations. ``bottleneck`` uses specialized cython routines to achieve large speedups. If installed,
-  must be Version 1.3.1 or higher.
+  must be Version 1.3.2 or higher.
 
 .. note::
 
@@ -259,6 +270,23 @@ For example, :func:`pandas.read_hdf` requires the ``pytables`` package, while
 optional dependency is not installed, pandas will raise an ``ImportError`` when
 the method requiring that dependency is called.
 
+Timezones
+^^^^^^^^^
+
+========================= ========================= =============================================================
+Dependency                Minimum Version           Notes
+========================= ========================= =============================================================
+tzdata                    2022.1(pypi)/             Allows the use of ``zoneinfo`` timezones with pandas.
+                          2022a(for system tzdata)  **Note**: You only need to install the pypi package if your
+                                                    system does not already provide the IANA tz database.
+                                                    However, the minimum tzdata version still applies, even if it
+                                                    is not enforced through an error.
+
+                                                    If you would like to keep your system tzdata version updated,
+                                                    it is recommended to use the ``tzdata`` package from
+                                                    conda-forge.
+========================= ========================= =============================================================
+
 Visualization
 ^^^^^^^^^^^^^
 
@@ -266,8 +294,8 @@ Visualization
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
 matplotlib                3.3.2              Plotting library
-Jinja2                    2.11               Conditional formatting with DataFrame.style
-tabulate                  0.8.7              Printing in Markdown-friendly format (see `tabulate`_)
+Jinja2                    3.0.0              Conditional formatting with DataFrame.style
+tabulate                  0.8.9              Printing in Markdown-friendly format (see `tabulate`_)
 ========================= ================== =============================================================
 
 Computation
@@ -276,10 +304,10 @@ Computation
 ========================= ================== =============================================================
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
-SciPy                     1.14.1             Miscellaneous statistical functions
-numba                     0.50.1             Alternative execution engine for rolling operations
+SciPy                     1.7.1              Miscellaneous statistical functions
+numba                     0.53.1             Alternative execution engine for rolling operations
                                              (see :ref:`Enhancing Performance <enhancingperf.numba>`)
-xarray                    0.15.1             pandas-like API for N-dimensional data
+xarray                    0.19.0             pandas-like API for N-dimensional data
 ========================= ================== =============================================================
 
 Excel files
@@ -290,9 +318,9 @@ Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
 xlrd                      2.0.1              Reading Excel
 xlwt                      1.3.0              Writing Excel
-xlsxwriter                1.2.2              Writing Excel
-openpyxl                  3.0.3              Reading / writing for xlsx files
-pyxlsb                    1.0.6              Reading for xlsb files
+xlsxwriter                1.4.3              Writing Excel
+openpyxl                  3.0.7              Reading / writing for xlsx files
+pyxlsb                    1.0.8              Reading for xlsb files
 ========================= ================== =============================================================
 
 HTML
@@ -301,9 +329,9 @@ HTML
 ========================= ================== =============================================================
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
-BeautifulSoup4            4.8.2              HTML parser for read_html
+BeautifulSoup4            4.9.3              HTML parser for read_html
 html5lib                  1.1                HTML parser for read_html
-lxml                      4.5.0              HTML parser for read_html
+lxml                      4.6.3              HTML parser for read_html
 ========================= ================== =============================================================
 
 One of the following combinations of libraries is needed to use the
@@ -345,9 +373,9 @@ SQL databases
 ========================= ================== =============================================================
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
-SQLAlchemy                1.4.0               SQL support for databases other than sqlite
-psycopg2                  2.8.4               PostgreSQL engine for sqlalchemy
-pymysql                   0.10.1              MySQL engine for sqlalchemy
+SQLAlchemy                1.4.16             SQL support for databases other than sqlite
+psycopg2                  2.8.6              PostgreSQL engine for sqlalchemy
+pymysql                   1.0.2              MySQL engine for sqlalchemy
 ========================= ================== =============================================================
 
 Other data sources
@@ -357,11 +385,11 @@ Other data sources
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
 PyTables                  3.6.1              HDF5-based reading / writing
-blosc                     1.20.1             Compression for HDF5
+blosc                     1.21.0             Compression for HDF5
 zlib                                         Compression for HDF5
 fastparquet               0.4.0              Parquet reading / writing
 pyarrow                   1.0.1              Parquet, ORC, and feather reading / writing
-pyreadstat                                   SPSS files (.sav) reading
+pyreadstat                1.1.2              SPSS files (.sav) reading
 ========================= ================== =============================================================
 
 .. _install.warn_orc:
@@ -385,10 +413,10 @@ Access data in the cloud
 ========================= ================== =============================================================
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
-fsspec                    0.7.4              Handling files aside from simple local and HTTP
-gcsfs                     0.6.0              Google Cloud Storage access
-pandas-gbq                0.14.0             Google Big Query access
-s3fs                      0.4.0              Amazon S3 access
+fsspec                    2021.7.0           Handling files aside from simple local and HTTP
+gcsfs                     2021.7.0           Google Cloud Storage access
+pandas-gbq                0.15.0             Google Big Query access
+s3fs                      2021.08.0          Amazon S3 access
 ========================= ================== =============================================================
 
 Clipboard
@@ -410,5 +438,7 @@ Compression
 ========================= ================== =============================================================
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
-Zstandard                                    Zstandard compression
+brotli                    0.7.0              Brotli compression
+python-snappy             0.6.0              Snappy compression
+Zstandard                 0.15.2             Zstandard compression
 ========================= ================== =============================================================
diff --git a/doc/source/getting_started/intro_tutorials/03_subset_data.rst b/doc/source/getting_started/intro_tutorials/03_subset_data.rst
index 4106b0e064823..291cbddff58eb 100644
--- a/doc/source/getting_started/intro_tutorials/03_subset_data.rst
+++ b/doc/source/getting_started/intro_tutorials/03_subset_data.rst
@@ -242,7 +242,7 @@ I want to work with passenger data for which the age is known.
     age_no_na.head()
 
 The :meth:`~Series.notna` conditional function returns a ``True`` for each row the
-values are not an ``Null`` value. As such, this can be combined with the
+values are not a ``Null`` value. As such, this can be combined with the
 selection brackets ``[]`` to filter the data table.
 
 .. raw:: html
@@ -358,9 +358,9 @@ See the user guide section on :ref:`different choices for indexing <indexing.cho
    of column/row labels, a slice of labels, a conditional expression or
    a colon.
 -  Select specific rows and/or columns using ``loc`` when using the row
-   and column names
+   and column names.
 -  Select specific rows and/or columns using ``iloc`` when using the
-   positions in the table
+   positions in the table.
 -  You can assign new values to a selection based on ``loc``/``iloc``.
 
 .. raw:: html
diff --git a/doc/source/getting_started/intro_tutorials/04_plotting.rst b/doc/source/getting_started/intro_tutorials/04_plotting.rst
index a6d8142e68073..b6f1ac212f821 100644
--- a/doc/source/getting_started/intro_tutorials/04_plotting.rst
+++ b/doc/source/getting_started/intro_tutorials/04_plotting.rst
@@ -2,6 +2,12 @@
 
 {{ header }}
 
+How do I create plots in pandas?
+----------------------------------
+
+.. image:: ../../_static/schemas/04_plot_overview.svg
+   :align: center
+
 .. ipython:: python
 
     import pandas as pd
@@ -35,12 +41,6 @@
     </ul>
     </div>
 
-How to create plots in pandas?
-------------------------------
-
-.. image:: ../../_static/schemas/04_plot_overview.svg
-   :align: center
-
 .. raw:: html
 
     <ul class="task-bullet">
@@ -52,6 +52,7 @@ I want a quick visual check of the data.
 
     @savefig 04_airqual_quick.png
     air_quality.plot()
+    plt.show()
 
 With a ``DataFrame``, pandas creates by default one line plot for each of
 the columns with numeric data.
@@ -68,10 +69,19 @@ the columns with numeric data.
 
 I want to plot only the columns of the data table with the data from Paris.
 
+.. ipython:: python
+   :suppress:
+
+    # We need to clear the figure here as, within doc generation, the plot
+    # accumulates data on each plot(). This is not needed when running
+    # in a notebook, so is suppressed from output.
+    plt.clf()
+
 .. ipython:: python
 
     @savefig 04_airqual_paris.png
     air_quality["station_paris"].plot()
+    plt.show()
 
 To plot a specific column, use the selection method of the
 :ref:`subset data tutorial <10min_tut_03_subset>` in combination with the :meth:`~DataFrame.plot`
@@ -88,12 +98,13 @@ method. Hence, the :meth:`~DataFrame.plot` method works on both ``Series`` and
     <ul class="task-bullet">
         <li>
 
-I want to visually compare the :math:`N0_2` values measured in London versus Paris.
+I want to visually compare the :math:`NO_2` values measured in London versus Paris.
 
 .. ipython:: python
 
     @savefig 04_airqual_scatter.png
     air_quality.plot.scatter(x="station_london", y="station_paris", alpha=0.5)
+    plt.show()
 
 .. raw:: html
 
@@ -125,6 +136,7 @@ method is applicable on the air quality example data:
 
     @savefig 04_airqual_boxplot.png
     air_quality.plot.box()
+    plt.show()
 
 .. raw:: html
 
@@ -148,6 +160,7 @@ I want each of the columns in a separate subplot.
 
     @savefig 04_airqual_area_subplot.png
     axs = air_quality.plot.area(figsize=(12, 4), subplots=True)
+    plt.show()
 
 Separate subplots for each of the data columns are supported by the ``subplots`` argument
 of the ``plot`` functions. The builtin options available in each of the pandas plot
@@ -180,9 +193,10 @@ I want to further customize, extend or save the resulting plot.
 
     fig, axs = plt.subplots(figsize=(12, 4))
     air_quality.plot.area(ax=axs)
-    @savefig 04_airqual_customized.png
     axs.set_ylabel("NO$_2$ concentration")
+    @savefig 04_airqual_customized.png
     fig.savefig("no2_concentrations.png")
+    plt.show()
 
 .. ipython:: python
    :suppress:
@@ -197,26 +211,27 @@ I want to further customize, extend or save the resulting plot.
     </ul>
 
 Each of the plot objects created by pandas is a
-`matplotlib <https://matplotlib.org/>`__ object. As Matplotlib provides
+`Matplotlib <https://matplotlib.org/>`__ object. As Matplotlib provides
 plenty of options to customize plots, making the link between pandas and
-Matplotlib explicit enables all the power of matplotlib to the plot.
+Matplotlib explicit enables all the power of Matplotlib to the plot.
 This strategy is applied in the previous example:
 
 ::
 
-   fig, axs = plt.subplots(figsize=(12, 4))        # Create an empty matplotlib Figure and Axes
+   fig, axs = plt.subplots(figsize=(12, 4))        # Create an empty Matplotlib Figure and Axes
    air_quality.plot.area(ax=axs)                   # Use pandas to put the area plot on the prepared Figure/Axes
-   axs.set_ylabel("NO$_2$ concentration")          # Do any matplotlib customization you like
-   fig.savefig("no2_concentrations.png")           # Save the Figure/Axes using the existing matplotlib method.
+   axs.set_ylabel("NO$_2$ concentration")          # Do any Matplotlib customization you like
+   fig.savefig("no2_concentrations.png")           # Save the Figure/Axes using the existing Matplotlib method.
+   plt.show()                                      # Display the plot
 
 .. raw:: html
 
     <div class="shadow gs-callout gs-callout-remember">
         <h4>REMEMBER</h4>
 
--  The ``.plot.*`` methods are applicable on both Series and DataFrames
+-  The ``.plot.*`` methods are applicable on both Series and DataFrames.
 -  By default, each of the columns is plotted as a different element
-   (line, boxplot,…)
+   (line, boxplot,…).
 -  Any plot created by pandas is a Matplotlib object.
 
 .. raw:: html
diff --git a/doc/source/getting_started/intro_tutorials/05_add_columns.rst b/doc/source/getting_started/intro_tutorials/05_add_columns.rst
index dc18be935b973..6cf7c0ea9593f 100644
--- a/doc/source/getting_started/intro_tutorials/05_add_columns.rst
+++ b/doc/source/getting_started/intro_tutorials/05_add_columns.rst
@@ -41,7 +41,7 @@ How to create new columns derived from existing columns?
     <ul class="task-bullet">
         <li>
 
-I want to express the :math:`NO_2` concentration of the station in London in mg/m\ :math:`^3`
+I want to express the :math:`NO_2` concentration of the station in London in mg/m\ :math:`^3`.
 
 (*If we assume temperature of 25 degrees Celsius and pressure of 1013
 hPa, the conversion factor is 1.882*)
@@ -60,7 +60,7 @@ at the left side of the assignment.
     </ul>
 
 .. note::
-    The calculation of the values is done **element_wise**. This
+    The calculation of the values is done **element-wise**. This
     means all values in the given column are multiplied by the value 1.882
     at once. You do not need to use a loop to iterate each of the rows!
 
@@ -72,7 +72,7 @@ at the left side of the assignment.
     <ul class="task-bullet">
         <li>
 
-I want to check the ratio of the values in Paris versus Antwerp and save the result in a new column
+I want to check the ratio of the values in Paris versus Antwerp and save the result in a new column.
 
 .. ipython:: python
 
@@ -89,8 +89,8 @@ values in each row*.
         </li>
     </ul>
 
-Also other mathematical operators (``+``, ``-``, ``\*``, ``/``) or
-logical operators (``<``, ``>``, ``=``,…) work element wise. The latter was already
+Also other mathematical operators (``+``, ``-``, ``*``, ``/``,…) or
+logical operators (``<``, ``>``, ``==``,…) work element-wise. The latter was already
 used in the :ref:`subset data tutorial <10min_tut_03_subset>` to filter
 rows of a table using a conditional expression.
 
@@ -101,7 +101,7 @@ If you need more advanced logic, you can use arbitrary Python code via :meth:`~D
     <ul class="task-bullet">
         <li>
 
-I want to rename the data columns to the corresponding station identifiers used by openAQ
+I want to rename the data columns to the corresponding station identifiers used by `OpenAQ <https://openaq.org/>`__.
 
 .. ipython:: python
 
diff --git a/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst b/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst
index fcf754e340ab2..9e5968580ccf4 100644
--- a/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst
+++ b/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst
@@ -74,7 +74,7 @@ What is the median age and ticket fare price of the Titanic passengers?
     titanic[["Age", "Fare"]].median()
 
 The statistic applied to multiple columns of a ``DataFrame`` (the selection of two columns
-return a ``DataFrame``, see the :ref:`subset data tutorial <10min_tut_03_subset>`) is calculated for each numeric column.
+returns a ``DataFrame``, see the :ref:`subset data tutorial <10min_tut_03_subset>`) is calculated for each numeric column.
 
 .. raw:: html
 
@@ -82,7 +82,7 @@ return a ``DataFrame``, see the :ref:`subset data tutorial <10min_tut_03_subset>
     </ul>
 
 The aggregating statistic can be calculated for multiple columns at the
-same time. Remember the ``describe`` function from :ref:`first tutorial <10min_tut_01_tableoriented>` tutorial?
+same time. Remember the ``describe`` function from the :ref:`first tutorial <10min_tut_01_tableoriented>`?
 
 .. ipython:: python
 
@@ -143,8 +143,8 @@ returned.
 
 Calculating a given statistic (e.g. ``mean`` age) *for each category in
 a column* (e.g. male/female in the ``Sex`` column) is a common pattern.
-The ``groupby`` method is used to support this type of operations. More
-general, this fits in the more general ``split-apply-combine`` pattern:
+The ``groupby`` method is used to support this type of operations. This
+fits in the more general ``split-apply-combine`` pattern:
 
 -  **Split** the data into groups
 -  **Apply** a function to each group independently
@@ -154,14 +154,14 @@ The apply and combine steps are typically done together in pandas.
 
 In the previous example, we explicitly selected the 2 columns first. If
 not, the ``mean`` method is applied to each column containing numerical
-columns:
+columns by passing ``numeric_only=True``:
 
 .. ipython:: python
 
-    titanic.groupby("Sex").mean()
+    titanic.groupby("Sex").mean(numeric_only=True)
 
 It does not make much sense to get the average value of the ``Pclass``.
-if we are only interested in the average age for each gender, the
+If we are only interested in the average age for each gender, the
 selection of columns (rectangular brackets ``[]`` as usual) is supported
 on the grouped data as well:
 
@@ -254,7 +254,7 @@ within each group:
     <div class="d-flex flex-row gs-torefguide">
         <span class="badge badge-info">To user guide</span>
 
-The user guide has a dedicated section on ``value_counts`` , see page on :ref:`discretization <basics.discretization>`.
+The user guide has a dedicated section on ``value_counts`` , see the page on :ref:`discretization <basics.discretization>`.
 
 .. raw:: html
 
@@ -265,10 +265,10 @@ The user guide has a dedicated section on ``value_counts`` , see page on :ref:`d
     <div class="shadow gs-callout gs-callout-remember">
         <h4>REMEMBER</h4>
 
--  Aggregation statistics can be calculated on entire columns or rows
--  ``groupby`` provides the power of the *split-apply-combine* pattern
+-  Aggregation statistics can be calculated on entire columns or rows.
+-  ``groupby`` provides the power of the *split-apply-combine* pattern.
 -  ``value_counts`` is a convenient shortcut to count the number of
-   entries in each category of a variable
+   entries in each category of a variable.
 
 .. raw:: html
 
diff --git a/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst b/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst
index bd4a617fe753b..27d6f95923ed0 100644
--- a/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst
+++ b/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst
@@ -37,7 +37,7 @@
 
 This tutorial uses air quality data about :math:`NO_2` and Particulate matter less than 2.5
 micrometers, made available by
-`openaq <https://openaq.org>`__ and using the
+`OpenAQ <https://openaq.org>`__ and using the
 `py-openaq <http://dhhagan.github.io/py-openaq/index.html>`__ package.
 The ``air_quality_long.csv`` data set provides :math:`NO_2` and
 :math:`PM_{25}` values for the measurement stations *FR04014*, *BETR801*
@@ -67,7 +67,7 @@ measurement.
 .. raw:: html
 
                     </p>
-                <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/air_quality_long.csv" class="btn btn-dark btn-sm">To raw data</a>
+                <a href="https://github.com/pandas-dev/pandas/tree/main/doc/data/air_quality_long.csv" class="btn btn-dark btn-sm">To raw data</a>
             </div>
         </div>
 
@@ -117,7 +117,7 @@ I want to sort the Titanic data according to the cabin class and age in descendi
 
     titanic.sort_values(by=['Pclass', 'Age'], ascending=False).head()
 
-With :meth:`Series.sort_values`, the rows in the table are sorted according to the
+With :meth:`DataFrame.sort_values`, the rows in the table are sorted according to the
 defined column(s). The index will follow the row order.
 
 .. raw:: html
@@ -130,7 +130,7 @@ defined column(s). The index will follow the row order.
     <div class="d-flex flex-row gs-torefguide">
         <span class="badge badge-info">To user guide</span>
 
-More details about sorting of tables is provided in the using guide section on :ref:`sorting data <basics.sorting>`.
+More details about sorting of tables is provided in the user guide section on :ref:`sorting data <basics.sorting>`.
 
 .. raw:: html
 
@@ -142,7 +142,7 @@ Long to wide table format
 Let’s use a small subset of the air quality data set. We focus on
 :math:`NO_2` data and only use the first two measurements of each
 location (i.e. the head of each group). The subset of data will be
-called ``no2_subset``
+called ``no2_subset``.
 
 .. ipython:: python
 
@@ -163,7 +163,7 @@ called ``no2_subset``
     <ul class="task-bullet">
         <li>
 
-I want the values for the three stations as separate columns next to each other
+I want the values for the three stations as separate columns next to each other.
 
 .. ipython:: python
 
@@ -177,7 +177,7 @@ for each index/column combination is required.
         </li>
     </ul>
 
-As pandas support plotting of multiple columns (see :ref:`plotting tutorial <10min_tut_04_plotting>`) out of the box, the conversion from
+As pandas supports plotting of multiple columns (see :ref:`plotting tutorial <10min_tut_04_plotting>`) out of the box, the conversion from
 *long* to *wide* table format enables the plotting of the different time
 series at the same time:
 
@@ -216,7 +216,7 @@ Pivot table
     <ul class="task-bullet">
         <li>
 
-I want the mean concentrations for :math:`NO_2` and :math:`PM_{2.5}` in each of the stations in table form
+I want the mean concentrations for :math:`NO_2` and :math:`PM_{2.5}` in each of the stations in table form.
 
 .. ipython:: python
 
@@ -226,7 +226,7 @@ I want the mean concentrations for :math:`NO_2` and :math:`PM_{2.5}` in each of
 
 In the case of :meth:`~DataFrame.pivot`, the data is only rearranged. When multiple
 values need to be aggregated (in this specific case, the values on
-different time steps) :meth:`~DataFrame.pivot_table` can be used, providing an
+different time steps), :meth:`~DataFrame.pivot_table` can be used, providing an
 aggregation function (e.g. mean) on how to combine these values.
 
 .. raw:: html
@@ -235,8 +235,8 @@ aggregation function (e.g. mean) on how to combine these values.
     </ul>
 
 Pivot table is a well known concept in spreadsheet software. When
-interested in summary columns for each variable separately as well, put
-the ``margin`` parameter to ``True``:
+interested in the row/column margins (subtotals) for each variable, set
+the ``margins`` parameter to ``True``:
 
 .. ipython:: python
 
@@ -283,7 +283,7 @@ Wide to long format
 ~~~~~~~~~~~~~~~~~~~
 
 Starting again from the wide format table created in the previous
-section:
+section, we add a new index to the ``DataFrame`` with :meth:`~DataFrame.reset_index`.
 
 .. ipython:: python
 
@@ -298,7 +298,7 @@ section:
     <ul class="task-bullet">
         <li>
 
-I want to collect all air quality :math:`NO_2` measurements in a single column (long format)
+I want to collect all air quality :math:`NO_2` measurements in a single column (long format).
 
 .. ipython:: python
 
@@ -319,7 +319,7 @@ will *melt* all columns NOT mentioned in ``id_vars`` together into two
 columns: A column with the column header names and a column with the
 values itself. The latter column gets by default the name ``value``.
 
-The :func:`pandas.melt` method can be defined in more detail:
+The parameters passed to :func:`pandas.melt` can be defined in more detail:
 
 .. ipython:: python
 
@@ -331,9 +331,9 @@ The :func:`pandas.melt` method can be defined in more detail:
     )
     no_2.head()
 
-The result in the same, but in more detail defined:
+The additional parameters have the following effects:
 
--  ``value_vars`` defines explicitly which columns to *melt* together
+-  ``value_vars`` defines which columns to *melt* together
 -  ``value_name`` provides a custom column name for the values column
    instead of the default column name ``value``
 -  ``var_name`` provides a custom column name for the column collecting
@@ -360,11 +360,11 @@ Conversion from wide to long format with :func:`pandas.melt` is explained in the
     <div class="shadow gs-callout gs-callout-remember">
         <h4>REMEMBER</h4>
 
--  Sorting by one or more columns is supported by ``sort_values``
+-  Sorting by one or more columns is supported by ``sort_values``.
 -  The ``pivot`` function is purely restructuring of the data,
-   ``pivot_table`` supports aggregations
+   ``pivot_table`` supports aggregations.
 -  The reverse of ``pivot`` (long to wide format) is ``melt`` (wide to
-   long format)
+   long format).
 
 .. raw:: html
 
diff --git a/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst b/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst
index be4c284912db4..b2b3891056017 100644
--- a/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst
+++ b/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst
@@ -24,7 +24,7 @@
                         <p class="card-text">
 
 For this tutorial, air quality data about :math:`NO_2` is used, made available by
-`openaq <https://openaq.org>`__ and downloaded using the
+`OpenAQ <https://openaq.org>`__ and downloaded using the
 `py-openaq <http://dhhagan.github.io/py-openaq/index.html>`__ package.
 
 The ``air_quality_no2_long.csv`` data set provides :math:`NO_2`
@@ -34,7 +34,7 @@ Westminster* in respectively Paris, Antwerp and London.
 .. raw:: html
 
                         </p>
-                    <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/air_quality_no2_long.csv" class="btn btn-dark btn-sm">To raw data</a>
+                    <a href="https://github.com/pandas-dev/pandas/tree/main/doc/data/air_quality_no2_long.csv" class="btn btn-dark btn-sm">To raw data</a>
                 </div>
             </div>
 
@@ -59,7 +59,7 @@ Westminster* in respectively Paris, Antwerp and London.
 
 For this tutorial, air quality data about Particulate
 matter less than 2.5 micrometers is used, made available by
-`openaq <https://openaq.org>`__ and downloaded using the
+`OpenAQ <https://openaq.org>`__ and downloaded using the
 `py-openaq <http://dhhagan.github.io/py-openaq/index.html>`__ package.
 
 The ``air_quality_pm25_long.csv`` data set provides :math:`PM_{25}`
@@ -69,7 +69,7 @@ Westminster* in respectively Paris, Antwerp and London.
 .. raw:: html
 
                     </p>
-                <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/air_quality_pm25_long.csv" class="btn btn-dark btn-sm">To raw data</a>
+                <a href="https://github.com/pandas-dev/pandas/tree/main/doc/data/air_quality_pm25_long.csv" class="btn btn-dark btn-sm">To raw data</a>
             </div>
         </div>
 
@@ -102,7 +102,7 @@ Concatenating objects
     <ul class="task-bullet">
         <li>
 
-I want to combine the measurements of :math:`NO_2` and :math:`PM_{25}`, two tables with a similar structure, in a single table
+I want to combine the measurements of :math:`NO_2` and :math:`PM_{25}`, two tables with a similar structure, in a single table.
 
 .. ipython:: python
 
@@ -110,7 +110,7 @@ I want to combine the measurements of :math:`NO_2` and :math:`PM_{25}`, two tabl
     air_quality.head()
 
 The :func:`~pandas.concat` function performs concatenation operations of multiple
-tables along one of the axis (row-wise or column-wise).
+tables along one of the axes (row-wise or column-wise).
 
 .. raw:: html
 
@@ -149,16 +149,13 @@ origin of the table (either ``no2`` from table ``air_quality_no2`` or
 
 In this specific example, the ``parameter`` column provided by the data
 ensures that each of the original tables can be identified. This is not
-always the case. the ``concat`` function provides a convenient solution
+always the case. The ``concat`` function provides a convenient solution
 with the ``keys`` argument, adding an additional (hierarchical) row
 index. For example:
 
 .. ipython:: python
 
     air_quality_ = pd.concat([air_quality_pm25, air_quality_no2], keys=["PM25", "NO2"])
-
-.. ipython:: python
-
     air_quality_.head()
 
 .. note::
@@ -254,7 +251,7 @@ supports multiple join options similar to database-style operations.
     <ul class="task-bullet">
         <li>
 
-Add the parameter full description and name, provided by the parameters metadata table, to the measurements table
+Add the parameters' full description and name, provided by the parameters metadata table, to the measurements table.
 
 .. warning::
     The air quality parameters metadata are stored in a data file
diff --git a/doc/source/getting_started/intro_tutorials/09_timeseries.rst b/doc/source/getting_started/intro_tutorials/09_timeseries.rst
index b9cab0747196e..9d3bc805a915e 100644
--- a/doc/source/getting_started/intro_tutorials/09_timeseries.rst
+++ b/doc/source/getting_started/intro_tutorials/09_timeseries.rst
@@ -26,7 +26,7 @@
 
 For this tutorial, air quality data about :math:`NO_2` and Particulate
 matter less than 2.5 micrometers is used, made available by
-`openaq <https://openaq.org>`__ and downloaded using the
+`OpenAQ <https://openaq.org>`__ and downloaded using the
 `py-openaq <http://dhhagan.github.io/py-openaq/index.html>`__ package.
 The ``air_quality_no2_long.csv"`` data set provides :math:`NO_2` values
 for the measurement stations *FR04014*, *BETR801* and *London
@@ -35,7 +35,7 @@ Westminster* in respectively Paris, Antwerp and London.
 .. raw:: html
 
                         </p>
-                    <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/air_quality_no2_long.csv" class="btn btn-dark btn-sm">To raw data</a>
+                    <a href="https://github.com/pandas-dev/pandas/tree/main/doc/data/air_quality_no2_long.csv" class="btn btn-dark btn-sm">To raw data</a>
                 </div>
             </div>
 
@@ -209,7 +209,7 @@ Plot the typical :math:`NO_2` pattern during the day of our time series of all s
     air_quality.groupby(air_quality["datetime"].dt.hour)["value"].mean().plot(
         kind='bar', rot=0, ax=axs
     )
-    plt.xlabel("Hour of the day");  # custom x label using matplotlib
+    plt.xlabel("Hour of the day");  # custom x label using Matplotlib
     @savefig 09_bar_chart.png
     plt.ylabel("$NO_2 (µg/m^3)$");
 
diff --git a/doc/source/getting_started/intro_tutorials/10_text_data.rst b/doc/source/getting_started/intro_tutorials/10_text_data.rst
index 63db920164ac3..148ac246d7bf8 100644
--- a/doc/source/getting_started/intro_tutorials/10_text_data.rst
+++ b/doc/source/getting_started/intro_tutorials/10_text_data.rst
@@ -179,7 +179,7 @@ applied to integers, so no ``str`` is used.
 
 Based on the index name of the row (``307``) and the column (``Name``),
 we can do a selection using the ``loc`` operator, introduced in the
-`tutorial on subsetting <3_subset_data.ipynb>`__.
+:ref:`tutorial on subsetting <10min_tut_03_subset>`.
 
 .. raw:: html
 
diff --git a/doc/source/getting_started/intro_tutorials/includes/air_quality_no2.rst b/doc/source/getting_started/intro_tutorials/includes/air_quality_no2.rst
index a5a5442330e43..43790bd53f587 100644
--- a/doc/source/getting_started/intro_tutorials/includes/air_quality_no2.rst
+++ b/doc/source/getting_started/intro_tutorials/includes/air_quality_no2.rst
@@ -8,7 +8,7 @@
             <p class="card-text">
 
 For this tutorial, air quality data about :math:`NO_2` is used, made
-available by `openaq <https://openaq.org>`__ and using the
+available by `OpenAQ <https://openaq.org>`__ and using the
 `py-openaq <http://dhhagan.github.io/py-openaq/index.html>`__ package.
 The ``air_quality_no2.csv`` data set provides :math:`NO_2` values for
 the measurement stations *FR04014*, *BETR801* and *London Westminster*
@@ -17,6 +17,6 @@ in respectively Paris, Antwerp and London.
 .. raw:: html
 
             </p>
-            <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/air_quality_no2.csv" class="btn btn-dark btn-sm">To raw data</a>
+            <a href="https://github.com/pandas-dev/pandas/tree/main/doc/data/air_quality_no2.csv" class="btn btn-dark btn-sm">To raw data</a>
         </div>
     </div>
diff --git a/doc/source/getting_started/intro_tutorials/includes/titanic.rst b/doc/source/getting_started/intro_tutorials/includes/titanic.rst
index 7032b70b3f1cf..19b8e81914e31 100644
--- a/doc/source/getting_started/intro_tutorials/includes/titanic.rst
+++ b/doc/source/getting_started/intro_tutorials/includes/titanic.rst
@@ -11,22 +11,21 @@ This tutorial uses the Titanic data set, stored as CSV. The data
 consists of the following data columns:
 
 -  PassengerId: Id of every passenger.
--  Survived: This feature have value 0 and 1. 0 for not survived and 1
-   for survived.
--  Pclass: There are 3 classes: Class 1, Class 2 and Class 3.
+-  Survived: Indication whether passenger survived. ``0`` for yes and ``1`` for no.
+-  Pclass: One out of the 3 ticket classes: Class ``1``, Class ``2`` and Class ``3``.
 -  Name: Name of passenger.
 -  Sex: Gender of passenger.
--  Age: Age of passenger.
--  SibSp: Indication that passenger have siblings and spouse.
--  Parch: Whether a passenger is alone or have family.
+-  Age: Age of passenger in years.
+-  SibSp: Number of siblings or spouses aboard.
+-  Parch: Number of parents or children aboard.
 -  Ticket: Ticket number of passenger.
 -  Fare: Indicating the fare.
--  Cabin: The cabin of passenger.
--  Embarked: The embarked category.
+-  Cabin: Cabin number of passenger.
+-  Embarked: Port of embarkation.
 
 .. raw:: html
 
             </p>
-            <a href="https://github.com/pandas-dev/pandas/tree/master/doc/data/titanic.csv" class="btn btn-dark btn-sm">To raw data</a>
+            <a href="https://github.com/pandas-dev/pandas/raw/main/doc/data/titanic.csv" class="btn btn-dark btn-sm">To raw data</a>
         </div>
     </div>
diff --git a/doc/source/getting_started/overview.rst b/doc/source/getting_started/overview.rst
index 306eb28d23fe7..320d2da01418c 100644
--- a/doc/source/getting_started/overview.rst
+++ b/doc/source/getting_started/overview.rst
@@ -75,7 +75,7 @@ Some other notes
    specialized tool.
 
  - pandas is a dependency of `statsmodels
-   <https://statsmodels.org>`__, making it an important part of the
+   <https://www.statsmodels.org/>`__, making it an important part of the
    statistical computing ecosystem in Python.
 
  - pandas has been used extensively in production in financial applications.
diff --git a/doc/source/getting_started/tutorials.rst b/doc/source/getting_started/tutorials.rst
index a349251bdfca6..bff50bb1e4c2d 100644
--- a/doc/source/getting_started/tutorials.rst
+++ b/doc/source/getting_started/tutorials.rst
@@ -75,6 +75,16 @@ Excel charts with pandas, vincent and xlsxwriter
 
 *  `Using Pandas and XlsxWriter to create Excel charts <https://pandas-xlsxwriter-charts.readthedocs.io/>`_
 
+Joyful pandas
+-------------
+
+A tutorial written in Chinese by Yuanhao Geng. It covers the basic operations
+for NumPy and pandas, 4 main data manipulation methods (including indexing, groupby, reshaping
+and concatenation) and 4 main data types (including missing data, string data, categorical
+data and time series data). At the end of each chapter, corresponding exercises are posted.
+All the datasets and related materials can be found in the GitHub repository
+`datawhalechina/joyful-pandas <https://github.com/datawhalechina/joyful-pandas>`_.
+
 Video tutorials
 ---------------
 
@@ -90,11 +100,11 @@ Video tutorials
 * `Data analysis in Python with pandas <https://www.youtube.com/playlist?list=PL5-da3qGB5ICCsgW1MxlZ0Hq8LL5U3u9y>`_
   (2016-2018)
   `GitHub repo <https://github.com/justmarkham/pandas-videos>`__ and
-  `Jupyter Notebook <https://nbviewer.jupyter.org/github/justmarkham/pandas-videos/blob/master/pandas.ipynb>`__
+  `Jupyter Notebook <https://nbviewer.org/github/justmarkham/pandas-videos/blob/master/pandas.ipynb>`__
 * `Best practices with pandas <https://www.youtube.com/playlist?list=PL5-da3qGB5IBITZj_dYSFqnd_15JgqwA6>`_
   (2018)
   `GitHub repo <https://github.com/justmarkham/pycon-2018-tutorial>`__ and
-  `Jupyter Notebook <https://nbviewer.jupyter.org/github/justmarkham/pycon-2018-tutorial/blob/master/tutorial.ipynb>`__
+  `Jupyter Notebook <https://nbviewer.org/github/justmarkham/pycon-2018-tutorial/blob/master/tutorial.ipynb>`__
 
 
 Various tutorials
@@ -108,3 +118,4 @@ Various tutorials
 * `Pandas and Python: Top 10, by Manish Amde <https://manishamde.github.io/blog/2013/03/07/pandas-and-python-top-10/>`_
 * `Pandas DataFrames Tutorial, by Karlijn Willems <https://www.datacamp.com/community/tutorials/pandas-tutorial-dataframe-python>`_
 * `A concise tutorial with real life examples <https://tutswiki.com/pandas-cookbook/chapter1/>`_
+* `430+ Searchable Pandas recipes by Isshin Inada <https://skytowner.com/explore/pandas_recipes_reference>`_
diff --git a/doc/source/index.rst.template b/doc/source/index.rst.template
index 3b440122c2b97..59280536536db 100644
--- a/doc/source/index.rst.template
+++ b/doc/source/index.rst.template
@@ -10,7 +10,7 @@ pandas documentation
 
 **Date**: |today| **Version**: |version|
 
-**Download documentation**: `PDF Version <pandas.pdf>`__ | `Zipped HTML <pandas.zip>`__
+**Download documentation**: `Zipped HTML <pandas.zip>`__
 
 **Previous versions**: Documentation of previous pandas versions is available at
 `pandas.pydata.org <https://pandas.pydata.org/>`__.
@@ -26,6 +26,7 @@ pandas documentation
 easy-to-use data structures and data analysis tools for the `Python <https://www.python.org/>`__
 programming language.
 
+{% if not single_doc -%}
 .. panels::
     :card: + intro-card text-center
     :column: col-lg-6 col-md-6 col-sm-6 col-xs-12 d-flex
@@ -96,16 +97,22 @@ programming language.
             :text: To the development guide
             :classes: btn-block btn-secondary stretched-link
 
-
+{% endif %}
 {% if single_doc and single_doc.endswith('.rst') -%}
 .. toctree::
     :maxdepth: 3
     :titlesonly:
 
     {{ single_doc[:-4] }}
+{% elif single_doc and single_doc.count('.') <= 1 %}
+.. autosummary::
+    :toctree: reference/api/
+
+    {{ single_doc }}
 {% elif single_doc %}
 .. autosummary::
     :toctree: reference/api/
+    :template: autosummary/accessor_method.rst
 
     {{ single_doc }}
 {% else -%}
diff --git a/doc/source/reference/arrays.rst b/doc/source/reference/arrays.rst
index 38792c46e5f54..6d09e10f284af 100644
--- a/doc/source/reference/arrays.rst
+++ b/doc/source/reference/arrays.rst
@@ -6,6 +6,10 @@
 pandas arrays, scalars, and data types
 ======================================
 
+*******
+Objects
+*******
+
 .. currentmodule:: pandas
 
 For most data types, pandas uses NumPy arrays as the concrete
@@ -15,19 +19,20 @@ objects contained with a :class:`Index`, :class:`Series`, or
 For some data types, pandas extends NumPy's type system. String aliases for these types
 can be found at :ref:`basics.dtypes`.
 
-=================== ========================= ================== =============================
-Kind of Data        pandas Data Type          Scalar             Array
-=================== ========================= ================== =============================
-TZ-aware datetime   :class:`DatetimeTZDtype`  :class:`Timestamp` :ref:`api.arrays.datetime`
-Timedeltas          (none)                    :class:`Timedelta` :ref:`api.arrays.timedelta`
-Period (time spans) :class:`PeriodDtype`      :class:`Period`    :ref:`api.arrays.period`
-Intervals           :class:`IntervalDtype`    :class:`Interval`  :ref:`api.arrays.interval`
-Nullable Integer    :class:`Int64Dtype`, ...  (none)             :ref:`api.arrays.integer_na`
-Categorical         :class:`CategoricalDtype` (none)             :ref:`api.arrays.categorical`
-Sparse              :class:`SparseDtype`      (none)             :ref:`api.arrays.sparse`
-Strings             :class:`StringDtype`      :class:`str`       :ref:`api.arrays.string`
-Boolean (with NA)   :class:`BooleanDtype`     :class:`bool`      :ref:`api.arrays.bool`
-=================== ========================= ================== =============================
+=================== ========================= ============================= =============================
+Kind of Data        pandas Data Type          Scalar                        Array
+=================== ========================= ============================= =============================
+TZ-aware datetime   :class:`DatetimeTZDtype`  :class:`Timestamp`            :ref:`api.arrays.datetime`
+Timedeltas          (none)                    :class:`Timedelta`            :ref:`api.arrays.timedelta`
+Period (time spans) :class:`PeriodDtype`      :class:`Period`               :ref:`api.arrays.period`
+Intervals           :class:`IntervalDtype`    :class:`Interval`             :ref:`api.arrays.interval`
+Nullable Integer    :class:`Int64Dtype`, ...  (none)                        :ref:`api.arrays.integer_na`
+Categorical         :class:`CategoricalDtype` (none)                        :ref:`api.arrays.categorical`
+Sparse              :class:`SparseDtype`      (none)                        :ref:`api.arrays.sparse`
+Strings             :class:`StringDtype`      :class:`str`                  :ref:`api.arrays.string`
+Boolean (with NA)   :class:`BooleanDtype`     :class:`bool`                 :ref:`api.arrays.bool`
+PyArrow             :class:`ArrowDtype`       Python Scalars or :class:`NA` :ref:`api.arrays.arrow`
+=================== ========================= ============================= =============================
 
 pandas and third-party libraries can extend NumPy's type system (see :ref:`extending.extension-types`).
 The top-level :meth:`array` method can be used to create a new array, which may be
@@ -38,10 +43,48 @@ stored in a :class:`Series`, :class:`Index`, or as a column in a :class:`DataFra
 
    array
 
+.. _api.arrays.arrow:
+
+PyArrow
+-------
+
+.. warning::
+
+    This feature is experimental, and the API can change in a future release without warning.
+
+The :class:`arrays.ArrowExtensionArray` is backed by a :external+pyarrow:py:class:`pyarrow.ChunkedArray` with a
+:external+pyarrow:py:class:`pyarrow.DataType` instead of a NumPy array and data type. The ``.dtype`` of a :class:`arrays.ArrowExtensionArray`
+is an :class:`ArrowDtype`.
+
+`Pyarrow <https://arrow.apache.org/docs/python/index.html>`__ provides similar array and `data type <https://arrow.apache.org/docs/python/api/datatypes.html>`__
+support as NumPy including first-class nullability support for all data types, immutability and more.
+
+.. note::
+
+    For string types (``pyarrow.string()``, ``string[pyarrow]``), PyArrow support is still facilitated
+    by :class:`arrays.ArrowStringArray` and ``StringDtype("pyarrow")``. See the :ref:`string section <api.arrays.string>`
+    below.
+
+While individual values in an :class:`arrays.ArrowExtensionArray` are stored as a PyArrow objects, scalars are **returned**
+as Python scalars corresponding to the data type, e.g. a PyArrow int64 will be returned as Python int, or :class:`NA` for missing
+values.
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   arrays.ArrowExtensionArray
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   ArrowDtype
+
 .. _api.arrays.datetime:
 
-Datetime data
--------------
+Datetimes
+---------
 
 NumPy cannot natively represent timezone-aware datetimes. pandas supports this
 with the :class:`arrays.DatetimeArray` extension array, which can hold timezone-naive
@@ -161,8 +204,8 @@ If the data are timezone-aware, then every value in the array must have the same
 
 .. _api.arrays.timedelta:
 
-Timedelta data
---------------
+Timedeltas
+----------
 
 NumPy can natively represent timedeltas. pandas provides :class:`Timedelta`
 for symmetry with :class:`Timestamp`.
@@ -216,8 +259,8 @@ A collection of :class:`Timedelta` may be stored in a :class:`TimedeltaArray`.
 
 .. _api.arrays.period:
 
-Timespan data
--------------
+Periods
+-------
 
 pandas represents spans of times as :class:`Period` objects.
 
@@ -284,8 +327,8 @@ Every period in a :class:`arrays.PeriodArray` must have the same ``freq``.
 
 .. _api.arrays.interval:
 
-Interval data
--------------
+Intervals
+---------
 
 Arbitrary intervals can be represented as :class:`Interval` objects.
 
@@ -379,8 +422,8 @@ pandas provides this through :class:`arrays.IntegerArray`.
 
 .. _api.arrays.categorical:
 
-Categorical data
-----------------
+Categoricals
+------------
 
 pandas defines a custom data type for representing data that can take only a
 limited, fixed set of values. The dtype of a :class:`Categorical` can be described by
@@ -444,8 +487,8 @@ data. See :ref:`api.series.cat` for more.
 
 .. _api.arrays.sparse:
 
-Sparse data
------------
+Sparse
+------
 
 Data where a single value is repeated many times (e.g. ``0`` or ``NaN``) may
 be stored efficiently as a :class:`arrays.SparseArray`.
@@ -464,13 +507,13 @@ be stored efficiently as a :class:`arrays.SparseArray`.
 
 The ``Series.sparse`` accessor may be used to access sparse-specific attributes
 and methods if the :class:`Series` contains sparse values. See
-:ref:`api.series.sparse` for more.
+:ref:`api.series.sparse` and :ref:`the user guide <sparse>` for more.
 
 
 .. _api.arrays.string:
 
-Text data
----------
+Strings
+-------
 
 When working with text data, where each valid element is a string or missing,
 we recommend using :class:`StringDtype` (with the alias ``"string"``).
@@ -494,8 +537,8 @@ See :ref:`api.series.str` for more.
 
 .. _api.arrays.bool:
 
-Boolean data with missing values
---------------------------------
+Nullable Boolean
+----------------
 
 The boolean dtype (with the alias ``"boolean"``) provides support for storing
 boolean data (``True``, ``False``) with missing values, which is not possible
@@ -525,3 +568,72 @@ with a bool :class:`numpy.ndarray`.
       DatetimeTZDtype.tz
       PeriodDtype.freq
       IntervalDtype.subtype
+
+*********
+Utilities
+*********
+
+Constructors
+------------
+.. autosummary::
+   :toctree: api/
+
+   api.types.union_categoricals
+   api.types.infer_dtype
+   api.types.pandas_dtype
+
+Data type introspection
+~~~~~~~~~~~~~~~~~~~~~~~
+.. autosummary::
+   :toctree: api/
+
+    api.types.is_bool_dtype
+    api.types.is_categorical_dtype
+    api.types.is_complex_dtype
+    api.types.is_datetime64_any_dtype
+    api.types.is_datetime64_dtype
+    api.types.is_datetime64_ns_dtype
+    api.types.is_datetime64tz_dtype
+    api.types.is_extension_type
+    api.types.is_extension_array_dtype
+    api.types.is_float_dtype
+    api.types.is_int64_dtype
+    api.types.is_integer_dtype
+    api.types.is_interval_dtype
+    api.types.is_numeric_dtype
+    api.types.is_object_dtype
+    api.types.is_period_dtype
+    api.types.is_signed_integer_dtype
+    api.types.is_string_dtype
+    api.types.is_timedelta64_dtype
+    api.types.is_timedelta64_ns_dtype
+    api.types.is_unsigned_integer_dtype
+    api.types.is_sparse
+
+Iterable introspection
+~~~~~~~~~~~~~~~~~~~~~~
+.. autosummary::
+   :toctree: api/
+
+    api.types.is_dict_like
+    api.types.is_file_like
+    api.types.is_list_like
+    api.types.is_named_tuple
+    api.types.is_iterator
+
+Scalar introspection
+~~~~~~~~~~~~~~~~~~~~
+.. autosummary::
+   :toctree: api/
+
+    api.types.is_bool
+    api.types.is_categorical
+    api.types.is_complex
+    api.types.is_float
+    api.types.is_hashable
+    api.types.is_integer
+    api.types.is_interval
+    api.types.is_number
+    api.types.is_re
+    api.types.is_re_compilable
+    api.types.is_scalar
diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst
index 9a1ebc8d670dc..e71ee80767d29 100644
--- a/doc/source/reference/frame.rst
+++ b/doc/source/reference/frame.rst
@@ -373,6 +373,7 @@ Serialization / IO / conversion
 
    DataFrame.from_dict
    DataFrame.from_records
+   DataFrame.to_orc
    DataFrame.to_parquet
    DataFrame.to_pickle
    DataFrame.to_csv
@@ -391,3 +392,4 @@ Serialization / IO / conversion
    DataFrame.to_clipboard
    DataFrame.to_markdown
    DataFrame.style
+   DataFrame.__dataframe__
diff --git a/doc/source/reference/general_functions.rst b/doc/source/reference/general_functions.rst
index b5832cb8aa591..474e37a85d857 100644
--- a/doc/source/reference/general_functions.rst
+++ b/doc/source/reference/general_functions.rst
@@ -23,6 +23,7 @@ Data manipulations
    merge_asof
    concat
    get_dummies
+   from_dummies
    factorize
    unique
    wide_to_long
@@ -37,15 +38,15 @@ Top-level missing data
    notna
    notnull
 
-Top-level conversions
-~~~~~~~~~~~~~~~~~~~~~
+Top-level dealing with numeric data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. autosummary::
    :toctree: api/
 
    to_numeric
 
-Top-level dealing with datetimelike
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Top-level dealing with datetimelike data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. autosummary::
    :toctree: api/
 
@@ -57,8 +58,8 @@ Top-level dealing with datetimelike
    timedelta_range
    infer_freq
 
-Top-level dealing with intervals
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Top-level dealing with Interval data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. autosummary::
    :toctree: api/
 
@@ -79,9 +80,9 @@ Hashing
    util.hash_array
    util.hash_pandas_object
 
-Testing
-~~~~~~~
+Importing from other DataFrame libraries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. autosummary::
    :toctree: api/
 
-   test
+   api.interchange.from_dataframe
diff --git a/doc/source/reference/general_utility_functions.rst b/doc/source/reference/general_utility_functions.rst
deleted file mode 100644
index ee17ef3831164..0000000000000
--- a/doc/source/reference/general_utility_functions.rst
+++ /dev/null
@@ -1,127 +0,0 @@
-{{ header }}
-
-.. _api.general_utility_functions:
-
-=========================
-General utility functions
-=========================
-.. currentmodule:: pandas
-
-Working with options
---------------------
-.. autosummary::
-   :toctree: api/
-
-   describe_option
-   reset_option
-   get_option
-   set_option
-   option_context
-
-.. _api.general.testing:
-
-Testing functions
------------------
-.. autosummary::
-   :toctree: api/
-
-   testing.assert_frame_equal
-   testing.assert_series_equal
-   testing.assert_index_equal
-   testing.assert_extension_array_equal
-
-Exceptions and warnings
------------------------
-.. autosummary::
-   :toctree: api/
-
-   errors.AbstractMethodError
-   errors.AccessorRegistrationWarning
-   errors.DtypeWarning
-   errors.DuplicateLabelError
-   errors.EmptyDataError
-   errors.InvalidIndexError
-   errors.IntCastingNaNError
-   errors.MergeError
-   errors.NullFrequencyError
-   errors.NumbaUtilError
-   errors.OptionError
-   errors.OutOfBoundsDatetime
-   errors.OutOfBoundsTimedelta
-   errors.ParserError
-   errors.ParserWarning
-   errors.PerformanceWarning
-   errors.UnsortedIndexError
-   errors.UnsupportedFunctionCall
-
-Data types related functionality
---------------------------------
-.. autosummary::
-   :toctree: api/
-
-   api.types.union_categoricals
-   api.types.infer_dtype
-   api.types.pandas_dtype
-
-Dtype introspection
-~~~~~~~~~~~~~~~~~~~
-.. autosummary::
-   :toctree: api/
-
-    api.types.is_bool_dtype
-    api.types.is_categorical_dtype
-    api.types.is_complex_dtype
-    api.types.is_datetime64_any_dtype
-    api.types.is_datetime64_dtype
-    api.types.is_datetime64_ns_dtype
-    api.types.is_datetime64tz_dtype
-    api.types.is_extension_type
-    api.types.is_extension_array_dtype
-    api.types.is_float_dtype
-    api.types.is_int64_dtype
-    api.types.is_integer_dtype
-    api.types.is_interval_dtype
-    api.types.is_numeric_dtype
-    api.types.is_object_dtype
-    api.types.is_period_dtype
-    api.types.is_signed_integer_dtype
-    api.types.is_string_dtype
-    api.types.is_timedelta64_dtype
-    api.types.is_timedelta64_ns_dtype
-    api.types.is_unsigned_integer_dtype
-    api.types.is_sparse
-
-Iterable introspection
-~~~~~~~~~~~~~~~~~~~~~~
-.. autosummary::
-   :toctree: api/
-
-    api.types.is_dict_like
-    api.types.is_file_like
-    api.types.is_list_like
-    api.types.is_named_tuple
-    api.types.is_iterator
-
-Scalar introspection
-~~~~~~~~~~~~~~~~~~~~
-.. autosummary::
-   :toctree: api/
-
-    api.types.is_bool
-    api.types.is_categorical
-    api.types.is_complex
-    api.types.is_float
-    api.types.is_hashable
-    api.types.is_integer
-    api.types.is_interval
-    api.types.is_number
-    api.types.is_re
-    api.types.is_re_compilable
-    api.types.is_scalar
-
-Bug report function
--------------------
-.. autosummary::
-   :toctree: api/
-
-   show_versions
diff --git a/doc/source/reference/groupby.rst b/doc/source/reference/groupby.rst
index 2bb0659264eb0..51bd659081b8f 100644
--- a/doc/source/reference/groupby.rst
+++ b/doc/source/reference/groupby.rst
@@ -132,9 +132,7 @@ The following methods are available only for ``SeriesGroupBy`` objects.
    SeriesGroupBy.hist
    SeriesGroupBy.nlargest
    SeriesGroupBy.nsmallest
-   SeriesGroupBy.nunique
    SeriesGroupBy.unique
-   SeriesGroupBy.value_counts
    SeriesGroupBy.is_monotonic_increasing
    SeriesGroupBy.is_monotonic_decreasing
 
diff --git a/doc/source/reference/index.rst b/doc/source/reference/index.rst
index f7c5eaf242b34..fc920db671ee5 100644
--- a/doc/source/reference/index.rst
+++ b/doc/source/reference/index.rst
@@ -37,8 +37,9 @@ public functions related to data types in pandas.
    resampling
    style
    plotting
-   general_utility_functions
+   options
    extensions
+   testing
 
 .. This is to prevent warnings in the doc build. We don't want to encourage
 .. these methods.
@@ -46,20 +47,11 @@ public functions related to data types in pandas.
 ..
     .. toctree::
 
-        api/pandas.DataFrame.blocks
-        api/pandas.DataFrame.as_matrix
         api/pandas.Index.asi8
-        api/pandas.Index.data
-        api/pandas.Index.flags
         api/pandas.Index.holds_integer
         api/pandas.Index.is_type_compatible
         api/pandas.Index.nlevels
         api/pandas.Index.sort
-        api/pandas.Series.asobject
-        api/pandas.Series.blocks
-        api/pandas.Series.from_array
-        api/pandas.Series.imag
-        api/pandas.Series.real
 
 
 .. Can't convince sphinx to generate toctree for this class attribute.
diff --git a/doc/source/reference/io.rst b/doc/source/reference/io.rst
index 7aad937d10a18..425b5f81be966 100644
--- a/doc/source/reference/io.rst
+++ b/doc/source/reference/io.rst
@@ -53,7 +53,6 @@ Excel
 
 .. autosummary::
    :toctree: api/
-   :template: autosummary/class_without_autosummary.rst
 
    ExcelWriter
 
@@ -135,7 +134,7 @@ HDFStore: PyTables (HDF5)
 
 .. warning::
 
-   One can store a subclass of ``DataFrame`` or ``Series`` to HDF5,
+   One can store a subclass of :class:`DataFrame` or :class:`Series` to HDF5,
    but the type of the subclass is lost upon storing.
 
 Feather
@@ -160,6 +159,7 @@ ORC
    :toctree: api/
 
    read_orc
+   DataFrame.to_orc
 
 SAS
 ~~~
diff --git a/doc/source/reference/options.rst b/doc/source/reference/options.rst
new file mode 100644
index 0000000000000..7316b6e9c72b1
--- /dev/null
+++ b/doc/source/reference/options.rst
@@ -0,0 +1,21 @@
+{{ header }}
+
+.. _api.options:
+
+====================
+Options and settings
+====================
+.. currentmodule:: pandas
+
+API for configuring global behavior. See :ref:`the User Guide <options>` for more.
+
+Working with options
+--------------------
+.. autosummary::
+   :toctree: api/
+
+   describe_option
+   reset_option
+   get_option
+   set_option
+   option_context
diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst
index a60dab549e66d..fcdc9ea9b95da 100644
--- a/doc/source/reference/series.rst
+++ b/doc/source/reference/series.rst
@@ -342,6 +342,7 @@ Datetime methods
    :toctree: api/
    :template: autosummary/accessor_method.rst
 
+   Series.dt.isocalendar
    Series.dt.to_period
    Series.dt.to_pydatetime
    Series.dt.tz_localize
diff --git a/doc/source/reference/style.rst b/doc/source/reference/style.rst
index a739993e4d376..5144f12fa373a 100644
--- a/doc/source/reference/style.rst
+++ b/doc/source/reference/style.rst
@@ -27,6 +27,7 @@ Styler properties
    Styler.template_html_style
    Styler.template_html_table
    Styler.template_latex
+   Styler.template_string
    Styler.loader
 
 Style application
@@ -40,7 +41,9 @@ Style application
    Styler.applymap_index
    Styler.format
    Styler.format_index
+   Styler.relabel_index
    Styler.hide
+   Styler.concat
    Styler.set_td_classes
    Styler.set_table_styles
    Styler.set_table_attributes
@@ -74,5 +77,6 @@ Style export and import
    Styler.to_html
    Styler.to_latex
    Styler.to_excel
+   Styler.to_string
    Styler.export
    Styler.use
diff --git a/doc/source/reference/testing.rst b/doc/source/reference/testing.rst
new file mode 100644
index 0000000000000..1144c767942d4
--- /dev/null
+++ b/doc/source/reference/testing.rst
@@ -0,0 +1,77 @@
+{{ header }}
+
+.. _api.testing:
+
+=======
+Testing
+=======
+.. currentmodule:: pandas
+
+.. _api.general.testing:
+
+Assertion functions
+-------------------
+.. autosummary::
+   :toctree: api/
+
+   testing.assert_frame_equal
+   testing.assert_series_equal
+   testing.assert_index_equal
+   testing.assert_extension_array_equal
+
+Exceptions and warnings
+-----------------------
+.. autosummary::
+   :toctree: api/
+
+   errors.AbstractMethodError
+   errors.AccessorRegistrationWarning
+   errors.AttributeConflictWarning
+   errors.CategoricalConversionWarning
+   errors.ClosedFileError
+   errors.CSSWarning
+   errors.DatabaseError
+   errors.DataError
+   errors.DtypeWarning
+   errors.DuplicateLabelError
+   errors.EmptyDataError
+   errors.IncompatibilityWarning
+   errors.IndexingError
+   errors.InvalidColumnName
+   errors.InvalidIndexError
+   errors.IntCastingNaNError
+   errors.MergeError
+   errors.NullFrequencyError
+   errors.NumbaUtilError
+   errors.NumExprClobberingError
+   errors.OptionError
+   errors.OutOfBoundsDatetime
+   errors.OutOfBoundsTimedelta
+   errors.ParserError
+   errors.ParserWarning
+   errors.PerformanceWarning
+   errors.PossibleDataLossError
+   errors.PossiblePrecisionLoss
+   errors.PyperclipException
+   errors.PyperclipWindowsException
+   errors.SettingWithCopyError
+   errors.SettingWithCopyWarning
+   errors.SpecificationError
+   errors.UndefinedVariableError
+   errors.UnsortedIndexError
+   errors.UnsupportedFunctionCall
+   errors.ValueLabelTypeMismatch
+
+Bug report function
+-------------------
+.. autosummary::
+   :toctree: api/
+
+   show_versions
+
+Test suite runner
+-----------------
+.. autosummary::
+   :toctree: api/
+
+   test
diff --git a/doc/source/user_guide/10min.rst b/doc/source/user_guide/10min.rst
index 08488a33936f0..c767fb1ebef7f 100644
--- a/doc/source/user_guide/10min.rst
+++ b/doc/source/user_guide/10min.rst
@@ -29,7 +29,7 @@ a default integer index:
    s = pd.Series([1, 3, 5, np.nan, 6, 8])
    s
 
-Creating a :class:`DataFrame` by passing a NumPy array, with a datetime index
+Creating a :class:`DataFrame` by passing a NumPy array, with a datetime index using :func:`date_range`
 and labeled columns:
 
 .. ipython:: python
@@ -93,14 +93,15 @@ Viewing data
 
 See the :ref:`Basics section <basics>`.
 
-Here is how to view the top and bottom rows of the frame:
+Use :meth:`DataFrame.head` and :meth:`DataFrame.tail` to view the top and bottom rows of the frame
+respectively:
 
 .. ipython:: python
 
    df.head()
    df.tail(3)
 
-Display the index, columns:
+Display the :attr:`DataFrame.index` or :attr:`DataFrame.columns`:
 
 .. ipython:: python
 
@@ -116,7 +117,7 @@ while pandas DataFrames have one dtype per column**. When you call
 of the dtypes in the DataFrame. This may end up being ``object``, which requires
 casting every value to a Python object.
 
-For ``df``, our :class:`DataFrame` of all floating-point values,
+For ``df``, our :class:`DataFrame` of all floating-point values, and
 :meth:`DataFrame.to_numpy` is fast and doesn't require copying data:
 
 .. ipython:: python
@@ -147,13 +148,13 @@ Transposing your data:
 
    df.T
 
-Sorting by an axis:
+:meth:`DataFrame.sort_index` sorts by an axis:
 
 .. ipython:: python
 
    df.sort_index(axis=1, ascending=False)
 
-Sorting by values:
+:meth:`DataFrame.sort_values` sorts by values:
 
 .. ipython:: python
 
@@ -166,8 +167,8 @@ Selection
 
    While standard Python / NumPy expressions for selecting and setting are
    intuitive and come in handy for interactive work, for production code, we
-   recommend the optimized pandas data access methods, ``.at``, ``.iat``,
-   ``.loc`` and ``.iloc``.
+   recommend the optimized pandas data access methods, :meth:`DataFrame.at`, :meth:`DataFrame.iat`,
+   :meth:`DataFrame.loc` and :meth:`DataFrame.iloc`.
 
 See the indexing documentation :ref:`Indexing and Selecting Data <indexing>` and :ref:`MultiIndex / Advanced Indexing <advanced>`.
 
@@ -181,7 +182,7 @@ equivalent to ``df.A``:
 
    df["A"]
 
-Selecting via ``[]``, which slices the rows:
+Selecting via ``[]`` (``__getitem__``), which slices the rows:
 
 .. ipython:: python
 
@@ -191,7 +192,7 @@ Selecting via ``[]``, which slices the rows:
 Selection by label
 ~~~~~~~~~~~~~~~~~~
 
-See more in :ref:`Selection by Label <indexing.label>`.
+See more in :ref:`Selection by Label <indexing.label>` using :meth:`DataFrame.loc` or :meth:`DataFrame.at`.
 
 For getting a cross section using a label:
 
@@ -232,7 +233,7 @@ For getting fast access to a scalar (equivalent to the prior method):
 Selection by position
 ~~~~~~~~~~~~~~~~~~~~~
 
-See more in :ref:`Selection by Position <indexing.integer>`.
+See more in :ref:`Selection by Position <indexing.integer>` using :meth:`DataFrame.iloc` or :meth:`DataFrame.at`.
 
 Select via the position of the passed integers:
 
@@ -327,6 +328,7 @@ Setting values by position:
 Setting by assigning with a NumPy array:
 
 .. ipython:: python
+   :okwarning:
 
    df.loc[:, "D"] = np.array([5] * len(df))
 
@@ -361,19 +363,19 @@ returns a copy of the data:
    df1.loc[dates[0] : dates[1], "E"] = 1
    df1
 
-To drop any rows that have missing data:
+:meth:`DataFrame.dropna` drops any rows that have missing data:
 
 .. ipython:: python
 
    df1.dropna(how="any")
 
-Filling missing data:
+:meth:`DataFrame.fillna` fills missing data:
 
 .. ipython:: python
 
    df1.fillna(value=5)
 
-To get the boolean mask where values are ``nan``:
+:func:`isna` gets the boolean mask where values are ``nan``:
 
 .. ipython:: python
 
@@ -415,7 +417,7 @@ In addition, pandas automatically broadcasts along the specified dimension:
 Apply
 ~~~~~
 
-Applying functions to the data:
+:meth:`DataFrame.apply` applies a user defined function to the data:
 
 .. ipython:: python
 
@@ -461,7 +463,7 @@ operations.
 
 See the :ref:`Merging section <merging>`.
 
-Concatenating pandas objects together with :func:`concat`:
+Concatenating pandas objects together along an axis with :func:`concat`:
 
 .. ipython:: python
 
@@ -482,7 +484,7 @@ Concatenating pandas objects together with :func:`concat`:
 Join
 ~~~~
 
-SQL style merges. See the :ref:`Database style joining <merging.join>` section.
+:func:`merge` enables SQL style join types along specific columns. See the :ref:`Database style joining <merging.join>` section.
 
 .. ipython:: python
 
@@ -531,7 +533,7 @@ groups:
 
 .. ipython:: python
 
-   df.groupby("A").sum()
+   df.groupby("A")[["C", "D"]].sum()
 
 Grouping by multiple columns forms a hierarchical index, and again we can
 apply the :meth:`~pandas.core.groupby.GroupBy.sum` function:
@@ -553,10 +555,8 @@ Stack
 
    tuples = list(
        zip(
-           *[
-               ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
-               ["one", "two", "one", "two", "one", "two", "one", "two"],
-           ]
+           ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+           ["one", "two", "one", "two", "one", "two", "one", "two"],
        )
    )
    index = pd.MultiIndex.from_tuples(tuples, names=["first", "second"])
@@ -572,7 +572,7 @@ columns:
    stacked = df2.stack()
    stacked
 
-With a "stacked" DataFrame or Series (having a ``MultiIndex`` as the
+With a "stacked" DataFrame or Series (having a :class:`MultiIndex` as the
 ``index``), the inverse operation of :meth:`~DataFrame.stack` is
 :meth:`~DataFrame.unstack`, which by default unstacks the **last level**:
 
@@ -599,7 +599,7 @@ See the section on :ref:`Pivot Tables <reshaping.pivot>`.
    )
    df
 
-We can produce pivot tables from this data very easily:
+:func:`pivot_table` pivots a :class:`DataFrame` specifying the ``values``, ``index`` and ``columns``
 
 .. ipython:: python
 
@@ -620,7 +620,7 @@ financial applications. See the :ref:`Time Series section <timeseries>`.
    ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
    ts.resample("5Min").sum()
 
-Time zone representation:
+:meth:`Series.tz_localize` localizes a time series to a time zone:
 
 .. ipython:: python
 
@@ -630,7 +630,7 @@ Time zone representation:
    ts_utc = ts.tz_localize("UTC")
    ts_utc
 
-Converting to another time zone:
+:meth:`Series.tz_convert` converts a timezones aware time series to another time zone:
 
 .. ipython:: python
 
@@ -680,12 +680,12 @@ Converting the raw grades to a categorical data type:
     df["grade"] = df["raw_grade"].astype("category")
     df["grade"]
 
-Rename the categories to more meaningful names (assigning to
-:meth:`Series.cat.categories` is in place!):
+Rename the categories to more meaningful names:
 
 .. ipython:: python
 
-    df["grade"].cat.categories = ["very good", "good", "very bad"]
+    new_categories = ["very good", "good", "very bad"]
+    df["grade"] = df["grade"].cat.rename_categories(new_categories)
 
 Reorder the categories and simultaneously add the missing categories (methods under :meth:`Series.cat` return a new :class:`Series` by default):
 
@@ -722,7 +722,7 @@ We use the standard convention for referencing the matplotlib API:
 
    plt.close("all")
 
-The :meth:`~plt.close` method is used to `close <https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.close.html>`__ a figure window:
+The ``plt.close`` method is used to `close <https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.close.html>`__ a figure window:
 
 .. ipython:: python
 
@@ -732,7 +732,7 @@ The :meth:`~plt.close` method is used to `close <https://matplotlib.org/3.1.1/ap
    @savefig series_plot_basic.png
    ts.plot();
 
-If running under Jupyter Notebook, the plot will appear on :meth:`~ts.plot`.  Otherwise use
+If running under Jupyter Notebook, the plot will appear on :meth:`~Series.plot`.  Otherwise use
 `matplotlib.pyplot.show <https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.show.html>`__ to show it or
 `matplotlib.pyplot.savefig <https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.savefig.html>`__ to write it to a file.
 
@@ -756,19 +756,19 @@ of the columns with labels:
    @savefig frame_plot_basic.png
    plt.legend(loc='best');
 
-Getting data in/out
--------------------
+Importing and exporting data
+----------------------------
 
 CSV
 ~~~
 
-:ref:`Writing to a csv file: <io.store_in_csv>`
+:ref:`Writing to a csv file: <io.store_in_csv>` using :meth:`DataFrame.to_csv`
 
 .. ipython:: python
 
    df.to_csv("foo.csv")
 
-:ref:`Reading from a csv file: <io.read_csv_table>`
+:ref:`Reading from a csv file: <io.read_csv_table>` using :func:`read_csv`
 
 .. ipython:: python
 
@@ -786,13 +786,13 @@ HDF5
 
 Reading and writing to :ref:`HDFStores <io.hdf5>`.
 
-Writing to a HDF5 Store:
+Writing to a HDF5 Store using :meth:`DataFrame.to_hdf`:
 
 .. ipython:: python
 
    df.to_hdf("foo.h5", "df")
 
-Reading from a HDF5 Store:
+Reading from a HDF5 Store using :func:`read_hdf`:
 
 .. ipython:: python
 
@@ -806,15 +806,15 @@ Reading from a HDF5 Store:
 Excel
 ~~~~~
 
-Reading and writing to :ref:`MS Excel <io.excel>`.
+Reading and writing to :ref:`Excel <io.excel>`.
 
-Writing to an excel file:
+Writing to an excel file using :meth:`DataFrame.to_excel`:
 
 .. ipython:: python
 
    df.to_excel("foo.xlsx", sheet_name="Sheet1")
 
-Reading from an excel file:
+Reading from an excel file using :func:`read_excel`:
 
 .. ipython:: python
 
@@ -828,16 +828,13 @@ Reading from an excel file:
 Gotchas
 -------
 
-If you are attempting to perform an operation you might see an exception like:
+If you are attempting to perform a boolean operation on a :class:`Series` or :class:`DataFrame`
+you might see an exception like:
 
-.. code-block:: python
-
-    >>> if pd.Series([False, True, False]):
-    ...     print("I was true")
-    Traceback
-        ...
-    ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
+.. ipython:: python
+   :okexcept:
 
-See :ref:`Comparisons<basics.compare>` for an explanation and what to do.
+    if pd.Series([False, True, False]):
+        print("I was true")
 
-See :ref:`Gotchas<gotchas>` as well.
+See :ref:`Comparisons<basics.compare>` and :ref:`Gotchas<gotchas>` for an explanation and what to do.
diff --git a/doc/source/user_guide/advanced.rst b/doc/source/user_guide/advanced.rst
index 45b2e57f52c6c..b8df21ab5a5b4 100644
--- a/doc/source/user_guide/advanced.rst
+++ b/doc/source/user_guide/advanced.rst
@@ -1246,5 +1246,5 @@ This is because the (re)indexing operations above silently inserts ``NaNs`` and
 changes accordingly.  This can cause some issues when using ``numpy`` ``ufuncs``
 such as ``numpy.logical_and``.
 
-See the `this old issue <https://github.com/pydata/pandas/issues/2388>`__ for a more
+See the :issue:`2388` for a more
 detailed discussion.
diff --git a/doc/source/user_guide/basics.rst b/doc/source/user_guide/basics.rst
index 40ff1049e5820..a34d4891b9d77 100644
--- a/doc/source/user_guide/basics.rst
+++ b/doc/source/user_guide/basics.rst
@@ -848,8 +848,8 @@ have introduced the popular ``(%>%)`` (read pipe) operator for R_.
 The implementation of ``pipe`` here is quite clean and feels right at home in Python.
 We encourage you to view the source code of :meth:`~DataFrame.pipe`.
 
-.. _dplyr: https://github.com/hadley/dplyr
-.. _magrittr: https://github.com/smbache/magrittr
+.. _dplyr: https://github.com/tidyverse/dplyr
+.. _magrittr: https://github.com/tidyverse/magrittr
 .. _R: https://www.r-project.org
 
 
diff --git a/doc/source/user_guide/categorical.rst b/doc/source/user_guide/categorical.rst
index 0105cf99193dd..b5cb1d83a9f52 100644
--- a/doc/source/user_guide/categorical.rst
+++ b/doc/source/user_guide/categorical.rst
@@ -334,8 +334,7 @@ It's also possible to pass in the categories in a specific order:
 Renaming categories
 ~~~~~~~~~~~~~~~~~~~
 
-Renaming categories is done by assigning new values to the
-``Series.cat.categories`` property or by using the
+Renaming categories is done by using the
 :meth:`~pandas.Categorical.rename_categories` method:
 
 
@@ -343,9 +342,8 @@ Renaming categories is done by assigning new values to the
 
     s = pd.Series(["a", "b", "c", "a"], dtype="category")
     s
-    s.cat.categories = ["Group %s" % g for g in s.cat.categories]
-    s
-    s = s.cat.rename_categories([1, 2, 3])
+    new_categories = ["Group %s" % g for g in s.cat.categories]
+    s = s.cat.rename_categories(new_categories)
     s
     # You can also pass a dict-like object to map the renaming
     s = s.cat.rename_categories({1: "x", 2: "y", 3: "z"})
@@ -365,7 +363,7 @@ Categories must be unique or a ``ValueError`` is raised:
 .. ipython:: python
 
     try:
-        s.cat.categories = [1, 1, 1]
+        s = s.cat.rename_categories([1, 1, 1])
     except ValueError as e:
         print("ValueError:", str(e))
 
@@ -374,7 +372,7 @@ Categories must also not be ``NaN`` or a ``ValueError`` is raised:
 .. ipython:: python
 
     try:
-        s.cat.categories = [1, 2, np.nan]
+        s = s.cat.rename_categories([1, 2, np.nan])
     except ValueError as e:
         print("ValueError:", str(e))
 
@@ -702,7 +700,7 @@ of length "1".
 .. ipython:: python
 
     df.iat[0, 0]
-    df["cats"].cat.categories = ["x", "y", "z"]
+    df["cats"] = df["cats"].cat.rename_categories(["x", "y", "z"])
     df.at["h", "cats"]  # returns a string
 
 .. note::
@@ -960,7 +958,7 @@ relevant columns back to ``category`` and assign the right categories and catego
 
     s = pd.Series(pd.Categorical(["a", "b", "b", "a", "a", "d"]))
     # rename the categories
-    s.cat.categories = ["very good", "good", "bad"]
+    s = s.cat.rename_categories(["very good", "good", "bad"])
     # reorder the categories and add missing categories
     s = s.cat.set_categories(["very bad", "bad", "medium", "good", "very good"])
     df = pd.DataFrame({"cats": s, "vals": [1, 2, 3, 4, 5, 6]})
@@ -1164,6 +1162,7 @@ Constructing a ``Series`` from a ``Categorical`` will not copy the input
 change the original ``Categorical``:
 
 .. ipython:: python
+    :okwarning:
 
     cat = pd.Categorical([1, 2, 3, 10], categories=[1, 2, 3, 4, 10])
     s = pd.Series(cat, name="cat")
diff --git a/doc/source/user_guide/computation.rst b/doc/source/user_guide/computation.rst
deleted file mode 100644
index 6007129e96ba0..0000000000000
--- a/doc/source/user_guide/computation.rst
+++ /dev/null
@@ -1,212 +0,0 @@
-.. _computation:
-
-{{ header }}
-
-Computational tools
-===================
-
-
-Statistical functions
----------------------
-
-.. _computation.pct_change:
-
-Percent change
-~~~~~~~~~~~~~~
-
-``Series`` and ``DataFrame`` have a method
-:meth:`~DataFrame.pct_change` to compute the percent change over a given number
-of periods (using ``fill_method`` to fill NA/null values *before* computing
-the percent change).
-
-.. ipython:: python
-
-   ser = pd.Series(np.random.randn(8))
-
-   ser.pct_change()
-
-.. ipython:: python
-
-   df = pd.DataFrame(np.random.randn(10, 4))
-
-   df.pct_change(periods=3)
-
-.. _computation.covariance:
-
-Covariance
-~~~~~~~~~~
-
-:meth:`Series.cov` can be used to compute covariance between series
-(excluding missing values).
-
-.. ipython:: python
-
-   s1 = pd.Series(np.random.randn(1000))
-   s2 = pd.Series(np.random.randn(1000))
-   s1.cov(s2)
-
-Analogously, :meth:`DataFrame.cov` to compute pairwise covariances among the
-series in the DataFrame, also excluding NA/null values.
-
-.. _computation.covariance.caveats:
-
-.. note::
-
-    Assuming the missing data are missing at random this results in an estimate
-    for the covariance matrix which is unbiased. However, for many applications
-    this estimate may not be acceptable because the estimated covariance matrix
-    is not guaranteed to be positive semi-definite. This could lead to
-    estimated correlations having absolute values which are greater than one,
-    and/or a non-invertible covariance matrix. See `Estimation of covariance
-    matrices <https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_matrices>`_
-    for more details.
-
-.. ipython:: python
-
-   frame = pd.DataFrame(np.random.randn(1000, 5), columns=["a", "b", "c", "d", "e"])
-   frame.cov()
-
-``DataFrame.cov`` also supports an optional ``min_periods`` keyword that
-specifies the required minimum number of observations for each column pair
-in order to have a valid result.
-
-.. ipython:: python
-
-   frame = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"])
-   frame.loc[frame.index[:5], "a"] = np.nan
-   frame.loc[frame.index[5:10], "b"] = np.nan
-
-   frame.cov()
-
-   frame.cov(min_periods=12)
-
-
-.. _computation.correlation:
-
-Correlation
-~~~~~~~~~~~
-
-Correlation may be computed using the :meth:`~DataFrame.corr` method.
-Using the ``method`` parameter, several methods for computing correlations are
-provided:
-
-.. csv-table::
-    :header: "Method name", "Description"
-    :widths: 20, 80
-
-    ``pearson (default)``, Standard correlation coefficient
-    ``kendall``, Kendall Tau correlation coefficient
-    ``spearman``, Spearman rank correlation coefficient
-
-.. \rho = \cov(x, y) / \sigma_x \sigma_y
-
-All of these are currently computed using pairwise complete observations.
-Wikipedia has articles covering the above correlation coefficients:
-
-* `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_
-* `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_
-* `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_
-
-.. note::
-
-    Please see the :ref:`caveats <computation.covariance.caveats>` associated
-    with this method of calculating correlation matrices in the
-    :ref:`covariance section <computation.covariance>`.
-
-.. ipython:: python
-
-   frame = pd.DataFrame(np.random.randn(1000, 5), columns=["a", "b", "c", "d", "e"])
-   frame.iloc[::2] = np.nan
-
-   # Series with Series
-   frame["a"].corr(frame["b"])
-   frame["a"].corr(frame["b"], method="spearman")
-
-   # Pairwise correlation of DataFrame columns
-   frame.corr()
-
-Note that non-numeric columns will be automatically excluded from the
-correlation calculation.
-
-Like ``cov``, ``corr`` also supports the optional ``min_periods`` keyword:
-
-.. ipython:: python
-
-   frame = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"])
-   frame.loc[frame.index[:5], "a"] = np.nan
-   frame.loc[frame.index[5:10], "b"] = np.nan
-
-   frame.corr()
-
-   frame.corr(min_periods=12)
-
-
-The ``method`` argument can also be a callable for a generic correlation
-calculation. In this case, it should be a single function
-that produces a single value from two ndarray inputs. Suppose we wanted to
-compute the correlation based on histogram intersection:
-
-.. ipython:: python
-
-   # histogram intersection
-   def histogram_intersection(a, b):
-       return np.minimum(np.true_divide(a, a.sum()), np.true_divide(b, b.sum())).sum()
-
-
-   frame.corr(method=histogram_intersection)
-
-A related method :meth:`~DataFrame.corrwith` is implemented on DataFrame to
-compute the correlation between like-labeled Series contained in different
-DataFrame objects.
-
-.. ipython:: python
-
-   index = ["a", "b", "c", "d", "e"]
-   columns = ["one", "two", "three", "four"]
-   df1 = pd.DataFrame(np.random.randn(5, 4), index=index, columns=columns)
-   df2 = pd.DataFrame(np.random.randn(4, 4), index=index[:4], columns=columns)
-   df1.corrwith(df2)
-   df2.corrwith(df1, axis=1)
-
-.. _computation.ranking:
-
-Data ranking
-~~~~~~~~~~~~
-
-The :meth:`~Series.rank` method produces a data ranking with ties being
-assigned the mean of the ranks (by default) for the group:
-
-.. ipython:: python
-
-   s = pd.Series(np.random.randn(5), index=list("abcde"))
-   s["d"] = s["b"]  # so there's a tie
-   s.rank()
-
-:meth:`~DataFrame.rank` is also a DataFrame method and can rank either the rows
-(``axis=0``) or the columns (``axis=1``). ``NaN`` values are excluded from the
-ranking.
-
-.. ipython:: python
-
-   df = pd.DataFrame(np.random.randn(10, 6))
-   df[4] = df[2][:5]  # some ties
-   df
-   df.rank(1)
-
-``rank`` optionally takes a parameter ``ascending`` which by default is true;
-when false, data is reverse-ranked, with larger values assigned a smaller rank.
-
-``rank`` supports different tie-breaking methods, specified with the ``method``
-parameter:
-
-  - ``average`` : average rank of tied group
-  - ``min`` : lowest rank in the group
-  - ``max`` : highest rank in the group
-  - ``first`` : ranks assigned in the order they appear in the array
-
-.. _computation.windowing:
-
-Windowing functions
-~~~~~~~~~~~~~~~~~~~
-
-See :ref:`the window operations user guide <window.overview>` for an overview of windowing functions.
diff --git a/doc/source/user_guide/cookbook.rst b/doc/source/user_guide/cookbook.rst
index 8c2dd3ba60f13..daf5a0e481b8e 100644
--- a/doc/source/user_guide/cookbook.rst
+++ b/doc/source/user_guide/cookbook.rst
@@ -193,8 +193,7 @@ The :ref:`indexing <indexing>` docs.
 
    df[(df.AAA <= 6) & (df.index.isin([0, 2, 4]))]
 
-`Use loc for label-oriented slicing and iloc positional slicing
-<https://github.com/pandas-dev/pandas/issues/2904>`__
+Use loc for label-oriented slicing and iloc positional slicing :issue:`2904`
 
 .. ipython:: python
 
@@ -229,7 +228,7 @@ Ambiguity arises when an index consists of integers with a non-zero start or non
    df2.loc[1:3]  # Label-oriented
 
 `Using inverse operator (~) to take the complement of a mask
-<https://stackoverflow.com/questions/14986510/picking-out-elements-based-on-complement-of-indices-in-python-pandas>`__
+<https://stackoverflow.com/q/14986510>`__
 
 .. ipython:: python
 
@@ -259,7 +258,7 @@ New columns
    df
 
 `Keep other columns when using min() with groupby
-<https://stackoverflow.com/questions/23394476/keep-other-columns-when-using-min-with-groupby>`__
+<https://stackoverflow.com/q/23394476>`__
 
 .. ipython:: python
 
@@ -389,14 +388,13 @@ Sorting
 *******
 
 `Sort by specific column or an ordered list of columns, with a MultiIndex
-<https://stackoverflow.com/questions/14733871/mutli-index-sorting-in-pandas>`__
+<https://stackoverflow.com/q/14733871>`__
 
 .. ipython:: python
 
    df.sort_values(by=("Labs", "II"), ascending=False)
 
-`Partial selection, the need for sortedness;
-<https://github.com/pandas-dev/pandas/issues/2995>`__
+Partial selection, the need for sortedness :issue:`2995`
 
 Levels
 ******
@@ -405,7 +403,7 @@ Levels
 <https://stackoverflow.com/questions/14744068/prepend-a-level-to-a-pandas-multiindex>`__
 
 `Flatten Hierarchical columns
-<https://stackoverflow.com/questions/14507794/python-pandas-how-to-flatten-a-hierarchical-index-in-columns>`__
+<https://stackoverflow.com/q/14507794>`__
 
 .. _cookbook.missing_data:
 
@@ -425,7 +423,7 @@ Fill forward a reversed timeseries
    )
    df.loc[df.index[3], "A"] = np.nan
    df
-   df.reindex(df.index[::-1]).ffill()
+   df.bfill()
 
 `cumsum reset at NaN values
 <https://stackoverflow.com/questions/18196811/cumsum-reset-at-nan>`__
@@ -513,7 +511,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
 
    def replace(g):
        mask = g < 0
-       return g.where(mask, g[~mask].mean())
+       return g.where(~mask, g[~mask].mean())
 
    gb.transform(replace)
 
@@ -556,7 +554,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    ts
 
 `Create a value counts column and reassign back to the DataFrame
-<https://stackoverflow.com/questions/17709270/i-want-to-create-a-column-of-value-counts-in-my-pandas-dataframe>`__
+<https://stackoverflow.com/q/17709270>`__
 
 .. ipython:: python
 
@@ -663,7 +661,7 @@ Pivot
 The :ref:`Pivot <reshaping.pivot>` docs.
 
 `Partial sums and subtotals
-<https://stackoverflow.com/questions/15570099/pandas-pivot-tables-row-subtotals/15574875#15574875>`__
+<https://stackoverflow.com/a/15574875>`__
 
 .. ipython:: python
 
@@ -870,7 +868,7 @@ Timeseries
 <https://stackoverflow.com/questions/17559885/pandas-dataframe-mask-based-on-index>`__
 
 `Constructing a datetime range that excludes weekends and includes only certain times
-<https://stackoverflow.com/questions/24010830/pandas-generate-sequential-timestamp-with-jump/24014440#24014440?>`__
+<https://stackoverflow.com/a/24014440>`__
 
 `Vectorized Lookup
 <https://stackoverflow.com/questions/13893227/vectorized-look-up-of-values-in-pandas-dataframe>`__
@@ -910,8 +908,7 @@ Valid frequency arguments to Grouper :ref:`Timeseries <timeseries.offset_aliases
 `Grouping using a MultiIndex
 <https://stackoverflow.com/questions/41483763/pandas-timegrouper-on-multiindex>`__
 
-`Using TimeGrouper and another grouping to create subgroups, then apply a custom function
-<https://github.com/pandas-dev/pandas/issues/3791>`__
+Using TimeGrouper and another grouping to create subgroups, then apply a custom function :issue:`3791`
 
 `Resampling with custom periods
 <https://stackoverflow.com/questions/15408156/resampling-with-custom-periods>`__
@@ -947,8 +944,7 @@ Depending on df construction, ``ignore_index`` may be needed
    df = pd.concat([df1, df2], ignore_index=True)
    df
 
-`Self Join of a DataFrame
-<https://github.com/pandas-dev/pandas/issues/2996>`__
+Self Join of a DataFrame :issue:`2996`
 
 .. ipython:: python
 
@@ -1038,7 +1034,7 @@ Data in/out
 -----------
 
 `Performance comparison of SQL vs HDF5
-<https://stackoverflow.com/questions/16628329/hdf5-and-sqlite-concurrency-compression-i-o-performance>`__
+<https://stackoverflow.com/q/16628329>`__
 
 .. _cookbook.csv:
 
@@ -1070,14 +1066,7 @@ using that handle to read.
 `Inferring dtypes from a file
 <https://stackoverflow.com/questions/15555005/get-inferred-dataframe-types-iteratively-using-chunksize>`__
 
-`Dealing with bad lines
-<https://github.com/pandas-dev/pandas/issues/2886>`__
-
-`Dealing with bad lines II
-<http://nipunbatra.github.io/2013/06/reading-unclean-data-csv-using-pandas/>`__
-
-`Reading CSV with Unix timestamps and converting to local timezone
-<http://nipunbatra.github.io/2013/06/pandas-reading-csv-with-unix-timestamps-and-converting-to-local-timezone/>`__
+Dealing with bad lines :issue:`2886`
 
 `Write a multi-row index CSV without writing duplicates
 <https://stackoverflow.com/questions/17349574/pandas-write-multiindex-rows-with-to-csv>`__
@@ -1211,8 +1200,7 @@ The :ref:`Excel <io.excel>` docs
 `Modifying formatting in XlsxWriter output
 <https://pbpython.com/improve-pandas-excel-output.html>`__
 
-`Loading only visible sheets
-<https://github.com/pandas-dev/pandas/issues/19842#issuecomment-892150745>`__
+Loading only visible sheets :issue:`19842#issuecomment-892150745`
 
 .. _cookbook.html:
 
@@ -1232,8 +1220,7 @@ The :ref:`HDFStores <io.hdf5>` docs
 `Simple queries with a Timestamp Index
 <https://stackoverflow.com/questions/13926089/selecting-columns-from-pandas-hdfstore-table>`__
 
-`Managing heterogeneous data using a linked multiple table hierarchy
-<https://github.com/pandas-dev/pandas/issues/3032>`__
+Managing heterogeneous data using a linked multiple table hierarchy :issue:`3032`
 
 `Merging on-disk tables with millions of rows
 <https://stackoverflow.com/questions/14614512/merging-two-tables-with-millions-of-rows-in-python/14617925#14617925>`__
@@ -1253,7 +1240,7 @@ csv file and creating a store by chunks, with date parsing as well.
 <https://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural/16999397#16999397>`__
 
 `Large Data work flows
-<https://stackoverflow.com/questions/14262433/large-data-work-flows-using-pandas>`__
+<https://stackoverflow.com/q/14262433>`__
 
 `Reading in a sequence of files, then providing a global unique index to a store while appending
 <https://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural>`__
@@ -1384,7 +1371,7 @@ Computation
 -----------
 
 `Numerical integration (sample-based) of a time series
-<https://nbviewer.ipython.org/5720498>`__
+<https://nbviewer.ipython.org/gist/metakermit/5720498>`__
 
 Correlation
 ***********
diff --git a/doc/source/user_guide/dsintro.rst b/doc/source/user_guide/dsintro.rst
index efcf1a8703d2b..571f8980070af 100644
--- a/doc/source/user_guide/dsintro.rst
+++ b/doc/source/user_guide/dsintro.rst
@@ -8,7 +8,7 @@ Intro to data structures
 
 We'll start with a quick, non-comprehensive overview of the fundamental data
 structures in pandas to get you started. The fundamental behavior about data
-types, indexing, and axis labeling / alignment apply across all of the
+types, indexing, axis labeling, and alignment apply across all of the
 objects. To get started, import NumPy and load pandas into your namespace:
 
 .. ipython:: python
@@ -16,7 +16,7 @@ objects. To get started, import NumPy and load pandas into your namespace:
    import numpy as np
    import pandas as pd
 
-Here is a basic tenet to keep in mind: **data alignment is intrinsic**. The link
+Fundamentally, **data alignment is intrinsic**. The link
 between labels and data will not be broken unless done so explicitly by you.
 
 We'll give a brief intro to the data structures, then consider all of the broad
@@ -29,7 +29,7 @@ Series
 
 :class:`Series` is a one-dimensional labeled array capable of holding any data
 type (integers, strings, floating point numbers, Python objects, etc.). The axis
-labels are collectively referred to as the **index**. The basic method to create a Series is to call:
+labels are collectively referred to as the **index**. The basic method to create a :class:`Series` is to call:
 
 ::
 
@@ -61,32 +61,17 @@ index is passed, one will be created having values ``[0, ..., len(data) - 1]``.
 
     pandas supports non-unique index values. If an operation
     that does not support duplicate index values is attempted, an exception
-    will be raised at that time. The reason for being lazy is nearly all performance-based
-    (there are many instances in computations, like parts of GroupBy, where the index
-    is not used).
+    will be raised at that time.
 
 **From dict**
 
-Series can be instantiated from dicts:
+:class:`Series` can be instantiated from dicts:
 
 .. ipython:: python
 
    d = {"b": 1, "a": 0, "c": 2}
    pd.Series(d)
 
-.. note::
-
-   When the data is a dict, and an index is not passed, the ``Series`` index
-   will be ordered by the dict's insertion order, if you're using Python
-   version >= 3.6 and pandas version >= 0.23.
-
-   If you're using Python < 3.6 or pandas < 0.23, and an index is not passed,
-   the ``Series`` index will be the lexically ordered list of dict keys.
-
-In the example above, if you were on a Python version lower than 3.6 or a
-pandas version lower than 0.23, the ``Series`` would be ordered by the lexical
-order of the dict keys (i.e. ``['a', 'b', 'c']`` rather than ``['b', 'a', 'c']``).
-
 If an index is passed, the values in data corresponding to the labels in the
 index will be pulled out.
 
@@ -112,7 +97,7 @@ provided. The value will be repeated to match the length of **index**.
 Series is ndarray-like
 ~~~~~~~~~~~~~~~~~~~~~~
 
-``Series`` acts very similarly to a ``ndarray``, and is a valid argument to most NumPy functions.
+:class:`Series` acts very similarly to a ``ndarray`` and is a valid argument to most NumPy functions.
 However, operations such as slicing will also slice the index.
 
 .. ipython:: python
@@ -128,7 +113,7 @@ However, operations such as slicing will also slice the index.
    We will address array-based indexing like ``s[[4, 3, 1]]``
    in :ref:`section on indexing <indexing>`.
 
-Like a NumPy array, a pandas Series has a :attr:`~Series.dtype`.
+Like a NumPy array, a pandas :class:`Series` has a single :attr:`~Series.dtype`.
 
 .. ipython:: python
 
@@ -140,7 +125,7 @@ be an :class:`~pandas.api.extensions.ExtensionDtype`. Some examples within
 pandas are :ref:`categorical` and :ref:`integer_na`. See :ref:`basics.dtypes`
 for more.
 
-If you need the actual array backing a ``Series``, use :attr:`Series.array`.
+If you need the actual array backing a :class:`Series`, use :attr:`Series.array`.
 
 .. ipython:: python
 
@@ -151,24 +136,24 @@ index (to disable :ref:`automatic alignment <dsintro.alignment>`, for example).
 
 :attr:`Series.array` will always be an :class:`~pandas.api.extensions.ExtensionArray`.
 Briefly, an ExtensionArray is a thin wrapper around one or more *concrete* arrays like a
-:class:`numpy.ndarray`. pandas knows how to take an ``ExtensionArray`` and
-store it in a ``Series`` or a column of a ``DataFrame``.
+:class:`numpy.ndarray`. pandas knows how to take an :class:`~pandas.api.extensions.ExtensionArray` and
+store it in a :class:`Series` or a column of a :class:`DataFrame`.
 See :ref:`basics.dtypes` for more.
 
-While Series is ndarray-like, if you need an *actual* ndarray, then use
+While :class:`Series` is ndarray-like, if you need an *actual* ndarray, then use
 :meth:`Series.to_numpy`.
 
 .. ipython:: python
 
    s.to_numpy()
 
-Even if the Series is backed by a :class:`~pandas.api.extensions.ExtensionArray`,
+Even if the :class:`Series` is backed by a :class:`~pandas.api.extensions.ExtensionArray`,
 :meth:`Series.to_numpy` will return a NumPy ndarray.
 
 Series is dict-like
 ~~~~~~~~~~~~~~~~~~~
 
-A Series is like a fixed-size dict in that you can get and set values by index
+A :class:`Series` is also like a fixed-size dict in that you can get and set values by index
 label:
 
 .. ipython:: python
@@ -179,14 +164,14 @@ label:
     "e" in s
     "f" in s
 
-If a label is not contained, an exception is raised:
+If a label is not contained in the index, an exception is raised:
 
-.. code-block:: python
+.. ipython:: python
+    :okexcept:
 
-    >>> s["f"]
-    KeyError: 'f'
+    s["f"]
 
-Using the ``get`` method, a missing label will return None or specified default:
+Using the :meth:`Series.get` method, a missing label will return None or specified default:
 
 .. ipython:: python
 
@@ -194,14 +179,14 @@ Using the ``get`` method, a missing label will return None or specified default:
 
    s.get("f", np.nan)
 
-See also the :ref:`section on attribute access<indexing.attribute_access>`.
+These labels can also be accessed by :ref:`attribute<indexing.attribute_access>`.
 
 Vectorized operations and label alignment with Series
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When working with raw NumPy arrays, looping through value-by-value is usually
-not necessary. The same is true when working with Series in pandas.
-Series can also be passed into most NumPy methods expecting an ndarray.
+not necessary. The same is true when working with :class:`Series` in pandas.
+:class:`Series` can also be passed into most NumPy methods expecting an ndarray.
 
 .. ipython:: python
 
@@ -209,17 +194,17 @@ Series can also be passed into most NumPy methods expecting an ndarray.
     s * 2
     np.exp(s)
 
-A key difference between Series and ndarray is that operations between Series
+A key difference between :class:`Series` and ndarray is that operations between :class:`Series`
 automatically align the data based on label. Thus, you can write computations
-without giving consideration to whether the Series involved have the same
+without giving consideration to whether the :class:`Series` involved have the same
 labels.
 
 .. ipython:: python
 
     s[1:] + s[:-1]
 
-The result of an operation between unaligned Series will have the **union** of
-the indexes involved. If a label is not found in one Series or the other, the
+The result of an operation between unaligned :class:`Series` will have the **union** of
+the indexes involved. If a label is not found in one :class:`Series` or the other, the
 result will be marked as missing ``NaN``. Being able to write code without doing
 any explicit data alignment grants immense freedom and flexibility in
 interactive data analysis and research. The integrated data alignment features
@@ -240,7 +225,7 @@ Name attribute
 
 .. _dsintro.name_attribute:
 
-Series can also have a ``name`` attribute:
+:class:`Series` also has a ``name`` attribute:
 
 .. ipython:: python
 
@@ -248,10 +233,11 @@ Series can also have a ``name`` attribute:
    s
    s.name
 
-The Series ``name`` will be assigned automatically in many cases, in particular
-when taking 1D slices of DataFrame as you will see below.
+The :class:`Series` ``name`` can be assigned automatically in many cases, in particular,
+when selecting a single column from a :class:`DataFrame`, the ``name`` will be assigned
+the column label.
 
-You can rename a Series with the :meth:`pandas.Series.rename` method.
+You can rename a :class:`Series` with the :meth:`pandas.Series.rename` method.
 
 .. ipython:: python
 
@@ -265,17 +251,17 @@ Note that ``s`` and ``s2`` refer to different objects.
 DataFrame
 ---------
 
-**DataFrame** is a 2-dimensional labeled data structure with columns of
+:class:`DataFrame` is a 2-dimensional labeled data structure with columns of
 potentially different types. You can think of it like a spreadsheet or SQL
 table, or a dict of Series objects. It is generally the most commonly used
 pandas object. Like Series, DataFrame accepts many different kinds of input:
 
-* Dict of 1D ndarrays, lists, dicts, or Series
+* Dict of 1D ndarrays, lists, dicts, or :class:`Series`
 * 2-D numpy.ndarray
 * `Structured or record
   <https://numpy.org/doc/stable/user/basics.rec.html>`__ ndarray
-* A ``Series``
-* Another ``DataFrame``
+* A :class:`Series`
+* Another :class:`DataFrame`
 
 Along with the data, you can optionally pass **index** (row labels) and
 **columns** (column labels) arguments. If you pass an index and / or columns,
@@ -286,16 +272,6 @@ not matching up to the passed index.
 If axis labels are not passed, they will be constructed from the input data
 based on common sense rules.
 
-.. note::
-
-   When the data is a dict, and ``columns`` is not specified, the ``DataFrame``
-   columns will be ordered by the dict's insertion order, if you are using
-   Python version >= 3.6 and pandas >= 0.23.
-
-   If you are using Python < 3.6 or pandas < 0.23, and ``columns`` is not
-   specified, the ``DataFrame`` columns will be the lexically ordered list of dict
-   keys.
-
 From dict of Series or dicts
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -333,7 +309,7 @@ From dict of ndarrays / lists
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The ndarrays must all be the same length. If an index is passed, it must
-clearly also be the same length as the arrays. If no index is passed, the
+also be the same length as the arrays. If no index is passed, the
 result will be ``range(n)``, where ``n`` is the array length.
 
 .. ipython:: python
@@ -402,6 +378,10 @@ The result will be a DataFrame with the same index as the input Series, and
 with one column whose name is the original name of the Series (only if no other
 column name provided).
 
+.. ipython:: python
+
+   ser = pd.Series(range(3), index=list("abc"), name="ser")
+   pd.DataFrame(ser)
 
 .. _basics.dataframe.from_list_namedtuples:
 
@@ -409,8 +389,8 @@ From a list of namedtuples
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The field names of the first ``namedtuple`` in the list determine the columns
-of the ``DataFrame``. The remaining namedtuples (or tuples) are simply unpacked
-and their values are fed into the rows of the ``DataFrame``. If any of those
+of the :class:`DataFrame`. The remaining namedtuples (or tuples) are simply unpacked
+and their values are fed into the rows of the :class:`DataFrame`. If any of those
 tuples is shorter than the first ``namedtuple`` then the later columns in the
 corresponding row are marked as missing values. If any are longer than the
 first ``namedtuple``, a ``ValueError`` is raised.
@@ -440,7 +420,7 @@ can be passed into the DataFrame constructor.
 Passing a list of dataclasses is equivalent to passing a list of dictionaries.
 
 Please be aware, that all values in the list should be dataclasses, mixing
-types in the list would result in a TypeError.
+types in the list would result in a ``TypeError``.
 
 .. ipython:: python
 
@@ -452,11 +432,10 @@ types in the list would result in a TypeError.
 
 **Missing data**
 
-Much more will be said on this topic in the :ref:`Missing data <missing_data>`
-section. To construct a DataFrame with missing data, we use ``np.nan`` to
+To construct a DataFrame with missing data, we use ``np.nan`` to
 represent missing values. Alternatively, you may pass a ``numpy.MaskedArray``
 as the data argument to the DataFrame constructor, and its masked entries will
-be considered missing.
+be considered missing. See :ref:`Missing data <missing_data>` for more.
 
 Alternate constructors
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -465,8 +444,8 @@ Alternate constructors
 
 **DataFrame.from_dict**
 
-``DataFrame.from_dict`` takes a dict of dicts or a dict of array-like sequences
-and returns a DataFrame. It operates like the ``DataFrame`` constructor except
+:meth:`DataFrame.from_dict` takes a dict of dicts or a dict of array-like sequences
+and returns a DataFrame. It operates like the :class:`DataFrame` constructor except
 for the ``orient`` parameter which is ``'columns'`` by default, but which can be
 set to ``'index'`` in order to use the dict keys as row labels.
 
@@ -490,10 +469,10 @@ case, you can also pass the desired column names:
 
 **DataFrame.from_records**
 
-``DataFrame.from_records`` takes a list of tuples or an ndarray with structured
-dtype. It works analogously to the normal ``DataFrame`` constructor, except that
+:meth:`DataFrame.from_records` takes a list of tuples or an ndarray with structured
+dtype. It works analogously to the normal :class:`DataFrame` constructor, except that
 the resulting DataFrame index may be a specific field of the structured
-dtype. For example:
+dtype.
 
 .. ipython:: python
 
@@ -505,7 +484,7 @@ dtype. For example:
 Column selection, addition, deletion
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You can treat a DataFrame semantically like a dict of like-indexed Series
+You can treat a :class:`DataFrame` semantically like a dict of like-indexed :class:`Series`
 objects. Getting, setting, and deleting columns works with the same syntax as
 the analogous dict operations:
 
@@ -532,7 +511,7 @@ column:
    df["foo"] = "bar"
    df
 
-When inserting a Series that does not have the same index as the DataFrame, it
+When inserting a :class:`Series` that does not have the same index as the :class:`DataFrame`, it
 will be conformed to the DataFrame's index:
 
 .. ipython:: python
@@ -543,8 +522,8 @@ will be conformed to the DataFrame's index:
 You can insert raw ndarrays but their length must match the length of the
 DataFrame's index.
 
-By default, columns get inserted at the end. The ``insert`` function is
-available to insert at a particular location in the columns:
+By default, columns get inserted at the end. :meth:`DataFrame.insert`
+inserts at a particular location in the columns:
 
 .. ipython:: python
 
@@ -575,12 +554,12 @@ a function of one argument to be evaluated on the DataFrame being assigned to.
 
    iris.assign(sepal_ratio=lambda x: (x["SepalWidth"] / x["SepalLength"])).head()
 
-``assign`` **always** returns a copy of the data, leaving the original
+:meth:`~pandas.DataFrame.assign` **always** returns a copy of the data, leaving the original
 DataFrame untouched.
 
 Passing a callable, as opposed to an actual value to be inserted, is
 useful when you don't have a reference to the DataFrame at hand. This is
-common when using ``assign`` in a chain of operations. For example,
+common when using :meth:`~pandas.DataFrame.assign` in a chain of operations. For example,
 we can limit the DataFrame to just those observations with a Sepal Length
 greater than 5, calculate the ratio, and plot:
 
@@ -602,13 +581,13 @@ to those rows with sepal length greater than 5. The filtering happens first,
 and then the ratio calculations. This is an example where we didn't
 have a reference to the *filtered* DataFrame available.
 
-The function signature for ``assign`` is simply ``**kwargs``. The keys
+The function signature for :meth:`~pandas.DataFrame.assign` is simply ``**kwargs``. The keys
 are the column names for the new fields, and the values are either a value
-to be inserted (for example, a ``Series`` or NumPy array), or a function
-of one argument to be called on the ``DataFrame``. A *copy* of the original
-DataFrame is returned, with the new values inserted.
+to be inserted (for example, a :class:`Series` or NumPy array), or a function
+of one argument to be called on the :class:`DataFrame`. A *copy* of the original
+:class:`DataFrame` is returned, with the new values inserted.
 
-Starting with Python 3.6 the order of ``**kwargs`` is preserved. This allows
+The order of ``**kwargs`` is preserved. This allows
 for *dependent* assignment, where an expression later in ``**kwargs`` can refer
 to a column created earlier in the same :meth:`~DataFrame.assign`.
 
@@ -635,8 +614,8 @@ The basics of indexing are as follows:
     Slice rows, ``df[5:10]``, DataFrame
     Select rows by boolean vector, ``df[bool_vec]``, DataFrame
 
-Row selection, for example, returns a Series whose index is the columns of the
-DataFrame:
+Row selection, for example, returns a :class:`Series` whose index is the columns of the
+:class:`DataFrame`:
 
 .. ipython:: python
 
@@ -653,7 +632,7 @@ fundamentals of reindexing / conforming to new sets of labels in the
 Data alignment and arithmetic
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Data alignment between DataFrame objects automatically align on **both the
+Data alignment between :class:`DataFrame` objects automatically align on **both the
 columns and the index (row labels)**. Again, the resulting object will have the
 union of the column and row labels.
 
@@ -663,8 +642,8 @@ union of the column and row labels.
     df2 = pd.DataFrame(np.random.randn(7, 3), columns=["A", "B", "C"])
     df + df2
 
-When doing an operation between DataFrame and Series, the default behavior is
-to align the Series **index** on the DataFrame **columns**, thus `broadcasting
+When doing an operation between :class:`DataFrame` and :class:`Series`, the default behavior is
+to align the :class:`Series` **index** on the :class:`DataFrame` **columns**, thus `broadcasting
 <https://numpy.org/doc/stable/user/basics.broadcasting.html>`__
 row-wise. For example:
 
@@ -675,7 +654,7 @@ row-wise. For example:
 For explicit control over the matching and broadcasting behavior, see the
 section on :ref:`flexible binary operations <basics.binop>`.
 
-Operations with scalars are just as you would expect:
+Arithmetic operations with scalars operate element-wise:
 
 .. ipython:: python
 
@@ -685,7 +664,7 @@ Operations with scalars are just as you would expect:
 
 .. _dsintro.boolean:
 
-Boolean operators work as well:
+Boolean operators operate element-wise as well:
 
 .. ipython:: python
 
@@ -699,7 +678,7 @@ Boolean operators work as well:
 Transposing
 ~~~~~~~~~~~
 
-To transpose, access the ``T`` attribute (also the ``transpose`` function),
+To transpose, access the ``T`` attribute or :meth:`DataFrame.transpose`,
 similar to an ndarray:
 
 .. ipython:: python
@@ -712,23 +691,21 @@ similar to an ndarray:
 DataFrame interoperability with NumPy functions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Elementwise NumPy ufuncs (log, exp, sqrt, ...) and various other NumPy functions
-can be used with no issues on Series and DataFrame, assuming the data within
-are numeric:
+Most NumPy functions can be called directly on :class:`Series` and :class:`DataFrame`.
 
 .. ipython:: python
 
    np.exp(df)
    np.asarray(df)
 
-DataFrame is not intended to be a drop-in replacement for ndarray as its
+:class:`DataFrame` is not intended to be a drop-in replacement for ndarray as its
 indexing semantics and data model are quite different in places from an n-dimensional
 array.
 
 :class:`Series` implements ``__array_ufunc__``, which allows it to work with NumPy's
 `universal functions <https://numpy.org/doc/stable/reference/ufuncs.html>`_.
 
-The ufunc is applied to the underlying array in a Series.
+The ufunc is applied to the underlying array in a :class:`Series`.
 
 .. ipython:: python
 
@@ -737,7 +714,7 @@ The ufunc is applied to the underlying array in a Series.
 
 .. versionchanged:: 0.25.0
 
-   When multiple ``Series`` are passed to a ufunc, they are aligned before
+   When multiple :class:`Series` are passed to a ufunc, they are aligned before
    performing the operation.
 
 Like other parts of the library, pandas will automatically align labeled inputs
@@ -761,8 +738,8 @@ with missing values.
    ser3
    np.remainder(ser1, ser3)
 
-When a binary ufunc is applied to a :class:`Series` and :class:`Index`, the Series
-implementation takes precedence and a Series is returned.
+When a binary ufunc is applied to a :class:`Series` and :class:`Index`, the :class:`Series`
+implementation takes precedence and a :class:`Series` is returned.
 
 .. ipython:: python
 
@@ -778,10 +755,9 @@ the ufunc is applied without converting the underlying data to an ndarray.
 Console display
 ~~~~~~~~~~~~~~~
 
-Very large DataFrames will be truncated to display them in the console.
+A very large :class:`DataFrame` will be truncated to display them in the console.
 You can also get a summary using :meth:`~pandas.DataFrame.info`.
-(Here I am reading a CSV version of the **baseball** dataset from the **plyr**
-R package):
+(The **baseball** dataset is from the **plyr** R package):
 
 .. ipython:: python
    :suppress:
@@ -802,8 +778,8 @@ R package):
    # restore GlobalPrintConfig
    pd.reset_option(r"^display\.")
 
-However, using ``to_string`` will return a string representation of the
-DataFrame in tabular form, though it won't always fit the console width:
+However, using :meth:`DataFrame.to_string` will return a string representation of the
+:class:`DataFrame` in tabular form, though it won't always fit the console width:
 
 .. ipython:: python
 
@@ -855,7 +831,7 @@ This will print the table in one block.
 DataFrame column attribute access and IPython completion
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-If a DataFrame column label is a valid Python variable name, the column can be
+If a :class:`DataFrame` column label is a valid Python variable name, the column can be
 accessed like an attribute:
 
 .. ipython:: python
diff --git a/doc/source/user_guide/duplicates.rst b/doc/source/user_guide/duplicates.rst
index 36c2ec53d58b4..7894789846ce8 100644
--- a/doc/source/user_guide/duplicates.rst
+++ b/doc/source/user_guide/duplicates.rst
@@ -172,7 +172,7 @@ going forward, to ensure that your data pipeline doesn't introduce duplicates.
    >>> deduplicated = raw.groupby(level=0).first()  # remove duplicates
    >>> deduplicated.flags.allows_duplicate_labels = False  # disallow going forward
 
-Setting ``allows_duplicate_labels=True`` on a ``Series`` or ``DataFrame`` with duplicate
+Setting ``allows_duplicate_labels=False`` on a ``Series`` or ``DataFrame`` with duplicate
 labels or performing an operation that introduces duplicate labels on a ``Series`` or
 ``DataFrame`` that disallows duplicates will raise an
 :class:`errors.DuplicateLabelError`.
diff --git a/doc/source/user_guide/enhancingperf.rst b/doc/source/user_guide/enhancingperf.rst
index c78d972f33d65..1a1229f95523b 100644
--- a/doc/source/user_guide/enhancingperf.rst
+++ b/doc/source/user_guide/enhancingperf.rst
@@ -7,10 +7,10 @@ Enhancing performance
 *********************
 
 In this part of the tutorial, we will investigate how to speed up certain
-functions operating on pandas ``DataFrames`` using three different techniques:
+functions operating on pandas :class:`DataFrame` using three different techniques:
 Cython, Numba and :func:`pandas.eval`. We will see a speed improvement of ~200
 when we use Cython and Numba on a test function operating row-wise on the
-``DataFrame``. Using :func:`pandas.eval` we will speed up a sum by an order of
+:class:`DataFrame`. Using :func:`pandas.eval` we will speed up a sum by an order of
 ~2.
 
 .. note::
@@ -35,7 +35,7 @@ by trying to remove for-loops and making use of NumPy vectorization. It's always
 optimising in Python first.
 
 This tutorial walks through a "typical" process of cythonizing a slow computation.
-We use an `example from the Cython documentation <http://docs.cython.org/src/quickstart/cythonize.html>`__
+We use an `example from the Cython documentation <https://docs.cython.org/en/latest/src/quickstart/cythonize.html>`__
 but in the context of pandas. Our final cythonized solution is around 100 times
 faster than the pure Python solution.
 
@@ -44,7 +44,7 @@ faster than the pure Python solution.
 Pure Python
 ~~~~~~~~~~~
 
-We have a ``DataFrame`` to which we want to apply a function row-wise.
+We have a :class:`DataFrame` to which we want to apply a function row-wise.
 
 .. ipython:: python
 
@@ -73,12 +73,11 @@ Here's the function in pure Python:
            s += f(a + i * dx)
        return s * dx
 
-We achieve our result by using ``apply`` (row-wise):
+We achieve our result by using :meth:`DataFrame.apply` (row-wise):
 
-.. code-block:: ipython
+.. ipython:: python
 
-   In [7]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
-   10 loops, best of 3: 174 ms per loop
+   %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
 
 But clearly this isn't fast enough for us. Let's take a look and see where the
 time is spent during this operation (limited to the most time consuming
@@ -126,10 +125,9 @@ is here to distinguish between function versions):
   to be using bleeding edge IPython for paste to play well with cell magics.
 
 
-.. code-block:: ipython
+.. ipython:: python
 
-   In [4]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
-   10 loops, best of 3: 85.5 ms per loop
+   %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
 
 Already this has shaved a third off, not too bad for a simple copy and paste.
 
@@ -155,10 +153,9 @@ We get another huge improvement simply by providing type information:
       ...:     return s * dx
       ...:
 
-.. code-block:: ipython
+.. ipython:: python
 
-   In [4]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
-   10 loops, best of 3: 20.3 ms per loop
+   %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
 
 Now, we're talking! It's now over ten times faster than the original Python
 implementation, and we haven't *really* modified the code. Let's have another
@@ -173,7 +170,7 @@ look at what's eating up time:
 Using ndarray
 ~~~~~~~~~~~~~
 
-It's calling series... a lot! It's creating a Series from each row, and get-ting from both
+It's calling series a lot! It's creating a :class:`Series` from each row, and calling get from both
 the index and the series (three times for each row). Function calls are expensive
 in Python, so maybe we could minimize these by cythonizing the apply part.
 
@@ -216,10 +213,10 @@ the rows, applying our ``integrate_f_typed``, and putting this in the zeros arra
 
 .. warning::
 
-   You can **not pass** a ``Series`` directly as a ``ndarray`` typed parameter
+   You can **not pass** a :class:`Series` directly as a ``ndarray`` typed parameter
    to a Cython function. Instead pass the actual ``ndarray`` using the
    :meth:`Series.to_numpy`. The reason is that the Cython
-   definition is specific to an ndarray and not the passed ``Series``.
+   definition is specific to an ndarray and not the passed :class:`Series`.
 
    So, do not do this:
 
@@ -238,10 +235,9 @@ the rows, applying our ``integrate_f_typed``, and putting this in the zeros arra
     Loops like this would be *extremely* slow in Python, but in Cython looping
     over NumPy arrays is *fast*.
 
-.. code-block:: ipython
+.. ipython:: python
 
-   In [4]: %timeit apply_integrate_f(df["a"].to_numpy(), df["b"].to_numpy(), df["N"].to_numpy())
-   1000 loops, best of 3: 1.25 ms per loop
+   %timeit apply_integrate_f(df["a"].to_numpy(), df["b"].to_numpy(), df["N"].to_numpy())
 
 We've gotten another big improvement. Let's check again where the time is spent:
 
@@ -267,33 +263,33 @@ advanced Cython techniques:
       ...: cimport cython
       ...: cimport numpy as np
       ...: import numpy as np
-      ...: cdef double f_typed(double x) except? -2:
+      ...: cdef np.float64_t f_typed(np.float64_t x) except? -2:
       ...:     return x * (x - 1)
-      ...: cpdef double integrate_f_typed(double a, double b, int N):
-      ...:     cdef int i
-      ...:     cdef double s, dx
-      ...:     s = 0
+      ...: cpdef np.float64_t integrate_f_typed(np.float64_t a, np.float64_t b, np.int64_t N):
+      ...:     cdef np.int64_t i
+      ...:     cdef np.float64_t s = 0.0, dx
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f_typed(a + i * dx)
       ...:     return s * dx
       ...: @cython.boundscheck(False)
       ...: @cython.wraparound(False)
-      ...: cpdef np.ndarray[double] apply_integrate_f_wrap(np.ndarray[double] col_a,
-      ...:                                                 np.ndarray[double] col_b,
-      ...:                                                 np.ndarray[int] col_N):
-      ...:     cdef int i, n = len(col_N)
+      ...: cpdef np.ndarray[np.float64_t] apply_integrate_f_wrap(
+      ...:     np.ndarray[np.float64_t] col_a,
+      ...:     np.ndarray[np.float64_t] col_b,
+      ...:     np.ndarray[np.int64_t] col_N
+      ...: ):
+      ...:     cdef np.int64_t i, n = len(col_N)
       ...:     assert len(col_a) == len(col_b) == n
-      ...:     cdef np.ndarray[double] res = np.empty(n)
+      ...:     cdef np.ndarray[np.float64_t] res = np.empty(n, dtype=np.float64)
       ...:     for i in range(n):
       ...:         res[i] = integrate_f_typed(col_a[i], col_b[i], col_N[i])
       ...:     return res
       ...:
 
-.. code-block:: ipython
+.. ipython:: python
 
-   In [4]: %timeit apply_integrate_f_wrap(df["a"].to_numpy(), df["b"].to_numpy(), df["N"].to_numpy())
-   1000 loops, best of 3: 987 us per loop
+   %timeit apply_integrate_f_wrap(df["a"].to_numpy(), df["b"].to_numpy(), df["N"].to_numpy())
 
 Even faster, with the caveat that a bug in our Cython code (an off-by-one error,
 for example) might cause a segfault because memory access isn't checked.
@@ -321,7 +317,7 @@ Numba supports compilation of Python to run on either CPU or GPU hardware and is
 Numba can be used in 2 ways with pandas:
 
 #. Specify the ``engine="numba"`` keyword in select pandas methods
-#. Define your own Python function decorated with ``@jit`` and pass the underlying NumPy array of :class:`Series` or :class:`Dataframe` (using ``to_numpy()``) into the function
+#. Define your own Python function decorated with ``@jit`` and pass the underlying NumPy array of :class:`Series` or :class:`DataFrame` (using ``to_numpy()``) into the function
 
 pandas Numba Engine
 ~~~~~~~~~~~~~~~~~~~
@@ -354,6 +350,28 @@ a larger amount of data points (e.g. 1+ million).
    In [6]: %timeit roll.apply(f, engine='cython', raw=True)
    3.92 s ± 59 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
+If your compute hardware contains multiple CPUs, the largest performance gain can be realized by setting ``parallel`` to ``True``
+to leverage more than 1 CPU. Internally, pandas leverages numba to parallelize computations over the columns of a :class:`DataFrame`;
+therefore, this performance benefit is only beneficial for a :class:`DataFrame` with a large number of columns.
+
+.. code-block:: ipython
+
+   In [1]: import numba
+
+   In [2]: numba.set_num_threads(1)
+
+   In [3]: df = pd.DataFrame(np.random.randn(10_000, 100))
+
+   In [4]: roll = df.rolling(100)
+
+   In [5]: %timeit roll.mean(engine="numba", engine_kwargs={"parallel": True})
+   347 ms ± 26 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+   In [6]: numba.set_num_threads(2)
+
+   In [7]: %timeit roll.mean(engine="numba", engine_kwargs={"parallel": True})
+   201 ms ± 2.97 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
 Custom Function Examples
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -595,8 +613,8 @@ Now let's do the same thing but with comparisons:
    of type ``bool`` or ``np.bool_``. Again, you should perform these kinds of
    operations in plain Python.
 
-The ``DataFrame.eval`` method
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The :meth:`DataFrame.eval` method
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 In addition to the top level :func:`pandas.eval` function you can also
 evaluate an expression in the "context" of a :class:`~pandas.DataFrame`.
@@ -630,7 +648,7 @@ new column name or an existing column name, and it must be a valid Python
 identifier.
 
 The ``inplace`` keyword determines whether this assignment will performed
-on the original ``DataFrame`` or return a copy with the new column.
+on the original :class:`DataFrame` or return a copy with the new column.
 
 .. ipython:: python
 
@@ -640,7 +658,7 @@ on the original ``DataFrame`` or return a copy with the new column.
    df.eval("a = 1", inplace=True)
    df
 
-When ``inplace`` is set to ``False``, the default, a copy of the ``DataFrame`` with the
+When ``inplace`` is set to ``False``, the default, a copy of the :class:`DataFrame` with the
 new or modified columns is returned and the original frame is unchanged.
 
 .. ipython:: python
@@ -672,7 +690,7 @@ The equivalent in standard Python would be
    df["a"] = 1
    df
 
-The ``query`` method has a ``inplace`` keyword which determines
+The :class:`DataFrame.query` method has a ``inplace`` keyword which determines
 whether the query modifies the original frame.
 
 .. ipython:: python
@@ -814,7 +832,7 @@ computation. The two lines are two different engines.
        .. image:: ../_static/eval-perf-small.png
 
 
-This plot was created using a ``DataFrame`` with 3 columns each containing
+This plot was created using a :class:`DataFrame` with 3 columns each containing
 floating point values generated using ``numpy.random.randn()``.
 
 Technical minutia regarding expression evaluation
diff --git a/doc/source/user_guide/gotchas.rst b/doc/source/user_guide/gotchas.rst
index 1de978b195382..adb40e166eab4 100644
--- a/doc/source/user_guide/gotchas.rst
+++ b/doc/source/user_guide/gotchas.rst
@@ -10,13 +10,13 @@ Frequently Asked Questions (FAQ)
 
 DataFrame memory usage
 ----------------------
-The memory usage of a ``DataFrame`` (including the index) is shown when calling
+The memory usage of a :class:`DataFrame` (including the index) is shown when calling
 the :meth:`~DataFrame.info`. A configuration option, ``display.memory_usage``
 (see :ref:`the list of options <options.available>`), specifies if the
-``DataFrame``'s memory usage will be displayed when invoking the ``df.info()``
+:class:`DataFrame` memory usage will be displayed when invoking the ``df.info()``
 method.
 
-For example, the memory usage of the ``DataFrame`` below is shown
+For example, the memory usage of the :class:`DataFrame` below is shown
 when calling :meth:`~DataFrame.info`:
 
 .. ipython:: python
@@ -53,9 +53,9 @@ By default the display option is set to ``True`` but can be explicitly
 overridden by passing the ``memory_usage`` argument when invoking ``df.info()``.
 
 The memory usage of each column can be found by calling the
-:meth:`~DataFrame.memory_usage` method. This returns a ``Series`` with an index
+:meth:`~DataFrame.memory_usage` method. This returns a :class:`Series` with an index
 represented by column names and memory usage of each column shown in bytes. For
-the ``DataFrame`` above, the memory usage of each column and the total memory
+the :class:`DataFrame` above, the memory usage of each column and the total memory
 usage can be found with the ``memory_usage`` method:
 
 .. ipython:: python
@@ -65,8 +65,8 @@ usage can be found with the ``memory_usage`` method:
     # total memory usage of dataframe
     df.memory_usage().sum()
 
-By default the memory usage of the ``DataFrame``'s index is shown in the
-returned ``Series``, the memory usage of the index can be suppressed by passing
+By default the memory usage of the :class:`DataFrame` index is shown in the
+returned :class:`Series`, the memory usage of the index can be suppressed by passing
 the ``index=False`` argument:
 
 .. ipython:: python
@@ -75,7 +75,7 @@ the ``index=False`` argument:
 
 The memory usage displayed by the :meth:`~DataFrame.info` method utilizes the
 :meth:`~DataFrame.memory_usage` method to determine the memory usage of a
-``DataFrame`` while also formatting the output in human-readable units (base-2
+:class:`DataFrame` while also formatting the output in human-readable units (base-2
 representation; i.e. 1KB = 1024 bytes).
 
 See also :ref:`Categorical Memory Usage <categorical.memory>`.
@@ -98,32 +98,28 @@ of the following code should be:
 Should it be ``True`` because it's not zero-length, or ``False`` because there
 are ``False`` values? It is unclear, so instead, pandas raises a ``ValueError``:
 
-.. code-block:: python
+.. ipython:: python
+    :okexcept:
 
-    >>> if pd.Series([False, True, False]):
-    ...     print("I was true")
-    Traceback
-        ...
-    ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
+    if pd.Series([False, True, False]):
+        print("I was true")
 
-You need to explicitly choose what you want to do with the ``DataFrame``, e.g.
+You need to explicitly choose what you want to do with the :class:`DataFrame`, e.g.
 use :meth:`~DataFrame.any`, :meth:`~DataFrame.all` or :meth:`~DataFrame.empty`.
 Alternatively, you might want to compare if the pandas object is ``None``:
 
-.. code-block:: python
+.. ipython:: python
 
-    >>> if pd.Series([False, True, False]) is not None:
-    ...     print("I was not None")
-    I was not None
+    if pd.Series([False, True, False]) is not None:
+        print("I was not None")
 
 
 Below is how to check if any of the values are ``True``:
 
-.. code-block:: python
+.. ipython:: python
 
-    >>> if pd.Series([False, True, False]).any():
-    ...     print("I am any")
-    I am any
+    if pd.Series([False, True, False]).any():
+        print("I am any")
 
 To evaluate single-element pandas objects in a boolean context, use the method
 :meth:`~DataFrame.bool`:
@@ -138,27 +134,21 @@ To evaluate single-element pandas objects in a boolean context, use the method
 Bitwise boolean
 ~~~~~~~~~~~~~~~
 
-Bitwise boolean operators like ``==`` and ``!=`` return a boolean ``Series``,
-which is almost always what you want anyways.
+Bitwise boolean operators like ``==`` and ``!=`` return a boolean :class:`Series`
+which performs an element-wise comparison when compared to a scalar.
 
-.. code-block:: python
+.. ipython:: python
 
-   >>> s = pd.Series(range(5))
-   >>> s == 4
-   0    False
-   1    False
-   2    False
-   3    False
-   4     True
-   dtype: bool
+   s = pd.Series(range(5))
+   s == 4
 
 See :ref:`boolean comparisons<basics.compare>` for more examples.
 
 Using the ``in`` operator
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Using the Python ``in`` operator on a ``Series`` tests for membership in the
-index, not membership among the values.
+Using the Python ``in`` operator on a :class:`Series` tests for membership in the
+**index**, not membership among the values.
 
 .. ipython:: python
 
@@ -167,7 +157,7 @@ index, not membership among the values.
     'b' in s
 
 If this behavior is surprising, keep in mind that using ``in`` on a Python
-dictionary tests keys, not values, and ``Series`` are dict-like.
+dictionary tests keys, not values, and :class:`Series` are dict-like.
 To test for membership in the values, use the method :meth:`~pandas.Series.isin`:
 
 .. ipython:: python
@@ -175,7 +165,7 @@ To test for membership in the values, use the method :meth:`~pandas.Series.isin`
     s.isin([2])
     s.isin([2]).any()
 
-For ``DataFrames``, likewise, ``in`` applies to the column axis,
+For :class:`DataFrame`, likewise, ``in`` applies to the column axis,
 testing for membership in the list of column names.
 
 .. _gotchas.udf-mutation:
@@ -206,8 +196,8 @@ causing unexpected behavior. Consider the example:
 One probably would have expected that the result would be ``[1, 3, 5]``.
 When using a pandas method that takes a UDF, internally pandas is often
 iterating over the
-``DataFrame`` or other pandas object. Therefore, if the UDF mutates (changes)
-the ``DataFrame``, unexpected behavior can arise.
+:class:`DataFrame` or other pandas object. Therefore, if the UDF mutates (changes)
+the :class:`DataFrame`, unexpected behavior can arise.
 
 Here is a similar example with :meth:`DataFrame.apply`:
 
@@ -267,7 +257,7 @@ For many reasons we chose the latter. After years of production use it has
 proven, at least in my opinion, to be the best decision given the state of
 affairs in NumPy and Python in general. The special value ``NaN``
 (Not-A-Number) is used everywhere as the ``NA`` value, and there are API
-functions ``isna`` and ``notna`` which can be used across the dtypes to
+functions :meth:`DataFrame.isna` and :meth:`DataFrame.notna` which can be used across the dtypes to
 detect NA values.
 
 However, it comes with it a couple of trade-offs which I most certainly have
@@ -293,7 +283,7 @@ arrays. For example:
    s2.dtype
 
 This trade-off is made largely for memory and performance reasons, and also so
-that the resulting ``Series`` continues to be "numeric".
+that the resulting :class:`Series` continues to be "numeric".
 
 If you need to represent integers with possibly missing values, use one of
 the nullable-integer extension dtypes provided by pandas
@@ -318,7 +308,7 @@ See :ref:`integer_na` for more.
 ``NA`` type promotions
 ~~~~~~~~~~~~~~~~~~~~~~
 
-When introducing NAs into an existing ``Series`` or ``DataFrame`` via
+When introducing NAs into an existing :class:`Series` or :class:`DataFrame` via
 :meth:`~Series.reindex` or some other means, boolean and integer types will be
 promoted to a different dtype in order to store the NAs. The promotions are
 summarized in this table:
@@ -341,7 +331,7 @@ Why not make NumPy like R?
 
 Many people have suggested that NumPy should simply emulate the ``NA`` support
 present in the more domain-specific statistical programming language `R
-<https://r-project.org>`__. Part of the reason is the NumPy type hierarchy:
+<https://www.r-project.org/>`__. Part of the reason is the NumPy type hierarchy:
 
 .. csv-table::
    :header: "Typeclass","Dtypes"
@@ -376,18 +366,19 @@ integer arrays to floating when NAs must be introduced.
 
 Differences with NumPy
 ----------------------
-For ``Series`` and ``DataFrame`` objects, :meth:`~DataFrame.var` normalizes by
-``N-1`` to produce unbiased estimates of the sample variance, while NumPy's
-``var`` normalizes by N, which measures the variance of the sample. Note that
+For :class:`Series` and :class:`DataFrame` objects, :meth:`~DataFrame.var` normalizes by
+``N-1`` to produce `unbiased estimates of the population variance <https://en.wikipedia.org/wiki/Bias_of_an_estimator>`__, while NumPy's
+:meth:`numpy.var` normalizes by N, which measures the variance of the sample. Note that
 :meth:`~DataFrame.cov` normalizes by ``N-1`` in both pandas and NumPy.
 
+.. _gotchas.thread-safety:
 
 Thread-safety
 -------------
 
-As of pandas 0.11, pandas is not 100% thread safe. The known issues relate to
+pandas is not 100% thread safe. The known issues relate to
 the :meth:`~DataFrame.copy` method. If you are doing a lot of copying of
-``DataFrame`` objects shared among threads, we recommend holding locks inside
+:class:`DataFrame` objects shared among threads, we recommend holding locks inside
 the threads where the data copying occurs.
 
 See `this link <https://stackoverflow.com/questions/13592618/python-pandas-dataframe-thread-safe>`__
@@ -406,7 +397,7 @@ symptom of this issue is an error like::
 
 To deal
 with this issue you should convert the underlying NumPy array to the native
-system byte order *before* passing it to ``Series`` or ``DataFrame``
+system byte order *before* passing it to :class:`Series` or :class:`DataFrame`
 constructors using something similar to the following:
 
 .. ipython:: python
diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index 0fb59c50efa74..5d8ef7ce02097 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -477,7 +477,7 @@ An obvious one is aggregation via the
 .. ipython:: python
 
    grouped = df.groupby("A")
-   grouped.aggregate(np.sum)
+   grouped[["C", "D"]].aggregate(np.sum)
 
    grouped = df.groupby(["A", "B"])
    grouped.aggregate(np.sum)
@@ -492,7 +492,7 @@ changed by using the ``as_index`` option:
    grouped = df.groupby(["A", "B"], as_index=False)
    grouped.aggregate(np.sum)
 
-   df.groupby("A", as_index=False).sum()
+   df.groupby("A", as_index=False)[["C", "D"]].sum()
 
 Note that you could use the ``reset_index`` DataFrame function to achieve the
 same result as the column names are stored in the resulting ``MultiIndex``:
@@ -539,19 +539,19 @@ Some common aggregating functions are tabulated below:
     :widths: 20, 80
     :delim: ;
 
-	:meth:`~pd.core.groupby.DataFrameGroupBy.mean`;Compute mean of groups
-	:meth:`~pd.core.groupby.DataFrameGroupBy.sum`;Compute sum of group values
-	:meth:`~pd.core.groupby.DataFrameGroupBy.size`;Compute group sizes
-	:meth:`~pd.core.groupby.DataFrameGroupBy.count`;Compute count of group
-	:meth:`~pd.core.groupby.DataFrameGroupBy.std`;Standard deviation of groups
-	:meth:`~pd.core.groupby.DataFrameGroupBy.var`;Compute variance of groups
-	:meth:`~pd.core.groupby.DataFrameGroupBy.sem`;Standard error of the mean of groups
-	:meth:`~pd.core.groupby.DataFrameGroupBy.describe`;Generates descriptive statistics
-	:meth:`~pd.core.groupby.DataFrameGroupBy.first`;Compute first of group values
-	:meth:`~pd.core.groupby.DataFrameGroupBy.last`;Compute last of group values
-	:meth:`~pd.core.groupby.DataFrameGroupBy.nth`;Take nth value, or a subset if n is a list
-	:meth:`~pd.core.groupby.DataFrameGroupBy.min`;Compute min of group values
-	:meth:`~pd.core.groupby.DataFrameGroupBy.max`;Compute max of group values
+        :meth:`~pd.core.groupby.DataFrameGroupBy.mean`;Compute mean of groups
+        :meth:`~pd.core.groupby.DataFrameGroupBy.sum`;Compute sum of group values
+        :meth:`~pd.core.groupby.DataFrameGroupBy.size`;Compute group sizes
+        :meth:`~pd.core.groupby.DataFrameGroupBy.count`;Compute count of group
+        :meth:`~pd.core.groupby.DataFrameGroupBy.std`;Standard deviation of groups
+        :meth:`~pd.core.groupby.DataFrameGroupBy.var`;Compute variance of groups
+        :meth:`~pd.core.groupby.DataFrameGroupBy.sem`;Standard error of the mean of groups
+        :meth:`~pd.core.groupby.DataFrameGroupBy.describe`;Generates descriptive statistics
+        :meth:`~pd.core.groupby.DataFrameGroupBy.first`;Compute first of group values
+        :meth:`~pd.core.groupby.DataFrameGroupBy.last`;Compute last of group values
+        :meth:`~pd.core.groupby.DataFrameGroupBy.nth`;Take nth value, or a subset if n is a list
+        :meth:`~pd.core.groupby.DataFrameGroupBy.min`;Compute min of group values
+        :meth:`~pd.core.groupby.DataFrameGroupBy.max`;Compute max of group values
 
 
 The aggregating functions above will exclude NA values. Any function which
@@ -730,7 +730,7 @@ optimized Cython implementations:
 
 .. ipython:: python
 
-   df.groupby("A").sum()
+   df.groupby("A")[["C", "D"]].sum()
    df.groupby(["A", "B"]).mean()
 
 Of course ``sum`` and ``mean`` are implemented on pandas objects, so the above
@@ -761,7 +761,7 @@ different dtypes, then a common dtype will be determined in the same way as ``Da
 Transformation
 --------------
 
-The ``transform`` method returns an object that is indexed the same (same size)
+The ``transform`` method returns an object that is indexed the same
 as the one being grouped. The transform function must:
 
 * Return a result that is either the same size as the group chunk or
@@ -776,6 +776,14 @@ as the one being grouped. The transform function must:
 * (Optionally) operates on the entire group chunk. If this is supported, a
   fast path is used starting from the *second* chunk.
 
+.. deprecated:: 1.5.0
+
+    When using ``.transform`` on a grouped DataFrame and the transformation function
+    returns a DataFrame, currently pandas does not align the result's index
+    with the input's index. This behavior is deprecated and alignment will
+    be performed in a future version of pandas. You can apply ``.to_numpy()`` to the
+    result of the transformation function to avoid alignment.
+
 Similar to :ref:`groupby.aggregate.udfs`, the resulting dtype will reflect that of the
 transformation function. If the results from different groups have different dtypes, then
 a common dtype will be determined in the same way as ``DataFrame`` construction.
@@ -831,10 +839,10 @@ Alternatively, the built-in methods could be used to produce the same outputs.
 
 .. ipython:: python
 
-   max = ts.groupby(lambda x: x.year).transform("max")
-   min = ts.groupby(lambda x: x.year).transform("min")
+   max_ts = ts.groupby(lambda x: x.year).transform("max")
+   min_ts = ts.groupby(lambda x: x.year).transform("min")
 
-   max - min
+   max_ts - min_ts
 
 Another common data transform is to replace missing data with the group mean.
 
@@ -1052,7 +1060,14 @@ Some operations on the grouped data might not fit into either the aggregate or
 transform categories. Or, you may simply want GroupBy to infer how to combine
 the results. For these, use the ``apply`` function, which can be substituted
 for both ``aggregate`` and ``transform`` in many standard use cases. However,
-``apply`` can handle some exceptional use cases, for example:
+``apply`` can handle some exceptional use cases.
+
+.. note::
+
+   ``apply`` can act as a reducer, transformer, *or* filter function, depending
+   on exactly what is passed to it. It can depend on the passed function and
+   exactly what you are grouping. Thus the grouped column(s) may be included in
+   the output as well as set the indices.
 
 .. ipython:: python
 
@@ -1064,16 +1079,14 @@ for both ``aggregate`` and ``transform`` in many standard use cases. However,
 
 The dimension of the returned result can also change:
 
-.. ipython::
-
-    In [8]: grouped = df.groupby('A')['C']
+.. ipython:: python
 
-    In [10]: def f(group):
-       ....:     return pd.DataFrame({'original': group,
-       ....:                          'demeaned': group - group.mean()})
-       ....:
+    grouped = df.groupby('A')['C']
 
-    In [11]: grouped.apply(f)
+    def f(group):
+        return pd.DataFrame({'original': group,
+                             'demeaned': group - group.mean()})
+    grouped.apply(f)
 
 ``apply`` on a Series can operate on a returned value from the applied function,
 that is itself a series, and possibly upcast the result to a DataFrame:
@@ -1088,11 +1101,33 @@ that is itself a series, and possibly upcast the result to a DataFrame:
     s
     s.apply(f)
 
+Control grouped column(s) placement with ``group_keys``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 .. note::
 
-   ``apply`` can act as a reducer, transformer, *or* filter function, depending on exactly what is passed to it.
-   So depending on the path taken, and exactly what you are grouping. Thus the grouped columns(s) may be included in
-   the output as well as set the indices.
+   If ``group_keys=True`` is specified when calling :meth:`~DataFrame.groupby`,
+   functions passed to ``apply`` that return like-indexed outputs will have the
+   group keys added to the result index. Previous versions of pandas would add
+   the group keys only when the result from the applied function had a different
+   index than the input. If ``group_keys`` is not specified, the group keys will
+   not be added for like-indexed outputs. In the future this behavior
+   will change to always respect ``group_keys``, which defaults to ``True``.
+
+   .. versionchanged:: 1.5.0
+
+To control whether the grouped column(s) are included in the indices, you can use
+the argument ``group_keys``. Compare
+
+.. ipython:: python
+
+    df.groupby("A", group_keys=True).apply(lambda x: x)
+
+with
+
+.. ipython:: python
+
+    df.groupby("A", group_keys=False).apply(lambda x: x)
 
 Similar to :ref:`groupby.aggregate.udfs`, the resulting dtype will reflect that of the
 apply function. If the results from different groups have different dtypes, then
@@ -1132,13 +1167,12 @@ Again consider the example DataFrame we've been looking at:
 
 Suppose we wish to compute the standard deviation grouped by the ``A``
 column. There is a slight problem, namely that we don't care about the data in
-column ``B``. We refer to this as a "nuisance" column. If the passed
-aggregation function can't be applied to some columns, the troublesome columns
-will be (silently) dropped. Thus, this does not pose any problems:
+column ``B``. We refer to this as a "nuisance" column. You can avoid nuisance
+columns by specifying ``numeric_only=True``:
 
 .. ipython:: python
 
-   df.groupby("A").std()
+   df.groupby("A").std(numeric_only=True)
 
 Note that ``df.groupby('A').colname.std().`` is more efficient than
 ``df.groupby('A').std().colname``, so if the result of an aggregation function
@@ -1153,7 +1187,14 @@ is only interesting over one column (here ``colname``), it may be filtered
    If you do wish to include decimal or object columns in an aggregation with
    other non-nuisance data types, you must do so explicitly.
 
+.. warning::
+   The automatic dropping of nuisance columns has been deprecated and will be removed
+   in a future version of pandas. If columns are included that cannot be operated
+   on, pandas will instead raise an error. In order to avoid this, either select
+   the columns you wish to operate on or specify ``numeric_only=True``.
+
 .. ipython:: python
+    :okwarning:
 
     from decimal import Decimal
 
@@ -1277,7 +1318,7 @@ Groupby a specific column with the desired frequency. This is like resampling.
 
 .. ipython:: python
 
-   df.groupby([pd.Grouper(freq="1M", key="Date"), "Buyer"]).sum()
+   df.groupby([pd.Grouper(freq="1M", key="Date"), "Buyer"])[["Quantity"]].sum()
 
 You have an ambiguous specification in that you have a named index and a column
 that could be potential groupers.
@@ -1286,9 +1327,9 @@ that could be potential groupers.
 
    df = df.set_index("Date")
    df["Date"] = df.index + pd.offsets.MonthEnd(2)
-   df.groupby([pd.Grouper(freq="6M", key="Date"), "Buyer"]).sum()
+   df.groupby([pd.Grouper(freq="6M", key="Date"), "Buyer"])[["Quantity"]].sum()
 
-   df.groupby([pd.Grouper(freq="6M", level="Date"), "Buyer"]).sum()
+   df.groupby([pd.Grouper(freq="6M", level="Date"), "Buyer"])[["Quantity"]].sum()
 
 
 Taking the first rows of each group
diff --git a/doc/source/user_guide/index.rst b/doc/source/user_guide/index.rst
index 6b6e212cde635..a6392706eb7a3 100644
--- a/doc/source/user_guide/index.rst
+++ b/doc/source/user_guide/index.rst
@@ -17,6 +17,43 @@ For a high level summary of the pandas fundamentals, see :ref:`dsintro` and :ref
 Further information on any specific method can be obtained in the
 :ref:`api`.
 
+How to read these guides
+------------------------
+In these guides you will see input code inside code blocks such as:
+
+::
+
+    import pandas as pd
+    pd.DataFrame({'A': [1, 2, 3]})
+
+
+or:
+
+.. ipython:: python
+
+    import pandas as pd
+    pd.DataFrame({'A': [1, 2, 3]})
+
+The first block is a standard python input, while in the second the ``In [1]:`` indicates the input is inside a `notebook <https://jupyter.org>`__. In Jupyter Notebooks the last line is printed and plots are shown inline.
+
+For example:
+
+.. ipython:: python
+
+    a = 1
+    a
+is equivalent to:
+
+::
+
+    a = 1
+    print(a)
+
+
+
+Guides
+-------
+
 .. If you update this toctree, also update the manual toctree in the
    main index.rst.template
 
@@ -39,7 +76,6 @@ Further information on any specific method can be obtained in the
     boolean
     visualization
     style
-    computation
     groupby
     window
     timeseries
diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index e41f938170417..f939945fc6cda 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -89,7 +89,7 @@ Getting values from an object with multi-axes selection uses the following
 notation (using ``.loc`` as an example, but the following applies to ``.iloc`` as
 well). Any of the axes accessors may be the null slice ``:``. Axes left out of
 the specification are assumed to be ``:``, e.g. ``p.loc['a']`` is equivalent to
-``p.loc['a', :, :]``.
+``p.loc['a', :]``.
 
 .. csv-table::
     :header: "Object Type", "Indexers"
@@ -583,7 +583,7 @@ without using a temporary variable.
 .. ipython:: python
 
    bb = pd.read_csv('data/baseball.csv', index_col='id')
-   (bb.groupby(['year', 'team']).sum()
+   (bb.groupby(['year', 'team']).sum(numeric_only=True)
       .loc[lambda df: df['r'] > 100])
 
 
@@ -1885,7 +1885,7 @@ chained indexing expression, you can set the :ref:`option <options>`
 ``mode.chained_assignment`` to one of these values:
 
 * ``'warn'``, the default, means a ``SettingWithCopyWarning`` is printed.
-* ``'raise'`` means pandas will raise a ``SettingWithCopyException``
+* ``'raise'`` means pandas will raise a ``SettingWithCopyError``
   you have to deal with.
 * ``None`` will suppress the warnings entirely.
 
@@ -1953,7 +1953,7 @@ Last, the subsequent example will **not** work at all, and so should be avoided:
    >>> dfd.loc[0]['a'] = 1111
    Traceback (most recent call last)
         ...
-   SettingWithCopyException:
+   SettingWithCopyError:
         A value is trying to be set on a copy of a slice from a DataFrame.
         Try using .loc[row_index,col_indexer] = value instead
 
diff --git a/doc/source/user_guide/integer_na.rst b/doc/source/user_guide/integer_na.rst
index 2ce8bf23de824..fe732daccb649 100644
--- a/doc/source/user_guide/integer_na.rst
+++ b/doc/source/user_guide/integer_na.rst
@@ -29,7 +29,7 @@ Construction
 ------------
 
 pandas can represent integer data with possibly missing values using
-:class:`arrays.IntegerArray`. This is an :ref:`extension types <extending.extension-types>`
+:class:`arrays.IntegerArray`. This is an :ref:`extension type <extending.extension-types>`
 implemented within pandas.
 
 .. ipython:: python
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 9faef9b15bfb4..7a7e518e1f7db 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -26,11 +26,11 @@ The pandas I/O API is a set of top level ``reader`` functions accessed like
     text;`XML <https://www.w3.org/standards/xml/core>`__;:ref:`read_xml<io.read_xml>`;:ref:`to_xml<io.xml>`
     text; Local clipboard;:ref:`read_clipboard<io.clipboard>`;:ref:`to_clipboard<io.clipboard>`
     binary;`MS Excel <https://en.wikipedia.org/wiki/Microsoft_Excel>`__;:ref:`read_excel<io.excel_reader>`;:ref:`to_excel<io.excel_writer>`
-    binary;`OpenDocument <http://www.opendocumentformat.org>`__;:ref:`read_excel<io.ods>`;
+    binary;`OpenDocument <http://opendocumentformat.org>`__;:ref:`read_excel<io.ods>`;
     binary;`HDF5 Format <https://support.hdfgroup.org/HDF5/whatishdf5.html>`__;:ref:`read_hdf<io.hdf5>`;:ref:`to_hdf<io.hdf5>`
     binary;`Feather Format <https://github.com/wesm/feather>`__;:ref:`read_feather<io.feather>`;:ref:`to_feather<io.feather>`
     binary;`Parquet Format <https://parquet.apache.org/>`__;:ref:`read_parquet<io.parquet>`;:ref:`to_parquet<io.parquet>`
-    binary;`ORC Format <https://orc.apache.org/>`__;:ref:`read_orc<io.orc>`;
+    binary;`ORC Format <https://orc.apache.org/>`__;:ref:`read_orc<io.orc>`;:ref:`to_orc<io.orc>`
     binary;`Stata <https://en.wikipedia.org/wiki/Stata>`__;:ref:`read_stata<io.stata_reader>`;:ref:`to_stata<io.stata_writer>`
     binary;`SAS <https://en.wikipedia.org/wiki/SAS_(software)>`__;:ref:`read_sas<io.sas_reader>`;
     binary;`SPSS <https://en.wikipedia.org/wiki/SPSS>`__;:ref:`read_spss<io.spss_reader>`;
@@ -107,9 +107,10 @@ index_col : int, str, sequence of int / str, or False, optional, default ``None`
   string name or column index. If a sequence of int / str is given, a
   MultiIndex is used.
 
-  Note: ``index_col=False`` can be used to force pandas to *not* use the first
-  column as the index, e.g. when you have a malformed file with delimiters at
-  the end of each line.
+  .. note::
+     ``index_col=False`` can be used to force pandas to *not* use the first
+     column as the index, e.g. when you have a malformed file with delimiters at
+     the end of each line.
 
   The default value of ``None`` instructs pandas to guess. If the number of
   fields in the column header row is equal to the number of fields in the body
@@ -178,14 +179,24 @@ mangle_dupe_cols : boolean, default ``True``
   Passing in ``False`` will cause data to be overwritten if there are duplicate
   names in the columns.
 
+  .. deprecated:: 1.5.0
+     The argument was never implemented, and a new argument where the
+     renaming pattern can be specified will be added instead.
+
 General parsing configuration
 +++++++++++++++++++++++++++++
 
 dtype : Type name or dict of column -> type, default ``None``
-  Data type for data or columns. E.g. ``{'a': np.float64, 'b': np.int32}``
-  (unsupported with ``engine='python'``). Use ``str`` or ``object`` together
-  with suitable ``na_values`` settings to preserve and
-  not interpret dtype.
+  Data type for data or columns. E.g. ``{'a': np.float64, 'b': np.int32, 'c': 'Int64'}``
+  Use ``str`` or ``object`` together with suitable ``na_values`` settings to preserve
+  and not interpret dtype. If converters are specified, they will be applied INSTEAD
+  of dtype conversion.
+
+  .. versionadded:: 1.5.0
+
+     Support for defaultdict was added. Specify a defaultdict as input where
+     the default determines the dtype of the columns which are not explicitly
+     listed.
 engine : {``'c'``, ``'python'``, ``'pyarrow'``}
   Parser engine to use. The C and pyarrow engines are faster, while the python engine
   is currently more feature-complete. Multithreading is currently only supported by
@@ -278,7 +289,9 @@ parse_dates : boolean or list of ints or names or list of lists or dict, default
   * If ``[[1, 3]]`` -> combine columns 1 and 3 and parse as a single date
     column.
   * If ``{'foo': [1, 3]}`` -> parse columns 1, 3 as date and call result 'foo'.
-    A fast-path exists for iso8601-formatted dates.
+
+  .. note::
+     A fast-path exists for iso8601-formatted dates.
 infer_datetime_format : boolean, default ``False``
   If ``True`` and parse_dates is enabled for a column, attempt to infer the
   datetime format to speed up the processing.
@@ -549,7 +562,8 @@ This matches the behavior of :meth:`Categorical.set_categories`.
       df = pd.read_csv(StringIO(data), dtype="category")
       df.dtypes
       df["col3"]
-      df["col3"].cat.categories = pd.to_numeric(df["col3"].cat.categories)
+      new_categories = pd.to_numeric(df["col3"].cat.categories)
+      df["col3"] = df["col3"].cat.rename_categories(new_categories)
       df["col3"]
 
 
@@ -601,6 +615,10 @@ If the header is in a row other than the first, pass the row number to
 Duplicate names parsing
 '''''''''''''''''''''''
 
+  .. deprecated:: 1.5.0
+     ``mangle_dupe_cols`` was never implemented, and a new argument where the
+     renaming pattern can be specified will be added instead.
+
 If the file or header contains duplicate names, pandas will by default
 distinguish between them so as to prevent overwriting data:
 
@@ -611,27 +629,7 @@ distinguish between them so as to prevent overwriting data:
 
 There is no more duplicate data because ``mangle_dupe_cols=True`` by default,
 which modifies a series of duplicate columns 'X', ..., 'X' to become
-'X', 'X.1', ..., 'X.N'.  If ``mangle_dupe_cols=False``, duplicate data can
-arise:
-
-.. code-block:: ipython
-
-   In [2]: data = 'a,b,a\n0,1,2\n3,4,5'
-   In [3]: pd.read_csv(StringIO(data), mangle_dupe_cols=False)
-   Out[3]:
-      a  b  a
-   0  2  1  2
-   1  5  4  5
-
-To prevent users from encountering this problem with duplicate data, a ``ValueError``
-exception is raised if ``mangle_dupe_cols != True``:
-
-.. code-block:: ipython
-
-   In [2]: data = 'a,b,a\n0,1,2\n3,4,5'
-   In [3]: pd.read_csv(StringIO(data), mangle_dupe_cols=False)
-   ...
-   ValueError: Setting mangle_dupe_cols=False is not supported yet
+'X', 'X.1', ..., 'X.N'.
 
 .. _io.usecols:
 
@@ -837,13 +835,9 @@ input text data into ``datetime`` objects.
 The simplest case is to just pass in ``parse_dates=True``:
 
 .. ipython:: python
-   :suppress:
 
-   f = open("foo.csv", "w")
-   f.write("date,A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5")
-   f.close()
-
-.. ipython:: python
+   with open("foo.csv", mode="w") as f:
+       f.write("date,A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5")
 
    # Use a column as an index, and parse it as dates.
    df = pd.read_csv("foo.csv", index_col=0, parse_dates=True)
@@ -862,7 +856,6 @@ order) and the new column names will be the concatenation of the component
 column names:
 
 .. ipython:: python
-   :suppress:
 
    data = (
        "KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
@@ -876,9 +869,6 @@ column names:
    with open("tmp.csv", "w") as fh:
        fh.write(data)
 
-.. ipython:: python
-
-    print(open("tmp.csv").read())
     df = pd.read_csv("tmp.csv", header=None, parse_dates=[[1, 2], [1, 3]])
     df
 
@@ -1058,19 +1048,20 @@ While US date formats tend to be MM/DD/YYYY, many international formats use
 DD/MM/YYYY instead. For convenience, a ``dayfirst`` keyword is provided:
 
 .. ipython:: python
-   :suppress:
 
    data = "date,value,cat\n1/6/2000,5,a\n2/6/2000,10,b\n3/6/2000,15,c"
+   print(data)
    with open("tmp.csv", "w") as fh:
        fh.write(data)
 
-.. ipython:: python
-
-   print(open("tmp.csv").read())
-
    pd.read_csv("tmp.csv", parse_dates=[0])
    pd.read_csv("tmp.csv", dayfirst=True, parse_dates=[0])
 
+.. ipython:: python
+   :suppress:
+
+   os.remove("tmp.csv")
+
 Writing CSVs to binary file objects
 +++++++++++++++++++++++++++++++++++
 
@@ -1133,8 +1124,9 @@ For large numbers that have been written with a thousands separator, you can
 set the ``thousands`` keyword to a string of length 1 so that integers will be parsed
 correctly:
 
+By default, numbers with a thousands separator will be parsed as strings:
+
 .. ipython:: python
-   :suppress:
 
    data = (
        "ID|level|category\n"
@@ -1146,11 +1138,6 @@ correctly:
    with open("tmp.csv", "w") as fh:
        fh.write(data)
 
-By default, numbers with a thousands separator will be parsed as strings:
-
-.. ipython:: python
-
-    print(open("tmp.csv").read())
     df = pd.read_csv("tmp.csv", sep="|")
     df
 
@@ -1160,7 +1147,6 @@ The ``thousands`` keyword allows integers to be parsed correctly:
 
 .. ipython:: python
 
-    print(open("tmp.csv").read())
     df = pd.read_csv("tmp.csv", sep="|", thousands=",")
     df
 
@@ -1239,16 +1225,13 @@ as a ``Series``:
    ``read_csv`` instead.
 
 .. ipython:: python
-   :suppress:
+   :okwarning:
 
    data = "level\nPatient1,123000\nPatient2,23000\nPatient3,1234018"
 
    with open("tmp.csv", "w") as fh:
        fh.write(data)
 
-.. ipython:: python
-   :okwarning:
-
    print(open("tmp.csv").read())
 
    output = pd.read_csv("tmp.csv", squeeze=True)
@@ -1305,14 +1288,38 @@ You can elect to skip bad lines:
     0  1  2   3
     1  8  9  10
 
+Or pass a callable function to handle the bad line if ``engine="python"``.
+The bad line will be a list of strings that was split by the ``sep``:
+
+.. code-block:: ipython
+
+    In [29]: external_list = []
+
+    In [30]: def bad_lines_func(line):
+        ...:     external_list.append(line)
+        ...:     return line[-3:]
+
+    In [31]: pd.read_csv(StringIO(data), on_bad_lines=bad_lines_func, engine="python")
+    Out[31]:
+       a  b   c
+    0  1  2   3
+    1  5  6   7
+    2  8  9  10
+
+    In [32]: external_list
+    Out[32]: [4, 5, 6, 7]
+
+    .. versionadded:: 1.4.0
+
+
 You can also use the ``usecols`` parameter to eliminate extraneous column
 data that appear in some lines but not others:
 
 .. code-block:: ipython
 
-   In [30]: pd.read_csv(StringIO(data), usecols=[0, 1, 2])
+   In [33]: pd.read_csv(StringIO(data), usecols=[0, 1, 2])
 
-    Out[30]:
+    Out[33]:
        a  b   c
     0  1  2   3
     1  4  5   6
@@ -1324,9 +1331,9 @@ fields are filled with ``NaN``.
 
 .. code-block:: ipython
 
-   In [31]: pd.read_csv(StringIO(data), names=['a', 'b', 'c', 'd'])
+   In [34]: pd.read_csv(StringIO(data), names=['a', 'b', 'c', 'd'])
 
-   Out[31]:
+   Out[34]:
        a  b   c  d
     0  1  2   3  NaN
     1  4  5   6  7
@@ -1341,15 +1348,11 @@ The ``dialect`` keyword gives greater flexibility in specifying the file format.
 By default it uses the Excel dialect but you can specify either the dialect name
 or a :class:`python:csv.Dialect` instance.
 
-.. ipython:: python
-   :suppress:
-
-   data = "label1,label2,label3\n" 'index1,"a,c,e\n' "index2,b,d,f"
-
 Suppose you had data with unenclosed quotes:
 
 .. ipython:: python
 
+   data = "label1,label2,label3\n" 'index1,"a,c,e\n' "index2,b,d,f"
    print(data)
 
 By default, ``read_csv`` uses the Excel dialect and treats the double quote as
@@ -1425,10 +1428,10 @@ a different usage of the ``delimiter`` parameter:
   Can be used to specify the filler character of the fields
   if it is not spaces (e.g., '~').
 
+Consider a typical fixed-width data file:
+
 .. ipython:: python
-   :suppress:
 
-   f = open("bar.csv", "w")
    data1 = (
        "id8141    360.242940   149.910199   11950.7\n"
        "id1594    444.953632   166.985655   11788.4\n"
@@ -1436,14 +1439,8 @@ a different usage of the ``delimiter`` parameter:
        "id1230    413.836124   184.375703   11916.8\n"
        "id1948    502.953953   173.237159   12468.3"
    )
-   f.write(data1)
-   f.close()
-
-Consider a typical fixed-width data file:
-
-.. ipython:: python
-
-   print(open("bar.csv").read())
+   with open("bar.csv", "w") as f:
+       f.write(data1)
 
 In order to parse this file into a ``DataFrame``, we simply need to supply the
 column specifications to the ``read_fwf`` function along with the file name:
@@ -1499,19 +1496,15 @@ Indexes
 Files with an "implicit" index column
 +++++++++++++++++++++++++++++++++++++
 
-.. ipython:: python
-   :suppress:
-
-   f = open("foo.csv", "w")
-   f.write("A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5")
-   f.close()
-
 Consider a file with one less entry in the header than the number of data
 column:
 
 .. ipython:: python
 
-   print(open("foo.csv").read())
+   data = "A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5"
+   print(data)
+   with open("foo.csv", "w") as f:
+       f.write(data)
 
 In this special case, ``read_csv`` assumes that the first column is to be used
 as the index of the ``DataFrame``:
@@ -1543,7 +1536,10 @@ Suppose you have data indexed by two columns:
 
 .. ipython:: python
 
-   print(open("data/mindex_ex.csv").read())
+   data = 'year,indiv,zit,xit\n1977,"A",1.2,.6\n1977,"B",1.5,.5'
+   print(data)
+   with open("mindex_ex.csv", mode="w") as f:
+       f.write(data)
 
 The ``index_col`` argument to ``read_csv`` can take a list of
 column numbers to turn multiple columns into a ``MultiIndex`` for the index of the
@@ -1551,9 +1547,14 @@ returned object:
 
 .. ipython:: python
 
-   df = pd.read_csv("data/mindex_ex.csv", index_col=[0, 1])
+   df = pd.read_csv("mindex_ex.csv", index_col=[0, 1])
    df
-   df.loc[1978]
+   df.loc[1977]
+
+.. ipython:: python
+   :suppress:
+
+   os.remove("mindex_ex.csv")
 
 .. _io.multi_index_columns:
 
@@ -1577,20 +1578,18 @@ rows will skip the intervening rows.
 of multi-columns indices.
 
 .. ipython:: python
-   :suppress:
 
    data = ",a,a,a,b,c,c\n,q,r,s,t,u,v\none,1,2,3,4,5,6\ntwo,7,8,9,10,11,12"
-   fh = open("mi2.csv", "w")
-   fh.write(data)
-   fh.close()
-
-.. ipython:: python
+   print(data)
+   with open("mi2.csv", "w") as fh:
+       fh.write(data)
 
-   print(open("mi2.csv").read())
    pd.read_csv("mi2.csv", header=[0, 1], index_col=0)
 
-Note: If an ``index_col`` is not specified (e.g. you don't have an index, or wrote it
-with ``df.to_csv(..., index=False)``, then any ``names`` on the columns index will be *lost*.
+.. note::
+   If an ``index_col`` is not specified (e.g. you don't have an index, or wrote it
+   with ``df.to_csv(..., index=False)``, then any ``names`` on the columns index will
+   be *lost*.
 
 .. ipython:: python
    :suppress:
@@ -1608,16 +1607,16 @@ comma-separated) files, as pandas uses the :class:`python:csv.Sniffer`
 class of the csv module. For this, you have to specify ``sep=None``.
 
 .. ipython:: python
-   :suppress:
 
    df = pd.DataFrame(np.random.randn(10, 4))
-   df.to_csv("tmp.sv", sep="|")
-   df.to_csv("tmp2.sv", sep=":")
+   df.to_csv("tmp.csv", sep="|")
+   df.to_csv("tmp2.csv", sep=":")
+   pd.read_csv("tmp2.csv", sep=None, engine="python")
 
 .. ipython:: python
+   :suppress:
 
-   print(open("tmp2.sv").read())
-   pd.read_csv("tmp2.sv", sep=None, engine="python")
+   os.remove("tmp2.csv")
 
 .. _io.multiple_files:
 
@@ -1638,8 +1637,9 @@ rather than reading the entire file into memory, such as the following:
 
 .. ipython:: python
 
-   print(open("tmp.sv").read())
-   table = pd.read_csv("tmp.sv", sep="|")
+   df = pd.DataFrame(np.random.randn(10, 4))
+   df.to_csv("tmp.csv", sep="|")
+   table = pd.read_csv("tmp.csv", sep="|")
    table
 
 
@@ -1648,7 +1648,7 @@ value will be an iterable object of type ``TextFileReader``:
 
 .. ipython:: python
 
-   with pd.read_csv("tmp.sv", sep="|", chunksize=4) as reader:
+   with pd.read_csv("tmp.csv", sep="|", chunksize=4) as reader:
        reader
        for chunk in reader:
            print(chunk)
@@ -1661,14 +1661,13 @@ Specifying ``iterator=True`` will also return the ``TextFileReader`` object:
 
 .. ipython:: python
 
-   with pd.read_csv("tmp.sv", sep="|", iterator=True) as reader:
+   with pd.read_csv("tmp.csv", sep="|", iterator=True) as reader:
        reader.get_chunk(5)
 
 .. ipython:: python
    :suppress:
 
-   os.remove("tmp.sv")
-   os.remove("tmp2.sv")
+   os.remove("tmp.csv")
 
 Specifying the parser engine
 ''''''''''''''''''''''''''''
@@ -1827,7 +1826,7 @@ function takes a number of arguments. Only the first is required.
 * ``mode`` : Python write mode, default 'w'
 * ``encoding``: a string representing the encoding to use if the contents are
   non-ASCII, for Python versions prior to 3
-* ``line_terminator``: Character sequence denoting line end (default ``os.linesep``)
+* ``lineterminator``: Character sequence denoting line end (default ``os.linesep``)
 * ``quoting``: Set quoting rules as in csv module (default csv.QUOTE_MINIMAL). Note that if you have set a ``float_format`` then floats are converted to strings and csv.QUOTE_NONNUMERIC will treat them as non-numeric
 * ``quotechar``: Character used to quote fields (default '"')
 * ``doublequote``: Control quoting of ``quotechar`` in fields (default True)
@@ -2555,42 +2554,66 @@ Let's look at a few examples.
 
 Read a URL with no options:
 
-.. ipython:: python
+.. code-block:: ipython
 
-   url = "https://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list"
-   dfs = pd.read_html(url)
-   dfs
+   In [320]: "https://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list"
+   In [321]: pd.read_html(url)
+   Out[321]:
+   [                         Bank NameBank           CityCity StateSt  ...              Acquiring InstitutionAI Closing DateClosing FundFund
+    0                    Almena State Bank             Almena      KS  ...                          Equity Bank    October 23, 2020    10538
+    1           First City Bank of Florida  Fort Walton Beach      FL  ...            United Fidelity Bank, fsb    October 16, 2020    10537
+    2                 The First State Bank      Barboursville      WV  ...                       MVB Bank, Inc.       April 3, 2020    10536
+    3                   Ericson State Bank            Ericson      NE  ...           Farmers and Merchants Bank   February 14, 2020    10535
+    4     City National Bank of New Jersey             Newark      NJ  ...                      Industrial Bank    November 1, 2019    10534
+    ..                                 ...                ...     ...  ...                                  ...                 ...      ...
+    558                 Superior Bank, FSB           Hinsdale      IL  ...                Superior Federal, FSB       July 27, 2001     6004
+    559                Malta National Bank              Malta      OH  ...                    North Valley Bank         May 3, 2001     4648
+    560    First Alliance Bank & Trust Co.         Manchester      NH  ...  Southern New Hampshire Bank & Trust    February 2, 2001     4647
+    561  National State Bank of Metropolis         Metropolis      IL  ...              Banterra Bank of Marion   December 14, 2000     4646
+    562                   Bank of Honolulu           Honolulu      HI  ...                   Bank of the Orient    October 13, 2000     4645
+
+    [563 rows x 7 columns]]
 
 .. note::
 
-   The data from the above URL changes every Monday so the resulting data above
-   and the data below may be slightly different.
+   The data from the above URL changes every Monday so the resulting data above may be slightly different.
 
 Read in the content of the file from the above URL and pass it to ``read_html``
 as a string:
 
 .. ipython:: python
-   :suppress:
 
-   rel_path = os.path.join("..", "pandas", "tests", "io", "data", "html",
-                           "banklist.html")
-   file_path = os.path.abspath(rel_path)
+   html_str = """
+            <table>
+                <tr>
+                    <th>A</th>
+                    <th colspan="1">B</th>
+                    <th rowspan="1">C</th>
+                </tr>
+                <tr>
+                    <td>a</td>
+                    <td>b</td>
+                    <td>c</td>
+                </tr>
+            </table>
+        """
+
+   with open("tmp.html", "w") as f:
+       f.write(html_str)
+   df = pd.read_html("tmp.html")
+   df[0]
 
 .. ipython:: python
+   :suppress:
 
-   with open(file_path, "r") as f:
-       dfs = pd.read_html(f.read())
-   dfs
+   os.remove("tmp.html")
 
 You can even pass in an instance of ``StringIO`` if you so desire:
 
 .. ipython:: python
 
-   with open(file_path, "r") as f:
-       sio = StringIO(f.read())
-
-   dfs = pd.read_html(sio)
-   dfs
+   dfs = pd.read_html(StringIO(html_str))
+   dfs[0]
 
 .. note::
 
@@ -2598,7 +2621,7 @@ You can even pass in an instance of ``StringIO`` if you so desire:
    that having so many network-accessing functions slows down the documentation
    build. If you spot an error or an example that doesn't run, please do not
    hesitate to report it over on `pandas GitHub issues page
-   <https://www.github.com/pandas-dev/pandas/issues>`__.
+   <https://github.com/pandas-dev/pandas/issues>`__.
 
 
 Read a URL and match a table that contains specific text:
@@ -2708,6 +2731,30 @@ succeeds, the function will return*.
 
    dfs = pd.read_html(url, "Metcalf Bank", index_col=0, flavor=["lxml", "bs4"])
 
+Links can be extracted from cells along with the text using ``extract_links="all"``.
+
+.. ipython:: python
+
+    html_table = """
+    <table>
+      <tr>
+        <th>GitHub</th>
+      </tr>
+      <tr>
+        <td><a href="https://github.com/pandas-dev/pandas">pandas</a></td>
+      </tr>
+    </table>
+    """
+
+    df = pd.read_html(
+        html_table,
+        extract_links="all"
+    )[0]
+    df
+    df[("GitHub", None)]
+    df[("GitHub", None)].str[1]
+
+.. versionadded:: 1.5.0
 
 .. _io.html:
 
@@ -2724,77 +2771,48 @@ in the method ``to_string`` described above.
    brevity's sake. See :func:`~pandas.core.frame.DataFrame.to_html` for the
    full set of options.
 
-.. ipython:: python
-   :suppress:
+.. note::
 
-   def write_html(df, filename, *args, **kwargs):
-       static = os.path.abspath(os.path.join("source", "_static"))
-       with open(os.path.join(static, filename + ".html"), "w") as f:
-           df.to_html(f, *args, **kwargs)
+   In an HTML-rendering supported environment like a Jupyter Notebook, ``display(HTML(...))```
+   will render the raw HTML into the environment.
 
 .. ipython:: python
 
+   from IPython.display import display, HTML
+
    df = pd.DataFrame(np.random.randn(2, 2))
    df
-   print(df.to_html())  # raw html
-
-.. ipython:: python
-   :suppress:
-
-   write_html(df, "basic")
-
-HTML:
-
-.. raw:: html
-   :file: ../_static/basic.html
+   html = df.to_html()
+   print(html)  # raw html
+   display(HTML(html))
 
 The ``columns`` argument will limit the columns shown:
 
 .. ipython:: python
 
-   print(df.to_html(columns=[0]))
-
-.. ipython:: python
-   :suppress:
-
-   write_html(df, "columns", columns=[0])
-
-HTML:
-
-.. raw:: html
-   :file: ../_static/columns.html
+   html = df.to_html(columns=[0])
+   print(html)
+   display(HTML(html))
 
 ``float_format`` takes a Python callable to control the precision of floating
 point values:
 
 .. ipython:: python
 
-   print(df.to_html(float_format="{0:.10f}".format))
+   html = df.to_html(float_format="{0:.10f}".format)
+   print(html)
+   display(HTML(html))
 
-.. ipython:: python
-   :suppress:
-
-   write_html(df, "float_format", float_format="{0:.10f}".format)
-
-HTML:
-
-.. raw:: html
-   :file: ../_static/float_format.html
 
 ``bold_rows`` will make the row labels bold by default, but you can turn that
 off:
 
 .. ipython:: python
 
-   print(df.to_html(bold_rows=False))
-
-.. ipython:: python
-   :suppress:
-
-   write_html(df, "nobold", bold_rows=False)
+   html = df.to_html(bold_rows=False)
+   print(html)
+   display(HTML(html))
 
-.. raw:: html
-   :file: ../_static/nobold.html
 
 The ``classes`` argument provides the ability to give the resulting HTML
 table CSS classes. Note that these classes are *appended* to the existing
@@ -2815,17 +2833,9 @@ that contain URLs.
            "url": ["https://www.python.org/", "https://pandas.pydata.org/"],
        }
    )
-   print(url_df.to_html(render_links=True))
-
-.. ipython:: python
-   :suppress:
-
-   write_html(url_df, "render_links", render_links=True)
-
-HTML:
-
-.. raw:: html
-   :file: ../_static/render_links.html
+   html = url_df.to_html(render_links=True)
+   print(html)
+   display(HTML(html))
 
 Finally, the ``escape`` argument allows you to control whether the
 "<", ">" and "&" characters escaped in the resulting HTML (by default it is
@@ -2835,30 +2845,21 @@ Finally, the ``escape`` argument allows you to control whether the
 
    df = pd.DataFrame({"a": list("&<>"), "b": np.random.randn(3)})
 
-
-.. ipython:: python
-   :suppress:
-
-   write_html(df, "escape")
-   write_html(df, "noescape", escape=False)
-
 Escaped:
 
 .. ipython:: python
 
-   print(df.to_html())
-
-.. raw:: html
-   :file: ../_static/escape.html
+   html = df.to_html()
+   print(html)
+   display(HTML(html))
 
 Not escaped:
 
 .. ipython:: python
 
-   print(df.to_html(escape=False))
-
-.. raw:: html
-   :file: ../_static/noescape.html
+   html = df.to_html(escape=False)
+   print(html)
+   display(HTML(html))
 
 .. note::
 
@@ -3038,13 +3039,10 @@ Read in the content of the "books.xml" file and pass it to ``read_xml``
 as a string:
 
 .. ipython:: python
-   :suppress:
 
-   rel_path = os.path.join("..", "pandas", "tests", "io", "data", "xml",
-                           "books.xml")
-   file_path = os.path.abspath(rel_path)
-
-.. ipython:: python
+   file_path = "books.xml"
+   with open(file_path, "w") as f:
+       f.write(xml)
 
    with open(file_path, "r") as f:
        df = pd.read_xml(f.read())
@@ -3069,15 +3067,15 @@ Read in the content of the "books.xml" as instance of ``StringIO`` or
    df = pd.read_xml(bio)
    df
 
-Even read XML from AWS S3 buckets such as Python Software Foundation's IRS 990 Form:
+Even read XML from AWS S3 buckets such as NIH NCBI PMC Article Datasets providing
+Biomedical and Life Science Jorurnals:
 
 .. ipython:: python
    :okwarning:
 
    df = pd.read_xml(
-       "s3://irs-form-990/201923199349319487_public.xml",
-       xpath=".//irs:Form990PartVIISectionAGrp",
-       namespaces={"irs": "http://www.irs.gov/efile"}
+       "s3://pmc-oa-opendata/oa_comm/xml/all/PMC1236943.xml",
+       xpath=".//journal-meta",
    )
    df
 
@@ -3104,6 +3102,11 @@ Specify only elements or only attributes to parse:
    df = pd.read_xml(file_path, attrs_only=True)
    df
 
+.. ipython:: python
+   :suppress:
+
+   os.remove("books.xml")
+
 XML documents can have namespaces with prefixes and default namespaces without
 prefixes both of which are denoted with a special attribute ``xmlns``. In order
 to parse by node under a namespace context, ``xpath`` must reference a prefix.
@@ -3266,6 +3269,45 @@ output (as shown below for demonstration) for easier parse into ``DataFrame``:
    df = pd.read_xml(xml, stylesheet=xsl)
    df
 
+For very large XML files that can range in hundreds of megabytes to gigabytes, :func:`pandas.read_xml`
+supports parsing such sizeable files using `lxml's iterparse`_ and `etree's iterparse`_
+which are memory-efficient methods to iterate through an XML tree and extract specific elements and attributes.
+without holding entire tree in memory.
+
+    .. versionadded:: 1.5.0
+
+.. _`lxml's iterparse`: https://lxml.de/3.2/parsing.html#iterparse-and-iterwalk
+.. _`etree's iterparse`: https://docs.python.org/3/library/xml.etree.elementtree.html#xml.etree.ElementTree.iterparse
+
+To use this feature, you must pass a physical XML file path into ``read_xml`` and use the ``iterparse`` argument.
+Files should not be compressed or point to online sources but stored on local disk. Also, ``iterparse`` should be
+a dictionary where the key is the repeating nodes in document (which become the rows) and the value is a list of
+any element or attribute that is a descendant (i.e., child, grandchild) of repeating node. Since XPath is not
+used in this method, descendants do not need to share same relationship with one another. Below shows example
+of reading in Wikipedia's very large (12 GB+) latest article data dump.
+
+.. code-block:: ipython
+
+    In [1]: df = pd.read_xml(
+    ...         "/path/to/downloaded/enwikisource-latest-pages-articles.xml",
+    ...         iterparse = {"page": ["title", "ns", "id"]}
+    ...     )
+    ...     df
+    Out[2]:
+                                                         title   ns        id
+    0                                       Gettysburg Address    0     21450
+    1                                                Main Page    0     42950
+    2                            Declaration by United Nations    0      8435
+    3             Constitution of the United States of America    0      8435
+    4                     Declaration of Independence (Israel)    0     17858
+    ...                                                    ...  ...       ...
+    3578760               Page:Black cat 1897 07 v2 n10.pdf/17  104    219649
+    3578761               Page:Black cat 1897 07 v2 n10.pdf/43  104    219649
+    3578762               Page:Black cat 1897 07 v2 n10.pdf/44  104    219649
+    3578763      The History of Tom Jones, a Foundling/Book IX    0  12084291
+    3578764  Page:Shakespeare of Stratford (1926) Yale.djvu/91  104     21450
+
+    [3578765 rows x 3 columns]
 
 .. _io.xml:
 
@@ -3464,7 +3506,7 @@ See the :ref:`cookbook<cookbook.excel>` for some advanced strategies.
    **Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.**
    This is no longer supported, switch to using ``openpyxl`` instead.
 
-   Attempting to use the the ``xlwt`` engine will raise a ``FutureWarning``
+   Attempting to use the ``xlwt`` engine will raise a ``FutureWarning``
    unless the option :attr:`io.excel.xls.writer` is set to ``"xlwt"``.
    While this option is now deprecated and will also raise a ``FutureWarning``,
    it can be globally set and the warning suppressed. Users are recommended to
@@ -3654,6 +3696,10 @@ should be passed to ``index_col`` and ``header``:
 
    os.remove("path_to_file.xlsx")
 
+Missing values in columns specified in ``index_col`` will be forward filled to
+allow roundtripping with ``to_excel`` for ``merged_cells=True``. To avoid forward
+filling the missing values use ``set_index`` after reading the data instead of
+``index_col``.
 
 Parsing specific columns
 ++++++++++++++++++++++++
@@ -4968,7 +5014,7 @@ control compression: ``complevel`` and ``complib``.
     rates but is somewhat slow.
   - `lzo <https://www.oberhumer.com/opensource/lzo/>`_: Fast
     compression and decompression.
-  - `bzip2 <http://bzip.org/>`_: Good compression rates.
+  - `bzip2 <https://sourceware.org/bzip2/>`_: Good compression rates.
   - `blosc <https://www.blosc.org/>`_: Fast compression and
     decompression.
 
@@ -4977,10 +5023,10 @@ control compression: ``complevel`` and ``complib``.
     - `blosc:blosclz <https://www.blosc.org/>`_ This is the
       default compressor for ``blosc``
     - `blosc:lz4
-      <https://fastcompression.blogspot.dk/p/lz4.html>`_:
+      <https://fastcompression.blogspot.com/p/lz4.html>`_:
       A compact, very popular and fast compressor.
     - `blosc:lz4hc
-      <https://fastcompression.blogspot.dk/p/lz4.html>`_:
+      <https://fastcompression.blogspot.com/p/lz4.html>`_:
       A tweaked version of LZ4, produces better
       compression ratios at the expense of speed.
     - `blosc:snappy <https://google.github.io/snappy/>`_:
@@ -5401,7 +5447,7 @@ See the documentation for `pyarrow <https://arrow.apache.org/docs/python/>`__ an
 .. note::
 
    These engines are very similar and should read/write nearly identical parquet format files.
-   Currently ``pyarrow`` does not support timedelta data, ``fastparquet>=0.1.4`` supports timezone aware datetimes.
+   ``pyarrow>=8.0.0`` supports timedelta data, ``fastparquet>=0.1.4`` supports timezone aware datetimes.
    These libraries differ by having different underlying dependencies (``fastparquet`` by using ``numba``, while ``pyarrow`` uses a c-library).
 
 .. ipython:: python
@@ -5548,13 +5594,64 @@ ORC
 .. versionadded:: 1.0.0
 
 Similar to the :ref:`parquet <io.parquet>` format, the `ORC Format <https://orc.apache.org/>`__ is a binary columnar serialization
-for data frames. It is designed to make reading data frames efficient. pandas provides *only* a reader for the
-ORC format, :func:`~pandas.read_orc`. This requires the `pyarrow <https://arrow.apache.org/docs/python/>`__ library.
+for data frames. It is designed to make reading data frames efficient. pandas provides both the reader and the writer for the
+ORC format, :func:`~pandas.read_orc` and :func:`~pandas.DataFrame.to_orc`. This requires the `pyarrow <https://arrow.apache.org/docs/python/>`__ library.
 
 .. warning::
 
    * It is *highly recommended* to install pyarrow using conda due to some issues occurred by pyarrow.
-   * :func:`~pandas.read_orc` is not supported on Windows yet, you can find valid environments on :ref:`install optional dependencies <install.warn_orc>`.
+   * :func:`~pandas.DataFrame.to_orc` requires pyarrow>=7.0.0.
+   * :func:`~pandas.read_orc` and :func:`~pandas.DataFrame.to_orc` are not supported on Windows yet, you can find valid environments on :ref:`install optional dependencies <install.warn_orc>`.
+   * For supported dtypes please refer to `supported ORC features in Arrow <https://arrow.apache.org/docs/cpp/orc.html#data-types>`__.
+   * Currently timezones in datetime columns are not preserved when a dataframe is converted into ORC files.
+
+.. ipython:: python
+
+   df = pd.DataFrame(
+       {
+           "a": list("abc"),
+           "b": list(range(1, 4)),
+           "c": np.arange(4.0, 7.0, dtype="float64"),
+           "d": [True, False, True],
+           "e": pd.date_range("20130101", periods=3),
+       }
+   )
+
+   df
+   df.dtypes
+
+Write to an orc file.
+
+.. ipython:: python
+   :okwarning:
+
+   df.to_orc("example_pa.orc", engine="pyarrow")
+
+Read from an orc file.
+
+.. ipython:: python
+   :okwarning:
+
+   result = pd.read_orc("example_pa.orc")
+
+   result.dtypes
+
+Read only certain columns of an orc file.
+
+.. ipython:: python
+
+   result = pd.read_orc(
+       "example_pa.orc",
+       columns=["a", "b"],
+   )
+   result.dtypes
+
+
+.. ipython:: python
+   :suppress:
+
+   os.remove("example_pa.orc")
+
 
 .. _io.sql:
 
@@ -5564,7 +5661,7 @@ SQL queries
 The :mod:`pandas.io.sql` module provides a collection of query wrappers to both
 facilitate data retrieval and to reduce dependency on DB-specific API. Database abstraction
 is provided by SQLAlchemy if installed. In addition you will need a driver library for
-your database. Examples of such drivers are `psycopg2 <http://initd.org/psycopg/>`__
+your database. Examples of such drivers are `psycopg2 <https://www.psycopg.org/>`__
 for PostgreSQL or `pymysql <https://github.com/PyMySQL/PyMySQL>`__ for MySQL.
 For `SQLite <https://docs.python.org/3/library/sqlite3.html>`__ this is
 included in Python's standard library by default.
@@ -5596,7 +5693,7 @@ The key functions are:
     the provided input (database table name or sql query).
     Table names do not need to be quoted if they have special characters.
 
-In the following example, we use the `SQlite <https://www.sqlite.org/>`__ SQL database
+In the following example, we use the `SQlite <https://www.sqlite.org/index.html>`__ SQL database
 engine. You can use a temporary SQLite database where data are stored in
 "memory".
 
@@ -5626,9 +5723,9 @@ for an explanation of how the database connection is handled.
 
 .. warning::
 
-	When you open a connection to a database you are also responsible for closing it.
-	Side effects of leaving a connection open may include locking the database or
-	other breaking behaviour.
+        When you open a connection to a database you are also responsible for closing it.
+        Side effects of leaving a connection open may include locking the database or
+        other breaking behaviour.
 
 Writing DataFrames
 ''''''''''''''''''
@@ -5648,7 +5745,6 @@ the database using :func:`~pandas.DataFrame.to_sql`.
 
 
 .. ipython:: python
-   :suppress:
 
    import datetime
 
@@ -5661,10 +5757,8 @@ the database using :func:`~pandas.DataFrame.to_sql`.
 
    data = pd.DataFrame(d, columns=c)
 
-.. ipython:: python
-
-    data
-    data.to_sql("data", engine)
+   data
+   data.to_sql("data", engine)
 
 With some databases, writing large DataFrames can result in errors due to
 packet size limitations being exceeded. This can be avoided by setting the
@@ -5760,7 +5854,7 @@ Possible values are:
   specific backend dialect features.
 
 Example of a callable using PostgreSQL `COPY clause
-<https://www.postgresql.org/docs/current/static/sql-copy.html>`__::
+<https://www.postgresql.org/docs/current/sql-copy.html>`__::
 
   # Alternative to_sql() *method* for DBs that support COPY FROM
   import csv
@@ -6022,7 +6116,7 @@ pandas integrates with this external package. if ``pandas-gbq`` is installed, yo
 use the pandas methods ``pd.read_gbq`` and ``DataFrame.to_gbq``, which will call the
 respective functions from ``pandas-gbq``.
 
-Full documentation can be found `here <https://pandas-gbq.readthedocs.io/>`__.
+Full documentation can be found `here <https://pandas-gbq.readthedocs.io/en/latest/>`__.
 
 .. _io.stata:
 
@@ -6230,7 +6324,7 @@ Obtain an iterator and read an XPORT file 100,000 lines at a time:
 The specification_ for the xport file format is available from the SAS
 web site.
 
-.. _specification: https://support.sas.com/techsup/technote/ts140.pdf
+.. _specification: https://support.sas.com/content/dam/SAS/support/en/technical-papers/record-layout-of-a-sas-version-5-or-6-data-set-in-sas-transport-xport-format.pdf
 
 No official documentation is available for the SAS7BDAT format.
 
@@ -6272,7 +6366,7 @@ avoid converting categorical columns into ``pd.Categorical``:
 
 More information about the SAV and ZSAV file formats is available here_.
 
-.. _here: https://www.ibm.com/support/knowledgecenter/en/SSLVMB_22.0.0/com.ibm.spss.statistics.help/spss/base/savedatatypes.htm
+.. _here: https://www.ibm.com/docs/en/spss-statistics/22.0.0
 
 .. _io.other:
 
@@ -6290,7 +6384,7 @@ xarray_ provides data structures inspired by the pandas ``DataFrame`` for workin
 with multi-dimensional datasets, with a focus on the netCDF file format and
 easy conversion to and from pandas.
 
-.. _xarray: https://xarray.pydata.org/
+.. _xarray: https://xarray.pydata.org/en/stable/
 
 .. _io.perf:
 
diff --git a/doc/source/user_guide/missing_data.rst b/doc/source/user_guide/missing_data.rst
index 1621b37f31b23..3052ee3001681 100644
--- a/doc/source/user_guide/missing_data.rst
+++ b/doc/source/user_guide/missing_data.rst
@@ -470,7 +470,7 @@ at the new values.
    interp_s = ser.reindex(new_index).interpolate(method="pchip")
    interp_s[49:51]
 
-.. _scipy: https://www.scipy.org
+.. _scipy: https://scipy.org/
 .. _documentation: https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation
 .. _guide: https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html
 
@@ -580,7 +580,7 @@ String/regular expression replacement
    backslashes than strings without this prefix. Backslashes in raw strings
    will be interpreted as an escaped backslash, e.g., ``r'\' == '\\'``. You
    should `read about them
-   <https://docs.python.org/3/reference/lexical_analysis.html#string-literals>`__
+   <https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals>`__
    if this is unclear.
 
 Replace the '.' with ``NaN`` (str -> str):
diff --git a/doc/source/user_guide/options.rst b/doc/source/user_guide/options.rst
index 93448dae578c9..c7f5d3ddf66d3 100644
--- a/doc/source/user_guide/options.rst
+++ b/doc/source/user_guide/options.rst
@@ -8,8 +8,8 @@ Options and settings
 
 Overview
 --------
-pandas has an options system that lets you customize some aspects of its behaviour,
-display-related options being those the user is most likely to adjust.
+pandas has an options API configure and customize global behavior related to
+:class:`DataFrame` display, data behavior and more.
 
 Options have a full "dotted-style", case-insensitive name (e.g. ``display.max_rows``).
 You can get/set options directly as attributes of the top-level ``options`` attribute:
@@ -31,10 +31,12 @@ namespace:
 * :func:`~pandas.option_context` - execute a codeblock with a set of options
   that revert to prior settings after execution.
 
-**Note:** Developers can check out `pandas/core/config_init.py <https://github.com/pandas-dev/pandas/blob/master/pandas/core/config_init.py>`_ for more information.
+.. note::
+
+   Developers can check out `pandas/core/config_init.py <https://github.com/pandas-dev/pandas/blob/main/pandas/core/config_init.py>`_ for more information.
 
 All of the functions above accept a regexp pattern (``re.search`` style) as an argument,
-and so passing in a substring will work - as long as it is unambiguous:
+to match an unambiguous substring:
 
 .. ipython:: python
 
@@ -51,17 +53,13 @@ The following will **not work** because it matches multiple option names, e.g.
 .. ipython:: python
    :okexcept:
 
-   try:
-       pd.get_option("max")
-   except KeyError as e:
-       print(e)
+   pd.get_option("max")
 
 
-**Note:** Using this form of shorthand may cause your code to break if new options with similar names are added in future versions.
+.. warning::
 
+    Using this form of shorthand may cause your code to break if new options with similar names are added in future versions.
 
-You can get a list of available options and their descriptions with ``describe_option``. When called
-with no argument ``describe_option`` will print out the descriptions for all available options.
 
 .. ipython:: python
    :suppress:
@@ -69,6 +67,18 @@ with no argument ``describe_option`` will print out the descriptions for all ava
 
    pd.reset_option("all")
 
+.. _options.available:
+
+Available options
+-----------------
+
+You can get a list of available options and their descriptions with :func:`~pandas.describe_option`. When called
+with no argument :func:`~pandas.describe_option` will print out the descriptions for all available options.
+
+.. ipython:: python
+
+   pd.describe_option()
+
 Getting and setting options
 ---------------------------
 
@@ -82,9 +92,11 @@ are available from the pandas namespace.  To change an option, call
    pd.set_option("mode.sim_interactive", True)
    pd.get_option("mode.sim_interactive")
 
-**Note:** The option 'mode.sim_interactive' is mostly used for debugging purposes.
+.. note::
+
+   The option ``'mode.sim_interactive'`` is mostly used for debugging purposes.
 
-All options also have a default value, and you can use ``reset_option`` to do just that:
+You can use :func:`~pandas.reset_option` to revert to a setting's default value
 
 .. ipython:: python
    :suppress:
@@ -108,7 +120,7 @@ It's also possible to reset multiple options at once (using a regex):
    pd.reset_option("^display")
 
 
-``option_context`` context manager has been exposed through
+:func:`~pandas.option_context` context manager has been exposed through
 the top-level API, allowing you to execute code with given option values. Option values
 are restored automatically when you exit the ``with`` block:
 
@@ -124,7 +136,9 @@ are restored automatically when you exit the ``with`` block:
 Setting startup options in Python/IPython environment
 -----------------------------------------------------
 
-Using startup scripts for the Python/IPython environment to import pandas and set options makes working with pandas more efficient.  To do this, create a .py or .ipy script in the startup directory of the desired profile.  An example where the startup folder is in a default IPython profile can be found at:
+Using startup scripts for the Python/IPython environment to import pandas and set options makes working with pandas more efficient.
+To do this, create a ``.py`` or ``.ipy`` script in the startup directory of the desired profile.
+An example where the startup folder is in a default IPython profile can be found at:
 
 .. code-block:: none
 
@@ -144,10 +158,10 @@ More information can be found in the `IPython documentation
 
 Frequently used options
 -----------------------
-The following is a walk-through of the more frequently used display options.
+The following is a demonstrates the more frequently used display options.
 
 ``display.max_rows`` and ``display.max_columns`` sets the maximum number
-of rows and columns displayed when a frame is pretty-printed.  Truncated
+of rows and columns displayed when a frame is pretty-printed. Truncated
 lines are replaced by an ellipsis.
 
 .. ipython:: python
@@ -175,8 +189,8 @@ determines how many rows are shown in the truncated repr.
    pd.reset_option("display.max_rows")
    pd.reset_option("display.min_rows")
 
-``display.expand_frame_repr`` allows for the representation of
-dataframes to stretch across pages, wrapped over the full column vs row-wise.
+``display.expand_frame_repr`` allows for the representation of a
+:class:`DataFrame` to stretch across pages, wrapped over the all the columns.
 
 .. ipython:: python
 
@@ -187,8 +201,8 @@ dataframes to stretch across pages, wrapped over the full column vs row-wise.
    df
    pd.reset_option("expand_frame_repr")
 
-``display.large_repr`` lets you select whether to display dataframes that exceed
-``max_columns`` or ``max_rows`` as a truncated frame, or as a summary.
+``display.large_repr`` displays a :class:`DataFrame` that exceed
+``max_columns`` or ``max_rows`` as a truncated frame or summary.
 
 .. ipython:: python
 
@@ -220,8 +234,8 @@ of this length or longer will be truncated with an ellipsis.
    df
    pd.reset_option("max_colwidth")
 
-``display.max_info_columns`` sets a threshold for when by-column info
-will be given.
+``display.max_info_columns`` sets a threshold for the number of columns
+displayed when calling :meth:`~pandas.DataFrame.info`.
 
 .. ipython:: python
 
@@ -232,10 +246,10 @@ will be given.
    df.info()
    pd.reset_option("max_info_columns")
 
-``display.max_info_rows``: ``df.info()`` will usually show null-counts for each column.
-For large frames this can be quite slow. ``max_info_rows`` and ``max_info_cols``
-limit this null check only to frames with smaller dimensions then specified. Note that you
-can specify the option ``df.info(null_counts=True)`` to override on showing a particular frame.
+``display.max_info_rows``: :meth:`~pandas.DataFrame.info` will usually show null-counts for each column.
+For a large :class:`DataFrame`, this can be quite slow. ``max_info_rows`` and ``max_info_cols``
+limit this null check to the specified rows and columns respectively. The :meth:`~pandas.DataFrame.info`
+keyword argument ``null_counts=True`` will override this.
 
 .. ipython:: python
 
@@ -248,7 +262,6 @@ can specify the option ``df.info(null_counts=True)`` to override on showing a pa
    pd.reset_option("max_info_rows")
 
 ``display.precision`` sets the output display precision in terms of decimal places.
-This is only a suggestion.
 
 .. ipython:: python
 
@@ -258,8 +271,8 @@ This is only a suggestion.
    pd.set_option("display.precision", 4)
    df
 
-``display.chop_threshold`` sets at what level pandas rounds to zero when
-it displays a Series of DataFrame. This setting does not change the
+``display.chop_threshold`` sets the rounding threshold to zero when displaying a
+:class:`Series` or :class:`DataFrame`. This setting does not change the
 precision at which the number is stored.
 
 .. ipython:: python
@@ -272,7 +285,7 @@ precision at which the number is stored.
    pd.reset_option("chop_threshold")
 
 ``display.colheader_justify`` controls the justification of the headers.
-The options are 'right', and 'left'.
+The options are ``'right'``, and ``'left'``.
 
 .. ipython:: python
 
@@ -288,238 +301,6 @@ The options are 'right', and 'left'.
    pd.reset_option("colheader_justify")
 
 
-
-.. _options.available:
-
-Available options
------------------
-
-======================================= ============ ==================================
-Option                                  Default      Function
-======================================= ============ ==================================
-display.chop_threshold                  None         If set to a float value, all float
-                                                     values smaller then the given
-                                                     threshold will be displayed as
-                                                     exactly 0 by repr and friends.
-display.colheader_justify               right        Controls the justification of
-                                                     column headers. used by DataFrameFormatter.
-display.column_space                    12           No description available.
-display.date_dayfirst                   False        When True, prints and parses dates
-                                                     with the day first, eg 20/01/2005
-display.date_yearfirst                  False        When True, prints and parses dates
-                                                     with the year first, eg 2005/01/20
-display.encoding                        UTF-8        Defaults to the detected encoding
-                                                     of the console. Specifies the encoding
-                                                     to be used for strings returned by
-                                                     to_string, these are generally strings
-                                                     meant to be displayed on the console.
-display.expand_frame_repr               True         Whether to print out the full DataFrame
-                                                     repr for wide DataFrames across
-                                                     multiple lines, ``max_columns`` is
-                                                     still respected, but the output will
-                                                     wrap-around across multiple "pages"
-                                                     if its width exceeds ``display.width``.
-display.float_format                    None         The callable should accept a floating
-                                                     point number and return a string with
-                                                     the desired format of the number.
-                                                     This is used in some places like
-                                                     SeriesFormatter.
-                                                     See core.format.EngFormatter for an example.
-display.large_repr                      truncate     For DataFrames exceeding max_rows/max_cols,
-                                                     the repr (and HTML repr) can show
-                                                     a truncated table (the default),
-                                                     or switch to the view from df.info()
-                                                     (the behaviour in earlier versions of pandas).
-                                                     allowable settings, ['truncate', 'info']
-display.latex.repr                      False        Whether to produce a latex DataFrame
-                                                     representation for Jupyter frontends
-                                                     that support it.
-display.latex.escape                    True         Escapes special characters in DataFrames, when
-                                                     using the to_latex method.
-display.latex.longtable                 False        Specifies if the to_latex method of a DataFrame
-                                                     uses the longtable format.
-display.latex.multicolumn               True         Combines columns when using a MultiIndex
-display.latex.multicolumn_format        'l'          Alignment of multicolumn labels
-display.latex.multirow                  False        Combines rows when using a MultiIndex.
-                                                     Centered instead of top-aligned,
-                                                     separated by clines.
-display.max_columns                     0 or 20      max_rows and max_columns are used
-                                                     in __repr__() methods to decide if
-                                                     to_string() or info() is used to
-                                                     render an object to a string.  In
-                                                     case Python/IPython is running in
-                                                     a terminal this is set to 0 by default and
-                                                     pandas will correctly auto-detect
-                                                     the width of the terminal and switch to
-                                                     a smaller format in case all columns
-                                                     would not fit vertically. The IPython
-                                                     notebook, IPython qtconsole, or IDLE
-                                                     do not run in a terminal and hence
-                                                     it is not possible to do correct
-                                                     auto-detection, in which case the default
-                                                     is set to 20. 'None' value means unlimited.
-display.max_colwidth                    50           The maximum width in characters of
-                                                     a column in the repr of a pandas
-                                                     data structure. When the column overflows,
-                                                     a "..." placeholder is embedded in
-                                                     the output. 'None' value means unlimited.
-display.max_info_columns                100          max_info_columns is used in DataFrame.info
-                                                     method to decide if per column information
-                                                     will be printed.
-display.max_info_rows                   1690785      df.info() will usually show null-counts
-                                                     for each column. For large frames
-                                                     this can be quite slow. max_info_rows
-                                                     and max_info_cols limit this null
-                                                     check only to frames with smaller
-                                                     dimensions then specified.
-display.max_rows                        60           This sets the maximum number of rows
-                                                     pandas should output when printing
-                                                     out various output. For example,
-                                                     this value determines whether the
-                                                     repr() for a dataframe prints out
-                                                     fully or just a truncated or summary repr.
-                                                     'None' value means unlimited.
-display.min_rows                        10           The numbers of rows to show in a truncated
-                                                     repr (when ``max_rows`` is exceeded). Ignored
-                                                     when ``max_rows`` is set to None or 0. When set
-                                                     to None, follows the value of ``max_rows``.
-display.max_seq_items                   100          when pretty-printing a long sequence,
-                                                     no more then ``max_seq_items`` will
-                                                     be printed. If items are omitted,
-                                                     they will be denoted by the addition
-                                                     of "..." to the resulting string.
-                                                     If set to None, the number of items
-                                                     to be printed is unlimited.
-display.memory_usage                    True         This specifies if the memory usage of
-                                                     a DataFrame should be displayed when the
-                                                     df.info() method is invoked.
-display.multi_sparse                    True         "Sparsify" MultiIndex display (don't
-                                                     display repeated elements in outer
-                                                     levels within groups)
-display.notebook_repr_html              True         When True, IPython notebook will
-                                                     use html representation for
-                                                     pandas objects (if it is available).
-display.pprint_nest_depth               3            Controls the number of nested levels
-                                                     to process when pretty-printing
-display.precision                       6            Floating point output precision in
-                                                     terms of number of places after the
-                                                     decimal, for regular formatting as well
-                                                     as scientific notation. Similar to
-                                                     numpy's ``precision`` print option
-display.show_dimensions                 truncate     Whether to print out dimensions
-                                                     at the end of DataFrame repr.
-                                                     If 'truncate' is specified, only
-                                                     print out the dimensions if the
-                                                     frame is truncated (e.g. not display
-                                                     all rows and/or columns)
-display.width                           80           Width of the display in characters.
-                                                     In case Python/IPython is running in
-                                                     a terminal this can be set to None
-                                                     and pandas will correctly auto-detect
-                                                     the width. Note that the IPython notebook,
-                                                     IPython qtconsole, or IDLE do not run in a
-                                                     terminal and hence it is not possible
-                                                     to correctly detect the width.
-display.html.table_schema               False        Whether to publish a Table Schema
-                                                     representation for frontends that
-                                                     support it.
-display.html.border                     1            A ``border=value`` attribute is
-                                                     inserted in the ``<table>`` tag
-                                                     for the DataFrame HTML repr.
-display.html.use_mathjax                True         When True, Jupyter notebook will process
-                                                     table contents using MathJax, rendering
-                                                     mathematical expressions enclosed by the
-                                                     dollar symbol.
-display.max_dir_items                   100          The number of columns from a dataframe that
-                                                     are added to dir. These columns can then be
-                                                     suggested by tab completion. 'None' value means
-                                                     unlimited.
-io.excel.xls.writer                     xlwt         The default Excel writer engine for
-                                                     'xls' files.
-
-                                                     .. deprecated:: 1.2.0
-
-                                                        As `xlwt <https://pypi.org/project/xlwt/>`__
-                                                        package is no longer maintained, the ``xlwt``
-                                                        engine will be removed in a future version of
-                                                        pandas. Since this is the only engine in pandas
-                                                        that supports writing to ``.xls`` files,
-                                                        this option will also be removed.
-
-io.excel.xlsm.writer                    openpyxl     The default Excel writer engine for
-                                                     'xlsm' files. Available options:
-                                                     'openpyxl' (the default).
-io.excel.xlsx.writer                    openpyxl     The default Excel writer engine for
-                                                     'xlsx' files.
-io.hdf.default_format                   None         default format writing format, if
-                                                     None, then put will default to
-                                                     'fixed' and append will default to
-                                                     'table'
-io.hdf.dropna_table                     True         drop ALL nan rows when appending
-                                                     to a table
-io.parquet.engine                       None         The engine to use as a default for
-                                                     parquet reading and writing. If None
-                                                     then try 'pyarrow' and 'fastparquet'
-io.sql.engine                           None         The engine to use as a default for
-                                                     sql reading and writing, with SQLAlchemy
-                                                     as a higher level interface. If None
-                                                     then try 'sqlalchemy'
-mode.chained_assignment                 warn         Controls ``SettingWithCopyWarning``:
-                                                     'raise', 'warn', or None. Raise an
-                                                     exception, warn, or no action if
-                                                     trying to use :ref:`chained assignment <indexing.evaluation_order>`.
-mode.sim_interactive                    False        Whether to simulate interactive mode
-                                                     for purposes of testing.
-mode.use_inf_as_na                      False        True means treat None, NaN, -INF,
-                                                     INF as NA (old way), False means
-                                                     None and NaN are null, but INF, -INF
-                                                     are not NA (new way).
-compute.use_bottleneck                  True         Use the bottleneck library to accelerate
-                                                     computation if it is installed.
-compute.use_numexpr                     True         Use the numexpr library to accelerate
-                                                     computation if it is installed.
-plotting.backend                        matplotlib   Change the plotting backend to a different
-                                                     backend than the current matplotlib one.
-                                                     Backends can be implemented as third-party
-                                                     libraries implementing the pandas plotting
-                                                     API. They can use other plotting libraries
-                                                     like Bokeh, Altair, etc.
-plotting.matplotlib.register_converters True         Register custom converters with
-                                                     matplotlib. Set to False to de-register.
-styler.sparse.index                     True         "Sparsify" MultiIndex display for rows
-                                                     in Styler output (don't display repeated
-                                                     elements in outer levels within groups).
-styler.sparse.columns                   True         "Sparsify" MultiIndex display for columns
-                                                     in Styler output.
-styler.render.repr                      html         Standard output format for Styler rendered in Jupyter Notebook.
-                                                     Should be one of "html" or "latex".
-styler.render.max_elements              262144       Maximum number of datapoints that Styler will render
-                                                     trimming either rows, columns or both to fit.
-styler.render.max_rows                  None         Maximum number of rows that Styler will render. By default
-                                                     this is dynamic based on ``max_elements``.
-styler.render.max_columns               None         Maximum number of columns that Styler will render. By default
-                                                     this is dynamic based on ``max_elements``.
-styler.render.encoding                  utf-8        Default encoding for output HTML or LaTeX files.
-styler.format.formatter                 None         Object to specify formatting functions to ``Styler.format``.
-styler.format.na_rep                    None         String representation for missing data.
-styler.format.precision                 6            Precision to display floating point and complex numbers.
-styler.format.decimal                   .            String representation for decimal point separator for floating
-                                                     point and complex numbers.
-styler.format.thousands                 None         String representation for thousands separator for
-                                                     integers, and floating point and complex numbers.
-styler.format.escape                    None         Whether to escape "html" or "latex" special
-                                                     characters in the display representation.
-styler.html.mathjax                     True         If set to False will render specific CSS classes to
-                                                     table attributes that will prevent Mathjax from rendering
-                                                     in Jupyter Notebook.
-styler.latex.multicol_align             r            Alignment of headers in a merged column due to sparsification. Can be in {"r", "c", "l"}.
-styler.latex.multirow_align             c            Alignment of index labels in a merged row due to sparsification. Can be in {"c", "t", "b"}.
-styler.latex.environment                None         If given will replace the default ``\\begin{table}`` environment. If "longtable" is specified
-                                                     this will render with a specific "longtable" template with longtable features.
-styler.latex.hrules                     False        If set to True will render ``\\toprule``, ``\\midrule``, and ``\bottomrule`` by default.
-======================================= ============ ==================================
-
-
 .. _basics.console_output:
 
 Number formatting
@@ -532,8 +313,6 @@ Use the ``set_eng_float_format`` function
 to alter the floating-point formatting of pandas objects to produce a particular
 format.
 
-For instance:
-
 .. ipython:: python
 
    import numpy as np
@@ -549,7 +328,7 @@ For instance:
 
    pd.reset_option("^display")
 
-To round floats on a case-by-case basis, you can also use :meth:`~pandas.Series.round` and :meth:`~pandas.DataFrame.round`.
+Use :meth:`~pandas.DataFrame.round` to specifically control rounding of an individual :class:`DataFrame`
 
 .. _options.east_asian_width:
 
@@ -564,15 +343,11 @@ Unicode formatting
 Some East Asian countries use Unicode characters whose width corresponds to two Latin characters.
 If a DataFrame or Series contains these characters, the default output mode may not align them properly.
 
-.. note:: Screen captures are attached for each output to show the actual results.
-
 .. ipython:: python
 
    df = pd.DataFrame({"国籍": ["UK", "日本"], "名前": ["Alice", "しのぶ"]})
    df
 
-.. image:: ../_static/option_unicode01.png
-
 Enabling ``display.unicode.east_asian_width`` allows pandas to check each character's "East Asian Width" property.
 These characters can be aligned properly by setting this option to ``True``. However, this will result in longer render
 times than the standard ``len`` function.
@@ -582,19 +357,16 @@ times than the standard ``len`` function.
    pd.set_option("display.unicode.east_asian_width", True)
    df
 
-.. image:: ../_static/option_unicode02.png
-
-In addition, Unicode characters whose width is "Ambiguous" can either be 1 or 2 characters wide depending on the
+In addition, Unicode characters whose width is "ambiguous" can either be 1 or 2 characters wide depending on the
 terminal setting or encoding. The option ``display.unicode.ambiguous_as_wide`` can be used to handle the ambiguity.
 
-By default, an "Ambiguous" character's width, such as "¡" (inverted exclamation) in the example below, is taken to be 1.
+By default, an "ambiguous" character's width, such as "¡" (inverted exclamation) in the example below, is taken to be 1.
 
 .. ipython:: python
 
    df = pd.DataFrame({"a": ["xxx", "¡¡"], "b": ["yyy", "¡¡"]})
    df
 
-.. image:: ../_static/option_unicode03.png
 
 Enabling ``display.unicode.ambiguous_as_wide`` makes pandas interpret these characters' widths to be 2.
 (Note that this option will only be effective when ``display.unicode.east_asian_width`` is enabled.)
@@ -606,7 +378,6 @@ However, setting this option incorrectly for your terminal will cause these char
    pd.set_option("display.unicode.ambiguous_as_wide", True)
    df
 
-.. image:: ../_static/option_unicode04.png
 
 .. ipython:: python
    :suppress:
@@ -619,8 +390,8 @@ However, setting this option incorrectly for your terminal will cause these char
 Table schema display
 --------------------
 
-``DataFrame`` and ``Series`` will publish a Table Schema representation
-by default. False by default, this can be enabled globally with the
+:class:`DataFrame` and :class:`Series` will publish a Table Schema representation
+by default. This can be enabled globally with the
 ``display.html.table_schema`` option:
 
 .. ipython:: python
diff --git a/doc/source/user_guide/reshaping.rst b/doc/source/user_guide/reshaping.rst
index e74272c825e46..adca9de6c130a 100644
--- a/doc/source/user_guide/reshaping.rst
+++ b/doc/source/user_guide/reshaping.rst
@@ -13,37 +13,12 @@ Reshaping by pivoting DataFrame objects
 
 .. image:: ../_static/reshaping_pivot.png
 
-.. ipython:: python
-   :suppress:
-
-   import pandas._testing as tm
-
-   def unpivot(frame):
-       N, K = frame.shape
-       data = {
-           "value": frame.to_numpy().ravel("F"),
-           "variable": np.asarray(frame.columns).repeat(N),
-           "date": np.tile(np.asarray(frame.index), K),
-       }
-       columns = ["date", "variable", "value"]
-       return pd.DataFrame(data, columns=columns)
-
-   df = unpivot(tm.makeTimeDataFrame(3))
-
 Data is often stored in so-called "stacked" or "record" format:
 
 .. ipython:: python
 
-   df
-
-
-For the curious here is how the above ``DataFrame`` was created:
-
-.. code-block:: python
-
    import pandas._testing as tm
 
-
    def unpivot(frame):
        N, K = frame.shape
        data = {
@@ -53,14 +28,15 @@ For the curious here is how the above ``DataFrame`` was created:
        }
        return pd.DataFrame(data, columns=["date", "variable", "value"])
 
-
    df = unpivot(tm.makeTimeDataFrame(3))
+   df
 
 To select out everything for variable ``A`` we could do:
 
 .. ipython:: python
 
-   df[df["variable"] == "A"]
+   filtered = df[df["variable"] == "A"]
+   filtered
 
 But suppose we wish to do time series operations with the variables. A better
 representation would be where the ``columns`` are the unique variables and an
@@ -70,11 +46,12 @@ top level function :func:`~pandas.pivot`):
 
 .. ipython:: python
 
-   df.pivot(index="date", columns="variable", values="value")
+   pivoted = df.pivot(index="date", columns="variable", values="value")
+   pivoted
 
-If the ``values`` argument is omitted, and the input ``DataFrame`` has more than
-one column of values which are not used as column or index inputs to ``pivot``,
-then the resulting "pivoted" ``DataFrame`` will have :ref:`hierarchical columns
+If the ``values`` argument is omitted, and the input :class:`DataFrame` has more than
+one column of values which are not used as column or index inputs to :meth:`~DataFrame.pivot`,
+then the resulting "pivoted" :class:`DataFrame` will have :ref:`hierarchical columns
 <advanced.hierarchical>` whose topmost level indicates the respective value
 column:
 
@@ -84,7 +61,7 @@ column:
    pivoted = df.pivot(index="date", columns="variable")
    pivoted
 
-You can then select subsets from the pivoted ``DataFrame``:
+You can then select subsets from the pivoted :class:`DataFrame`:
 
 .. ipython:: python
 
@@ -108,16 +85,16 @@ Reshaping by stacking and unstacking
 
 Closely related to the :meth:`~DataFrame.pivot` method are the related
 :meth:`~DataFrame.stack` and :meth:`~DataFrame.unstack` methods available on
-``Series`` and ``DataFrame``. These methods are designed to work together with
-``MultiIndex`` objects (see the section on :ref:`hierarchical indexing
+:class:`Series` and :class:`DataFrame`. These methods are designed to work together with
+:class:`MultiIndex` objects (see the section on :ref:`hierarchical indexing
 <advanced.hierarchical>`). Here are essentially what these methods do:
 
-* ``stack``: "pivot" a level of the (possibly hierarchical) column labels,
-  returning a ``DataFrame`` with an index with a new inner-most level of row
+* :meth:`~DataFrame.stack`: "pivot" a level of the (possibly hierarchical) column labels,
+  returning a :class:`DataFrame` with an index with a new inner-most level of row
   labels.
-* ``unstack``: (inverse operation of ``stack``) "pivot" a level of the
+* :meth:`~DataFrame.unstack`: (inverse operation of :meth:`~DataFrame.stack`) "pivot" a level of the
   (possibly hierarchical) row index to the column axis, producing a reshaped
-  ``DataFrame`` with a new inner-most level of column labels.
+  :class:`DataFrame` with a new inner-most level of column labels.
 
 .. image:: ../_static/reshaping_unstack.png
 
@@ -139,22 +116,22 @@ from the hierarchical indexing section:
    df2 = df[:4]
    df2
 
-The ``stack`` function "compresses" a level in the ``DataFrame``'s columns to
+The :meth:`~DataFrame.stack` function "compresses" a level in the :class:`DataFrame` columns to
 produce either:
 
-* A ``Series``, in the case of a simple column Index.
-* A ``DataFrame``, in the case of a ``MultiIndex`` in the columns.
+* A :class:`Series`, in the case of a simple column Index.
+* A :class:`DataFrame`, in the case of a :class:`MultiIndex` in the columns.
 
-If the columns have a ``MultiIndex``, you can choose which level to stack. The
-stacked level becomes the new lowest level in a ``MultiIndex`` on the columns:
+If the columns have a :class:`MultiIndex`, you can choose which level to stack. The
+stacked level becomes the new lowest level in a :class:`MultiIndex` on the columns:
 
 .. ipython:: python
 
    stacked = df2.stack()
    stacked
 
-With a "stacked" ``DataFrame`` or ``Series`` (having a ``MultiIndex`` as the
-``index``), the inverse operation of ``stack`` is ``unstack``, which by default
+With a "stacked" :class:`DataFrame` or :class:`Series` (having a :class:`MultiIndex` as the
+``index``), the inverse operation of :meth:`~DataFrame.stack` is :meth:`~DataFrame.unstack`, which by default
 unstacks the **last level**:
 
 .. ipython:: python
@@ -177,9 +154,9 @@ the level numbers:
 
 .. image:: ../_static/reshaping_unstack_0.png
 
-Notice that the ``stack`` and ``unstack`` methods implicitly sort the index
-levels involved. Hence a call to ``stack`` and then ``unstack``, or vice versa,
-will result in a **sorted** copy of the original ``DataFrame`` or ``Series``:
+Notice that the :meth:`~DataFrame.stack` and :meth:`~DataFrame.unstack` methods implicitly sort the index
+levels involved. Hence a call to :meth:`~DataFrame.stack` and then :meth:`~DataFrame.unstack`, or vice versa,
+will result in a **sorted** copy of the original :class:`DataFrame` or :class:`Series`:
 
 .. ipython:: python
 
@@ -188,7 +165,7 @@ will result in a **sorted** copy of the original ``DataFrame`` or ``Series``:
    df
    all(df.unstack().stack() == df.sort_index())
 
-The above code will raise a ``TypeError`` if the call to ``sort_index`` is
+The above code will raise a ``TypeError`` if the call to :meth:`~DataFrame.sort_index` is
 removed.
 
 .. _reshaping.stack_multiple:
@@ -231,7 +208,7 @@ Missing data
 These functions are intelligent about handling missing data and do not expect
 each subgroup within the hierarchical index to have the same set of labels.
 They also can handle the index being unsorted (but you can make it sorted by
-calling ``sort_index``, of course). Here is a more complex example:
+calling :meth:`~DataFrame.sort_index`, of course). Here is a more complex example:
 
 .. ipython:: python
 
@@ -251,7 +228,7 @@ calling ``sort_index``, of course). Here is a more complex example:
    df2 = df.iloc[[0, 1, 2, 4, 5, 7]]
    df2
 
-As mentioned above, ``stack`` can be called with a ``level`` argument to select
+As mentioned above, :meth:`~DataFrame.stack` can be called with a ``level`` argument to select
 which level in the columns to stack:
 
 .. ipython:: python
@@ -281,7 +258,7 @@ the value of missing data.
 With a MultiIndex
 ~~~~~~~~~~~~~~~~~
 
-Unstacking when the columns are a ``MultiIndex`` is also careful about doing
+Unstacking when the columns are a :class:`MultiIndex` is also careful about doing
 the right thing:
 
 .. ipython:: python
@@ -297,7 +274,7 @@ Reshaping by melt
 .. image:: ../_static/reshaping_melt.png
 
 The top-level :func:`~pandas.melt` function and the corresponding :meth:`DataFrame.melt`
-are useful to massage a ``DataFrame`` into a format where one or more columns
+are useful to massage a :class:`DataFrame` into a format where one or more columns
 are *identifier variables*, while all other columns, considered *measured
 variables*, are "unpivoted" to the row axis, leaving just two non-identifier
 columns, "variable" and "value". The names of those columns can be customized
@@ -363,7 +340,7 @@ user-friendly.
 Combining with stats and GroupBy
 --------------------------------
 
-It should be no shock that combining ``pivot`` / ``stack`` / ``unstack`` with
+It should be no shock that combining :meth:`~DataFrame.pivot` / :meth:`~DataFrame.stack` / :meth:`~DataFrame.unstack` with
 GroupBy and the basic Series and DataFrame statistical functions can produce
 some very expressive and fast data manipulations.
 
@@ -385,8 +362,6 @@ Pivot tables
 
 .. _reshaping.pivot:
 
-
-
 While :meth:`~DataFrame.pivot` provides general purpose pivoting with various
 data types (strings, numerics, etc.), pandas also provides :func:`~pandas.pivot_table`
 for pivoting with aggregation of numeric data.
@@ -437,30 +412,29 @@ We can produce pivot tables from this data very easily:
        aggfunc=np.sum,
    )
 
-The result object is a ``DataFrame`` having potentially hierarchical indexes on the
+The result object is a :class:`DataFrame` having potentially hierarchical indexes on the
 rows and columns. If the ``values`` column name is not given, the pivot table
-will include all of the data that can be aggregated in an additional level of
-hierarchy in the columns:
+will include all of the data in an additional level of hierarchy in the columns:
 
 .. ipython:: python
 
-   pd.pivot_table(df, index=["A", "B"], columns=["C"])
+   pd.pivot_table(df[["A", "B", "C", "D", "E"]], index=["A", "B"], columns=["C"])
 
-Also, you can use ``Grouper`` for ``index`` and ``columns`` keywords. For detail of ``Grouper``, see :ref:`Grouping with a Grouper specification <groupby.specify>`.
+Also, you can use :class:`Grouper` for ``index`` and ``columns`` keywords. For detail of :class:`Grouper`, see :ref:`Grouping with a Grouper specification <groupby.specify>`.
 
 .. ipython:: python
 
    pd.pivot_table(df, values="D", index=pd.Grouper(freq="M", key="F"), columns="C")
 
 You can render a nice output of the table omitting the missing values by
-calling ``to_string`` if you wish:
+calling :meth:`~DataFrame.to_string` if you wish:
 
 .. ipython:: python
 
-   table = pd.pivot_table(df, index=["A", "B"], columns=["C"])
+   table = pd.pivot_table(df, index=["A", "B"], columns=["C"], values=["D", "E"])
    print(table.to_string(na_rep=""))
 
-Note that ``pivot_table`` is also available as an instance method on DataFrame,
+Note that :meth:`~DataFrame.pivot_table` is also available as an instance method on DataFrame,
  i.e. :meth:`DataFrame.pivot_table`.
 
 .. _reshaping.pivot.margins:
@@ -468,13 +442,19 @@ Note that ``pivot_table`` is also available as an instance method on DataFrame,
 Adding margins
 ~~~~~~~~~~~~~~
 
-If you pass ``margins=True`` to ``pivot_table``, special ``All`` columns and
+If you pass ``margins=True`` to :meth:`~DataFrame.pivot_table`, special ``All`` columns and
 rows will be added with partial group aggregates across the categories on the
 rows and columns:
 
 .. ipython:: python
 
-   table = df.pivot_table(index=["A", "B"], columns="C", margins=True, aggfunc=np.std)
+   table = df.pivot_table(
+       index=["A", "B"],
+       columns="C",
+       values=["D", "E"],
+       margins=True,
+       aggfunc=np.std
+   )
    table
 
 Additionally, you can call :meth:`DataFrame.stack` to display a pivoted DataFrame
@@ -490,7 +470,7 @@ Cross tabulations
 -----------------
 
 Use :func:`~pandas.crosstab` to compute a cross-tabulation of two (or more)
-factors. By default ``crosstab`` computes a frequency table of the factors
+factors. By default :func:`~pandas.crosstab` computes a frequency table of the factors
 unless an array of values and an aggregation function are passed.
 
 It takes a number of arguments
@@ -509,7 +489,7 @@ It takes a number of arguments
   Normalize by dividing all values by the sum of values.
 
 
-Any ``Series`` passed will have their name attributes used unless row or column
+Any :class:`Series` passed will have their name attributes used unless row or column
 names for the cross-tabulation are specified
 
 For example:
@@ -523,7 +503,7 @@ For example:
     pd.crosstab(a, [b, c], rownames=["a"], colnames=["b", "c"])
 
 
-If ``crosstab`` receives only two Series, it will provide a frequency table.
+If :func:`~pandas.crosstab` receives only two Series, it will provide a frequency table.
 
 .. ipython:: python
 
@@ -534,8 +514,8 @@ If ``crosstab`` receives only two Series, it will provide a frequency table.
 
     pd.crosstab(df["A"], df["B"])
 
-``crosstab`` can also be implemented
-to ``Categorical`` data.
+:func:`~pandas.crosstab` can also be implemented
+to :class:`Categorical` data.
 
 .. ipython:: python
 
@@ -568,9 +548,9 @@ using the ``normalize`` argument:
 
    pd.crosstab(df["A"], df["B"], normalize="columns")
 
-``crosstab`` can also be passed a third ``Series`` and an aggregation function
-(``aggfunc``) that will be applied to the values of the third ``Series`` within
-each group defined by the first two ``Series``:
+:func:`~pandas.crosstab` can also be passed a third :class:`Series` and an aggregation function
+(``aggfunc``) that will be applied to the values of the third :class:`Series` within
+each group defined by the first two :class:`Series`:
 
 .. ipython:: python
 
@@ -611,7 +591,7 @@ Alternatively we can specify custom bin-edges:
    c = pd.cut(ages, bins=[0, 18, 35, 70])
    c
 
-If the ``bins`` keyword is an ``IntervalIndex``, then these will be
+If the ``bins`` keyword is an :class:`IntervalIndex`, then these will be
 used to bin the passed data.::
 
    pd.cut([25, 20, 50], bins=c.categories)
@@ -622,9 +602,9 @@ used to bin the passed data.::
 Computing indicator / dummy variables
 -------------------------------------
 
-To convert a categorical variable into a "dummy" or "indicator" ``DataFrame``,
-for example a column in a ``DataFrame`` (a ``Series``) which has ``k`` distinct
-values, can derive a ``DataFrame`` containing ``k`` columns of 1s and 0s using
+To convert a categorical variable into a "dummy" or "indicator" :class:`DataFrame`,
+for example a column in a :class:`DataFrame` (a :class:`Series`) which has ``k`` distinct
+values, can derive a :class:`DataFrame` containing ``k`` columns of 1s and 0s using
 :func:`~pandas.get_dummies`:
 
 .. ipython:: python
@@ -634,7 +614,7 @@ values, can derive a ``DataFrame`` containing ``k`` columns of 1s and 0s using
    pd.get_dummies(df["key"])
 
 Sometimes it's useful to prefix the column names, for example when merging the result
-with the original ``DataFrame``:
+with the original :class:`DataFrame`:
 
 .. ipython:: python
 
@@ -643,7 +623,7 @@ with the original ``DataFrame``:
 
    df[["data1"]].join(dummies)
 
-This function is often used along with discretization functions like ``cut``:
+This function is often used along with discretization functions like :func:`~pandas.cut`:
 
 .. ipython:: python
 
@@ -656,7 +636,7 @@ This function is often used along with discretization functions like ``cut``:
 
 See also :func:`Series.str.get_dummies <pandas.Series.str.get_dummies>`.
 
-:func:`get_dummies` also accepts a ``DataFrame``. By default all categorical
+:func:`get_dummies` also accepts a :class:`DataFrame`. By default all categorical
 variables (categorical in the statistical sense, those with ``object`` or
 ``categorical`` dtype) are encoded as dummy variables.
 
@@ -677,8 +657,8 @@ Notice that the ``B`` column is still included in the output, it just hasn't
 been encoded. You can drop ``B`` before calling ``get_dummies`` if you don't
 want to include it in the output.
 
-As with the ``Series`` version, you can pass values for the ``prefix`` and
-``prefix_sep``. By default the column name is used as the prefix, and '_' as
+As with the :class:`Series` version, you can pass values for the ``prefix`` and
+``prefix_sep``. By default the column name is used as the prefix, and ``_`` as
 the prefix separator. You can specify ``prefix`` and ``prefix_sep`` in 3 ways:
 
 * string: Use the same value for ``prefix`` or ``prefix_sep`` for each column
@@ -726,6 +706,30 @@ To choose another dtype, use the ``dtype`` argument:
 
     pd.get_dummies(df, dtype=bool).dtypes
 
+.. versionadded:: 1.5.0
+
+To convert a "dummy" or "indicator" ``DataFrame``, into a categorical ``DataFrame``,
+for example ``k`` columns of a ``DataFrame`` containing 1s and 0s can derive a
+``DataFrame`` which has ``k`` distinct values using
+:func:`~pandas.from_dummies`:
+
+.. ipython:: python
+
+   df = pd.DataFrame({"prefix_a": [0, 1, 0], "prefix_b": [1, 0, 1]})
+   df
+
+   pd.from_dummies(df, sep="_")
+
+Dummy coded data only requires ``k - 1`` categories to be included, in this case
+the ``k`` th category is the default category, implied by not being assigned any of
+the other ``k - 1`` categories, can be passed via ``default_category``.
+
+.. ipython:: python
+
+   df = pd.DataFrame({"prefix_a": [0, 1, 0]})
+   df
+
+   pd.from_dummies(df, sep="_", default_category="b")
 
 .. _reshaping.factorize:
 
@@ -742,7 +746,7 @@ To encode 1-d values as an enumerated type use :func:`~pandas.factorize`:
    labels
    uniques
 
-Note that ``factorize`` is similar to ``numpy.unique``, but differs in its
+Note that :func:`~pandas.factorize` is similar to ``numpy.unique``, but differs in its
 handling of NaN:
 
 .. note::
@@ -750,16 +754,12 @@ handling of NaN:
    because of an ordering bug. See also
    `here <https://github.com/numpy/numpy/issues/641>`__.
 
-.. code-block:: ipython
-
-    In [1]: x = pd.Series(['A', 'A', np.nan, 'B', 3.14, np.inf])
-    In [2]: pd.factorize(x, sort=True)
-    Out[2]:
-    (array([ 2,  2, -1,  3,  0,  1]),
-     Index([3.14, inf, 'A', 'B'], dtype='object'))
+.. ipython:: python
+   :okexcept:
 
-    In [3]: np.unique(x, return_inverse=True)[::-1]
-    Out[3]: (array([3, 3, 0, 4, 1, 2]), array([nan, 3.14, inf, 'A', 'B'], dtype=object))
+   ser = pd.Series(['A', 'A', np.nan, 'B', 3.14, np.inf])
+   pd.factorize(ser, sort=True)
+   np.unique(ser, return_inverse=True)[::-1]
 
 .. note::
     If you just want to handle one column as a categorical variable (like R's factor),
@@ -907,13 +907,13 @@ We can 'explode' the ``values`` column, transforming each list-like to a separat
 
    df["values"].explode()
 
-You can also explode the column in the ``DataFrame``.
+You can also explode the column in the :class:`DataFrame`.
 
 .. ipython:: python
 
    df.explode("values")
 
-:meth:`Series.explode` will replace empty lists with ``np.nan`` and preserve scalar entries. The dtype of the resulting ``Series`` is always ``object``.
+:meth:`Series.explode` will replace empty lists with ``np.nan`` and preserve scalar entries. The dtype of the resulting :class:`Series` is always ``object``.
 
 .. ipython:: python
 
diff --git a/doc/source/user_guide/scale.rst b/doc/source/user_guide/scale.rst
index 71aef4fdd75f6..129f43dd36930 100644
--- a/doc/source/user_guide/scale.rst
+++ b/doc/source/user_guide/scale.rst
@@ -18,36 +18,9 @@ tool for all situations. If you're working with very large datasets and a tool
 like PostgreSQL fits your needs, then you should probably be using that.
 Assuming you want or need the expressiveness and power of pandas, let's carry on.
 
-.. ipython:: python
-
-   import pandas as pd
-   import numpy as np
-
-.. ipython:: python
-   :suppress:
-
-   from pandas._testing import _make_timeseries
-
-   # Make a random in-memory dataset
-   ts = _make_timeseries(freq="30S", seed=0)
-   ts.to_csv("timeseries.csv")
-   ts.to_parquet("timeseries.parquet")
-
-
 Load less data
 --------------
 
-.. ipython:: python
-   :suppress:
-
-   # make a similar dataset with many columns
-   timeseries = [
-       _make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
-       for i in range(10)
-   ]
-   ts_wide = pd.concat(timeseries, axis=1)
-   ts_wide.to_parquet("timeseries_wide.parquet")
-
 Suppose our raw dataset on disk has many columns::
 
                         id_0    name_0       x_0       y_0  id_1   name_1       x_1  ...  name_8       x_8       y_8  id_9   name_9       x_9       y_9
@@ -66,6 +39,34 @@ Suppose our raw dataset on disk has many columns::
 
    [525601 rows x 40 columns]
 
+That can be generated by the following code snippet:
+
+.. ipython:: python
+
+   import pandas as pd
+   import numpy as np
+
+   def make_timeseries(start="2000-01-01", end="2000-12-31", freq="1D", seed=None):
+       index = pd.date_range(start=start, end=end, freq=freq, name="timestamp")
+       n = len(index)
+       state = np.random.RandomState(seed)
+       columns = {
+           "name": state.choice(["Alice", "Bob", "Charlie"], size=n),
+           "id": state.poisson(1000, size=n),
+           "x": state.rand(n) * 2 - 1,
+           "y": state.rand(n) * 2 - 1,
+       }
+       df = pd.DataFrame(columns, index=index, columns=sorted(columns))
+       if df.index[-1] == end:
+           df = df.iloc[:-1]
+       return df
+
+   timeseries = [
+       make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
+       for i in range(10)
+   ]
+   ts_wide = pd.concat(timeseries, axis=1)
+   ts_wide.to_parquet("timeseries_wide.parquet")
 
 To load the columns we want, we have two options.
 Option 1 loads in all the data and then filters to what we need.
@@ -82,6 +83,13 @@ Option 2 only loads the columns we request.
 
    pd.read_parquet("timeseries_wide.parquet", columns=columns)
 
+.. ipython:: python
+   :suppress:
+
+   import os
+
+   os.remove("timeseries_wide.parquet")
+
 If we were to measure the memory usage of the two calls, we'd see that specifying
 ``columns`` uses about 1/10th the memory in this case.
 
@@ -99,9 +107,16 @@ can store larger datasets in memory.
 
 .. ipython:: python
 
+   ts = make_timeseries(freq="30S", seed=0)
+   ts.to_parquet("timeseries.parquet")
    ts = pd.read_parquet("timeseries.parquet")
    ts
 
+.. ipython:: python
+   :suppress:
+
+   os.remove("timeseries.parquet")
+
 Now, let's inspect the data types and memory usage to see where we should focus our
 attention.
 
@@ -116,7 +131,7 @@ attention.
 
 The ``name`` column is taking up much more memory than any other. It has just a
 few unique values, so it's a good candidate for converting to a
-:class:`Categorical`. With a Categorical, we store each unique name once and use
+:class:`pandas.Categorical`. With a :class:`pandas.Categorical`, we store each unique name once and use
 space-efficient integers to know which specific name is used in each row.
 
 
@@ -147,7 +162,7 @@ using :func:`pandas.to_numeric`.
 In all, we've reduced the in-memory footprint of this dataset to 1/5 of its
 original size.
 
-See :ref:`categorical` for more on ``Categorical`` and :ref:`basics.dtypes`
+See :ref:`categorical` for more on :class:`pandas.Categorical` and :ref:`basics.dtypes`
 for an overview of all of pandas' dtypes.
 
 Use chunking
@@ -168,7 +183,6 @@ Suppose we have an even larger "logical dataset" on disk that's a directory of p
 files. Each file in the directory represents a different year of the entire dataset.
 
 .. ipython:: python
-   :suppress:
 
    import pathlib
 
@@ -179,7 +193,7 @@ files. Each file in the directory represents a different year of the entire data
    pathlib.Path("data/timeseries").mkdir(exist_ok=True)
 
    for i, (start, end) in enumerate(zip(starts, ends)):
-       ts = _make_timeseries(start=start, end=end, freq="1T", seed=i)
+       ts = make_timeseries(start=start, end=end, freq="1T", seed=i)
        ts.to_parquet(f"data/timeseries/ts-{i:0>2d}.parquet")
 
 
@@ -200,7 +214,7 @@ files. Each file in the directory represents a different year of the entire data
        ├── ts-10.parquet
        └── ts-11.parquet
 
-Now we'll implement an out-of-core ``value_counts``. The peak memory usage of this
+Now we'll implement an out-of-core :meth:`pandas.Series.value_counts`. The peak memory usage of this
 workflow is the single largest chunk, plus a small series storing the unique value
 counts up to this point. As long as each individual file fits in memory, this will
 work for arbitrary-sized datasets.
@@ -211,9 +225,7 @@ work for arbitrary-sized datasets.
    files = pathlib.Path("data/timeseries/").glob("ts*.parquet")
    counts = pd.Series(dtype=int)
    for path in files:
-       # Only one dataframe is in memory at a time...
        df = pd.read_parquet(path)
-       # ... plus a small Series ``counts``, which is updated.
        counts = counts.add(df["name"].value_counts(), fill_value=0)
    counts.astype(int)
 
@@ -221,7 +233,7 @@ Some readers, like :meth:`pandas.read_csv`, offer parameters to control the
 ``chunksize`` when reading a single file.
 
 Manually chunking is an OK option for workflows that don't
-require too sophisticated of operations. Some operations, like ``groupby``, are
+require too sophisticated of operations. Some operations, like :meth:`pandas.DataFrame.groupby`, are
 much harder to do chunkwise. In these cases, you may be better switching to a
 different library that implements these out-of-core algorithms for you.
 
@@ -259,7 +271,7 @@ Inspecting the ``ddf`` object, we see a few things
 * There are new attributes like ``.npartitions`` and ``.divisions``
 
 The partitions and divisions are how Dask parallelizes computation. A **Dask**
-DataFrame is made up of many pandas DataFrames. A single method call on a
+DataFrame is made up of many pandas :class:`pandas.DataFrame`. A single method call on a
 Dask DataFrame ends up making many pandas method calls, and Dask knows how to
 coordinate everything to get the result.
 
@@ -275,6 +287,7 @@ column names and dtypes. That's because Dask hasn't actually read the data yet.
 Rather than executing immediately, doing operations build up a **task graph**.
 
 .. ipython:: python
+   :okwarning:
 
    ddf
    ddf["name"]
@@ -282,8 +295,8 @@ Rather than executing immediately, doing operations build up a **task graph**.
 
 Each of these calls is instant because the result isn't being computed yet.
 We're just building up a list of computation to do when someone needs the
-result. Dask knows that the return type of a ``pandas.Series.value_counts``
-is a pandas Series with a certain dtype and a certain name. So the Dask version
+result. Dask knows that the return type of a :class:`pandas.Series.value_counts`
+is a pandas :class:`pandas.Series` with a certain dtype and a certain name. So the Dask version
 returns a Dask Series with the same dtype and the same name.
 
 To get the actual result you can call ``.compute()``.
@@ -293,13 +306,13 @@ To get the actual result you can call ``.compute()``.
    %time ddf["name"].value_counts().compute()
 
 At that point, you get back the same thing you'd get with pandas, in this case
-a concrete pandas Series with the count of each ``name``.
+a concrete pandas :class:`pandas.Series` with the count of each ``name``.
 
 Calling ``.compute`` causes the full task graph to be executed. This includes
 reading the data, selecting the columns, and doing the ``value_counts``. The
 execution is done *in parallel* where possible, and Dask tries to keep the
 overall memory footprint small. You can work with datasets that are much larger
-than memory, as long as each partition (a regular pandas DataFrame) fits in memory.
+than memory, as long as each partition (a regular pandas :class:`pandas.DataFrame`) fits in memory.
 
 By default, ``dask.dataframe`` operations use a threadpool to do operations in
 parallel. We can also connect to a cluster to distribute the work on many
@@ -333,6 +346,7 @@ known automatically. In this case, since we created the parquet files manually,
 we need to supply the divisions manually.
 
 .. ipython:: python
+   :okwarning:
 
    N = 12
    starts = [f"20{i:>02d}-01-01" for i in range(N)]
@@ -364,6 +378,13 @@ out of memory. At that point it's just a regular pandas object.
    @savefig dask_resample.png
    ddf[["x", "y"]].resample("1D").mean().cumsum().compute().plot()
 
+.. ipython:: python
+   :suppress:
+
+   import shutil
+
+   shutil.rmtree("data/timeseries")
+
 These Dask examples have all be done using multiple processes on a single
 machine. Dask can be `deployed on a cluster
 <https://docs.dask.org/en/latest/setup.html>`_ to scale up to even larger
diff --git a/doc/source/user_guide/sparse.rst b/doc/source/user_guide/sparse.rst
index b2b3678e48534..bc4eec1c23a35 100644
--- a/doc/source/user_guide/sparse.rst
+++ b/doc/source/user_guide/sparse.rst
@@ -23,7 +23,7 @@ array that are ``nan`` aren't actually stored, only the non-``nan`` elements are
 Those non-``nan`` elements have a ``float64`` dtype.
 
 The sparse objects exist for memory efficiency reasons. Suppose you had a
-large, mostly NA ``DataFrame``:
+large, mostly NA :class:`DataFrame`:
 
 .. ipython:: python
 
@@ -139,7 +139,7 @@ Sparse calculation
 ------------------
 
 You can apply NumPy `ufuncs <https://numpy.org/doc/stable/reference/ufuncs.html>`_
-to ``SparseArray`` and get a ``SparseArray`` as a result.
+to :class:`arrays.SparseArray` and get a :class:`arrays.SparseArray` as a result.
 
 .. ipython:: python
 
@@ -183,7 +183,7 @@ your code, rather than ignoring the warning.
 **Construction**
 
 From an array-like, use the regular :class:`Series` or
-:class:`DataFrame` constructors with :class:`SparseArray` values.
+:class:`DataFrame` constructors with :class:`arrays.SparseArray` values.
 
 .. code-block:: python
 
@@ -240,7 +240,7 @@ Sparse-specific properties, like ``density``, are available on the ``.sparse`` a
 **General differences**
 
 In a ``SparseDataFrame``, *all* columns were sparse. A :class:`DataFrame` can have a mixture of
-sparse and dense columns. As a consequence, assigning new columns to a ``DataFrame`` with sparse
+sparse and dense columns. As a consequence, assigning new columns to a :class:`DataFrame` with sparse
 values will not automatically convert the input to be sparse.
 
 .. code-block:: python
@@ -266,10 +266,10 @@ have no replacement.
 
 .. _sparse.scipysparse:
 
-Interaction with scipy.sparse
------------------------------
+Interaction with *scipy.sparse*
+-------------------------------
 
-Use :meth:`DataFrame.sparse.from_spmatrix` to create a ``DataFrame`` with sparse values from a sparse matrix.
+Use :meth:`DataFrame.sparse.from_spmatrix` to create a :class:`DataFrame` with sparse values from a sparse matrix.
 
 .. versionadded:: 0.25.0
 
@@ -294,9 +294,9 @@ To convert back to sparse SciPy matrix in COO format, you can use the :meth:`Dat
 
    sdf.sparse.to_coo()
 
-:meth:`Series.sparse.to_coo` is implemented for transforming a ``Series`` with sparse values indexed by a :class:`MultiIndex` to a :class:`scipy.sparse.coo_matrix`.
+:meth:`Series.sparse.to_coo` is implemented for transforming a :class:`Series` with sparse values indexed by a :class:`MultiIndex` to a :class:`scipy.sparse.coo_matrix`.
 
-The method requires a ``MultiIndex`` with two or more levels.
+The method requires a :class:`MultiIndex` with two or more levels.
 
 .. ipython:: python
 
@@ -315,7 +315,7 @@ The method requires a ``MultiIndex`` with two or more levels.
    ss = s.astype('Sparse')
    ss
 
-In the example below, we transform the ``Series`` to a sparse representation of a 2-d array by specifying that the first and second ``MultiIndex`` levels define labels for the rows and the third and fourth levels define labels for the columns. We also specify that the column and row labels should be sorted in the final sparse representation.
+In the example below, we transform the :class:`Series` to a sparse representation of a 2-d array by specifying that the first and second ``MultiIndex`` levels define labels for the rows and the third and fourth levels define labels for the columns. We also specify that the column and row labels should be sorted in the final sparse representation.
 
 .. ipython:: python
 
@@ -341,7 +341,7 @@ Specifying different row and column labels (and not sorting them) yields a diffe
    rows
    columns
 
-A convenience method :meth:`Series.sparse.from_coo` is implemented for creating a ``Series`` with sparse values from a ``scipy.sparse.coo_matrix``.
+A convenience method :meth:`Series.sparse.from_coo` is implemented for creating a :class:`Series` with sparse values from a ``scipy.sparse.coo_matrix``.
 
 .. ipython:: python
 
@@ -350,7 +350,7 @@ A convenience method :meth:`Series.sparse.from_coo` is implemented for creating
    A
    A.todense()
 
-The default behaviour (with ``dense_index=False``) simply returns a ``Series`` containing
+The default behaviour (with ``dense_index=False``) simply returns a :class:`Series` containing
 only the non-null entries.
 
 .. ipython:: python
diff --git a/doc/source/user_guide/style.ipynb b/doc/source/user_guide/style.ipynb
index f94f86b4eea58..620e3806a33b5 100644
--- a/doc/source/user_guide/style.ipynb
+++ b/doc/source/user_guide/style.ipynb
@@ -11,7 +11,7 @@
     "\n",
     "[styler]: ../reference/api/pandas.io.formats.style.Styler.rst\n",
     "[viz]: visualization.rst\n",
-    "[download]: https://nbviewer.ipython.org/github/pandas-dev/pandas/blob/master/doc/source/user_guide/style.ipynb"
+    "[download]: https://nbviewer.ipython.org/github/pandas-dev/pandas/blob/main/doc/source/user_guide/style.ipynb"
    ]
   },
   {
@@ -151,7 +151,7 @@
     "\n",
     "### Formatting Values\n",
     "\n",
-    "Before adding styles it is useful to show that the [Styler][styler] can distinguish the *display* value from the *actual* value, in both datavlaues and index or columns headers. To control the display value, the text is printed in each cell as string, and we can use the [.format()][formatfunc] and [.format_index()][formatfuncindex] methods to manipulate this according to a [format spec string][format] or a callable that takes a single value and returns a string. It is possible to define this for the whole table, or index, or for individual columns, or MultiIndex levels. \n",
+    "Before adding styles it is useful to show that the [Styler][styler] can distinguish the *display* value from the *actual* value, in both datavalues and index or columns headers. To control the display value, the text is printed in each cell as string, and we can use the [.format()][formatfunc] and [.format_index()][formatfuncindex] methods to manipulate this according to a [format spec string][format] or a callable that takes a single value and returns a string. It is possible to define this for the whole table, or index, or for individual columns, or MultiIndex levels. \n",
     "\n",
     "Additionally, the format function has a **precision** argument to specifically help formatting floats, as well as **decimal** and **thousands** separators to support other locales, an **na_rep** argument to display missing data, and an **escape** argument to help displaying safe-HTML or safe-LaTeX. The default formatter is configured to adopt pandas' `styler.format.precision` option, controllable using `with pd.option_context('format.precision', 2):` \n",
     "\n",
@@ -612,7 +612,7 @@
    "source": [
     "### Acting on the Index and Column Headers\n",
     "\n",
-    "Similar application is acheived for headers by using:\n",
+    "Similar application is achieved for headers by using:\n",
     "    \n",
     "- [.applymap_index()][applymapindex] (elementwise): accepts a function that takes a single value and returns a string with the CSS attribute-value pair.\n",
     "- [.apply_index()][applyindex] (level-wise): accepts a function that takes a Series and returns a Series, or numpy array with an identical shape where each element is a string with a CSS attribute-value pair. This method passes each level of your Index one-at-a-time. To style the index use `axis=0` and to style the column headers use `axis=1`.\n",
@@ -1100,7 +1100,7 @@
     " - [.highlight_null][nullfunc]: for use with identifying missing data. \n",
     " - [.highlight_min][minfunc] and [.highlight_max][maxfunc]: for use with identifying extremeties in data.\n",
     " - [.highlight_between][betweenfunc] and [.highlight_quantile][quantilefunc]: for use with identifying classes within data.\n",
-    " - [.background_gradient][bgfunc]: a flexible method for highlighting cells based or their, or other, values on a numeric scale.\n",
+    " - [.background_gradient][bgfunc]: a flexible method for highlighting cells based on their, or other, values on a numeric scale.\n",
     " - [.text_gradient][textfunc]: similar method for highlighting text based on their, or other, values on a numeric scale.\n",
     " - [.bar][barfunc]: to display mini-charts within cell backgrounds.\n",
     " \n",
@@ -1131,7 +1131,7 @@
    "source": [
     "df2.iloc[0,2] = np.nan\n",
     "df2.iloc[4,3] = np.nan\n",
-    "df2.loc[:4].style.highlight_null(null_color='yellow')"
+    "df2.loc[:4].style.highlight_null(color='yellow')"
    ]
   },
   {
@@ -1196,7 +1196,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can create \"heatmaps\" with the `background_gradient` and `text_gradient` methods. These require matplotlib, and we'll use [Seaborn](https://stanford.edu/~mwaskom/software/seaborn/) to get a nice colormap."
+    "You can create \"heatmaps\" with the `background_gradient` and `text_gradient` methods. These require matplotlib, and we'll use [Seaborn](http://seaborn.pydata.org/) to get a nice colormap."
    ]
   },
   {
@@ -1577,6 +1577,9 @@
     "Some support (*since version 0.20.0*) is available for exporting styled `DataFrames` to Excel worksheets using the `OpenPyXL` or `XlsxWriter` engines. CSS2.2 properties handled include:\n",
     "\n",
     "- `background-color`\n",
+    "- `border-style` properties\n",
+    "- `border-width` properties\n",
+    "- `border-color` properties\n",
     "- `color`\n",
     "- `font-family`\n",
     "- `font-style`\n",
@@ -1587,12 +1590,13 @@
     "- `white-space: nowrap`\n",
     "\n",
     "\n",
-    "- Currently broken: `border-style`, `border-width`, `border-color` and their {`top`, `right`, `bottom`, `left` variants}\n",
+    "- Shorthand and side-specific border properties are supported (e.g. `border-style` and `border-left-style`) as well as the `border` shorthands for all sides (`border: 1px solid green`) or specified sides (`border-left: 1px solid green`). Using a `border` shorthand will override any border properties set before it (See [CSS Working Group](https://drafts.csswg.org/css-backgrounds/#border-shorthands) for more details)\n",
     "\n",
     "\n",
     "- Only CSS2 named colors and hex colors of the form `#rgb` or `#rrggbb` are currently supported.\n",
-    "- The following pseudo CSS properties are also available to set excel specific style properties:\n",
+    "- The following pseudo CSS properties are also available to set Excel specific style properties:\n",
     "    - `number-format`\n",
+    "    - `border-style` (for Excel-specific styles: \"hair\", \"mediumDashDot\", \"dashDotDot\", \"mediumDashDotDot\", \"dashDot\", \"slantDashDot\", or \"mediumDashed\")\n",
     "\n",
     "Table level styles, and data cell CSS-classes are not included in the export to Excel: individual cells must have their properties mapped by the `Styler.apply` and/or `Styler.applymap` methods."
    ]
@@ -1759,7 +1763,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the above case the text is blue because the selector `#T_b_ .cls-1` is worth 110 (ID plus class), which takes precendence."
+    "In the above case the text is blue because the selector `#T_b_ .cls-1` is worth 110 (ID plus class), which takes precedence."
    ]
   },
   {
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index 6df234a027ee9..474068e43a4d4 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -388,7 +388,7 @@ We subtract the epoch (midnight at January 1, 1970 UTC) and then floor divide by
 
 .. _timeseries.origin:
 
-Using the ``origin`` Parameter
+Using the ``origin`` parameter
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Using the ``origin`` parameter, one can specify an alternative starting point for creation
@@ -869,6 +869,7 @@ arithmetic operator (``+``) can be used to perform the shift.
    friday + two_business_days
    (friday + two_business_days).day_name()
 
+
 Most ``DateOffsets`` have associated frequencies strings, or offset aliases, that can be passed
 into ``freq`` keyword arguments. The available date offsets and associated frequency strings can be found below:
 
@@ -1522,7 +1523,7 @@ or calendars with additional rules.
 
 .. _timeseries.advanced_datetime:
 
-Time series-related instance methods
+Time Series-related instance methods
 ------------------------------------
 
 Shifting / lagging
@@ -1820,7 +1821,7 @@ to resample based on datetimelike column in the frame, it can passed to the
        ),
    )
    df
-   df.resample("M", on="date").sum()
+   df.resample("M", on="date")[["a"]].sum()
 
 Similarly, if you instead want to resample by a datetimelike
 level of ``MultiIndex``, its name or location can be passed to the
@@ -1828,7 +1829,7 @@ level of ``MultiIndex``, its name or location can be passed to the
 
 .. ipython:: python
 
-   df.resample("M", level="d").sum()
+   df.resample("M", level="d")[["a"]].sum()
 
 .. _timeseries.iterating-label:
 
@@ -1980,7 +1981,6 @@ frequency. Arithmetic is not allowed between ``Period`` with different ``freq``
    p = pd.Period("2012-01", freq="2M")
    p + 2
    p - 1
-   @okexcept
    p == pd.Period("2012-01", freq="3M")
 
 
@@ -2404,9 +2404,9 @@ you can use the ``tz_convert`` method.
 
 .. warning::
 
-	Be wary of conversions between libraries. For some time zones, ``pytz`` and ``dateutil`` have different
-	definitions of the zone. This is more of a problem for unusual time zones than for
-	'standard' zones like ``US/Eastern``.
+        Be wary of conversions between libraries. For some time zones, ``pytz`` and ``dateutil`` have different
+        definitions of the zone. This is more of a problem for unusual time zones than for
+        'standard' zones like ``US/Eastern``.
 
 .. warning::
 
@@ -2600,7 +2600,7 @@ Transform nonexistent times to ``NaT`` or shift the times.
 
 .. _timeseries.timezone_series:
 
-Time zone series operations
+Time zone Series operations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A :class:`Series` with time zone **naive** values is
diff --git a/doc/source/user_guide/visualization.rst b/doc/source/user_guide/visualization.rst
index fd0af7583f5dc..147981f29476f 100644
--- a/doc/source/user_guide/visualization.rst
+++ b/doc/source/user_guide/visualization.rst
@@ -3,9 +3,14 @@
 {{ header }}
 
 *******************
-Chart Visualization
+Chart visualization
 *******************
 
+
+.. note::
+
+   The examples below assume that you're using `Jupyter <https://jupyter.org/>`_.
+
 This section demonstrates visualization through charting. For information on
 visualization of tabular data please see the section on `Table Visualization <style.ipynb>`_.
 
@@ -272,7 +277,7 @@ horizontal and cumulative histograms can be drawn by
    plt.close("all")
 
 See the :meth:`hist <matplotlib.axes.Axes.hist>` method and the
-`matplotlib hist documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hist>`__ for more.
+`matplotlib hist documentation <https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.hist.html>`__ for more.
 
 
 The existing interface ``DataFrame.hist`` to plot histogram still can be used.
@@ -410,7 +415,7 @@ For example, horizontal and custom-positioned boxplot can be drawn by
 
 
 See the :meth:`boxplot <matplotlib.axes.Axes.boxplot>` method and the
-`matplotlib boxplot documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.boxplot>`__ for more.
+`matplotlib boxplot documentation <https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.boxplot.html>`__ for more.
 
 
 The existing interface ``DataFrame.boxplot`` to plot boxplot still can be used.
@@ -620,6 +625,7 @@ To plot multiple column groups in a single axes, repeat ``plot`` method specifyi
 It is recommended to specify ``color`` and ``label`` keywords to distinguish each groups.
 
 .. ipython:: python
+   :okwarning:
 
    ax = df.plot.scatter(x="a", y="b", color="DarkBlue", label="Group 1")
    @savefig scatter_plot_repeated.png
@@ -674,7 +680,7 @@ bubble chart using a column of the ``DataFrame`` as the bubble size.
    plt.close("all")
 
 See the :meth:`scatter <matplotlib.axes.Axes.scatter>` method and the
-`matplotlib scatter documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter>`__ for more.
+`matplotlib scatter documentation <https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html>`__ for more.
 
 .. _visualization.hexbin:
 
@@ -734,7 +740,7 @@ given by column ``z``. The bins are aggregated with NumPy's ``max`` function.
    plt.close("all")
 
 See the :meth:`hexbin <matplotlib.axes.Axes.hexbin>` method and the
-`matplotlib hexbin documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hexbin>`__ for more.
+`matplotlib hexbin documentation <https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.hexbin.html>`__ for more.
 
 .. _visualization.pie:
 
@@ -823,7 +829,7 @@ Also, other keywords supported by :func:`matplotlib.pyplot.pie` can be used.
        figsize=(6, 6),
    );
 
-If you pass values whose sum total is less than 1.0, matplotlib draws a semicircle.
+If you pass values whose sum total is less than 1.0 they will be rescaled so that they sum to 1.
 
 .. ipython:: python
    :suppress:
@@ -839,7 +845,7 @@ If you pass values whose sum total is less than 1.0, matplotlib draws a semicirc
    @savefig series_pie_plot_semi.png
    series.plot.pie(figsize=(6, 6));
 
-See the `matplotlib pie documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.pie>`__ for more.
+See the `matplotlib pie documentation <https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.pie.html>`__ for more.
 
 .. ipython:: python
     :suppress:
@@ -956,7 +962,7 @@ for more information. By coloring these curves differently for each class
 it is possible to visualize data clustering. Curves belonging to samples
 of the same class will usually be closer together and form larger structures.
 
-**Note**: The "Iris" dataset is available `here <https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/iris.csv>`__.
+**Note**: The "Iris" dataset is available `here <https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv>`__.
 
 .. ipython:: python
 
@@ -1113,10 +1119,10 @@ unit interval). The point in the plane, where our sample settles to (where the
 forces acting on our sample are at an equilibrium) is where a dot representing
 our sample will be drawn. Depending on which class that sample belongs it will
 be colored differently.
-See the R package `Radviz <https://cran.r-project.org/package=Radviz/>`__
+See the R package `Radviz <https://cran.r-project.org/web/packages/Radviz/index.html>`__
 for more information.
 
-**Note**: The "Iris" dataset is available `here <https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/iris.csv>`__.
+**Note**: The "Iris" dataset is available `here <https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv>`__.
 
 .. ipython:: python
 
@@ -1384,7 +1390,7 @@ tick locator methods, it is useful to call the automatic
 date tick adjustment from matplotlib for figures whose ticklabels overlap.
 
 See the :meth:`autofmt_xdate <matplotlib.figure.autofmt_xdate>` method and the
-`matplotlib documentation <https://matplotlib.org/users/recipes.html#fixing-common-date-annoyances>`__ for more.
+`matplotlib documentation <https://matplotlib.org/2.0.2/users/recipes.html#fixing-common-date-annoyances>`__ for more.
 
 Subplots
 ~~~~~~~~
@@ -1620,7 +1626,7 @@ as seen in the example below.
 There also exists a helper function ``pandas.plotting.table``, which creates a
 table from :class:`DataFrame` or :class:`Series`, and adds it to an
 ``matplotlib.Axes`` instance. This function can accept keywords which the
-matplotlib `table <https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.table>`__ has.
+matplotlib `table <https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.table.html>`__ has.
 
 .. ipython:: python
 
@@ -1746,7 +1752,7 @@ Andrews curves charts:
 
    plt.close("all")
 
-Plotting directly with matplotlib
+Plotting directly with Matplotlib
 ---------------------------------
 
 In some situations it may still be preferable or necessary to prepare plots
diff --git a/doc/source/user_guide/window.rst b/doc/source/user_guide/window.rst
index 3e533cbadc5f7..e08fa81c5fa09 100644
--- a/doc/source/user_guide/window.rst
+++ b/doc/source/user_guide/window.rst
@@ -3,7 +3,7 @@
 {{ header }}
 
 ********************
-Windowing Operations
+Windowing operations
 ********************
 
 pandas contains a compact set of APIs for performing windowing operations - an operation that performs
@@ -287,7 +287,7 @@ and we want to use an expanding window where ``use_expanding`` is ``True`` other
    3     3.0
    4    10.0
 
-You can view other examples of ``BaseIndexer`` subclasses `here <https://github.com/pandas-dev/pandas/blob/master/pandas/core/window/indexers.py>`__
+You can view other examples of ``BaseIndexer`` subclasses `here <https://github.com/pandas-dev/pandas/blob/main/pandas/core/indexers/objects.py>`__
 
 .. versionadded:: 1.1
 
@@ -427,10 +427,16 @@ can even be omitted:
 .. note::
 
     Missing values are ignored and each entry is computed using the pairwise
-    complete observations.  Please see the :ref:`covariance section
-    <computation.covariance>` for :ref:`caveats
-    <computation.covariance.caveats>` associated with this method of
-    calculating covariance and correlation matrices.
+    complete observations.
+
+    Assuming the missing data are missing at random this results in an estimate
+    for the covariance matrix which is unbiased. However, for many applications
+    this estimate may not be acceptable because the estimated covariance matrix
+    is not guaranteed to be positive semi-definite. This could lead to
+    estimated correlations having absolute values which are greater than one,
+    and/or a non-invertible covariance matrix. See `Estimation of covariance
+    matrices <https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_matrices>`_
+    for more details.
 
 .. ipython:: python
 
@@ -484,7 +490,7 @@ For all supported aggregation functions, see :ref:`api.functions_expanding`.
 
 .. _window.exponentially_weighted:
 
-Exponentially Weighted window
+Exponentially weighted window
 -----------------------------
 
 An exponentially weighted window is similar to an expanding window but with each prior point
@@ -618,13 +624,13 @@ average of ``3, NaN, 5`` would be calculated as
 
 .. math::
 
-	\frac{(1-\alpha)^2 \cdot 3 + 1 \cdot 5}{(1-\alpha)^2 + 1}.
+        \frac{(1-\alpha)^2 \cdot 3 + 1 \cdot 5}{(1-\alpha)^2 + 1}.
 
 Whereas if ``ignore_na=True``, the weighted average would be calculated as
 
 .. math::
 
-	\frac{(1-\alpha) \cdot 3 + 1 \cdot 5}{(1-\alpha) + 1}.
+        \frac{(1-\alpha) \cdot 3 + 1 \cdot 5}{(1-\alpha) + 1}.
 
 The :meth:`~Ewm.var`, :meth:`~Ewm.std`, and :meth:`~Ewm.cov` functions have a ``bias`` argument,
 specifying whether the result should contain biased or unbiased statistics.
diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index df33174804a33..e2f3b45d47bef 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -10,12 +10,27 @@ This is the list of changes to pandas between each release. For full details,
 see the `commit logs <https://github.com/pandas-dev/pandas/commits/>`_. For install and
 upgrade instructions, see :ref:`install`.
 
+Version 1.5
+-----------
+
+.. toctree::
+   :maxdepth: 2
+
+   v1.5.3
+   v1.5.2
+   v1.5.1
+   v1.5.0
+
 Version 1.4
 -----------
 
 .. toctree::
    :maxdepth: 2
 
+   v1.4.4
+   v1.4.3
+   v1.4.2
+   v1.4.1
    v1.4.0
 
 Version 1.3
diff --git a/doc/source/whatsnew/v0.13.0.rst b/doc/source/whatsnew/v0.13.0.rst
index b2596358d0c9d..44223bc694360 100644
--- a/doc/source/whatsnew/v0.13.0.rst
+++ b/doc/source/whatsnew/v0.13.0.rst
@@ -664,7 +664,7 @@ Enhancements
      other = pd.DataFrame({'A': [1, 3, 3, 7], 'B': ['e', 'f', 'f', 'e']})
      mask = dfi.isin(other)
      mask
-     dfi[mask.any(1)]
+     dfi[mask.any(axis=1)]
 
 - ``Series`` now supports a ``to_frame`` method to convert it to a single-column DataFrame (:issue:`5164`)
 
@@ -733,7 +733,7 @@ Enhancements
 
 .. _scipy: http://www.scipy.org
 .. _documentation: http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation
-.. _guide: http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html
+.. _guide: https://docs.scipy.org/doc/scipy/tutorial/interpolate.html
 
 - ``to_csv`` now takes a ``date_format`` keyword argument that specifies how
   output datetime objects should be formatted. Datetimes encountered in the
diff --git a/doc/source/whatsnew/v0.15.0.rst b/doc/source/whatsnew/v0.15.0.rst
index fc2b070df4392..04506f1655c7d 100644
--- a/doc/source/whatsnew/v0.15.0.rst
+++ b/doc/source/whatsnew/v0.15.0.rst
@@ -462,15 +462,15 @@ Rolling/expanding moments improvements
 
   .. code-block:: ipython
 
-	In [51]: ewma(s, com=3., min_periods=2)
-	Out[51]:
-	0         NaN
-	1         NaN
-	2    1.000000
-	3    1.000000
-	4    1.571429
-	5    2.189189
-	dtype: float64
+        In [51]: pd.ewma(s, com=3., min_periods=2)
+        Out[51]:
+        0         NaN
+        1         NaN
+        2    1.000000
+        3    1.000000
+        4    1.571429
+        5    2.189189
+        dtype: float64
 
   New behavior (note values start at index ``4``, the location of the 2nd (since ``min_periods=2``) non-empty value):
 
@@ -557,21 +557,21 @@ Rolling/expanding moments improvements
 
   .. code-block:: ipython
 
-	 In [89]: ewmvar(s, com=2., bias=False)
-	 Out[89]:
-	 0   -2.775558e-16
-	 1    3.000000e-01
-	 2    9.556787e-01
-	 3    3.585799e+00
-	 dtype: float64
-
-	 In [90]: ewmvar(s, com=2., bias=False) / ewmvar(s, com=2., bias=True)
-	 Out[90]:
-	 0    1.25
-	 1    1.25
-	 2    1.25
-	 3    1.25
-	 dtype: float64
+         In [89]: pd.ewmvar(s, com=2., bias=False)
+         Out[89]:
+         0   -2.775558e-16
+         1    3.000000e-01
+         2    9.556787e-01
+         3    3.585799e+00
+         dtype: float64
+
+         In [90]: pd.ewmvar(s, com=2., bias=False) / pd.ewmvar(s, com=2., bias=True)
+         Out[90]:
+         0    1.25
+         1    1.25
+         2    1.25
+         3    1.25
+         dtype: float64
 
   Note that entry ``0`` is approximately 0, and the debiasing factors are a constant 1.25.
   By comparison, the following 0.15.0 results have a ``NaN`` for entry ``0``,
diff --git a/doc/source/whatsnew/v0.16.2.rst b/doc/source/whatsnew/v0.16.2.rst
index 40d764e880c9c..c6c134a383e11 100644
--- a/doc/source/whatsnew/v0.16.2.rst
+++ b/doc/source/whatsnew/v0.16.2.rst
@@ -83,7 +83,7 @@ popular ``(%>%)`` pipe operator for R_.
 
 See the :ref:`documentation <basics.pipe>` for more. (:issue:`10129`)
 
-.. _dplyr: https://github.com/hadley/dplyr
+.. _dplyr: https://github.com/tidyverse/dplyr
 .. _magrittr: https://github.com/smbache/magrittr
 .. _R: http://www.r-project.org
 
diff --git a/doc/source/whatsnew/v0.17.0.rst b/doc/source/whatsnew/v0.17.0.rst
index 991b9a40d151b..7067407604d24 100644
--- a/doc/source/whatsnew/v0.17.0.rst
+++ b/doc/source/whatsnew/v0.17.0.rst
@@ -363,16 +363,12 @@ Some East Asian countries use Unicode characters its width is corresponding to 2
 .. ipython:: python
 
    df = pd.DataFrame({u"国籍": ["UK", u"日本"], u"名前": ["Alice", u"しのぶ"]})
-   df;
-
-.. image:: ../_static/option_unicode01.png
+   df
 
 .. ipython:: python
 
    pd.set_option("display.unicode.east_asian_width", True)
-   df;
-
-.. image:: ../_static/option_unicode02.png
+   df
 
 For further details, see :ref:`here <options.east_asian_width>`
 
diff --git a/doc/source/whatsnew/v0.17.1.rst b/doc/source/whatsnew/v0.17.1.rst
index 6b0a28ec47568..774d17e6ff6b0 100644
--- a/doc/source/whatsnew/v0.17.1.rst
+++ b/doc/source/whatsnew/v0.17.1.rst
@@ -37,9 +37,7 @@ Conditional HTML formatting
 .. warning::
     This is a new feature and is under active development.
     We'll be adding features an  possibly making breaking changes in future
-    releases. Feedback is welcome_.
-
-.. _welcome: https://github.com/pandas-dev/pandas/issues/11610
+    releases. Feedback is welcome in :issue:`11610`
 
 We've added *experimental* support for conditional HTML formatting:
 the visual styling of a DataFrame based on the data.
diff --git a/doc/source/whatsnew/v0.18.1.rst b/doc/source/whatsnew/v0.18.1.rst
index 3db00f686d62c..7d9008fdbdecd 100644
--- a/doc/source/whatsnew/v0.18.1.rst
+++ b/doc/source/whatsnew/v0.18.1.rst
@@ -149,8 +149,8 @@ can return a valid boolean indexer or anything which is valid for these indexer'
    # callable returns list of labels
    df.loc[lambda x: [1, 2], lambda x: ["A", "B"]]
 
-Indexing with``[]``
-"""""""""""""""""""
+Indexing with ``[]``
+""""""""""""""""""""
 
 Finally, you can use a callable in ``[]`` indexing of Series, DataFrame and Panel.
 The callable must return a valid input for ``[]`` indexing depending on its
@@ -166,7 +166,7 @@ without using temporary variable.
 .. ipython:: python
 
    bb = pd.read_csv("data/baseball.csv", index_col="id")
-   (bb.groupby(["year", "team"]).sum().loc[lambda df: df.r > 100])
+   (bb.groupby(["year", "team"]).sum(numeric_only=True).loc[lambda df: df.r > 100])
 
 .. _whatsnew_0181.partial_string_indexing:
 
diff --git a/doc/source/whatsnew/v0.19.0.rst b/doc/source/whatsnew/v0.19.0.rst
index 340e1ce9ee1ef..f2fdd23af1297 100644
--- a/doc/source/whatsnew/v0.19.0.rst
+++ b/doc/source/whatsnew/v0.19.0.rst
@@ -271,6 +271,7 @@ Individual columns can be parsed as a ``Categorical`` using a dict specification
    such as :func:`to_datetime`.
 
    .. ipython:: python
+      :okwarning:
 
       df = pd.read_csv(StringIO(data), dtype="category")
       df.dtypes
@@ -497,8 +498,8 @@ Other enhancements
          ),
      )
      df
-     df.resample("M", on="date").sum()
-     df.resample("M", level="d").sum()
+     df.resample("M", on="date")[["a"]].sum()
+     df.resample("M", level="d")[["a"]].sum()
 
 - The ``.get_credentials()`` method of ``GbqConnector`` can now first try to fetch `the application default credentials <https://developers.google.com/identity/protocols/application-default-credentials>`__. See the docs for more details (:issue:`13577`).
 - The ``.tz_localize()`` method of ``DatetimeIndex`` and ``Timestamp`` has gained the ``errors`` keyword, so you can potentially coerce nonexistent timestamps to ``NaT``. The default behavior remains to raising a ``NonExistentTimeError`` (:issue:`13057`)
@@ -1553,7 +1554,7 @@ Bug fixes
 - Bug in invalid datetime parsing in ``to_datetime`` and ``DatetimeIndex`` may raise ``TypeError`` rather than ``ValueError`` (:issue:`11169`, :issue:`11287`)
 - Bug in ``Index`` created with tz-aware ``Timestamp`` and mismatched ``tz`` option incorrectly coerces timezone (:issue:`13692`)
 - Bug in ``DatetimeIndex`` with nanosecond frequency does not include timestamp specified with ``end`` (:issue:`13672`)
-- Bug in ```Series`` when setting a slice with a ``np.timedelta64`` (:issue:`14155`)
+- Bug in ``Series`` when setting a slice with a ``np.timedelta64`` (:issue:`14155`)
 - Bug in ``Index`` raises ``OutOfBoundsDatetime`` if ``datetime`` exceeds ``datetime64[ns]`` bounds, rather than coercing to ``object`` dtype (:issue:`13663`)
 - Bug in ``Index`` may ignore specified ``datetime64`` or ``timedelta64`` passed as ``dtype``  (:issue:`13981`)
 - Bug in ``RangeIndex`` can be created without no arguments rather than raises ``TypeError`` (:issue:`13793`)
diff --git a/doc/source/whatsnew/v0.19.2.rst b/doc/source/whatsnew/v0.19.2.rst
index bba89d78be869..db9d9e65c923d 100644
--- a/doc/source/whatsnew/v0.19.2.rst
+++ b/doc/source/whatsnew/v0.19.2.rst
@@ -18,7 +18,7 @@ We recommend that all users upgrade to this version.
 Highlights include:
 
 - Compatibility with Python 3.6
-- Added a `Pandas Cheat Sheet <https://github.com/pandas-dev/pandas/tree/master/doc/cheatsheet/Pandas_Cheat_Sheet.pdf>`__. (:issue:`13202`).
+- Added a `Pandas Cheat Sheet <https://github.com/pandas-dev/pandas/tree/main/doc/cheatsheet/Pandas_Cheat_Sheet.pdf>`__. (:issue:`13202`).
 
 
 .. contents:: What's new in v0.19.2
diff --git a/doc/source/whatsnew/v0.20.0.rst b/doc/source/whatsnew/v0.20.0.rst
index 239431b7621c6..faf4b1ac44d5b 100644
--- a/doc/source/whatsnew/v0.20.0.rst
+++ b/doc/source/whatsnew/v0.20.0.rst
@@ -188,7 +188,7 @@ support for bz2 compression in the python 2 C-engine improved (:issue:`14874`).
 
    url = ('https://github.com/%7Brepo%7D/raw/%7Bbranch%7D/%7Bpath%7D'
           .format(repo='pandas-dev/pandas',
-                  branch='master',
+                  branch='main',
                   path='pandas/tests/io/parser/data/salaries.csv.bz2'))
    # default, infer compression
    df = pd.read_csv(url, sep='\t', compression='infer')
@@ -328,7 +328,7 @@ more information about the data.
 You must enable this by setting the ``display.html.table_schema`` option to ``True``.
 
 .. _Table Schema: http://specs.frictionlessdata.io/json-table-schema/
-.. _nteract: http://nteract.io/
+.. _nteract: https://nteract.io/
 
 .. _whatsnew_0200.enhancements.scipy_sparse:
 
diff --git a/doc/source/whatsnew/v0.21.1.rst b/doc/source/whatsnew/v0.21.1.rst
index 090a988d6406a..e217e1a75efc5 100644
--- a/doc/source/whatsnew/v0.21.1.rst
+++ b/doc/source/whatsnew/v0.21.1.rst
@@ -125,7 +125,7 @@ Indexing
 IO
 ^^
 
-- Bug in class:`~pandas.io.stata.StataReader` not converting date/time columns with display formatting addressed (:issue:`17990`). Previously columns with display formatting were normally left as ordinal numbers and not converted to datetime objects.
+- Bug in :class:`~pandas.io.stata.StataReader` not converting date/time columns with display formatting addressed (:issue:`17990`). Previously columns with display formatting were normally left as ordinal numbers and not converted to datetime objects.
 - Bug in :func:`read_csv` when reading a compressed UTF-16 encoded file (:issue:`18071`)
 - Bug in :func:`read_csv` for handling null values in index columns when specifying ``na_filter=False`` (:issue:`5239`)
 - Bug in :func:`read_csv` when reading numeric category fields with high cardinality (:issue:`18186`)
diff --git a/doc/source/whatsnew/v0.23.0.rst b/doc/source/whatsnew/v0.23.0.rst
index be84c562b3c32..9f24bc8e8ec50 100644
--- a/doc/source/whatsnew/v0.23.0.rst
+++ b/doc/source/whatsnew/v0.23.0.rst
@@ -1126,7 +1126,7 @@ Removal of prior version deprecations/changes
 - The ``Panel`` class has dropped the ``to_long`` and ``toLong`` methods (:issue:`19077`)
 - The options ``display.line_with`` and ``display.height`` are removed in favor of ``display.width`` and ``display.max_rows`` respectively (:issue:`4391`, :issue:`19107`)
 - The ``labels`` attribute of the ``Categorical`` class has been removed in favor of :attr:`Categorical.codes` (:issue:`7768`)
-- The ``flavor`` parameter have been removed from func:`to_sql` method (:issue:`13611`)
+- The ``flavor`` parameter have been removed from :func:`to_sql` method (:issue:`13611`)
 - The modules ``pandas.tools.hashing`` and ``pandas.util.hashing`` have been removed (:issue:`16223`)
 - The top-level functions ``pd.rolling_*``, ``pd.expanding_*`` and ``pd.ewm*`` have been removed (Deprecated since v0.18).
   Instead, use the DataFrame/Series methods :attr:`~DataFrame.rolling`, :attr:`~DataFrame.expanding` and :attr:`~DataFrame.ewm` (:issue:`18723`)
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 9cbfa49cc8c5c..e4dd6fa091d80 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -342,10 +342,15 @@ Now every group is evaluated only a single time.
 
 *New behavior*:
 
-.. ipython:: python
-
-    df.groupby("a").apply(func)
+.. code-block:: python
 
+   In [3]: df.groupby('a').apply(func)
+   x
+   y
+   Out[3]:
+      a  b
+   0  x  1
+   1  y  2
 
 Concatenating sparse values
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1116,7 +1121,7 @@ Indexing
 - Bug in which :meth:`DataFrame.to_csv` caused a segfault for a reindexed data frame, when the indices were single-level :class:`MultiIndex` (:issue:`26303`).
 - Fixed bug where assigning a :class:`arrays.PandasArray` to a :class:`pandas.core.frame.DataFrame` would raise error (:issue:`26390`)
 - Allow keyword arguments for callable local reference used in the :meth:`DataFrame.query` string (:issue:`26426`)
-- Fixed a ``KeyError`` when indexing a :class:`MultiIndex`` level with a list containing exactly one label, which is missing (:issue:`27148`)
+- Fixed a ``KeyError`` when indexing a :class:`MultiIndex` level with a list containing exactly one label, which is missing (:issue:`27148`)
 - Bug which produced ``AttributeError`` on partial matching :class:`Timestamp` in a :class:`MultiIndex`  (:issue:`26944`)
 - Bug in :class:`Categorical` and  :class:`CategoricalIndex` with :class:`Interval` values when using the ``in`` operator (``__contains``) with objects that are not comparable to the values in the ``Interval`` (:issue:`23705`)
 - Bug in :meth:`DataFrame.loc` and :meth:`DataFrame.iloc` on a :class:`DataFrame` with a single timezone-aware datetime64[ns] column incorrectly returning a scalar instead of a :class:`Series` (:issue:`27110`)
diff --git a/doc/source/whatsnew/v0.6.0.rst b/doc/source/whatsnew/v0.6.0.rst
index 19e2e85c09a87..5ddcd5d90e65c 100644
--- a/doc/source/whatsnew/v0.6.0.rst
+++ b/doc/source/whatsnew/v0.6.0.rst
@@ -24,7 +24,7 @@ New features
 - :ref:`Added <groupby.multiindex>` multiple levels to groupby (:issue:`103`)
 - :ref:`Allow <basics.sorting>` multiple columns in ``by`` argument of ``DataFrame.sort_index`` (:issue:`92`, :issue:`362`)
 - :ref:`Added <indexing.basics.get_value>` fast ``get_value`` and ``put_value`` methods to DataFrame (:issue:`360`)
-- :ref:`Added <computation.covariance>` ``cov`` instance methods to Series and DataFrame (:issue:`194`, :issue:`362`)
+- Added ``cov`` instance methods to Series and DataFrame (:issue:`194`, :issue:`362`)
 - :ref:`Added <visualization.barplot>` ``kind='bar'`` option to ``DataFrame.plot`` (:issue:`348`)
 - :ref:`Added <basics.idxmin>` ``idxmin`` and ``idxmax`` to Series and DataFrame (:issue:`286`)
 - :ref:`Added <io.clipboard>` ``read_clipboard`` function to parse DataFrame from clipboard (:issue:`300`)
diff --git a/doc/source/whatsnew/v0.6.1.rst b/doc/source/whatsnew/v0.6.1.rst
index 4e72a630ad9f1..58a7d1ee13278 100644
--- a/doc/source/whatsnew/v0.6.1.rst
+++ b/doc/source/whatsnew/v0.6.1.rst
@@ -7,7 +7,7 @@ Version 0.6.1 (December 13, 2011)
 New features
 ~~~~~~~~~~~~
 - Can append single rows (as Series) to a DataFrame
-- Add Spearman and Kendall rank :ref:`correlation <computation.correlation>`
+- Add Spearman and Kendall rank correlation
   options to Series.corr and DataFrame.corr (:issue:`428`)
 - :ref:`Added <indexing.basics.get_value>` ``get_value`` and ``set_value`` methods to
   Series, DataFrame, and Panel for very low-overhead access (>2x faster in many
@@ -19,7 +19,7 @@ New features
 - Implement new :ref:`SparseArray <sparse.array>` and ``SparseList``
   data structures. SparseSeries now derives from SparseArray (:issue:`463`)
 - :ref:`Better console printing options <basics.console_output>` (:issue:`453`)
-- Implement fast :ref:`data ranking <computation.ranking>` for Series and
+- Implement fast data ranking for Series and
   DataFrame, fast versions of scipy.stats.rankdata (:issue:`428`)
 - Implement ``DataFrame.from_items`` alternate
   constructor (:issue:`444`)
diff --git a/doc/source/whatsnew/v0.7.0.rst b/doc/source/whatsnew/v0.7.0.rst
index 1b947030ab8ab..1ee6a9899a655 100644
--- a/doc/source/whatsnew/v0.7.0.rst
+++ b/doc/source/whatsnew/v0.7.0.rst
@@ -190,11 +190,11 @@ been added:
     :header: "Method","Description"
     :widths: 40,60
 
-	``Series.iget_value(i)``, Retrieve value stored at location ``i``
-	``Series.iget(i)``, Alias for ``iget_value``
-	``DataFrame.irow(i)``, Retrieve the ``i``-th row
-	``DataFrame.icol(j)``, Retrieve the ``j``-th column
-	"``DataFrame.iget_value(i, j)``", Retrieve the value at row ``i`` and column ``j``
+        ``Series.iget_value(i)``, Retrieve value stored at location ``i``
+        ``Series.iget(i)``, Alias for ``iget_value``
+        ``DataFrame.irow(i)``, Retrieve the ``i``-th row
+        ``DataFrame.icol(j)``, Retrieve the ``j``-th column
+        "``DataFrame.iget_value(i, j)``", Retrieve the value at row ``i`` and column ``j``
 
 API tweaks regarding label-based slicing
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/doc/source/whatsnew/v0.8.0.rst b/doc/source/whatsnew/v0.8.0.rst
index 490175914cef1..ce02525a69ace 100644
--- a/doc/source/whatsnew/v0.8.0.rst
+++ b/doc/source/whatsnew/v0.8.0.rst
@@ -145,7 +145,7 @@ Other new features
 - Add :ref:`'kde' <visualization.kde>` plot option for density plots
 - Support for converting DataFrame to R data.frame through rpy2
 - Improved support for complex numbers in Series and DataFrame
-- Add :ref:`pct_change <computation.pct_change>` method to all data structures
+- Add ``pct_change`` method to all data structures
 - Add max_colwidth configuration option for DataFrame console output
 - :ref:`Interpolate <missing_data.interpolate>` Series values using index values
 - Can select multiple columns from GroupBy
diff --git a/doc/source/whatsnew/v0.9.1.rst b/doc/source/whatsnew/v0.9.1.rst
index 6b05e5bcded7e..cdc0671feeeb2 100644
--- a/doc/source/whatsnew/v0.9.1.rst
+++ b/doc/source/whatsnew/v0.9.1.rst
@@ -54,52 +54,53 @@ New features
   - DataFrame has new ``where`` and ``mask`` methods to select values according to a
     given boolean mask (:issue:`2109`, :issue:`2151`)
 
-	DataFrame currently supports slicing via a boolean vector the same length as the DataFrame (inside the ``[]``).
-	The returned DataFrame has the same number of columns as the original, but is sliced on its index.
+        DataFrame currently supports slicing via a boolean vector the same length as the DataFrame (inside the ``[]``).
+        The returned DataFrame has the same number of columns as the original, but is sliced on its index.
 
         .. ipython:: python
 
-    	    df = DataFrame(np.random.randn(5, 3), columns = ['A','B','C'])
+            df = pd.DataFrame(np.random.randn(5, 3), columns=['A', 'B', 'C'])
 
-	    df
+            df
 
-	    df[df['A'] > 0]
+            df[df['A'] > 0]
 
-	If a DataFrame is sliced with a DataFrame based boolean condition (with the same size as the original DataFrame),
-	then a DataFrame the same size (index and columns) as the original is returned, with
-	elements that do not meet the boolean condition as ``NaN``. This is accomplished via
-	the new method ``DataFrame.where``. In addition, ``where`` takes an optional ``other`` argument for replacement.
+        If a DataFrame is sliced with a DataFrame based boolean condition (with the same size as the original DataFrame),
+        then a DataFrame the same size (index and columns) as the original is returned, with
+        elements that do not meet the boolean condition as ``NaN``. This is accomplished via
+        the new method ``DataFrame.where``. In addition, ``where`` takes an optional ``other`` argument for replacement.
 
-	.. ipython:: python
+        .. ipython:: python
 
-	   df[df>0]
+           df[df > 0]
 
-	   df.where(df>0)
+           df.where(df > 0)
 
-	   df.where(df>0,-df)
+           df.where(df > 0, -df)
 
-	Furthermore, ``where`` now aligns the input boolean condition (ndarray or DataFrame), such that partial selection
-	with setting is possible. This is analogous to partial setting via ``.ix`` (but on the contents rather than the axis labels)
+        Furthermore, ``where`` now aligns the input boolean condition (ndarray or DataFrame), such that partial selection
+        with setting is possible. This is analogous to partial setting via ``.ix`` (but on the contents rather than the axis labels)
 
-	.. ipython:: python
+        .. ipython:: python
 
-	   df2 = df.copy()
-   	   df2[ df2[1:4] > 0 ] = 3
-	   df2
+           df2 = df.copy()
+           df2[df2[1:4] > 0] = 3
+           df2
 
-	``DataFrame.mask`` is the inverse boolean operation of ``where``.
+        ``DataFrame.mask`` is the inverse boolean operation of ``where``.
 
-	.. ipython:: python
+        .. ipython:: python
 
-	   df.mask(df<=0)
+           df.mask(df <= 0)
 
   - Enable referencing of Excel columns by their column names (:issue:`1936`)
 
-    .. ipython:: python
+    .. code-block:: ipython
+
+       In [1]: xl = pd.ExcelFile('data/test.xls')
 
-        xl = pd.ExcelFile('data/test.xls')
-        xl.parse('Sheet1', index_col=0, parse_dates=True,
-                 parse_cols='A:D')
+       In [2]: xl.parse('Sheet1', index_col=0, parse_dates=True,
+                        parse_cols='A:D')
 
 
   - Added option to disable pandas-style tick locators and formatters
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 03dfe475475a1..2ab0af46cda88 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -525,7 +525,7 @@ Use :meth:`arrays.IntegerArray.to_numpy` with an explicit ``na_value`` instead.
 
    a.to_numpy(dtype="float", na_value=np.nan)
 
-**Reductions can return ``pd.NA``**
+**Reductions can return** ``pd.NA``
 
 When performing a reduction such as a sum with ``skipna=False``, the result
 will now be ``pd.NA`` instead of ``np.nan`` in presence of missing values
diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 9f3ccb3e14116..e1f54c439ae9b 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -265,7 +265,7 @@ SSH, FTP, dropbox and github. For docs and capabilities, see the `fsspec docs`_.
 The existing capability to interface with S3 and GCS will be unaffected by this
 change, as ``fsspec`` will still bring in the same packages as before.
 
-.. _Azure Datalake and Blob: https://github.com/dask/adlfs
+.. _Azure Datalake and Blob: https://github.com/fsspec/adlfs
 
 .. _fsspec docs: https://filesystem-spec.readthedocs.io/en/latest/
 
@@ -665,9 +665,9 @@ the previous index (:issue:`32240`).
    In [4]: result
    Out[4]:
         min_val
-    0 	x
-    1 	y
-    2 	z
+    0   x
+    1   y
+    2   z
 
 *New behavior*:
 
diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 3d3ec53948a01..49f9abd99db53 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -354,6 +354,7 @@ of columns could result in a larger Series result. See (:issue:`37799`).
 *New behavior*:
 
 .. ipython:: python
+   :okwarning:
 
     In [5]: df.all(bool_only=True)
 
diff --git a/doc/source/whatsnew/v1.3.0.rst b/doc/source/whatsnew/v1.3.0.rst
index ed66861efad93..a392aeb5274c2 100644
--- a/doc/source/whatsnew/v1.3.0.rst
+++ b/doc/source/whatsnew/v1.3.0.rst
@@ -811,7 +811,7 @@ Other Deprecations
 - Deprecated allowing scalars to be passed to the :class:`Categorical` constructor (:issue:`38433`)
 - Deprecated constructing :class:`CategoricalIndex` without passing list-like data (:issue:`38944`)
 - Deprecated allowing subclass-specific keyword arguments in the :class:`Index` constructor, use the specific subclass directly instead (:issue:`14093`, :issue:`21311`, :issue:`22315`, :issue:`26974`)
-- Deprecated the :meth:`astype` method of datetimelike (``timedelta64[ns]``, ``datetime64[ns]``, ``Datetime64TZDtype``, ``PeriodDtype``) to convert to integer dtypes, use ``values.view(...)`` instead (:issue:`38544`)
+- Deprecated the :meth:`astype` method of datetimelike (``timedelta64[ns]``, ``datetime64[ns]``, ``Datetime64TZDtype``, ``PeriodDtype``) to convert to integer dtypes, use ``values.view(...)`` instead (:issue:`38544`). This deprecation was later reverted in pandas 1.4.0.
 - Deprecated :meth:`MultiIndex.is_lexsorted` and :meth:`MultiIndex.lexsort_depth`, use :meth:`MultiIndex.is_monotonic_increasing` instead (:issue:`32259`)
 - Deprecated keyword ``try_cast`` in :meth:`Series.where`, :meth:`Series.mask`, :meth:`DataFrame.where`, :meth:`DataFrame.mask`; cast results manually if desired (:issue:`38836`)
 - Deprecated comparison of :class:`Timestamp` objects with ``datetime.date`` objects.  Instead of e.g. ``ts <= mydate`` use ``ts <= pd.Timestamp(mydate)`` or ``ts.date() <= mydate`` (:issue:`36131`)
diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 54fb6555fa05d..697070e50a40a 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -1,6 +1,6 @@
 .. _whatsnew_140:
 
-What's new in 1.4.0 (January ??, 2022)
+What's new in 1.4.0 (January 22, 2022)
 --------------------------------------
 
 These are the changes in pandas 1.4.0. See :ref:`release` for a full changelog
@@ -20,7 +20,8 @@ Enhancements
 Improved warning messages
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Previously, warning messages may have pointed to lines within the pandas library. Running the script ``setting_with_copy_warning.py``
+Previously, warning messages may have pointed to lines within the pandas
+library. Running the script ``setting_with_copy_warning.py``
 
 .. code-block:: python
 
@@ -34,7 +35,10 @@ with pandas 1.3 resulted in::
     .../site-packages/pandas/core/indexing.py:1951: SettingWithCopyWarning:
     A value is trying to be set on a copy of a slice from a DataFrame.
 
-This made it difficult to determine where the warning was being generated from. Now pandas will inspect the call stack, reporting the first line outside of the pandas library that gave rise to the warning. The output of the above script is now::
+This made it difficult to determine where the warning was being generated from.
+Now pandas will inspect the call stack, reporting the first line outside of the
+pandas library that gave rise to the warning. The output of the above script is
+now::
 
     setting_with_copy_warning.py:4: SettingWithCopyWarning:
     A value is trying to be set on a copy of a slice from a DataFrame.
@@ -47,8 +51,9 @@ This made it difficult to determine where the warning was being generated from.
 Index can hold arbitrary ExtensionArrays
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast the
-array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary ExtensionArrays (:issue:`43930`).
+Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast
+the array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary
+ExtensionArrays (:issue:`43930`).
 
 *Previous behavior*:
 
@@ -87,39 +92,45 @@ Styler
 
   - Styling and formatting of indexes has been added, with :meth:`.Styler.apply_index`, :meth:`.Styler.applymap_index` and :meth:`.Styler.format_index`. These mirror the signature of the methods already used to style and format data values, and work with both HTML, LaTeX and Excel format (:issue:`41893`, :issue:`43101`, :issue:`41993`, :issue:`41995`)
   - The new method :meth:`.Styler.hide` deprecates :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` (:issue:`43758`)
-  - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
+  - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of Index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
   - The :meth:`.Styler.export` and :meth:`.Styler.use` have been updated to address all of the added functionality from v1.2.0 and v1.3.0 (:issue:`40675`)
-  - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax``. (:issue:`41395`)
+  - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax`` (:issue:`41395`)
   - Validation of certain keyword arguments, e.g. ``caption`` (:issue:`43368`)
   - Various bug fixes as recorded below
 
 Additionally there are specific enhancements to the HTML specific rendering:
 
-  - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`).
-  - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`).
+  - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`)
+  - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`)
   - :meth:`.Styler.to_html` omits CSSStyle rules for hidden table elements as a performance enhancement (:issue:`43619`)
   - Custom CSS classes can now be directly specified without string replacement (:issue:`43686`)
   - Ability to render hyperlinks automatically via a new ``hyperlinks`` formatting keyword argument (:issue:`45058`)
 
 There are also some LaTeX specific enhancements:
 
-  - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`).
+  - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`)
   - Naive sparsification is now possible for LaTeX without the necessity of including the multirow package (:issue:`43369`)
+  - *cline* support has been added for :class:`MultiIndex` row sparsification through a keyword argument (:issue:`45138`)
 
 .. _whatsnew_140.enhancements.pyarrow_csv_engine:
 
-Multithreaded CSV reading with a new CSV Engine based on pyarrow
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multi-threaded CSV reading with a new CSV Engine based on pyarrow
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least ``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore machines
-with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for more info. (:issue:`23697`, :issue:`43706`)
+:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least
+``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore
+machines with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for
+more info. (:issue:`23697`, :issue:`43706`)
 
 .. _whatsnew_140.enhancements.window_rank:
 
 Rank function for rolling and expanding windows
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new function supports the ``method``, ``ascending``, and ``pct`` flags of :meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and ``average`` ranking methods.
+Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new
+function supports the ``method``, ``ascending``, and ``pct`` flags of
+:meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and
+``average`` ranking methods.
 Example:
 
 .. ipython:: python
@@ -134,10 +145,12 @@ Example:
 Groupby positional indexing
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-It is now possible to specify positional ranges relative to the ends of each group.
+It is now possible to specify positional ranges relative to the ends of each
+group.
 
-Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work correctly and result in ranges relative to the end and start of each group, respectively.
-Previously, negative arguments returned empty frames.
+Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work
+correctly and result in ranges relative to the end and start of each group,
+respectively. Previously, negative arguments returned empty frames.
 
 .. ipython:: python
 
@@ -166,10 +179,11 @@ Previously, negative arguments returned empty frames.
 DataFrame.from_dict and DataFrame.to_dict have new ``'tight'`` option
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries and names
-is now available with the :meth:`DataFrame.from_dict` and :meth:`DataFrame.to_dict` methods
-and can be used with the standard ``json`` library to produce a tight
-representation of :class:`DataFrame` objects (:issue:`4889`).
+A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries
+and names is now available with the :meth:`DataFrame.from_dict` and
+:meth:`DataFrame.to_dict` methods and can be used with the standard ``json``
+library to produce a tight representation of :class:`DataFrame` objects
+(:issue:`4889`).
 
 .. ipython:: python
 
@@ -187,41 +201,42 @@ representation of :class:`DataFrame` objects (:issue:`4889`).
 
 Other enhancements
 ^^^^^^^^^^^^^^^^^^
-- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different. (:issue:`41828`)
+- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different (:issue:`41828`)
 - :class:`DataFrameGroupBy` operations with ``as_index=False`` now correctly retain ``ExtensionDtype`` dtypes for columns being grouped on (:issue:`41373`)
 - Add support for assigning values to ``by`` argument in :meth:`DataFrame.plot.hist` and :meth:`DataFrame.plot.box` (:issue:`15079`)
 - :meth:`Series.sample`, :meth:`DataFrame.sample`, and :meth:`.GroupBy.sample` now accept a ``np.random.Generator`` as input to ``random_state``. A generator will be more performant, especially with ``replace=False`` (:issue:`38100`)
-- :meth:`Series.ewm`, :meth:`DataFrame.ewm`, now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
+- :meth:`Series.ewm` and :meth:`DataFrame.ewm` now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
 - :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` now support the argument ``skipna`` (:issue:`34047`)
 - :meth:`read_table` now supports the argument ``storage_options`` (:issue:`39167`)
-- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns
+- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns (:issue:`38454`)
 - Methods that relied on hashmap based algos such as :meth:`DataFrameGroupBy.value_counts`, :meth:`DataFrameGroupBy.count` and :func:`factorize` ignored imaginary component for complex numbers (:issue:`17927`)
 - Add :meth:`Series.str.removeprefix` and :meth:`Series.str.removesuffix` introduced in Python 3.9 to remove pre-/suffixes from string-type :class:`Series` (:issue:`36944`)
 - Attempting to write into a file in missing parent directory with :meth:`DataFrame.to_csv`, :meth:`DataFrame.to_html`, :meth:`DataFrame.to_excel`, :meth:`DataFrame.to_feather`, :meth:`DataFrame.to_parquet`, :meth:`DataFrame.to_stata`, :meth:`DataFrame.to_json`, :meth:`DataFrame.to_pickle`, and :meth:`DataFrame.to_xml` now explicitly mentions missing parent directory, the same is true for :class:`Series` counterparts (:issue:`24306`)
 - Indexing with ``.loc`` and ``.iloc`` now supports ``Ellipsis`` (:issue:`37750`)
 - :meth:`IntegerArray.all` , :meth:`IntegerArray.any`, :meth:`FloatingArray.any`, and :meth:`FloatingArray.all` use Kleene logic (:issue:`41967`)
 - Added support for nullable boolean and integer types in :meth:`DataFrame.to_stata`, :class:`~pandas.io.stata.StataWriter`, :class:`~pandas.io.stata.StataWriter117`, and :class:`~pandas.io.stata.StataWriterUTF8` (:issue:`40855`)
-- :meth:`DataFrame.__pos__`, :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
+- :meth:`DataFrame.__pos__` and :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
 - The error raised when an optional dependency can't be imported now includes the original exception, for easier investigation (:issue:`43882`)
 - Added :meth:`.ExponentialMovingWindow.sum` (:issue:`13297`)
 - :meth:`Series.str.split` now supports a ``regex`` argument that explicitly specifies whether the pattern is a regular expression. Default is ``None`` (:issue:`43563`, :issue:`32835`, :issue:`25549`)
 - :meth:`DataFrame.dropna` now accepts a single label as ``subset`` along with array-like (:issue:`41021`)
 - Added :meth:`DataFrameGroupBy.value_counts` (:issue:`43564`)
+- :func:`read_csv` now accepts a ``callable`` function in ``on_bad_lines`` when ``engine="python"`` for custom handling of bad lines (:issue:`5686`)
 - :class:`ExcelWriter` argument ``if_sheet_exists="overlay"`` option added (:issue:`40231`)
 - :meth:`read_excel` now accepts a ``decimal`` argument that allow the user to specify the decimal point when parsing string columns to numeric (:issue:`14403`)
-- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, :meth:`.GroupBy.sum` now supports `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
-- :meth:`Timestamp.isoformat`, now handles the ``timespec`` argument from the base :class:``datetime`` class (:issue:`26131`)
+- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, and :meth:`.GroupBy.sum` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
+- :meth:`Timestamp.isoformat` now handles the ``timespec`` argument from the base ``datetime`` class (:issue:`26131`)
 - :meth:`NaT.to_numpy` ``dtype`` argument is now respected, so ``np.timedelta64`` can be returned (:issue:`44460`)
 - New option ``display.max_dir_items`` customizes the number of columns added to :meth:`Dataframe.__dir__` and suggested for tab completion (:issue:`37996`)
-- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar``.  See also `Other API changes`_.
-- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
+- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar`` (:issue:`44574`)
+- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, and :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
 - :meth:`Series.info` has been added, for compatibility with :meth:`DataFrame.info` (:issue:`5167`)
-- Implemented :meth:`IntervalArray.min`, :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
+- Implemented :meth:`IntervalArray.min` and :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
 - :meth:`UInt64Index.map` now retains ``dtype`` where possible (:issue:`44609`)
 - :meth:`read_json` can now parse unsigned long long integers (:issue:`26068`)
 - :meth:`DataFrame.take` now raises a ``TypeError`` when passed a scalar for the indexer (:issue:`42875`)
 - :meth:`is_list_like` now identifies duck-arrays as list-like unless ``.ndim == 0`` (:issue:`35131`)
-- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`).
+- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`)
 - Add support for `Zstandard <http://facebook.github.io/zstd/>`_ compression to :meth:`DataFrame.to_pickle`/:meth:`read_pickle` and friends (:issue:`43925`)
 - :meth:`DataFrame.to_sql` now returns an ``int`` of the number of written rows (:issue:`23998`)
 
@@ -239,24 +254,30 @@ These are bug fixes that might have notable behavior changes.
 Inconsistent date string parsing
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead to surprising behaviour:
+The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead
+to surprising behavior:
 
 .. ipython:: python
     :okwarning:
 
     pd.to_datetime(["31-12-2021"], dayfirst=False)
 
-Now, a warning will be raised if a date string cannot be parsed accordance to the given ``dayfirst`` value when
-the value is a delimited date string (e.g. ``31-12-2012``).
+Now, a warning will be raised if a date string cannot be parsed accordance to
+the given ``dayfirst`` value when the value is a delimited date string (e.g.
+``31-12-2012``).
 
 .. _whatsnew_140.notable_bug_fixes.concat_with_empty_or_all_na:
 
 Ignoring dtypes in concat with empty or all-NA columns
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+.. note::
+    This behaviour change has been reverted in pandas 1.4.3.
+
 When using :func:`concat` to concatenate two or more :class:`DataFrame` objects,
-if one of the DataFrames was empty or had all-NA values, its dtype was *sometimes*
-ignored when finding the concatenated dtype.  These are now consistently *not* ignored (:issue:`43507`).
+if one of the DataFrames was empty or had all-NA values, its dtype was
+*sometimes* ignored when finding the concatenated dtype.  These are now
+consistently *not* ignored (:issue:`43507`).
 
 .. ipython:: python
 
@@ -264,7 +285,9 @@ ignored when finding the concatenated dtype.  These are now consistently *not* i
     df2 = pd.DataFrame({"bar": np.nan}, index=range(1, 2))
     res = pd.concat([df1, df2])
 
-Previously, the float-dtype in ``df2`` would be ignored so the result dtype would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to ``NaT``.
+Previously, the float-dtype in ``df2`` would be ignored so the result dtype
+would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to
+``NaT``.
 
 *Previous behavior*:
 
@@ -276,20 +299,30 @@ Previously, the float-dtype in ``df2`` would be ignored so the result dtype woul
     0 2013-01-01
     1        NaT
 
-Now the float-dtype is respected. Since the common dtype for these DataFrames is object, the ``np.nan`` is retained.
+Now the float-dtype is respected. Since the common dtype for these DataFrames is
+object, the ``np.nan`` is retained.
 
 *New behavior*:
 
-.. ipython:: python
+.. code-block:: ipython
+
+    In [4]: res
+    Out[4]:
+                       bar
+    0  2013-01-01 00:00:00
+    1                  NaN
+
 
-    res
 
 .. _whatsnew_140.notable_bug_fixes.value_counts_and_mode_do_not_coerce_to_nan:
 
 Null-values are no longer coerced to NaN-value in value_counts and mode
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``, ``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This behavior is now consistent with ``unique``, ``isin`` and others (:issue:`42688`).
+:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``,
+``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This
+behavior is now consistent with ``unique``, ``isin`` and others
+(:issue:`42688`).
 
 .. ipython:: python
 
@@ -318,11 +351,12 @@ Now null-values are no longer mangled.
 
 .. _whatsnew_140.notable_bug_fixes.read_csv_mangle_dup_cols:
 
-mangle_dupe_cols in read_csv no longer renaming unique columns conflicting with target names
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+mangle_dupe_cols in read_csv no longer renames unique columns conflicting with target names
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-:func:`read_csv` no longer renaming unique cols, which conflict with the target names of duplicated columns.
-Already existing columns are jumped, e.g. the next available index is used for the target column name (:issue:`14704`).
+:func:`read_csv` no longer renames unique column labels which conflict with the target
+names of duplicated columns. Already existing columns are skipped, i.e. the next
+available index is used for the target column name (:issue:`14704`).
 
 .. ipython:: python
 
@@ -331,7 +365,8 @@ Already existing columns are jumped, e.g. the next available index is used for t
     data = "a,a,a.1\n1,2,3"
     res = pd.read_csv(io.StringIO(data))
 
-Previously, the second column was called ``a.1``, while the third col was also renamed to ``a.1.1``.
+Previously, the second column was called ``a.1``, while the third column was
+also renamed to ``a.1.1``.
 
 *Previous behavior*:
 
@@ -342,8 +377,9 @@ Previously, the second column was called ``a.1``, while the third col was also r
         a  a.1  a.1.1
     0   1    2      3
 
-Now the renaming checks if ``a.1`` already exists when changing the name of the second column and jumps this index. The
-second column is instead renamed to ``a.2``.
+Now the renaming checks if ``a.1`` already exists when changing the name of the
+second column and jumps this index. The second column is instead renamed to
+``a.2``.
 
 *New behavior*:
 
@@ -356,9 +392,10 @@ second column is instead renamed to ``a.2``.
 unstack and pivot_table no longer raises ValueError for result that would exceed int32 limit
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would raise a ``ValueError`` if the operation
-could produce a result with more than ``2**31 - 1`` elements. This operation now raises a :class:`errors.PerformanceWarning`
-instead (:issue:`26314`).
+Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would
+raise a ``ValueError`` if the operation could produce a result with more than
+``2**31 - 1`` elements. This operation now raises a
+:class:`errors.PerformanceWarning` instead (:issue:`26314`).
 
 *Previous behavior*:
 
@@ -377,11 +414,86 @@ instead (:issue:`26314`).
 
 .. ---------------------------------------------------------------------------
 
+.. _whatsnew_140.notable_bug_fixes.groupby_apply_mutation:
+
+groupby.apply consistent transform detection
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`.GroupBy.apply` is designed to be flexible, allowing users to perform
+aggregations, transformations, filters, and use it with user-defined functions
+that might not fall into any of these categories. As part of this, apply will
+attempt to detect when an operation is a transform, and in such a case, the
+result will have the same index as the input. In order to determine if the
+operation is a transform, pandas compares the input's index to the result's and
+determines if it has been mutated. Previously in pandas 1.3, different code
+paths used different definitions of "mutated": some would use Python's ``is``
+whereas others would test only up to equality.
+
+This inconsistency has been removed, pandas now tests up to equality.
+
+.. ipython:: python
+
+    def func(x):
+        return x.copy()
+
+    df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
+    df
+
+*Previous behavior*:
+
+.. code-block:: ipython
+
+    In [3]: df.groupby(['a']).apply(func)
+    Out[3]:
+         a  b  c
+    a
+    1 0  1  3  5
+    2 1  2  4  6
+
+    In [4]: df.set_index(['a', 'b']).groupby(['a']).apply(func)
+    Out[4]:
+         c
+    a b
+    1 3  5
+    2 4  6
+
+In the examples above, the first uses a code path where pandas uses ``is`` and
+determines that ``func`` is not a transform whereas the second tests up to
+equality and determines that ``func`` is a transform. In the first case, the
+result's index is not the same as the input's.
+
+*New behavior*:
+
+.. code-block:: ipython
+
+    In [5]: df.groupby(['a']).apply(func)
+    Out[5]:
+       a  b  c
+    0  1  3  5
+    1  2  4  6
+
+    In [6]: df.set_index(['a', 'b']).groupby(['a']).apply(func)
+    Out[6]:
+         c
+    a b
+    1 3  5
+    2 4  6
+
+Now in both cases it is determined that ``func`` is a transform. In each case,
+the result has the same index as the input.
+
 .. _whatsnew_140.api_breaking:
 
 Backwards incompatible API changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+.. _whatsnew_140.api_breaking.python:
+
+Increased minimum version for Python
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+pandas 1.4.0 supports Python 3.8 and higher.
+
 .. _whatsnew_140.api_breaking.deps:
 
 Increased minimum versions for dependencies
@@ -407,9 +519,12 @@ If installed, we now require:
 | mypy (dev)      | 0.930           |          |    X    |
 +-----------------+-----------------+----------+---------+
 
-For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
-The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
-Optional libraries below the lowest tested version may still work, but are not considered supported.
+For `optional libraries
+<https://pandas.pydata.org/docs/getting_started/install.html>`_ the general
+recommendation is to use the latest version. The following table lists the
+lowest version per library that is currently being tested throughout the
+development of pandas. Optional libraries below the lowest tested version may
+still work, but are not considered supported.
 
 +-----------------+-----------------+---------+
 | Package         | Minimum Version | Changed |
@@ -430,6 +545,8 @@ Optional libraries below the lowest tested version may still work, but are not c
 +-----------------+-----------------+---------+
 | openpyxl        | 3.0.3           |    X    |
 +-----------------+-----------------+---------+
+| pandas-gbq      | 0.14.0          |    X    |
++-----------------+-----------------+---------+
 | pyarrow         | 1.0.1           |    X    |
 +-----------------+-----------------+---------+
 | pymysql         | 0.10.1          |    X    |
@@ -452,8 +569,6 @@ Optional libraries below the lowest tested version may still work, but are not c
 +-----------------+-----------------+---------+
 | xlwt            | 1.3.0           |         |
 +-----------------+-----------------+---------+
-| pandas-gbq      | 0.14.0          |    X    |
-+-----------------+-----------------+---------+
 
 See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
 
@@ -461,7 +576,7 @@ See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for mor
 
 Other API changes
 ^^^^^^^^^^^^^^^^^
-- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than 'target'); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
+- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than ``target``); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
 - Change in the position of the ``min_rows`` argument in :meth:`DataFrame.to_string` due to change in the docstring (:issue:`44304`)
 - Reduction operations for :class:`DataFrame` or :class:`Series` now raising a ``ValueError`` when ``None`` is passed for ``skipna`` (:issue:`44178`)
 - :func:`read_csv` and :func:`read_html` no longer raising an error when one of the header rows consists only of ``Unnamed:`` columns (:issue:`13054`)
@@ -477,7 +592,6 @@ Other API changes
    - "Thanksgiving" is now "Thanksgiving Day"
    - "Christmas" is now "Christmas Day"
    - Added "Juneteenth National Independence Day"
--
 
 .. ---------------------------------------------------------------------------
 
@@ -491,11 +605,13 @@ Deprecations
 Deprecated Int64Index, UInt64Index & Float64Index
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been deprecated
-in favor of the base :class:`Index` class and will be removed in Pandas 2.0 (:issue:`43028`).
+:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been
+deprecated in favor of the base :class:`Index` class and will be removed in
+Pandas 2.0 (:issue:`43028`).
 
-For constructing a numeric index, you can use the base :class:`Index` class instead
-specifying the data type (which will also work on older pandas releases):
+For constructing a numeric index, you can use the base :class:`Index` class
+instead specifying the data type (which will also work on older pandas
+releases):
 
 .. code-block:: python
 
@@ -514,9 +630,10 @@ checks with checking the ``dtype``:
     # with
     idx.dtype == "int64"
 
-Currently, in order to maintain backward compatibility, calls to
-:class:`Index` will continue to return :class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index`
-when given numeric data, but in the future, an :class:`Index` will be returned.
+Currently, in order to maintain backward compatibility, calls to :class:`Index`
+will continue to return :class:`Int64Index`, :class:`UInt64Index` and
+:class:`Float64Index` when given numeric data, but in the future, an
+:class:`Index` will be returned.
 
 *Current behavior*:
 
@@ -539,11 +656,11 @@ when given numeric data, but in the future, an :class:`Index` will be returned.
 
 .. _whatsnew_140.deprecations.frame_series_append:
 
-Deprecated Frame.append and Series.append
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Deprecated DataFrame.append and Series.append
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will be removed in Pandas 2.0.
-Use :func:`pandas.concat` instead (:issue:`35407`).
+:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will
+be removed in a future version. Use :func:`pandas.concat` instead (:issue:`35407`).
 
 *Deprecated syntax*
 
@@ -588,28 +705,27 @@ Other Deprecations
 - Deprecated ``method`` argument in :meth:`Index.get_loc`, use ``index.get_indexer([label], method=...)`` instead (:issue:`42269`)
 - Deprecated treating integer keys in :meth:`Series.__setitem__` as positional when the index is a :class:`Float64Index` not containing the key, a :class:`IntervalIndex` with no entries containing the key, or a :class:`MultiIndex` with leading :class:`Float64Index` level not containing the key (:issue:`33469`)
 - Deprecated treating ``numpy.datetime64`` objects as UTC times when passed to the :class:`Timestamp` constructor along with a timezone. In a future version, these will be treated as wall-times. To retain the old behavior, use ``Timestamp(dt64).tz_localize("UTC").tz_convert(tz)`` (:issue:`24559`)
-- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a MultiIndex (:issue:`42351`)
-- Creating an empty Series without a dtype will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
-- Deprecated the 'kind' argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, :meth:`Index.slice_locs`; in a future version passing 'kind' will raise (:issue:`42857`)
+- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a :class:`MultiIndex` (:issue:`42351`)
+- Creating an empty :class:`Series` without a ``dtype`` will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
+- Deprecated the ``kind`` argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, and :meth:`Index.slice_locs`; in a future version passing ``kind`` will raise (:issue:`42857`)
 - Deprecated dropping of nuisance columns in :class:`Rolling`, :class:`Expanding`, and :class:`EWM` aggregations (:issue:`42738`)
-- Deprecated :meth:`Index.reindex` with a non-unique index (:issue:`42568`)
-- Deprecated :meth:`.Styler.render` in favour of :meth:`.Styler.to_html` (:issue:`42140`)
-- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favour of :meth:`.Styler.hide` (:issue:`43758`)
+- Deprecated :meth:`Index.reindex` with a non-unique :class:`Index` (:issue:`42568`)
+- Deprecated :meth:`.Styler.render` in favor of :meth:`.Styler.to_html` (:issue:`42140`)
+- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favor of :meth:`.Styler.hide` (:issue:`43758`)
 - Deprecated passing in a string column label into ``times`` in :meth:`DataFrame.ewm` (:issue:`43265`)
-- Deprecated the 'include_start' and 'include_end' arguments in :meth:`DataFrame.between_time`; in a future version passing 'include_start' or 'include_end' will raise (:issue:`40245`)
-- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead. (:issue:`43242`)
+- Deprecated the ``include_start`` and ``include_end`` arguments in :meth:`DataFrame.between_time`; in a future version passing ``include_start`` or ``include_end`` will raise (:issue:`40245`)
+- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the :class:`DataFrame` afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
 - Deprecated the ``index`` argument to :class:`SparseArray` construction (:issue:`23089`)
 - Deprecated the ``closed`` argument in :meth:`date_range` and :meth:`bdate_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
 - Deprecated :meth:`.Rolling.validate`, :meth:`.Expanding.validate`, and :meth:`.ExponentialMovingWindow.validate` (:issue:`43665`)
 - Deprecated silent dropping of columns that raised a ``TypeError`` in :class:`Series.transform` and :class:`DataFrame.transform` when used with a dictionary (:issue:`43740`)
 - Deprecated silent dropping of columns that raised a ``TypeError``, ``DataError``, and some cases of ``ValueError`` in :meth:`Series.aggregate`, :meth:`DataFrame.aggregate`, :meth:`Series.groupby.aggregate`, and :meth:`DataFrame.groupby.aggregate` when used with a list (:issue:`43740`)
 - Deprecated casting behavior when setting timezone-aware value(s) into a timezone-aware :class:`Series` or :class:`DataFrame` column when the timezones do not match. Previously this cast to object dtype. In a future version, the values being inserted will be converted to the series or column's existing timezone (:issue:`37605`)
-- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object dtype. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`,:issue:`44940`)
-- Deprecated the 'errors' keyword argument in :meth:`Series.where`, :meth:`DataFrame.where`, :meth:`Series.mask`, and :meth:`DataFrame.mask`; in a future version the argument will be removed (:issue:`44294`)
+- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object ``dtype``. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`, :issue:`44940`)
 - Deprecated the ``prefix`` keyword argument in :func:`read_csv` and :func:`read_table`, in a future version the argument will be removed (:issue:`43396`)
-- Deprecated passing non boolean argument to sort in :func:`concat` (:issue:`41518`)
-- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`):
-- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`):
+- Deprecated passing non boolean argument to ``sort`` in :func:`concat` (:issue:`41518`)
+- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`)
+- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`)
 - Deprecated passing ``skipna=None`` for :meth:`DataFrame.mad` and :meth:`Series.mad`, pass ``skipna=True`` instead (:issue:`44580`)
 - Deprecated the behavior of :func:`to_datetime` with the string "now" with ``utc=False``; in a future version this will match ``Timestamp("now")``, which in turn matches :meth:`Timestamp.now` returning the local time (:issue:`18705`)
 - Deprecated :meth:`DateOffset.apply`, use ``offset + other`` instead (:issue:`44522`)
@@ -629,6 +745,7 @@ Other Deprecations
 - Deprecated the behavior of :meth:`Timestamp.utcfromtimestamp`, in the future it will return a timezone-aware UTC :class:`Timestamp` (:issue:`22451`)
 - Deprecated :meth:`NaT.freq` (:issue:`45071`)
 - Deprecated behavior of :class:`Series` and :class:`DataFrame` construction when passed float-dtype data containing ``NaN`` and an integer dtype ignoring the dtype argument; in a future version this will raise (:issue:`40110`)
+- Deprecated the behaviour of :meth:`Series.to_frame` and :meth:`Index.to_frame` to ignore the ``name`` argument when ``name=None``. Currently, this means to preserve the existing name, but in the future explicitly passing ``name=None`` will set ``None`` as the name of the column in the resulting DataFrame (:issue:`44212`)
 
 .. ---------------------------------------------------------------------------
 
@@ -650,9 +767,9 @@ Performance improvements
 - Performance improvement in :meth:`Series.sparse.to_coo` (:issue:`42880`)
 - Performance improvement in indexing with a :class:`UInt64Index` (:issue:`43862`)
 - Performance improvement in indexing with a :class:`Float64Index` (:issue:`43705`)
-- Performance improvement in indexing with a non-unique Index (:issue:`43792`)
+- Performance improvement in indexing with a non-unique :class:`Index` (:issue:`43792`)
 - Performance improvement in indexing with a listlike indexer on a :class:`MultiIndex` (:issue:`43370`)
-- Performance improvement in indexing with a :class:`MultiIndex` indexer on another :class:`MultiIndex` (:issue:43370`)
+- Performance improvement in indexing with a :class:`MultiIndex` indexer on another :class:`MultiIndex` (:issue:`43370`)
 - Performance improvement in :meth:`GroupBy.quantile` (:issue:`43469`, :issue:`43725`)
 - Performance improvement in :meth:`GroupBy.count` (:issue:`43730`, :issue:`43694`)
 - Performance improvement in :meth:`GroupBy.any` and :meth:`GroupBy.all` (:issue:`43675`, :issue:`42841`)
@@ -709,26 +826,28 @@ Datetimelike
 - :func:`to_datetime` would silently swap ``MM/DD/YYYY`` and ``DD/MM/YYYY`` formats if the given ``dayfirst`` option could not be respected - now, a warning is raised in the case of delimited date strings (e.g. ``31-12-2012``) (:issue:`12585`)
 - Bug in :meth:`date_range` and :meth:`bdate_range` do not return right bound when ``start`` = ``end`` and set is closed on one side (:issue:`43394`)
 - Bug in inplace addition and subtraction of :class:`DatetimeIndex` or :class:`TimedeltaIndex` with :class:`DatetimeArray` or :class:`TimedeltaArray` (:issue:`43904`)
-- Bug in in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
+- Bug in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
 - Bug in constructing a :class:`Series` from datetime-like strings with mixed timezones incorrectly partially-inferring datetime values (:issue:`40111`)
-- Bug in addition with a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
+- Bug in addition of a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
 - ``np.maximum.reduce`` and ``np.minimum.reduce`` now correctly return :class:`Timestamp` and :class:`Timedelta` objects when operating on :class:`Series`, :class:`DataFrame`, or :class:`Index` with ``datetime64[ns]`` or ``timedelta64[ns]`` dtype (:issue:`43923`)
 - Bug in adding a ``np.timedelta64`` object to a :class:`BusinessDay` or :class:`CustomBusinessDay` object incorrectly raising (:issue:`44532`)
 - Bug in :meth:`Index.insert` for inserting ``np.datetime64``, ``np.timedelta64`` or ``tuple`` into :class:`Index` with ``dtype='object'`` with negative loc adding ``None`` and replacing existing value (:issue:`44509`)
+- Bug in :meth:`Timestamp.to_pydatetime` failing to retain the ``fold`` attribute (:issue:`45087`)
 - Bug in :meth:`Series.mode` with ``DatetimeTZDtype`` incorrectly returning timezone-naive and ``PeriodDtype`` incorrectly raising (:issue:`41927`)
-- Bug in :class:`DateOffset`` addition with :class:`Timestamp` where ``offset.nanoseconds`` would not be included in the result (:issue:`43968`, :issue:`36589`)
+- Fixed regression in :meth:`~Series.reindex` raising an error when using an incompatible fill value with a datetime-like dtype (or not raising a deprecation warning for using a ``datetime.date`` as fill value) (:issue:`42921`)
+- Bug in :class:`DateOffset` addition with :class:`Timestamp` where ``offset.nanoseconds`` would not be included in the result (:issue:`43968`, :issue:`36589`)
 - Bug in :meth:`Timestamp.fromtimestamp` not supporting the ``tz`` argument (:issue:`45083`)
 - Bug in :class:`DataFrame` construction from dict of :class:`Series` with mismatched index dtypes sometimes raising depending on the ordering of the passed dict (:issue:`44091`)
 - Bug in :class:`Timestamp` hashing during some DST transitions caused a segmentation fault (:issue:`33931` and :issue:`40817`)
 
 Timedelta
 ^^^^^^^^^
-- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype arraylike of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
+- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype array like of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
 - Bug in floor division of ``timedelta64[ns]`` data with a scalar returning garbage values (:issue:`44466`)
-- Bug in :class:`Timedelta` now properly taking into account any nanoseconds contribution of any kwarg (:issue:`43764`)
+- Bug in :class:`Timedelta` now properly taking into account any nanoseconds contribution of any kwarg (:issue:`43764`, :issue:`45227`)
 
-Timezones
-^^^^^^^^^
+Time Zones
+^^^^^^^^^^
 - Bug in :func:`to_datetime` with ``infer_datetime_format=True`` failing to parse zero UTC offset (``Z``) correctly (:issue:`41047`)
 - Bug in :meth:`Series.dt.tz_convert` resetting index in a :class:`Series` with :class:`CategoricalIndex` (:issue:`43080`)
 - Bug in ``Timestamp`` and ``DatetimeIndex`` incorrectly raising a ``TypeError`` when subtracting two timezone-aware objects with mismatched timezones (:issue:`31793`)
@@ -747,11 +866,11 @@ Numeric
 
 Conversion
 ^^^^^^^^^^
-- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large too hold in int64 (:issue:`42201`)
+- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large to hold in int64 (:issue:`42201`)
 - Bug in :class:`Series` constructor returning 0 for missing values with dtype ``int64`` and ``False`` for dtype ``bool`` (:issue:`43017`, :issue:`43018`)
 - Bug in constructing a :class:`DataFrame` from a :class:`PandasArray` containing :class:`Series` objects behaving differently than an equivalent ``np.ndarray`` (:issue:`43986`)
 - Bug in :class:`IntegerDtype` not allowing coercion from string dtype (:issue:`25472`)
-- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises TypeError (:issue:`44053`)
+- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises ``TypeError`` (:issue:`44053`)
 - Bug in :meth:`DataFrame.convert_dtypes` not returning the correct type when a subclass does not overload :meth:`_constructor_sliced` (:issue:`43201`)
 - Bug in :meth:`DataFrame.astype` not propagating ``attrs`` from the original :class:`DataFrame` (:issue:`44414`)
 - Bug in :meth:`DataFrame.convert_dtypes` result losing ``columns.names`` (:issue:`41435`)
@@ -760,7 +879,7 @@ Conversion
 
 Strings
 ^^^^^^^
-- Fixed bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ImportError when pyarrow is not installed (:issue:`44276`)
+- Bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ``ImportError`` when pyarrow is not installed (:issue:`44276`)
 
 Interval
 ^^^^^^^^
@@ -768,18 +887,18 @@ Interval
 
 Indexing
 ^^^^^^^^
-- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided. (:issue:`43659`)
-- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's Index has a length greater than one but only one unique value (:issue:`42365`)
+- Bug in :meth:`Series.rename` with :class:`MultiIndex` and ``level`` is provided (:issue:`43659`)
+- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's :class:`Index` has a length greater than one but only one unique value (:issue:`42365`)
 - Bug in :meth:`Series.loc` and :meth:`DataFrame.loc` with a :class:`MultiIndex` when indexing with a tuple in which one of the levels is also a tuple (:issue:`27591`)
-- Bug in :meth:`Series.loc` when with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
+- Bug in :meth:`Series.loc` with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
 - Bug in indexing on a :class:`Series` or :class:`DataFrame` with a :class:`DatetimeIndex` when passing a string, the return type depended on whether the index was monotonic (:issue:`24892`)
 - Bug in indexing on a :class:`MultiIndex` failing to drop scalar levels when the indexer is a tuple containing a datetime-like string (:issue:`42476`)
 - Bug in :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` when passing an ascending value, failed to raise or incorrectly raising ``ValueError`` (:issue:`41634`)
 - Bug in updating values of :class:`pandas.Series` using boolean index, created by using :meth:`pandas.DataFrame.pop` (:issue:`42530`)
 - Bug in :meth:`Index.get_indexer_non_unique` when index contains multiple ``np.nan`` (:issue:`35392`)
-- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a dataframe (:issue:`42826`)
+- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a :class:`DataFrame` (:issue:`42826`)
 - Bug in :meth:`DataFrame.drop` where the error message did not show missing labels with commas when raising ``KeyError`` (:issue:`42881`)
-- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed. (:issue:`22435`)
+- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed (:issue:`22435`)
 - Bug in :meth:`DataFrame.nlargest` and :meth:`Series.nlargest` where sorted result did not count indexes containing ``np.nan`` (:issue:`28984`)
 - Bug in indexing on a non-unique object-dtype :class:`Index` with an NA scalar (e.g. ``np.nan``) (:issue:`43711`)
 - Bug in :meth:`DataFrame.__setitem__` incorrectly writing into an existing column's array rather than setting a new array when the new dtype and the old dtype match (:issue:`43406`)
@@ -802,16 +921,16 @@ Indexing
 - Bug in :meth:`IntervalIndex.get_indexer_non_unique` not handling targets of ``dtype`` 'object' with NaNs correctly (:issue:`44482`)
 - Fixed regression where a single column ``np.matrix`` was no longer coerced to a 1d ``np.ndarray`` when added to a :class:`DataFrame` (:issue:`42376`)
 - Bug in :meth:`Series.__getitem__` with a :class:`CategoricalIndex` of integers treating lists of integers as positional indexers, inconsistent with the behavior with a single scalar integer (:issue:`15470`, :issue:`14865`)
-- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype series failing to upcast when necessary to retain precision (:issue:`45121`)
+- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype :class:`Series` failing to upcast when necessary to retain precision (:issue:`45121`)
 - Bug in :meth:`DataFrame.iloc.__setitem__` ignores axis argument (:issue:`45032`)
 
 Missing
 ^^^^^^^
-- Bug in :meth:`DataFrame.fillna` with limit and no method ignores axis='columns' or ``axis = 1`` (:issue:`40989`)
+- Bug in :meth:`DataFrame.fillna` with ``limit`` and no ``method`` ignores ``axis='columns'`` or ``axis = 1`` (:issue:`40989`, :issue:`17399`)
 - Bug in :meth:`DataFrame.fillna` not replacing missing values when using a dict-like ``value`` and duplicate column names (:issue:`43476`)
 - Bug in constructing a :class:`DataFrame` with a dictionary ``np.datetime64`` as a value and ``dtype='timedelta64[ns]'``, or vice-versa, incorrectly casting instead of raising (:issue:`44428`)
 - Bug in :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` with ``inplace=True`` not writing to the underlying array(s) in-place (:issue:`44749`)
-- Bug in :meth:`Index.fillna` incorrectly returning an un-filled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
+- Bug in :meth:`Index.fillna` incorrectly returning an unfilled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
 - Bug in :meth:`DataFrame.dropna` changing :class:`Index` even if no entries were dropped (:issue:`41965`)
 - Bug in :meth:`Series.fillna` with an object-dtype incorrectly ignoring ``downcast="infer"`` (:issue:`44241`)
 
@@ -830,33 +949,33 @@ I/O
 - Bug in :func:`json_normalize` where ``errors=ignore`` could fail to ignore missing values of ``meta`` when ``record_path`` has a length greater than one (:issue:`41876`)
 - Bug in :func:`read_csv` with multi-header input and arguments referencing column names as tuples (:issue:`42446`)
 - Bug in :func:`read_fwf`, where difference in lengths of ``colspecs`` and ``names`` was not raising ``ValueError`` (:issue:`40830`)
-- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serialising plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
+- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serializing plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
 - Column headers are dropped when constructing a :class:`DataFrame` from a sqlalchemy's ``Row`` object (:issue:`40682`)
-- Bug in unpickling a :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
-- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raising uncontrolled ``IndexError`` (:issue:`43102`)
+- Bug in unpickling an :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
+- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raised ``IndexError`` (:issue:`43102`)
 - Bug in :func:`read_csv` raising ``ParserError`` when reading file in chunks and some chunk blocks have fewer columns than header for ``engine="c"`` (:issue:`21211`)
 - Bug in :func:`read_csv`, changed exception class when expecting a file path name or file-like object from ``OSError`` to ``TypeError`` (:issue:`43366`)
 - Bug in :func:`read_csv` and :func:`read_fwf` ignoring all ``skiprows`` except first when ``nrows`` is specified for ``engine='python'`` (:issue:`44021`, :issue:`10261`)
 - Bug in :func:`read_csv` keeping the original column in object format when ``keep_date_col=True`` is set (:issue:`13378`)
 - Bug in :func:`read_json` not handling non-numpy dtypes correctly (especially ``category``) (:issue:`21892`, :issue:`33205`)
 - Bug in :func:`json_normalize` where multi-character ``sep`` parameter is incorrectly prefixed to every key (:issue:`43831`)
-- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect errors="ignore" (:issue:`44312`)
+- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect ``errors="ignore"`` (:issue:`44312`)
 - Bug in :func:`read_csv` used second row to guess implicit index if ``header`` was set to ``None`` for ``engine="python"`` (:issue:`22144`)
 - Bug in :func:`read_csv` not recognizing bad lines when ``names`` were given for ``engine="c"`` (:issue:`22144`)
 - Bug in :func:`read_csv` with :code:`float_precision="round_trip"` which did not skip initial/trailing whitespace (:issue:`43713`)
-- Bug when Python is built without lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used. (:issue:`43495`)
+- Bug when Python is built without the lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used (:issue:`43495`)
 - Bug in :func:`read_csv` not applying dtype for ``index_col`` (:issue:`9435`)
 - Bug in dumping/loading a :class:`DataFrame` with ``yaml.dump(frame)`` (:issue:`42748`)
-- Bug in :func:`read_csv` raising ``ValueError`` when names was longer than header but equal to data rows for ``engine="python"`` (:issue:`38453`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``names`` was longer than ``header`` but equal to data rows for ``engine="python"`` (:issue:`38453`)
 - Bug in :class:`ExcelWriter`, where ``engine_kwargs`` were not passed through to all engines (:issue:`43442`)
-- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with ``MultiIndex`` columns (:issue:`8991`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with :class:`MultiIndex` columns (:issue:`8991`)
 - Bug in :func:`read_csv` not raising an ``ValueError`` when ``\n`` was specified as ``delimiter`` or ``sep`` which conflicts with ``lineterminator`` (:issue:`43528`)
 - Bug in :func:`to_csv` converting datetimes in categorical :class:`Series` to integers (:issue:`40754`)
 - Bug in :func:`read_csv` converting columns to numeric after date parsing failed (:issue:`11019`)
 - Bug in :func:`read_csv` not replacing ``NaN`` values with ``np.nan`` before attempting date conversion (:issue:`26203`)
 - Bug in :func:`read_csv` raising ``AttributeError`` when attempting to read a .csv file and infer index column dtype from an nullable integer type (:issue:`44079`)
 - Bug in :func:`to_csv` always coercing datetime columns with different formats to the same format (:issue:`21734`)
-- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly. (:issue:`39465`)
+- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly (:issue:`39465`)
 - Bug in :func:`read_csv` where reading a mixed column of booleans and missing values to a float type results in the missing values becoming 1.0 rather than NaN (:issue:`42808`, :issue:`34120`)
 - Bug in :func:`to_xml` raising error for ``pd.NA`` with extension array dtype (:issue:`43903`)
 - Bug in :func:`read_csv` when passing simultaneously a parser in ``date_parser`` and ``parse_dates=False``, the parsing was still called (:issue:`44366`)
@@ -865,6 +984,8 @@ I/O
 - Bug in :func:`read_csv` when passing a ``tempfile.SpooledTemporaryFile`` opened in binary mode (:issue:`44748`)
 - Bug in :func:`read_json` raising ``ValueError`` when attempting to parse json strings containing "://" (:issue:`36271`)
 - Bug in :func:`read_csv` when ``engine="c"`` and ``encoding_errors=None`` which caused a segfault (:issue:`45180`)
+- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an unclosed file handle (:issue:`45384`)
+- Bug in :meth:`DataFrame.to_json` fix memory leak (:issue:`43877`)
 
 Period
 ^^^^^^
@@ -876,16 +997,16 @@ Period
 
 Plotting
 ^^^^^^^^
-- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist`. (:issue:`43480`)
+- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist` (:issue:`43480`)
 
 Groupby/resample/rolling
 ^^^^^^^^^^^^^^^^^^^^^^^^
-- Fixed bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
+- Bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
 - Bug in :meth:`Series.rolling.apply`, :meth:`DataFrame.rolling.apply`, :meth:`Series.expanding.apply` and :meth:`DataFrame.expanding.apply` with ``engine="numba"`` where ``*args`` were being cached with the user passed function (:issue:`42287`)
 - Bug in :meth:`GroupBy.max` and :meth:`GroupBy.min` with nullable integer dtypes losing precision (:issue:`41743`)
 - Bug in :meth:`DataFrame.groupby.rolling.var` would calculate the rolling variance only on the first group (:issue:`42442`)
-- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not None (:issue:`41556`)
-- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input Series was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
+- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not ``None`` (:issue:`41556`)
+- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input :class:`Series` was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
 - Bug in :meth:`pandas.DataFrame.ewm`, where non-float64 dtypes were silently failing (:issue:`42452`)
 - Bug in :meth:`pandas.DataFrame.rolling` operation along rows (``axis=1``) incorrectly omits columns containing ``float16`` and ``float32`` (:issue:`41779`)
 - Bug in :meth:`Resampler.aggregate` did not allow the use of Named Aggregation (:issue:`32803`)
@@ -894,37 +1015,37 @@ Groupby/resample/rolling
 - Bug in :meth:`DataFrame.groupby.rolling` when specifying ``on`` and calling ``__getitem__`` would subsequently return incorrect results (:issue:`43355`)
 - Bug in :meth:`GroupBy.apply` with time-based :class:`Grouper` objects incorrectly raising ``ValueError`` in corner cases where the grouping vector contains a ``NaT`` (:issue:`43500`, :issue:`43515`)
 - Bug in :meth:`GroupBy.mean` failing with ``complex`` dtype (:issue:`43701`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
 - Bug in :meth:`GroupBy.mean` raising ``KeyError`` when column was selected at least twice (:issue:`44924`)
 - Bug in :meth:`GroupBy.nth` failing on ``axis=1`` (:issue:`43926`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
 - Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` when using a :class:`pandas.api.indexers.BaseIndexer` subclass that returned unequal start and end arrays would segfault instead of raising a ``ValueError`` (:issue:`44470`)
-- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for Categorical grouping columns (:issue:`45128`)
+- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for ``categorical`` grouping columns (:issue:`45128`)
 - Bug in :meth:`GroupBy.head` and :meth:`GroupBy.tail` not dropping groups with ``NaN`` when ``dropna=True`` (:issue:`45089`)
-- Fixed bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`#44821`)
+- Bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`44821`)
 - Bug in :meth:`Groupby.rolling` when non-monotonic data passed, fails to correctly raise ``ValueError`` (:issue:`43909`)
-- Fixed bug where grouping by a :class:`Series` that has a categorical data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
+- Bug where grouping by a :class:`Series` that has a ``categorical`` data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
 
 Reshaping
 ^^^^^^^^^
 - Improved error message when creating a :class:`DataFrame` column from a multi-dimensional :class:`numpy.ndarray` (:issue:`42463`)
-- :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
-- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices (:issue:`42185`) and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42425`)
+- Bug in :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
+- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42185`, :issue:`42425`)
 - Bug in :meth:`DataFrame.append` failing to retain dtypes when appended columns do not match (:issue:`43392`)
 - Bug in :func:`concat` of ``bool`` and ``boolean`` dtypes resulting in ``object`` dtype instead of ``boolean`` dtype (:issue:`42800`)
-- Bug in :func:`crosstab` when inputs are are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
+- Bug in :func:`crosstab` when inputs are categorical :class:`Series`, there are categories that are not present in one or both of the :class:`Series`, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
 - Bug in :func:`concat` would fail when the ``objs`` argument all had the same index and the ``keys`` argument contained duplicates (:issue:`43595`)
 - Bug in :func:`concat` which ignored the ``sort`` parameter (:issue:`43375`)
-- Fixed bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
+- Bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
 - Bug in :func:`crosstab` would fail when inputs are lists or tuples (:issue:`44076`)
 - Bug in :meth:`DataFrame.append` failing to retain ``index.name`` when appending a list of :class:`Series` objects (:issue:`44109`)
 - Fixed metadata propagation in :meth:`Dataframe.apply` method, consequently fixing the same issue for :meth:`Dataframe.transform`, :meth:`Dataframe.nunique` and :meth:`Dataframe.mode` (:issue:`28283`)
-- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if the only consist of missing values (:issue:`44900`)
+- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if all levels only consist of missing values (:issue:`44900`)
 - Bug in :meth:`DataFrame.stack` with ``ExtensionDtype`` columns incorrectly raising (:issue:`43561`)
 - Bug in :func:`merge` raising ``KeyError`` when joining over differently named indexes with on keywords (:issue:`45094`)
 - Bug in :meth:`Series.unstack` with object doing unwanted type inference on resulting columns (:issue:`44595`)
-- Bug in :class:`MultiIndex` failing join operations with overlapping ``IntervalIndex`` levels (:issue:`44096`)
+- Bug in :meth:`MultiIndex.join()` with overlapping ``IntervalIndex`` levels (:issue:`44096`)
 - Bug in :meth:`DataFrame.replace` and :meth:`Series.replace` results is different ``dtype`` based on ``regex`` parameter (:issue:`44864`)
 - Bug in :meth:`DataFrame.pivot` with ``index=None`` when the :class:`DataFrame` index was a :class:`MultiIndex` (:issue:`23955`)
 
@@ -943,24 +1064,24 @@ ExtensionArray
 - NumPy ufuncs ``np.abs``, ``np.positive``, ``np.negative`` now correctly preserve dtype when called on ExtensionArrays that implement ``__abs__, __pos__, __neg__``, respectively. In particular this is fixed for :class:`TimedeltaArray` (:issue:`43899`, :issue:`23316`)
 - NumPy ufuncs ``np.minimum.reduce`` ``np.maximum.reduce``, ``np.add.reduce``, and ``np.prod.reduce`` now work correctly instead of raising ``NotImplementedError`` on :class:`Series` with ``IntegerDtype`` or ``FloatDtype`` (:issue:`43923`, :issue:`44793`)
 - NumPy ufuncs with ``out`` keyword are now supported by arrays with ``IntegerDtype`` and ``FloatingDtype`` (:issue:`45122`)
-- Avoid raising ``PerformanceWarning`` about fragmented DataFrame when using many columns with an extension dtype (:issue:`44098`)
+- Avoid raising ``PerformanceWarning`` about fragmented :class:`DataFrame` when using many columns with an extension dtype (:issue:`44098`)
 - Bug in :class:`IntegerArray` and :class:`FloatingArray` construction incorrectly coercing mismatched NA values (e.g. ``np.timedelta64("NaT")``) to numeric NA (:issue:`44514`)
 - Bug in :meth:`BooleanArray.__eq__` and :meth:`BooleanArray.__ne__` raising ``TypeError`` on comparison with an incompatible type (like a string). This caused :meth:`DataFrame.replace` to sometimes raise a ``TypeError`` if a nullable boolean column was included (:issue:`44499`)
 - Bug in :func:`array` incorrectly raising when passed a ``ndarray`` with ``float16`` dtype (:issue:`44715`)
 - Bug in calling ``np.sqrt`` on :class:`BooleanArray` returning a malformed :class:`FloatingArray` (:issue:`44715`)
-- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the series dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
-- Fixed bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
-- Fixed bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
-- Fixed bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
+- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the :class:`Series` dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
+- Bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
+- Bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
+- Bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
 
 Styler
 ^^^^^^
-- Minor bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
+- Bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
 - Bug in :meth:`.Styler.to_html` where the ``Styler`` object was updated if the ``to_html`` method was called with some args (:issue:`43034`)
 - Bug in :meth:`.Styler.copy` where ``uuid`` was not previously copied (:issue:`40675`)
-- Bug in :meth:`Styler.apply` where functions which returned Series objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
-- Bug when rendering an empty DataFrame with a named index (:issue:`43305`).
-- Bug when rendering a single level MultiIndex (:issue:`43383`).
+- Bug in :meth:`Styler.apply` where functions which returned :class:`Series` objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
+- Bug when rendering an empty :class:`DataFrame` with a named :class:`Index` (:issue:`43305`)
+- Bug when rendering a single level :class:`MultiIndex` (:issue:`43383`)
 - Bug when combining non-sparse rendering and :meth:`.Styler.hide_columns` or :meth:`.Styler.hide_index` (:issue:`43464`)
 - Bug setting a table style when using multiple selectors in :class:`.Styler` (:issue:`44011`)
 - Bugs where row trimming and column trimming failed to reflect hidden rows (:issue:`43703`, :issue:`44247`)
@@ -971,7 +1092,6 @@ Other
 - Bug in :meth:`CustomBusinessMonthBegin.__add__` (:meth:`CustomBusinessMonthEnd.__add__`) not applying the extra ``offset`` parameter when beginning (end) of the target month is already a business day (:issue:`41356`)
 - Bug in :meth:`RangeIndex.union` with another ``RangeIndex`` with matching (even) ``step`` and starts differing by strictly less than ``step / 2`` (:issue:`44019`)
 - Bug in :meth:`RangeIndex.difference` with ``sort=None`` and ``step<0`` failing to sort (:issue:`44085`)
-- Bug in :meth:`Series.to_frame` and :meth:`Index.to_frame` ignoring the ``name`` argument when ``name=None`` is explicitly passed (:issue:`44212`)
 - Bug in :meth:`Series.replace` and :meth:`DataFrame.replace` with ``value=None`` and ExtensionDtypes (:issue:`44270`, :issue:`37899`)
 - Bug in :meth:`FloatingArray.equals` failing to consider two arrays equal if they contain ``np.nan`` values (:issue:`44382`)
 - Bug in :meth:`DataFrame.shift` with ``axis=1`` and ``ExtensionDtype`` columns incorrectly raising when an incompatible ``fill_value`` is passed (:issue:`44564`)
@@ -980,6 +1100,7 @@ Other
 - Bug in :meth:`Series.replace` raising ``ValueError`` when using ``regex=True`` with a :class:`Series` containing ``np.nan`` values (:issue:`43344`)
 - Bug in :meth:`DataFrame.to_records` where an incorrect ``n`` was used when missing names were replaced by ``level_n`` (:issue:`44818`)
 - Bug in :meth:`DataFrame.eval` where ``resolvers`` argument was overriding the default resolvers (:issue:`34966`)
+- :meth:`Series.__repr__` and :meth:`DataFrame.__repr__` no longer replace all null-values in indexes with "NaN" but use their real string-representations. "NaN" is used only for ``float("nan")`` (:issue:`45263`)
 
 .. ---------------------------------------------------------------------------
 
@@ -988,4 +1109,4 @@ Other
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v1.3.5..v1.4.0|HEAD
+.. contributors:: v1.3.5..v1.4.0
diff --git a/doc/source/whatsnew/v1.4.1.rst b/doc/source/whatsnew/v1.4.1.rst
new file mode 100644
index 0000000000000..dd2002bb87648
--- /dev/null
+++ b/doc/source/whatsnew/v1.4.1.rst
@@ -0,0 +1,56 @@
+.. _whatsnew_141:
+
+What's new in 1.4.1 (February 12, 2022)
+---------------------------------------
+
+These are the changes in pandas 1.4.1. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_141.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Regression in :meth:`Series.mask` with ``inplace=True`` and ``PeriodDtype`` and an incompatible ``other`` coercing to a common dtype instead of raising (:issue:`45546`)
+- Regression in :func:`.assert_frame_equal` not respecting ``check_flags=False`` (:issue:`45554`)
+- Regression in :meth:`DataFrame.loc` raising ``ValueError`` when indexing (getting values) on a :class:`MultiIndex` with one level (:issue:`45779`)
+- Regression in :meth:`Series.fillna` with ``downcast=False`` incorrectly downcasting ``object`` dtype (:issue:`45603`)
+- Regression in :func:`api.types.is_bool_dtype` raising an ``AttributeError`` when evaluating a categorical :class:`Series` (:issue:`45615`)
+- Regression in :meth:`DataFrame.iat` setting values leading to not propagating correctly in subsequent lookups (:issue:`45684`)
+- Regression when setting values with :meth:`DataFrame.loc` losing :class:`Index` name if :class:`DataFrame` was empty before (:issue:`45621`)
+- Regression in :meth:`~Index.join` with overlapping :class:`IntervalIndex` raising an ``InvalidIndexError`` (:issue:`45661`)
+- Regression when setting values with :meth:`Series.loc` raising with all ``False`` indexer and :class:`Series` on the right hand side (:issue:`45778`)
+- Regression in :func:`read_sql` with a DBAPI2 connection that is not an instance of ``sqlite3.Connection`` incorrectly requiring SQLAlchemy be installed (:issue:`45660`)
+- Regression in :class:`DateOffset` when constructing with an integer argument with no keywords (e.g. ``pd.DateOffset(n)``) would behave like ``datetime.timedelta(days=0)`` (:issue:`45643`, :issue:`45890`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_141.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Fixed segfault in :meth:`DataFrame.to_json` when dumping tz-aware datetimes in Python 3.10 (:issue:`42130`)
+- Stopped emitting unnecessary ``FutureWarning`` in :meth:`DataFrame.sort_values` with sparse columns (:issue:`45618`)
+- Fixed window aggregations in :meth:`DataFrame.rolling` and :meth:`Series.rolling` to skip over unused elements (:issue:`45647`)
+- Fixed builtin highlighters in :class:`.Styler` to be responsive to ``NA`` with nullable dtypes (:issue:`45804`)
+- Bug in :meth:`~Rolling.apply` with ``axis=1`` raising an erroneous ``ValueError`` (:issue:`45912`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_141.other:
+
+Other
+~~~~~
+- Reverted performance speedup of :meth:`DataFrame.corr` for ``method=pearson`` to fix precision regression (:issue:`45640`, :issue:`42761`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_141.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.4.0..v1.4.1
diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
new file mode 100644
index 0000000000000..64c36632bfefe
--- /dev/null
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -0,0 +1,45 @@
+.. _whatsnew_142:
+
+What's new in 1.4.2 (April 2, 2022)
+-----------------------------------
+
+These are the changes in pandas 1.4.2. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_142.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed regression in :meth:`DataFrame.drop` and :meth:`Series.drop` when :class:`Index` had extension dtype and duplicates (:issue:`45860`)
+- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
+- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
+- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
+- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46306`)
+- Fixed regression in :meth:`DataFrame.replace` when the replacement value was explicitly ``None`` when passed in a dictionary to ``to_replace`` (:issue:`45601`, :issue:`45836`)
+- Fixed regression when setting values with :meth:`DataFrame.loc` losing :class:`MultiIndex` names if :class:`DataFrame`  was empty before (:issue:`46317`)
+- Fixed regression when rendering boolean datatype columns with :meth:`.Styler` (:issue:`46384`)
+- Fixed regression in :meth:`Groupby.rolling` with a frequency window that would raise a ``ValueError`` even if the datetimes within each group were monotonic (:issue:`46061`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_142.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Fix some cases for subclasses that define their ``_constructor`` properties as general callables (:issue:`46018`)
+- Fixed "longtable" formatting in :meth:`.Styler.to_latex` when ``column_format`` is given in extended format (:issue:`46037`)
+- Fixed incorrect rendering in :meth:`.Styler.format` with ``hyperlinks="html"`` when the url contains a colon or other special characters (:issue:`46389`)
+- Improved error message in :class:`~pandas.core.window.Rolling` when ``window`` is a frequency and ``NaT`` is in the rolling axis (:issue:`46087`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_142.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.4.1..v1.4.2
diff --git a/doc/source/whatsnew/v1.4.3.rst b/doc/source/whatsnew/v1.4.3.rst
new file mode 100644
index 0000000000000..70b451a231453
--- /dev/null
+++ b/doc/source/whatsnew/v1.4.3.rst
@@ -0,0 +1,72 @@
+.. _whatsnew_143:
+
+What's new in 1.4.3 (June 23, 2022)
+-----------------------------------
+
+These are the changes in pandas 1.4.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_143.concat:
+
+Behavior of ``concat`` with empty or all-NA DataFrame columns
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The behavior change in version 1.4.0 to stop ignoring the data type
+of empty or all-NA columns with float or object dtype in :func:`concat`
+(:ref:`whatsnew_140.notable_bug_fixes.concat_with_empty_or_all_na`) has been
+reverted (:issue:`45637`).
+
+
+.. _whatsnew_143.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed regression in :meth:`DataFrame.replace` when the replacement value was explicitly ``None`` when passed in a dictionary to ``to_replace`` also casting other columns to object dtype even when there were no values to replace (:issue:`46634`)
+- Fixed regression in :meth:`DataFrame.to_csv` raising error when :class:`DataFrame` contains extension dtype categorical column (:issue:`46297`, :issue:`46812`)
+- Fixed regression in representation of ``dtypes`` attribute of :class:`MultiIndex` (:issue:`46900`)
+- Fixed regression when setting values with :meth:`DataFrame.loc` updating :class:`RangeIndex` when index was set as new column and column was updated afterwards (:issue:`47128`)
+- Fixed regression in :meth:`DataFrame.fillna` and :meth:`DataFrame.update` creating a copy when updating inplace (:issue:`47188`)
+- Fixed regression in :meth:`DataFrame.nsmallest` led to wrong results when the sorting column has ``np.nan`` values (:issue:`46589`)
+- Fixed regression in :func:`read_fwf` raising ``ValueError`` when ``widths`` was specified with ``usecols`` (:issue:`46580`)
+- Fixed regression in :func:`concat` not sorting columns for mixed column names (:issue:`47127`)
+- Fixed regression in :meth:`.Groupby.transform` and :meth:`.Groupby.agg` failing with ``engine="numba"`` when the index was a :class:`MultiIndex` (:issue:`46867`)
+- Fixed regression in ``NaN`` comparison for :class:`Index` operations where the same object was compared (:issue:`47105`)
+- Fixed regression is :meth:`.Styler.to_latex` and :meth:`.Styler.to_html` where ``buf`` failed in combination with ``encoding`` (:issue:`47053`)
+- Fixed regression in :func:`read_csv` with ``index_col=False`` identifying first row as index names when ``header=None`` (:issue:`46955`)
+- Fixed regression in :meth:`.DataFrameGroupBy.agg` when used with list-likes or dict-likes and ``axis=1`` that would give incorrect results; now raises ``NotImplementedError`` (:issue:`46995`)
+- Fixed regression in :meth:`DataFrame.resample` and :meth:`DataFrame.rolling` when used with list-likes or dict-likes and ``axis=1`` that would raise an unintuitive error message; now raises ``NotImplementedError`` (:issue:`46904`)
+- Fixed regression in :func:`testing.assert_index_equal` when ``check_order=False`` and :class:`Index` has extension or object dtype (:issue:`47207`)
+- Fixed regression in :func:`read_excel` returning ints as floats on certain input sheets (:issue:`46988`)
+- Fixed regression in :meth:`DataFrame.shift` when ``axis`` is ``columns`` and ``fill_value`` is absent, ``freq`` is ignored (:issue:`47039`)
+- Fixed regression in :meth:`DataFrame.to_json` causing a segmentation violation when :class:`DataFrame` is created with an ``index`` parameter of the type :class:`PeriodIndex` (:issue:`46683`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_143.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Bug in :func:`pandas.eval`, :meth:`DataFrame.eval` and :meth:`DataFrame.query` where passing empty ``local_dict`` or ``global_dict`` was treated as passing ``None`` (:issue:`47084`)
+- Most I/O methods no longer suppress ``OSError`` and ``ValueError`` when closing file handles (:issue:`47136`)
+- Improving error message raised by :meth:`DataFrame.from_dict` when passing an invalid ``orient`` parameter (:issue:`47450`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_143.other:
+
+Other
+~~~~~
+- The minimum version of Cython needed to compile pandas is now ``0.29.30`` (:issue:`41935`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_143.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.4.2..v1.4.3
diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
new file mode 100644
index 0000000000000..56b1254d8a359
--- /dev/null
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -0,0 +1,65 @@
+.. _whatsnew_144:
+
+What's new in 1.4.4 (August 31, 2022)
+-------------------------------------
+
+These are the changes in pandas 1.4.4. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_144.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed regression in :meth:`DataFrame.fillna` not working on a :class:`DataFrame` with a :class:`MultiIndex` (:issue:`47649`)
+- Fixed regression in taking NULL :class:`objects` from a :class:`DataFrame` causing a segmentation violation. These NULL values are created by :meth:`numpy.empty_like` (:issue:`46848`)
+- Fixed regression in :func:`concat` materializing the :class:`Index` during sorting even if the :class:`Index` was already sorted (:issue:`47501`)
+- Fixed regression in :func:`concat` or :func:`merge` handling of all-NaN ExtensionArrays with custom attributes (:issue:`47762`)
+- Fixed regression in calling bitwise numpy ufuncs (for example, ``np.bitwise_and``) on Index objects (:issue:`46769`)
+- Fixed regression in :func:`cut` when using a ``datetime64`` IntervalIndex as bins (:issue:`46218`)
+- Fixed regression in :meth:`DataFrame.select_dtypes` where ``include="number"`` included :class:`BooleanDtype` (:issue:`46870`)
+- Fixed regression in :meth:`DataFrame.loc` raising error when indexing with a ``NamedTuple`` (:issue:`48124`)
+- Fixed regression in :meth:`DataFrame.loc` not updating the cache correctly after values were set (:issue:`47867`)
+- Fixed regression in :meth:`DataFrame.loc` not aligning index in some cases when setting a :class:`DataFrame` (:issue:`47578`)
+- Fixed regression in :meth:`DataFrame.loc` setting a length-1 array like value to a single value in the DataFrame (:issue:`46268`)
+- Fixed regression when slicing with :meth:`DataFrame.loc` with :class:`DatetimeIndex` with a :class:`.DateOffset` object for its ``freq`` (:issue:`46671`)
+- Fixed regression in setting ``None`` or non-string value into a ``string``-dtype Series using a mask (:issue:`47628`)
+- Fixed regression in updating a DataFrame column through Series ``__setitem__`` (using chained assignment) not updating column values inplace and using too much memory (:issue:`47172`)
+- Fixed regression in :meth:`DataFrame.select_dtypes` returning a view on the original DataFrame (:issue:`48090`)
+- Fixed regression using custom Index subclasses (for example, used in xarray) with :meth:`~DataFrame.reset_index` or :meth:`Index.insert` (:issue:`47071`)
+- Fixed regression in :meth:`~Index.intersection` when the :class:`DatetimeIndex` has dates crossing daylight savings time (:issue:`46702`)
+- Fixed regression in :func:`merge` throwing an error when passing a :class:`Series` with a multi-level name (:issue:`47946`)
+- Fixed regression in :meth:`DataFrame.eval` creating a copy when updating inplace (:issue:`47449`)
+- Fixed regression where getting a row using :meth:`DataFrame.iloc` with :class:`SparseDtype` would raise (:issue:`46406`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_144.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- The ``FutureWarning`` raised when passing arguments (other than ``filepath_or_buffer``) as positional in :func:`read_csv` is now raised at the correct stacklevel (:issue:`47385`)
+- Bug in :meth:`DataFrame.to_sql` when ``method`` was a ``callable`` that did not return an ``int`` and would raise a ``TypeError`` (:issue:`46891`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` where ``subset`` had no effect (:issue:`46383`)
+- Bug when getting values with :meth:`DataFrame.loc` with a list of keys causing an internal inconsistency that could lead to a disconnect between ``frame.at[x, y]`` vs ``frame[y].loc[x]`` (:issue:`22372`)
+- Bug in the :meth:`Series.dt.strftime` accessor return a float instead of object dtype Series for all-NaT input, which also causes a spurious deprecation warning (:issue:`45858`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_144.other:
+
+Other
+~~~~~
+- The minimum version of Cython needed to compile pandas is now ``0.29.32`` (:issue:`47978`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_144.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.4.3..v1.4.4|HEAD
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
new file mode 100644
index 0000000000000..ecd38555be040
--- /dev/null
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -0,0 +1,1294 @@
+.. _whatsnew_150:
+
+What's new in 1.5.0 (September 19, 2022)
+----------------------------------------
+
+These are the changes in pandas 1.5.0. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.enhancements:
+
+Enhancements
+~~~~~~~~~~~~
+
+.. _whatsnew_150.enhancements.pandas-stubs:
+
+``pandas-stubs``
+^^^^^^^^^^^^^^^^
+
+The ``pandas-stubs`` library is now supported by the pandas development team, providing type stubs for the pandas API. Please visit
+https://github.com/pandas-dev/pandas-stubs for more information.
+
+We thank VirtusLab and Microsoft for their initial, significant contributions to ``pandas-stubs``
+
+.. _whatsnew_150.enhancements.arrow:
+
+Native PyArrow-backed ExtensionArray
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+With `Pyarrow <https://arrow.apache.org/docs/python/index.html>`__ installed, users can now create pandas objects
+that are backed by a ``pyarrow.ChunkedArray`` and ``pyarrow.DataType``.
+
+The ``dtype`` argument can accept a string of a `pyarrow data type <https://arrow.apache.org/docs/python/api/datatypes.html>`__
+with ``pyarrow`` in brackets e.g. ``"int64[pyarrow]"`` or, for pyarrow data types that take parameters, a :class:`ArrowDtype`
+initialized with a ``pyarrow.DataType``.
+
+.. ipython:: python
+
+    import pyarrow as pa
+    ser_float = pd.Series([1.0, 2.0, None], dtype="float32[pyarrow]")
+    ser_float
+
+    list_of_int_type = pd.ArrowDtype(pa.list_(pa.int64()))
+    ser_list = pd.Series([[1, 2], [3, None]], dtype=list_of_int_type)
+    ser_list
+
+    ser_list.take([1, 0])
+    ser_float * 5
+    ser_float.mean()
+    ser_float.dropna()
+
+Most operations are supported and have been implemented using `pyarrow compute <https://arrow.apache.org/docs/python/api/compute.html>`__ functions.
+We recommend installing the latest version of PyArrow to access the most recently implemented compute functions.
+
+.. warning::
+
+    This feature is experimental, and the API can change in a future release without warning.
+
+.. _whatsnew_150.enhancements.dataframe_interchange:
+
+DataFrame interchange protocol implementation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Pandas now implement the DataFrame interchange API spec.
+See the full details on the API at https://data-apis.org/dataframe-protocol/latest/index.html
+
+The protocol consists of two parts:
+
+- New method :meth:`DataFrame.__dataframe__` which produces the interchange object.
+  It effectively "exports" the pandas dataframe as an interchange object so
+  any other library which has the protocol implemented can "import" that dataframe
+  without knowing anything about the producer except that it makes an interchange object.
+- New function :func:`pandas.api.interchange.from_dataframe` which can take
+  an arbitrary interchange object from any conformant library and construct a
+  pandas DataFrame out of it.
+
+.. _whatsnew_150.enhancements.styler:
+
+Styler
+^^^^^^
+
+The most notable development is the new method :meth:`.Styler.concat` which
+allows adding customised footer rows to visualise additional calculations on the data,
+e.g. totals and counts etc. (:issue:`43875`, :issue:`46186`)
+
+Additionally there is an alternative output method :meth:`.Styler.to_string`,
+which allows using the Styler's formatting methods to create, for example, CSVs (:issue:`44502`).
+
+A new feature :meth:`.Styler.relabel_index` is also made available to provide full customisation of the display of
+index or column headers (:issue:`47864`)
+
+Minor feature improvements are:
+
+  - Adding the ability to render ``border`` and ``border-{side}`` CSS properties in Excel (:issue:`42276`)
+  - Making keyword arguments consist: :meth:`.Styler.highlight_null` now accepts ``color`` and deprecates ``null_color`` although this remains backwards compatible (:issue:`45907`)
+
+.. _whatsnew_150.enhancements.resample_group_keys:
+
+Control of index with ``group_keys`` in :meth:`DataFrame.resample`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The argument ``group_keys`` has been added to the method :meth:`DataFrame.resample`.
+As with :meth:`DataFrame.groupby`, this argument controls the whether each group is added
+to the index in the resample when :meth:`.Resampler.apply` is used.
+
+.. warning::
+   Not specifying the ``group_keys`` argument will retain the
+   previous behavior and emit a warning if the result will change
+   by specifying ``group_keys=False``. In a future version
+   of pandas, not specifying ``group_keys`` will default to
+   the same behavior as ``group_keys=False``.
+
+.. ipython:: python
+
+    df = pd.DataFrame(
+        {'a': range(6)},
+        index=pd.date_range("2021-01-01", periods=6, freq="8H")
+    )
+    df.resample("D", group_keys=True).apply(lambda x: x)
+    df.resample("D", group_keys=False).apply(lambda x: x)
+
+Previously, the resulting index would depend upon the values returned by ``apply``,
+as seen in the following example.
+
+.. code-block:: ipython
+
+    In [1]: # pandas 1.3
+    In [2]: df.resample("D").apply(lambda x: x)
+    Out[2]:
+                         a
+    2021-01-01 00:00:00  0
+    2021-01-01 08:00:00  1
+    2021-01-01 16:00:00  2
+    2021-01-02 00:00:00  3
+    2021-01-02 08:00:00  4
+    2021-01-02 16:00:00  5
+
+    In [3]: df.resample("D").apply(lambda x: x.reset_index())
+    Out[3]:
+                               index  a
+    2021-01-01 0 2021-01-01 00:00:00  0
+               1 2021-01-01 08:00:00  1
+               2 2021-01-01 16:00:00  2
+    2021-01-02 0 2021-01-02 00:00:00  3
+               1 2021-01-02 08:00:00  4
+               2 2021-01-02 16:00:00  5
+
+.. _whatsnew_150.enhancements.from_dummies:
+
+from_dummies
+^^^^^^^^^^^^
+
+Added new function :func:`~pandas.from_dummies` to convert a dummy coded :class:`DataFrame` into a categorical :class:`DataFrame`.
+
+.. ipython:: python
+
+    import pandas as pd
+
+    df = pd.DataFrame({"col1_a": [1, 0, 1], "col1_b": [0, 1, 0],
+                       "col2_a": [0, 1, 0], "col2_b": [1, 0, 0],
+                       "col2_c": [0, 0, 1]})
+
+    pd.from_dummies(df, sep="_")
+
+.. _whatsnew_150.enhancements.orc:
+
+Writing to ORC files
+^^^^^^^^^^^^^^^^^^^^
+
+The new method :meth:`DataFrame.to_orc` allows writing to ORC files (:issue:`43864`).
+
+This functionality depends the `pyarrow <http://arrow.apache.org/docs/python/>`__ library. For more details, see :ref:`the IO docs on ORC <io.orc>`.
+
+.. warning::
+
+   * It is *highly recommended* to install pyarrow using conda due to some issues occurred by pyarrow.
+   * :func:`~pandas.DataFrame.to_orc` requires pyarrow>=7.0.0.
+   * :func:`~pandas.DataFrame.to_orc` is not supported on Windows yet, you can find valid environments on :ref:`install optional dependencies <install.warn_orc>`.
+   * For supported dtypes please refer to `supported ORC features in Arrow <https://arrow.apache.org/docs/cpp/orc.html#data-types>`__.
+   * Currently timezones in datetime columns are not preserved when a dataframe is converted into ORC files.
+
+.. code-block:: python
+
+    df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]})
+    df.to_orc("./out.orc")
+
+.. _whatsnew_150.enhancements.tar:
+
+Reading directly from TAR archives
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+I/O methods like :func:`read_csv` or :meth:`DataFrame.to_json` now allow reading and writing
+directly on TAR archives (:issue:`44787`).
+
+.. code-block:: python
+
+   df = pd.read_csv("./movement.tar.gz")
+   # ...
+   df.to_csv("./out.tar.gz")
+
+This supports ``.tar``, ``.tar.gz``, ``.tar.bz`` and ``.tar.xz2`` archives.
+The used compression method is inferred from the filename.
+If the compression method cannot be inferred, use the ``compression`` argument:
+
+.. code-block:: python
+
+   df = pd.read_csv(some_file_obj, compression={"method": "tar", "mode": "r:gz"}) # noqa F821
+
+(``mode`` being one of ``tarfile.open``'s modes: https://docs.python.org/3/library/tarfile.html#tarfile.open)
+
+
+.. _whatsnew_150.enhancements.read_xml_dtypes:
+
+read_xml now supports ``dtype``, ``converters``, and ``parse_dates``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Similar to other IO methods, :func:`pandas.read_xml` now supports assigning specific dtypes to columns,
+apply converter methods, and parse dates (:issue:`43567`).
+
+.. ipython:: python
+
+    xml_dates = """<?xml version='1.0' encoding='utf-8'?>
+    <data>
+      <row>
+        <shape>square</shape>
+        <degrees>00360</degrees>
+        <sides>4.0</sides>
+        <date>2020-01-01</date>
+       </row>
+      <row>
+        <shape>circle</shape>
+        <degrees>00360</degrees>
+        <sides/>
+        <date>2021-01-01</date>
+      </row>
+      <row>
+        <shape>triangle</shape>
+        <degrees>00180</degrees>
+        <sides>3.0</sides>
+        <date>2022-01-01</date>
+      </row>
+    </data>"""
+
+    df = pd.read_xml(
+        xml_dates,
+        dtype={'sides': 'Int64'},
+        converters={'degrees': str},
+        parse_dates=['date']
+    )
+    df
+    df.dtypes
+
+
+.. _whatsnew_150.enhancements.read_xml_iterparse:
+
+read_xml now supports large XML using ``iterparse``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For very large XML files that can range in hundreds of megabytes to gigabytes, :func:`pandas.read_xml`
+now supports parsing such sizeable files using `lxml's iterparse`_ and `etree's iterparse`_
+which are memory-efficient methods to iterate through XML trees and extract specific elements
+and attributes without holding entire tree in memory (:issue:`45442`).
+
+.. code-block:: ipython
+
+    In [1]: df = pd.read_xml(
+    ...      "/path/to/downloaded/enwikisource-latest-pages-articles.xml",
+    ...      iterparse = {"page": ["title", "ns", "id"]})
+    ...  )
+    df
+    Out[2]:
+                                                         title   ns        id
+    0                                       Gettysburg Address    0     21450
+    1                                                Main Page    0     42950
+    2                            Declaration by United Nations    0      8435
+    3             Constitution of the United States of America    0      8435
+    4                     Declaration of Independence (Israel)    0     17858
+    ...                                                    ...  ...       ...
+    3578760               Page:Black cat 1897 07 v2 n10.pdf/17  104    219649
+    3578761               Page:Black cat 1897 07 v2 n10.pdf/43  104    219649
+    3578762               Page:Black cat 1897 07 v2 n10.pdf/44  104    219649
+    3578763      The History of Tom Jones, a Foundling/Book IX    0  12084291
+    3578764  Page:Shakespeare of Stratford (1926) Yale.djvu/91  104     21450
+
+    [3578765 rows x 3 columns]
+
+
+.. _`lxml's iterparse`: https://lxml.de/3.2/parsing.html#iterparse-and-iterwalk
+.. _`etree's iterparse`: https://docs.python.org/3/library/xml.etree.elementtree.html#xml.etree.ElementTree.iterparse
+
+.. _whatsnew_150.enhancements.copy_on_write:
+
+Copy on Write
+^^^^^^^^^^^^^
+
+A new feature ``copy_on_write`` was added (:issue:`46958`). Copy on write ensures that
+any DataFrame or Series derived from another in any way always behaves as a copy.
+Copy on write disallows updating any other object than the object the method
+was applied to.
+
+Copy on write can be enabled through:
+
+.. code-block:: python
+
+    pd.set_option("mode.copy_on_write", True)
+    pd.options.mode.copy_on_write = True
+
+Alternatively, copy on write can be enabled locally through:
+
+.. code-block:: python
+
+    with pd.option_context("mode.copy_on_write", True):
+        ...
+
+Without copy on write, the parent :class:`DataFrame` is updated when updating a child
+:class:`DataFrame` that was derived from this :class:`DataFrame`.
+
+.. ipython:: python
+
+    df = pd.DataFrame({"foo": [1, 2, 3], "bar": 1})
+    view = df["foo"]
+    view.iloc[0]
+    df
+
+With copy on write enabled, df won't be updated anymore:
+
+.. ipython:: python
+
+    with pd.option_context("mode.copy_on_write", True):
+        df = pd.DataFrame({"foo": [1, 2, 3], "bar": 1})
+        view = df["foo"]
+        view.iloc[0]
+        df
+
+A more detailed explanation can be found `here <https://phofl.github.io/cow-introduction.html>`_.
+
+.. _whatsnew_150.enhancements.other:
+
+Other enhancements
+^^^^^^^^^^^^^^^^^^
+- :meth:`Series.map` now raises when ``arg`` is dict but ``na_action`` is not either ``None`` or ``'ignore'`` (:issue:`46588`)
+- :meth:`MultiIndex.to_frame` now supports the argument ``allow_duplicates`` and raises on duplicate labels if it is missing or False (:issue:`45245`)
+- :class:`.StringArray` now accepts array-likes containing nan-likes (``None``, ``np.nan``) for the ``values`` parameter in its constructor in addition to strings and :attr:`pandas.NA`. (:issue:`40839`)
+- Improved the rendering of ``categories`` in :class:`CategoricalIndex` (:issue:`45218`)
+- :meth:`DataFrame.plot` will now allow the ``subplots`` parameter to be a list of iterables specifying column groups, so that columns may be grouped together in the same subplot (:issue:`29688`).
+- :meth:`to_numeric` now preserves float64 arrays when downcasting would generate values not representable in float32 (:issue:`43693`)
+- :meth:`Series.reset_index` and :meth:`DataFrame.reset_index` now support the argument ``allow_duplicates`` (:issue:`44410`)
+- :meth:`.GroupBy.min` and :meth:`.GroupBy.max` now supports `Numba <https://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`45428`)
+- :func:`read_csv` now supports ``defaultdict`` as a ``dtype`` parameter (:issue:`41574`)
+- :meth:`DataFrame.rolling` and :meth:`Series.rolling` now support a ``step`` parameter with fixed-length windows (:issue:`15354`)
+- Implemented a ``bool``-dtype :class:`Index`, passing a bool-dtype array-like to ``pd.Index`` will now retain ``bool`` dtype instead of casting to ``object`` (:issue:`45061`)
+- Implemented a complex-dtype :class:`Index`, passing a complex-dtype array-like to ``pd.Index`` will now retain complex dtype instead of casting to ``object`` (:issue:`45845`)
+- :class:`Series` and :class:`DataFrame` with :class:`IntegerDtype` now supports bitwise operations (:issue:`34463`)
+- Add ``milliseconds`` field support for :class:`.DateOffset` (:issue:`43371`)
+- :meth:`DataFrame.where` tries to maintain dtype of :class:`DataFrame` if fill value can be cast without loss of precision (:issue:`45582`)
+- :meth:`DataFrame.reset_index` now accepts a ``names`` argument which renames the index names (:issue:`6878`)
+- :func:`concat` now raises when ``levels`` is given but ``keys`` is None (:issue:`46653`)
+- :func:`concat` now raises when ``levels`` contains duplicate values (:issue:`46653`)
+- Added ``numeric_only`` argument to :meth:`DataFrame.corr`, :meth:`DataFrame.corrwith`, :meth:`DataFrame.cov`, :meth:`DataFrame.idxmin`, :meth:`DataFrame.idxmax`, :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.GroupBy.var`, :meth:`.GroupBy.std`, :meth:`.GroupBy.sem`, and :meth:`.DataFrameGroupBy.quantile` (:issue:`46560`)
+- A :class:`errors.PerformanceWarning` is now thrown when using ``string[pyarrow]`` dtype with methods that don't dispatch to ``pyarrow.compute`` methods (:issue:`42613`, :issue:`46725`)
+- Added ``validate`` argument to :meth:`DataFrame.join` (:issue:`46622`)
+- A :class:`errors.PerformanceWarning` is now thrown when using ``string[pyarrow]`` dtype with methods that don't dispatch to ``pyarrow.compute`` methods (:issue:`42613`)
+- Added ``numeric_only`` argument to :meth:`Resampler.sum`, :meth:`Resampler.prod`, :meth:`Resampler.min`, :meth:`Resampler.max`, :meth:`Resampler.first`, and :meth:`Resampler.last` (:issue:`46442`)
+- ``times`` argument in :class:`.ExponentialMovingWindow` now accepts ``np.timedelta64`` (:issue:`47003`)
+- :class:`.DataError`, :class:`.SpecificationError`, :class:`.SettingWithCopyError`, :class:`.SettingWithCopyWarning`, :class:`.NumExprClobberingError`, :class:`.UndefinedVariableError`, :class:`.IndexingError`, :class:`.PyperclipException`, :class:`.PyperclipWindowsException`, :class:`.CSSWarning`, :class:`.PossibleDataLossError`, :class:`.ClosedFileError`, :class:`.IncompatibilityWarning`, :class:`.AttributeConflictWarning`, :class:`.DatabaseError`, :class:`.PossiblePrecisionLoss`, :class:`.ValueLabelTypeMismatch`, :class:`.InvalidColumnName`, and :class:`.CategoricalConversionWarning` are now exposed in ``pandas.errors`` (:issue:`27656`)
+- Added ``check_like`` argument to :func:`testing.assert_series_equal` (:issue:`47247`)
+- Add support for :meth:`.GroupBy.ohlc` for extension array dtypes (:issue:`37493`)
+- Allow reading compressed SAS files with :func:`read_sas` (e.g., ``.sas7bdat.gz`` files)
+- :func:`pandas.read_html` now supports extracting links from table cells (:issue:`13141`)
+- :meth:`DatetimeIndex.astype` now supports casting timezone-naive indexes to ``datetime64[s]``, ``datetime64[ms]``, and ``datetime64[us]``, and timezone-aware indexes to the corresponding ``datetime64[unit, tzname]`` dtypes (:issue:`47579`)
+- :class:`Series` reducers (e.g. ``min``, ``max``, ``sum``, ``mean``) will now successfully operate when the dtype is numeric and ``numeric_only=True`` is provided; previously this would raise a ``NotImplementedError`` (:issue:`47500`)
+- :meth:`RangeIndex.union` now can return a :class:`RangeIndex` instead of a :class:`Int64Index` if the resulting values are equally spaced (:issue:`47557`, :issue:`43885`)
+- :meth:`DataFrame.compare` now accepts an argument ``result_names`` to allow the user to specify the result's names of both left and right DataFrame which are being compared. This is by default ``'self'`` and ``'other'`` (:issue:`44354`)
+- :meth:`DataFrame.quantile` gained a ``method`` argument that can accept ``table`` to evaluate multi-column quantiles (:issue:`43881`)
+- :class:`Interval` now supports checking whether one interval is contained by another interval (:issue:`46613`)
+- Added ``copy`` keyword to :meth:`Series.set_axis` and :meth:`DataFrame.set_axis` to allow user to set axis on a new object without necessarily copying the underlying data (:issue:`47932`)
+- The method :meth:`.ExtensionArray.factorize` accepts ``use_na_sentinel=False`` for determining how null values are to be treated (:issue:`46601`)
+- The ``Dockerfile`` now installs a dedicated ``pandas-dev`` virtual environment for pandas development instead of using the ``base`` environment (:issue:`48427`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.notable_bug_fixes:
+
+Notable bug fixes
+~~~~~~~~~~~~~~~~~
+
+These are bug fixes that might have notable behavior changes.
+
+.. _whatsnew_150.notable_bug_fixes.groupby_transform_dropna:
+
+Using ``dropna=True`` with ``groupby`` transforms
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A transform is an operation whose result has the same size as its input. When the
+result is a :class:`DataFrame` or :class:`Series`, it is also required that the
+index of the result matches that of the input. In pandas 1.4, using
+:meth:`.DataFrameGroupBy.transform` or :meth:`.SeriesGroupBy.transform` with null
+values in the groups and ``dropna=True`` gave incorrect results. Demonstrated by the
+examples below, the incorrect results either contained incorrect values, or the result
+did not have the same index as the input.
+
+.. ipython:: python
+
+    df = pd.DataFrame({'a': [1, 1, np.nan], 'b': [2, 3, 4]})
+
+*Old behavior*:
+
+.. code-block:: ipython
+
+    In [3]: # Value in the last row should be np.nan
+            df.groupby('a', dropna=True).transform('sum')
+    Out[3]:
+       b
+    0  5
+    1  5
+    2  5
+
+    In [3]: # Should have one additional row with the value np.nan
+            df.groupby('a', dropna=True).transform(lambda x: x.sum())
+    Out[3]:
+       b
+    0  5
+    1  5
+
+    In [3]: # The value in the last row is np.nan interpreted as an integer
+            df.groupby('a', dropna=True).transform('ffill')
+    Out[3]:
+                         b
+    0                    2
+    1                    3
+    2 -9223372036854775808
+
+    In [3]: # Should have one additional row with the value np.nan
+            df.groupby('a', dropna=True).transform(lambda x: x)
+    Out[3]:
+       b
+    0  2
+    1  3
+
+*New behavior*:
+
+.. ipython:: python
+
+    df.groupby('a', dropna=True).transform('sum')
+    df.groupby('a', dropna=True).transform(lambda x: x.sum())
+    df.groupby('a', dropna=True).transform('ffill')
+    df.groupby('a', dropna=True).transform(lambda x: x)
+
+.. _whatsnew_150.notable_bug_fixes.to_json_incorrectly_localizing_naive_timestamps:
+
+Serializing tz-naive Timestamps with to_json() with ``iso_dates=True``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`DataFrame.to_json`, :meth:`Series.to_json`, and :meth:`Index.to_json`
+would incorrectly localize DatetimeArrays/DatetimeIndexes with tz-naive Timestamps
+to UTC. (:issue:`38760`)
+
+Note that this patch does not fix the localization of tz-aware Timestamps to UTC
+upon serialization. (Related issue :issue:`12997`)
+
+*Old Behavior*
+
+.. ipython:: python
+
+    index = pd.date_range(
+        start='2020-12-28 00:00:00',
+        end='2020-12-28 02:00:00',
+        freq='1H',
+    )
+    a = pd.Series(
+        data=range(3),
+        index=index,
+    )
+
+.. code-block:: ipython
+
+    In [4]: a.to_json(date_format='iso')
+    Out[4]: '{"2020-12-28T00:00:00.000Z":0,"2020-12-28T01:00:00.000Z":1,"2020-12-28T02:00:00.000Z":2}'
+
+    In [5]: pd.read_json(a.to_json(date_format='iso'), typ="series").index == a.index
+    Out[5]: array([False, False, False])
+
+*New Behavior*
+
+.. ipython:: python
+
+    a.to_json(date_format='iso')
+    # Roundtripping now works
+    pd.read_json(a.to_json(date_format='iso'), typ="series").index == a.index
+
+.. _whatsnew_150.notable_bug_fixes.groupby_value_counts_categorical:
+
+DataFrameGroupBy.value_counts with non-grouping categorical columns and ``observed=True``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Calling :meth:`.DataFrameGroupBy.value_counts` with ``observed=True`` would incorrectly drop non-observed categories of non-grouping columns (:issue:`46357`).
+
+.. code-block:: ipython
+
+    In [6]: df = pd.DataFrame(["a", "b", "c"], dtype="category").iloc[0:2]
+    In [7]: df
+    Out[7]:
+       0
+    0  a
+    1  b
+
+*Old Behavior*
+
+.. code-block:: ipython
+
+    In [8]: df.groupby(level=0, observed=True).value_counts()
+    Out[8]:
+    0  a    1
+    1  b    1
+    dtype: int64
+
+
+*New Behavior*
+
+.. code-block:: ipython
+
+    In [9]: df.groupby(level=0, observed=True).value_counts()
+    Out[9]:
+    0  a    1
+    1  a    0
+       b    1
+    0  b    0
+       c    0
+    1  c    0
+    dtype: int64
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.api_breaking:
+
+Backwards incompatible API changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _whatsnew_150.api_breaking.deps:
+
+Increased minimum versions for dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Some minimum supported versions of dependencies were updated.
+If installed, we now require:
+
++-----------------+-----------------+----------+---------+
+| Package         | Minimum Version | Required | Changed |
++=================+=================+==========+=========+
+| numpy           | 1.20.3          |    X     |    X    |
++-----------------+-----------------+----------+---------+
+| mypy (dev)      | 0.971           |          |    X    |
++-----------------+-----------------+----------+---------+
+| beautifulsoup4  | 4.9.3           |          |    X    |
++-----------------+-----------------+----------+---------+
+| blosc           | 1.21.0          |          |    X    |
++-----------------+-----------------+----------+---------+
+| bottleneck      | 1.3.2           |          |    X    |
++-----------------+-----------------+----------+---------+
+| fsspec          | 2021.07.0       |          |    X    |
++-----------------+-----------------+----------+---------+
+| hypothesis      | 6.13.0          |          |    X    |
++-----------------+-----------------+----------+---------+
+| gcsfs           | 2021.07.0       |          |    X    |
++-----------------+-----------------+----------+---------+
+| jinja2          | 3.0.0           |          |    X    |
++-----------------+-----------------+----------+---------+
+| lxml            | 4.6.3           |          |    X    |
++-----------------+-----------------+----------+---------+
+| numba           | 0.53.1          |          |    X    |
++-----------------+-----------------+----------+---------+
+| numexpr         | 2.7.3           |          |    X    |
++-----------------+-----------------+----------+---------+
+| openpyxl        | 3.0.7           |          |    X    |
++-----------------+-----------------+----------+---------+
+| pandas-gbq      | 0.15.0          |          |    X    |
++-----------------+-----------------+----------+---------+
+| psycopg2        | 2.8.6           |          |    X    |
++-----------------+-----------------+----------+---------+
+| pymysql         | 1.0.2           |          |    X    |
++-----------------+-----------------+----------+---------+
+| pyreadstat      | 1.1.2           |          |    X    |
++-----------------+-----------------+----------+---------+
+| pyxlsb          | 1.0.8           |          |    X    |
++-----------------+-----------------+----------+---------+
+| s3fs            | 2021.08.0       |          |    X    |
++-----------------+-----------------+----------+---------+
+| scipy           | 1.7.1           |          |    X    |
++-----------------+-----------------+----------+---------+
+| sqlalchemy      | 1.4.16          |          |    X    |
++-----------------+-----------------+----------+---------+
+| tabulate        | 0.8.9           |          |    X    |
++-----------------+-----------------+----------+---------+
+| xarray          | 0.19.0          |          |    X    |
++-----------------+-----------------+----------+---------+
+| xlsxwriter      | 1.4.3           |          |    X    |
++-----------------+-----------------+----------+---------+
+
+For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
+The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
+Optional libraries below the lowest tested version may still work, but are not considered supported.
+
++-----------------+-----------------+---------+
+| Package         | Minimum Version | Changed |
++=================+=================+=========+
+| beautifulsoup4  |4.9.3            |    X    |
++-----------------+-----------------+---------+
+| blosc           |1.21.0           |    X    |
++-----------------+-----------------+---------+
+| bottleneck      |1.3.2            |    X    |
++-----------------+-----------------+---------+
+| brotlipy        |0.7.0            |         |
++-----------------+-----------------+---------+
+| fastparquet     |0.4.0            |         |
++-----------------+-----------------+---------+
+| fsspec          |2021.08.0        |    X    |
++-----------------+-----------------+---------+
+| html5lib        |1.1              |         |
++-----------------+-----------------+---------+
+| hypothesis      |6.13.0           |    X    |
++-----------------+-----------------+---------+
+| gcsfs           |2021.08.0        |    X    |
++-----------------+-----------------+---------+
+| jinja2          |3.0.0            |    X    |
++-----------------+-----------------+---------+
+| lxml            |4.6.3            |    X    |
++-----------------+-----------------+---------+
+| matplotlib      |3.3.2            |         |
++-----------------+-----------------+---------+
+| numba           |0.53.1           |    X    |
++-----------------+-----------------+---------+
+| numexpr         |2.7.3            |    X    |
++-----------------+-----------------+---------+
+| odfpy           |1.4.1            |         |
++-----------------+-----------------+---------+
+| openpyxl        |3.0.7            |    X    |
++-----------------+-----------------+---------+
+| pandas-gbq      |0.15.0           |    X    |
++-----------------+-----------------+---------+
+| psycopg2        |2.8.6            |    X    |
++-----------------+-----------------+---------+
+| pyarrow         |1.0.1            |         |
++-----------------+-----------------+---------+
+| pymysql         |1.0.2            |    X    |
++-----------------+-----------------+---------+
+| pyreadstat      |1.1.2            |    X    |
++-----------------+-----------------+---------+
+| pytables        |3.6.1            |         |
++-----------------+-----------------+---------+
+| python-snappy   |0.6.0            |         |
++-----------------+-----------------+---------+
+| pyxlsb          |1.0.8            |    X    |
++-----------------+-----------------+---------+
+| s3fs            |2021.08.0        |    X    |
++-----------------+-----------------+---------+
+| scipy           |1.7.1            |    X    |
++-----------------+-----------------+---------+
+| sqlalchemy      |1.4.16           |    X    |
++-----------------+-----------------+---------+
+| tabulate        |0.8.9            |    X    |
++-----------------+-----------------+---------+
+| tzdata          |2022a            |         |
++-----------------+-----------------+---------+
+| xarray          |0.19.0           |    X    |
++-----------------+-----------------+---------+
+| xlrd            |2.0.1            |         |
++-----------------+-----------------+---------+
+| xlsxwriter      |1.4.3            |    X    |
++-----------------+-----------------+---------+
+| xlwt            |1.3.0            |         |
++-----------------+-----------------+---------+
+| zstandard       |0.15.2           |         |
++-----------------+-----------------+---------+
+
+See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
+
+.. _whatsnew_150.api_breaking.other:
+
+Other API changes
+^^^^^^^^^^^^^^^^^
+
+- BigQuery I/O methods :func:`read_gbq` and :meth:`DataFrame.to_gbq` default to
+  ``auth_local_webserver = True``. Google has deprecated the
+  ``auth_local_webserver = False`` `"out of band" (copy-paste) flow
+  <https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html?m=1#disallowed-oob>`_.
+  The ``auth_local_webserver = False`` option is planned to stop working in
+  October 2022. (:issue:`46312`)
+- :func:`read_json` now raises ``FileNotFoundError`` (previously ``ValueError``) when input is a string ending in ``.json``, ``.json.gz``, ``.json.bz2``, etc. but no such file exists. (:issue:`29102`)
+- Operations with :class:`Timestamp` or :class:`Timedelta` that would previously raise ``OverflowError`` instead raise ``OutOfBoundsDatetime`` or ``OutOfBoundsTimedelta`` where appropriate (:issue:`47268`)
+- When :func:`read_sas` previously returned ``None``, it now returns an empty :class:`DataFrame` (:issue:`47410`)
+- :class:`DataFrame` constructor raises if ``index`` or ``columns`` arguments are sets (:issue:`47215`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.deprecations:
+
+Deprecations
+~~~~~~~~~~~~
+
+.. warning::
+
+    In the next major version release, 2.0, several larger API changes are being considered without a formal deprecation such as
+    making the standard library `zoneinfo <https://docs.python.org/3/library/zoneinfo.html>`_ the default timezone implementation instead of ``pytz``,
+    having the :class:`Index` support all data types instead of having multiple subclasses (:class:`CategoricalIndex`, :class:`Int64Index`, etc.), and more.
+    The changes under consideration are logged in `this Github issue <https://github.com/pandas-dev/pandas/issues/44823>`_, and any
+    feedback or concerns are welcome.
+
+.. _whatsnew_150.deprecations.int_slicing_series:
+
+Label-based integer slicing on a Series with an Int64Index or RangeIndex
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In a future version, integer slicing on a :class:`Series` with a :class:`Int64Index` or :class:`RangeIndex` will be treated as *label-based*, not positional. This will make the behavior consistent with other :meth:`Series.__getitem__` and :meth:`Series.__setitem__` behaviors (:issue:`45162`).
+
+For example:
+
+.. ipython:: python
+
+   ser = pd.Series([1, 2, 3, 4, 5], index=[2, 3, 5, 7, 11])
+
+In the old behavior, ``ser[2:4]`` treats the slice as positional:
+
+*Old behavior*:
+
+.. code-block:: ipython
+
+    In [3]: ser[2:4]
+    Out[3]:
+    5    3
+    7    4
+    dtype: int64
+
+In a future version, this will be treated as label-based:
+
+*Future behavior*:
+
+.. code-block:: ipython
+
+    In [4]: ser.loc[2:4]
+    Out[4]:
+    2    1
+    3    2
+    dtype: int64
+
+To retain the old behavior, use ``series.iloc[i:j]``. To get the future behavior,
+use ``series.loc[i:j]``.
+
+Slicing on a :class:`DataFrame` will not be affected.
+
+.. _whatsnew_150.deprecations.excel_writer_attributes:
+
+:class:`ExcelWriter` attributes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+All attributes of :class:`ExcelWriter` were previously documented as not
+public. However some third party Excel engines documented accessing
+``ExcelWriter.book`` or ``ExcelWriter.sheets``, and users were utilizing these
+and possibly other attributes. Previously these attributes were not safe to use;
+e.g. modifications to ``ExcelWriter.book`` would not update ``ExcelWriter.sheets``
+and conversely. In order to support this, pandas has made some attributes public
+and improved their implementations so that they may now be safely used. (:issue:`45572`)
+
+The following attributes are now public and considered safe to access.
+
+ - ``book``
+ - ``check_extension``
+ - ``close``
+ - ``date_format``
+ - ``datetime_format``
+ - ``engine``
+ - ``if_sheet_exists``
+ - ``sheets``
+ - ``supported_extensions``
+
+The following attributes have been deprecated. They now raise a ``FutureWarning``
+when accessed and will be removed in a future version. Users should be aware
+that their usage is considered unsafe, and can lead to unexpected results.
+
+ - ``cur_sheet``
+ - ``handles``
+ - ``path``
+ - ``save``
+ - ``write_cells``
+
+See the documentation of :class:`ExcelWriter` for further details.
+
+.. _whatsnew_150.deprecations.group_keys_in_apply:
+
+Using ``group_keys`` with transformers in :meth:`.GroupBy.apply`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In previous versions of pandas, if it was inferred that the function passed to
+:meth:`.GroupBy.apply` was a transformer (i.e. the resulting index was equal to
+the input index), the ``group_keys`` argument of :meth:`DataFrame.groupby` and
+:meth:`Series.groupby` was ignored and the group keys would never be added to
+the index of the result. In the future, the group keys will be added to the index
+when the user specifies ``group_keys=True``.
+
+As ``group_keys=True`` is the default value of :meth:`DataFrame.groupby` and
+:meth:`Series.groupby`, not specifying ``group_keys`` with a transformer will
+raise a ``FutureWarning``. This can be silenced and the previous behavior
+retained by specifying ``group_keys=False``.
+
+.. _whatsnew_150.deprecations.setitem_column_try_inplace:
+   _ see also _whatsnew_130.notable_bug_fixes.setitem_column_try_inplace
+
+Inplace operation when setting values with ``loc`` and ``iloc``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Most of the time setting values with :meth:`DataFrame.iloc` attempts to set values
+inplace, only falling back to inserting a new array if necessary. There are
+some cases where this rule is not followed, for example when setting an entire
+column from an array with different dtype:
+
+.. ipython:: python
+
+   df = pd.DataFrame({'price': [11.1, 12.2]}, index=['book1', 'book2'])
+   original_prices = df['price']
+   new_prices = np.array([98, 99])
+
+*Old behavior*:
+
+.. code-block:: ipython
+
+    In [3]: df.iloc[:, 0] = new_prices
+    In [4]: df.iloc[:, 0]
+    Out[4]:
+    book1    98
+    book2    99
+    Name: price, dtype: int64
+    In [5]: original_prices
+    Out[5]:
+    book1    11.1
+    book2    12.2
+    Name: price, float: 64
+
+This behavior is deprecated. In a future version, setting an entire column with
+iloc will attempt to operate inplace.
+
+*Future behavior*:
+
+.. code-block:: ipython
+
+    In [3]: df.iloc[:, 0] = new_prices
+    In [4]: df.iloc[:, 0]
+    Out[4]:
+    book1    98.0
+    book2    99.0
+    Name: price, dtype: float64
+    In [5]: original_prices
+    Out[5]:
+    book1    98.0
+    book2    99.0
+    Name: price, dtype: float64
+
+To get the old behavior, use :meth:`DataFrame.__setitem__` directly:
+
+.. code-block:: ipython
+
+    In [3]: df[df.columns[0]] = new_prices
+    In [4]: df.iloc[:, 0]
+    Out[4]
+    book1    98
+    book2    99
+    Name: price, dtype: int64
+    In [5]: original_prices
+    Out[5]:
+    book1    11.1
+    book2    12.2
+    Name: price, dtype: float64
+
+To get the old behaviour when ``df.columns`` is not unique and you want to
+change a single column by index, you can use :meth:`DataFrame.isetitem`, which
+has been added in pandas 1.5:
+
+.. code-block:: ipython
+
+    In [3]: df_with_duplicated_cols = pd.concat([df, df], axis='columns')
+    In [3]: df_with_duplicated_cols.isetitem(0, new_prices)
+    In [4]: df_with_duplicated_cols.iloc[:, 0]
+    Out[4]:
+    book1    98
+    book2    99
+    Name: price, dtype: int64
+    In [5]: original_prices
+    Out[5]:
+    book1    11.1
+    book2    12.2
+    Name: 0, dtype: float64
+
+.. _whatsnew_150.deprecations.numeric_only_default:
+
+``numeric_only`` default value
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Across the :class:`DataFrame`, :class:`.DataFrameGroupBy`, and :class:`.Resampler` operations such as
+``min``, ``sum``, and ``idxmax``, the default
+value of the ``numeric_only`` argument, if it exists at all, was inconsistent.
+Furthermore, operations with the default value ``None`` can lead to surprising
+results. (:issue:`46560`)
+
+.. code-block:: ipython
+
+    In [1]: df = pd.DataFrame({"a": [1, 2], "b": ["x", "y"]})
+
+    In [2]: # Reading the next line without knowing the contents of df, one would
+            # expect the result to contain the products for both columns a and b.
+            df[["a", "b"]].prod()
+    Out[2]:
+    a    2
+    dtype: int64
+
+To avoid this behavior, the specifying the value ``numeric_only=None`` has been
+deprecated, and will be removed in a future version of pandas. In the future,
+all operations with a ``numeric_only`` argument will default to ``False``. Users
+should either call the operation only with columns that can be operated on, or
+specify ``numeric_only=True`` to operate only on Boolean, integer, and float columns.
+
+In order to support the transition to the new behavior, the following methods have
+gained the ``numeric_only`` argument.
+
+- :meth:`DataFrame.corr`
+- :meth:`DataFrame.corrwith`
+- :meth:`DataFrame.cov`
+- :meth:`DataFrame.idxmin`
+- :meth:`DataFrame.idxmax`
+- :meth:`.DataFrameGroupBy.cummin`
+- :meth:`.DataFrameGroupBy.cummax`
+- :meth:`.DataFrameGroupBy.idxmin`
+- :meth:`.DataFrameGroupBy.idxmax`
+- :meth:`.GroupBy.var`
+- :meth:`.GroupBy.std`
+- :meth:`.GroupBy.sem`
+- :meth:`.DataFrameGroupBy.quantile`
+- :meth:`.Resampler.mean`
+- :meth:`.Resampler.median`
+- :meth:`.Resampler.sem`
+- :meth:`.Resampler.std`
+- :meth:`.Resampler.var`
+- :meth:`DataFrame.rolling` operations
+- :meth:`DataFrame.expanding` operations
+- :meth:`DataFrame.ewm` operations
+
+.. _whatsnew_150.deprecations.other:
+
+Other Deprecations
+^^^^^^^^^^^^^^^^^^
+- Deprecated the keyword ``line_terminator`` in :meth:`DataFrame.to_csv` and :meth:`Series.to_csv`, use ``lineterminator`` instead; this is for consistency with :func:`read_csv` and the standard library 'csv' module (:issue:`9568`)
+- Deprecated behavior of :meth:`SparseArray.astype`, :meth:`Series.astype`, and :meth:`DataFrame.astype` with :class:`SparseDtype` when passing a non-sparse ``dtype``. In a future version, this will cast to that non-sparse dtype instead of wrapping it in a :class:`SparseDtype` (:issue:`34457`)
+- Deprecated behavior of :meth:`DatetimeIndex.intersection` and :meth:`DatetimeIndex.symmetric_difference` (``union`` behavior was already deprecated in version 1.3.0) with mixed time zones; in a future version both will be cast to UTC instead of object dtype (:issue:`39328`, :issue:`45357`)
+- Deprecated :meth:`DataFrame.iteritems`, :meth:`Series.iteritems`, :meth:`HDFStore.iteritems` in favor of :meth:`DataFrame.items`, :meth:`Series.items`, :meth:`HDFStore.items`  (:issue:`45321`)
+- Deprecated :meth:`Series.is_monotonic` and :meth:`Index.is_monotonic` in favor of :meth:`Series.is_monotonic_increasing` and :meth:`Index.is_monotonic_increasing` (:issue:`45422`, :issue:`21335`)
+- Deprecated behavior of :meth:`DatetimeIndex.astype`, :meth:`TimedeltaIndex.astype`, :meth:`PeriodIndex.astype` when converting to an integer dtype other than ``int64``. In a future version, these will convert to exactly the specified dtype (instead of always ``int64``) and will raise if the conversion overflows (:issue:`45034`)
+- Deprecated the ``__array_wrap__`` method of DataFrame and Series, rely on standard numpy ufuncs instead (:issue:`45451`)
+- Deprecated treating float-dtype data as wall-times when passed with a timezone to :class:`Series` or :class:`DatetimeIndex` (:issue:`45573`)
+- Deprecated the behavior of :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtype and incompatible fill value; in a future version this will cast to a common dtype (usually object) instead of raising, matching the behavior of other dtypes (:issue:`45746`)
+- Deprecated the ``warn`` parameter in :func:`infer_freq` (:issue:`45947`)
+- Deprecated allowing non-keyword arguments in :meth:`.ExtensionArray.argsort` (:issue:`46134`)
+- Deprecated treating all-bool ``object``-dtype columns as bool-like in :meth:`DataFrame.any` and :meth:`DataFrame.all` with ``bool_only=True``, explicitly cast to bool instead (:issue:`46188`)
+- Deprecated behavior of method :meth:`DataFrame.quantile`, attribute ``numeric_only`` will default False. Including datetime/timedelta columns in the result (:issue:`7308`).
+- Deprecated :attr:`Timedelta.freq` and :attr:`Timedelta.is_populated` (:issue:`46430`)
+- Deprecated :attr:`Timedelta.delta` (:issue:`46476`)
+- Deprecated passing arguments as positional in :meth:`DataFrame.any` and :meth:`Series.any` (:issue:`44802`)
+- Deprecated passing positional arguments to :meth:`DataFrame.pivot` and :func:`pivot` except ``data`` (:issue:`30228`)
+- Deprecated the methods :meth:`DataFrame.mad`, :meth:`Series.mad`, and the corresponding groupby methods (:issue:`11787`)
+- Deprecated positional arguments to :meth:`Index.join` except for ``other``, use keyword-only arguments instead of positional arguments (:issue:`46518`)
+- Deprecated positional arguments to :meth:`StringMethods.rsplit` and :meth:`StringMethods.split` except for ``pat``, use keyword-only arguments instead of positional arguments (:issue:`47423`)
+- Deprecated indexing on a timezone-naive :class:`DatetimeIndex` using a string representing a timezone-aware datetime (:issue:`46903`, :issue:`36148`)
+- Deprecated allowing ``unit="M"`` or ``unit="Y"`` in :class:`Timestamp` constructor with a non-round float value (:issue:`47267`)
+- Deprecated the ``display.column_space`` global configuration option (:issue:`7576`)
+- Deprecated the argument ``na_sentinel`` in :func:`factorize`, :meth:`Index.factorize`, and :meth:`.ExtensionArray.factorize`; pass ``use_na_sentinel=True`` instead to use the sentinel ``-1`` for NaN values and ``use_na_sentinel=False`` instead of ``na_sentinel=None`` to encode NaN values (:issue:`46910`)
+- Deprecated :meth:`DataFrameGroupBy.transform` not aligning the result when the UDF returned DataFrame (:issue:`45648`)
+- Clarified warning from :func:`to_datetime` when delimited dates can't be parsed in accordance to specified ``dayfirst`` argument (:issue:`46210`)
+- Emit warning from :func:`to_datetime` when delimited dates can't be parsed in accordance to specified ``dayfirst`` argument even for dates where leading zero is omitted (e.g. ``31/1/2001``) (:issue:`47880`)
+- Deprecated :class:`Series` and :class:`Resampler` reducers (e.g. ``min``, ``max``, ``sum``, ``mean``) raising a ``NotImplementedError`` when the dtype is non-numric and ``numeric_only=True`` is provided; this will raise a ``TypeError`` in a future version (:issue:`47500`)
+- Deprecated :meth:`Series.rank` returning an empty result when the dtype is non-numeric and ``numeric_only=True`` is provided; this will raise a ``TypeError`` in a future version (:issue:`47500`)
+- Deprecated argument ``errors`` for :meth:`Series.mask`, :meth:`Series.where`, :meth:`DataFrame.mask`, and :meth:`DataFrame.where` as ``errors`` had no effect on this methods (:issue:`47728`)
+- Deprecated arguments ``*args`` and ``**kwargs`` in :class:`Rolling`, :class:`Expanding`, and :class:`ExponentialMovingWindow` ops. (:issue:`47836`)
+- Deprecated the ``inplace`` keyword in :meth:`Categorical.set_ordered`, :meth:`Categorical.as_ordered`, and :meth:`Categorical.as_unordered` (:issue:`37643`)
+- Deprecated setting a categorical's categories with ``cat.categories = ['a', 'b', 'c']``, use :meth:`Categorical.rename_categories` instead (:issue:`37643`)
+- Deprecated unused arguments ``encoding`` and ``verbose`` in :meth:`Series.to_excel` and :meth:`DataFrame.to_excel` (:issue:`47912`)
+- Deprecated the ``inplace`` keyword in :meth:`DataFrame.set_axis` and :meth:`Series.set_axis`, use ``obj = obj.set_axis(..., copy=False)`` instead (:issue:`48130`)
+- Deprecated producing a single element when iterating over a :class:`DataFrameGroupBy` or a :class:`SeriesGroupBy` that has been grouped by a list of length 1; A tuple of length one will be returned instead (:issue:`42795`)
+- Fixed up warning message of deprecation of :meth:`MultiIndex.lesort_depth` as public method, as the message previously referred to :meth:`MultiIndex.is_lexsorted` instead (:issue:`38701`)
+- Deprecated the ``sort_columns`` argument in :meth:`DataFrame.plot` and :meth:`Series.plot` (:issue:`47563`).
+- Deprecated positional arguments for all but the first argument of :meth:`DataFrame.to_stata` and :func:`read_stata`, use keyword arguments instead (:issue:`48128`).
+- Deprecated the ``mangle_dupe_cols`` argument in :func:`read_csv`, :func:`read_fwf`, :func:`read_table` and :func:`read_excel`. The argument was never implemented, and a new argument where the renaming pattern can be specified will be added instead (:issue:`47718`)
+- Deprecated allowing ``dtype='datetime64'`` or ``dtype=np.datetime64`` in :meth:`Series.astype`, use "datetime64[ns]" instead (:issue:`47844`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.performance:
+
+Performance improvements
+~~~~~~~~~~~~~~~~~~~~~~~~
+- Performance improvement in :meth:`DataFrame.corrwith` for column-wise (axis=0) Pearson and Spearman correlation when other is a :class:`Series` (:issue:`46174`)
+- Performance improvement in :meth:`.GroupBy.transform` for some user-defined DataFrame -> Series functions (:issue:`45387`)
+- Performance improvement in :meth:`DataFrame.duplicated` when subset consists of only one column (:issue:`45236`)
+- Performance improvement in :meth:`.GroupBy.diff` (:issue:`16706`)
+- Performance improvement in :meth:`.GroupBy.transform` when broadcasting values for user-defined functions (:issue:`45708`)
+- Performance improvement in :meth:`.GroupBy.transform` for user-defined functions when only a single group exists (:issue:`44977`)
+- Performance improvement in :meth:`.GroupBy.apply` when grouping on a non-unique unsorted index (:issue:`46527`)
+- Performance improvement in :meth:`DataFrame.loc` and :meth:`Series.loc` for tuple-based indexing of a :class:`MultiIndex` (:issue:`45681`, :issue:`46040`, :issue:`46330`)
+- Performance improvement in :meth:`.GroupBy.var` with ``ddof`` other than one (:issue:`48152`)
+- Performance improvement in :meth:`DataFrame.to_records` when the index is a :class:`MultiIndex` (:issue:`47263`)
+- Performance improvement in :attr:`MultiIndex.values` when the MultiIndex contains levels of type DatetimeIndex, TimedeltaIndex or ExtensionDtypes (:issue:`46288`)
+- Performance improvement in :func:`merge` when left and/or right are empty (:issue:`45838`)
+- Performance improvement in :meth:`DataFrame.join` when left and/or right are empty (:issue:`46015`)
+- Performance improvement in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when target is a :class:`MultiIndex` (:issue:`46235`)
+- Performance improvement when setting values in a pyarrow backed string array (:issue:`46400`)
+- Performance improvement in :func:`factorize` (:issue:`46109`)
+- Performance improvement in :class:`DataFrame` and :class:`Series` constructors for extension dtype scalars (:issue:`45854`)
+- Performance improvement in :func:`read_excel` when ``nrows`` argument provided (:issue:`32727`)
+- Performance improvement in :meth:`.Styler.to_excel` when applying repeated CSS formats (:issue:`47371`)
+- Performance improvement in :meth:`MultiIndex.is_monotonic_increasing`  (:issue:`47458`)
+- Performance improvement in :class:`BusinessHour` ``str`` and ``repr`` (:issue:`44764`)
+- Performance improvement in datetime arrays string formatting when one of the default strftime formats ``"%Y-%m-%d %H:%M:%S"`` or ``"%Y-%m-%d %H:%M:%S.%f"`` is used. (:issue:`44764`)
+- Performance improvement in :meth:`Series.to_sql` and :meth:`DataFrame.to_sql` (:class:`SQLiteTable`) when processing time arrays. (:issue:`44764`)
+- Performance improvement to :func:`read_sas` (:issue:`47404`)
+- Performance improvement in ``argmax`` and ``argmin`` for :class:`arrays.SparseArray` (:issue:`34197`)
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+Categorical
+^^^^^^^^^^^
+- Bug in :meth:`.Categorical.view` not accepting integer dtypes (:issue:`25464`)
+- Bug in :meth:`.CategoricalIndex.union` when the index's categories are integer-dtype and the index contains ``NaN`` values incorrectly raising instead of casting to ``float64`` (:issue:`45362`)
+- Bug in :meth:`concat` when concatenating two (or more) unordered :class:`CategoricalIndex` variables, whose categories are permutations, yields incorrect index values (:issue:`24845`)
+
+Datetimelike
+^^^^^^^^^^^^
+- Bug in :meth:`DataFrame.quantile` with datetime-like dtypes and no rows incorrectly returning ``float64`` dtype instead of retaining datetime-like dtype (:issue:`41544`)
+- Bug in :func:`to_datetime` with sequences of ``np.str_`` objects incorrectly raising (:issue:`32264`)
+- Bug in :class:`Timestamp` construction when passing datetime components as positional arguments and ``tzinfo`` as a keyword argument incorrectly raising (:issue:`31929`)
+- Bug in :meth:`Index.astype` when casting from object dtype to ``timedelta64[ns]`` dtype incorrectly casting ``np.datetime64("NaT")`` values to ``np.timedelta64("NaT")`` instead of raising (:issue:`45722`)
+- Bug in :meth:`SeriesGroupBy.value_counts` index when passing categorical column (:issue:`44324`)
+- Bug in :meth:`DatetimeIndex.tz_localize` localizing to UTC failing to make a copy of the underlying data (:issue:`46460`)
+- Bug in :meth:`DatetimeIndex.resolution` incorrectly returning "day" instead of "nanosecond" for nanosecond-resolution indexes (:issue:`46903`)
+- Bug in :class:`Timestamp` with an integer or float value and ``unit="Y"`` or ``unit="M"`` giving slightly-wrong results (:issue:`47266`)
+- Bug in :class:`.DatetimeArray` construction when passed another :class:`.DatetimeArray` and ``freq=None`` incorrectly inferring the freq from the given array (:issue:`47296`)
+- Bug in :func:`to_datetime` where ``OutOfBoundsDatetime`` would be thrown even if ``errors=coerce`` if there were more than 50 rows (:issue:`45319`)
+- Bug when adding a :class:`DateOffset` to a :class:`Series` would not add the ``nanoseconds`` field (:issue:`47856`)
+-
+
+Timedelta
+^^^^^^^^^
+- Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
+- Bug in constructing a :class:`Timedelta` with a ``np.timedelta64`` object and a ``unit`` sometimes silently overflowing and returning incorrect results instead of raising ``OutOfBoundsTimedelta`` (:issue:`46827`)
+- Bug in constructing a :class:`Timedelta` from a large integer or float with ``unit="W"`` silently overflowing and returning incorrect results instead of raising ``OutOfBoundsTimedelta`` (:issue:`47268`)
+-
+
+Time Zones
+^^^^^^^^^^
+- Bug in :class:`Timestamp` constructor raising when passed a ``ZoneInfo`` tzinfo object (:issue:`46425`)
+-
+
+Numeric
+^^^^^^^
+- Bug in operations with array-likes with ``dtype="boolean"`` and :attr:`NA` incorrectly altering the array in-place (:issue:`45421`)
+- Bug in arithmetic operations with nullable types without :attr:`NA` values not matching the same operation with non-nullable types (:issue:`48223`)
+- Bug in ``floordiv`` when dividing by ``IntegerDtype`` ``0`` would return ``0`` instead of ``inf`` (:issue:`48223`)
+- Bug in division, ``pow`` and ``mod`` operations on array-likes with ``dtype="boolean"`` not being like their ``np.bool_`` counterparts (:issue:`46063`)
+- Bug in multiplying a :class:`Series` with ``IntegerDtype`` or ``FloatingDtype`` by an array-like with ``timedelta64[ns]`` dtype incorrectly raising (:issue:`45622`)
+- Bug in :meth:`mean` where the optional dependency ``bottleneck`` causes precision loss linear in the length of the array. ``bottleneck`` has been disabled for :meth:`mean` improving the loss to log-linear but may result in a performance decrease. (:issue:`42878`)
+
+Conversion
+^^^^^^^^^^
+- Bug in :meth:`DataFrame.astype` not preserving subclasses (:issue:`40810`)
+- Bug in constructing a :class:`Series` from a float-containing list or a floating-dtype ndarray-like (e.g. ``dask.Array``) and an integer dtype raising instead of casting like we would with an ``np.ndarray`` (:issue:`40110`)
+- Bug in :meth:`Float64Index.astype` to unsigned integer dtype incorrectly casting to ``np.int64`` dtype (:issue:`45309`)
+- Bug in :meth:`Series.astype` and :meth:`DataFrame.astype` from floating dtype to unsigned integer dtype failing to raise in the presence of negative values (:issue:`45151`)
+- Bug in :func:`array` with ``FloatingDtype`` and values containing float-castable strings incorrectly raising (:issue:`45424`)
+- Bug when comparing string and datetime64ns objects causing ``OverflowError`` exception. (:issue:`45506`)
+- Bug in metaclass of generic abstract dtypes causing :meth:`DataFrame.apply` and :meth:`Series.apply` to raise for the built-in function ``type`` (:issue:`46684`)
+- Bug in :meth:`DataFrame.to_records` returning inconsistent numpy types if the index was a :class:`MultiIndex` (:issue:`47263`)
+- Bug in :meth:`DataFrame.to_dict` for ``orient="list"`` or ``orient="index"`` was not returning native types (:issue:`46751`)
+- Bug in :meth:`DataFrame.apply` that returns a :class:`DataFrame` instead of a :class:`Series` when applied to an empty :class:`DataFrame` and ``axis=1`` (:issue:`39111`)
+- Bug when inferring the dtype from an iterable that is *not* a NumPy ``ndarray`` consisting of all NumPy unsigned integer scalars did not result in an unsigned integer dtype (:issue:`47294`)
+- Bug in :meth:`DataFrame.eval` when pandas objects (e.g. ``'Timestamp'``) were column names (:issue:`44603`)
+-
+
+Strings
+^^^^^^^
+- Bug in :meth:`str.startswith` and :meth:`str.endswith` when using other series as parameter _pat_. Now raises ``TypeError`` (:issue:`3485`)
+- Bug in :meth:`Series.str.zfill` when strings contain leading signs, padding '0' before the sign character rather than after as ``str.zfill`` from standard library (:issue:`20868`)
+-
+
+Interval
+^^^^^^^^
+- Bug in :meth:`IntervalArray.__setitem__` when setting ``np.nan`` into an integer-backed array raising ``ValueError`` instead of ``TypeError`` (:issue:`45484`)
+- Bug in :class:`IntervalDtype` when using datetime64[ns, tz] as a dtype string (:issue:`46999`)
+
+Indexing
+^^^^^^^^
+- Bug in :meth:`DataFrame.iloc` where indexing a single row on a :class:`DataFrame` with a single ExtensionDtype column gave a copy instead of a view on the underlying data (:issue:`45241`)
+- Bug in :meth:`DataFrame.__getitem__` returning copy when :class:`DataFrame` has duplicated columns even if a unique column is selected (:issue:`45316`, :issue:`41062`)
+- Bug in :meth:`Series.align` does not create :class:`MultiIndex` with union of levels when both MultiIndexes intersections are identical (:issue:`45224`)
+- Bug in setting a NA value (``None`` or ``np.nan``) into a :class:`Series` with int-based :class:`IntervalDtype` incorrectly casting to object dtype instead of a float-based :class:`IntervalDtype` (:issue:`45568`)
+- Bug in indexing setting values into an ``ExtensionDtype`` column with ``df.iloc[:, i] = values`` with ``values`` having the same dtype as ``df.iloc[:, i]`` incorrectly inserting a new array instead of setting in-place (:issue:`33457`)
+- Bug in :meth:`Series.__setitem__` with a non-integer :class:`Index` when using an integer key to set a value that cannot be set inplace where a ``ValueError`` was raised instead of casting to a common dtype (:issue:`45070`)
+- Bug in :meth:`DataFrame.loc` not casting ``None`` to ``NA`` when setting value as a list into :class:`DataFrame` (:issue:`47987`)
+- Bug in :meth:`Series.__setitem__` when setting incompatible values into a ``PeriodDtype`` or ``IntervalDtype`` :class:`Series` raising when indexing with a boolean mask but coercing when indexing with otherwise-equivalent indexers; these now consistently coerce, along with :meth:`Series.mask` and :meth:`Series.where` (:issue:`45768`)
+- Bug in :meth:`DataFrame.where` with multiple columns with datetime-like dtypes failing to downcast results consistent with other dtypes (:issue:`45837`)
+- Bug in :func:`isin` upcasting to ``float64`` with unsigned integer dtype and list-like argument without a dtype (:issue:`46485`)
+- Bug in :meth:`Series.loc.__setitem__` and :meth:`Series.loc.__getitem__` not raising when using multiple keys without using a :class:`MultiIndex` (:issue:`13831`)
+- Bug in :meth:`Index.reindex` raising ``AssertionError`` when ``level`` was specified but no :class:`MultiIndex` was given; level is ignored now (:issue:`35132`)
+- Bug when setting a value too large for a :class:`Series` dtype failing to coerce to a common type (:issue:`26049`, :issue:`32878`)
+- Bug in :meth:`loc.__setitem__` treating ``range`` keys as positional instead of label-based (:issue:`45479`)
+- Bug in :meth:`DataFrame.__setitem__` casting extension array dtypes to object when setting with a scalar key and :class:`DataFrame` as value (:issue:`46896`)
+- Bug in :meth:`Series.__setitem__` when setting a scalar to a nullable pandas dtype would not raise a ``TypeError`` if the scalar could not be cast (losslessly) to the nullable type (:issue:`45404`)
+- Bug in :meth:`Series.__setitem__` when setting ``boolean`` dtype values containing ``NA`` incorrectly raising instead of casting to ``boolean`` dtype (:issue:`45462`)
+- Bug in :meth:`Series.loc` raising with boolean indexer containing ``NA`` when :class:`Index` did not match (:issue:`46551`)
+- Bug in :meth:`Series.__setitem__` where setting :attr:`NA` into a numeric-dtype :class:`Series` would incorrectly upcast to object-dtype rather than treating the value as ``np.nan`` (:issue:`44199`)
+- Bug in :meth:`DataFrame.loc` when setting values to a column and right hand side is a dictionary (:issue:`47216`)
+- Bug in :meth:`Series.__setitem__` with ``datetime64[ns]`` dtype, an all-``False`` boolean mask, and an incompatible value incorrectly casting to ``object`` instead of retaining ``datetime64[ns]`` dtype (:issue:`45967`)
+- Bug in :meth:`Index.__getitem__`  raising ``ValueError`` when indexer is from boolean dtype with ``NA`` (:issue:`45806`)
+- Bug in :meth:`Series.__setitem__` losing precision when enlarging :class:`Series` with scalar (:issue:`32346`)
+- Bug in :meth:`Series.mask` with ``inplace=True`` or setting values with a boolean mask with small integer dtypes incorrectly raising (:issue:`45750`)
+- Bug in :meth:`DataFrame.mask` with ``inplace=True`` and ``ExtensionDtype`` columns incorrectly raising (:issue:`45577`)
+- Bug in getting a column from a DataFrame with an object-dtype row index with datetime-like values: the resulting Series now preserves the exact object-dtype Index from the parent DataFrame (:issue:`42950`)
+- Bug in :meth:`DataFrame.__getattribute__` raising ``AttributeError`` if columns have ``"string"`` dtype (:issue:`46185`)
+- Bug in :meth:`DataFrame.compare` returning all ``NaN`` column when comparing extension array dtype and numpy dtype (:issue:`44014`)
+- Bug in :meth:`DataFrame.where` setting wrong values with ``"boolean"`` mask for numpy dtype (:issue:`44014`)
+- Bug in indexing on a :class:`DatetimeIndex` with a ``np.str_`` key incorrectly raising (:issue:`45580`)
+- Bug in :meth:`CategoricalIndex.get_indexer` when index contains ``NaN`` values, resulting in elements that are in target but not present in the index to be mapped to the index of the NaN element, instead of -1 (:issue:`45361`)
+- Bug in setting large integer values into :class:`Series` with ``float32`` or ``float16`` dtype incorrectly altering these values instead of coercing to ``float64`` dtype (:issue:`45844`)
+- Bug in :meth:`Series.asof` and :meth:`DataFrame.asof` incorrectly casting bool-dtype results to ``float64`` dtype (:issue:`16063`)
+- Bug in :meth:`NDFrame.xs`, :meth:`DataFrame.iterrows`, :meth:`DataFrame.loc` and :meth:`DataFrame.iloc` not always propagating metadata (:issue:`28283`)
+- Bug in :meth:`DataFrame.sum` min_count changes dtype if input contains NaNs (:issue:`46947`)
+- Bug in :class:`IntervalTree` that lead to an infinite recursion. (:issue:`46658`)
+- Bug in :class:`PeriodIndex` raising ``AttributeError`` when indexing on ``NA``, rather than putting ``NaT`` in its place. (:issue:`46673`)
+- Bug in :meth:`DataFrame.at` would allow the modification of multiple columns (:issue:`48296`)
+
+Missing
+^^^^^^^
+- Bug in :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``downcast`` keyword not being respected in some cases where there are no NA values present (:issue:`45423`)
+- Bug in :meth:`Series.fillna` and :meth:`DataFrame.fillna` with :class:`IntervalDtype` and incompatible value raising instead of casting to a common (usually object) dtype (:issue:`45796`)
+- Bug in :meth:`Series.map` not respecting ``na_action`` argument if mapper is a ``dict`` or :class:`Series` (:issue:`47527`)
+- Bug in :meth:`DataFrame.interpolate` with object-dtype column not returning a copy with ``inplace=False`` (:issue:`45791`)
+- Bug in :meth:`DataFrame.dropna` allows to set both ``how`` and ``thresh`` incompatible arguments (:issue:`46575`)
+- Bug in :meth:`DataFrame.fillna` ignored ``axis`` when :class:`DataFrame` is single block (:issue:`47713`)
+
+MultiIndex
+^^^^^^^^^^
+- Bug in :meth:`DataFrame.loc` returning empty result when slicing a :class:`MultiIndex` with a negative step size and non-null start/stop values (:issue:`46156`)
+- Bug in :meth:`DataFrame.loc` raising when slicing a :class:`MultiIndex` with a negative step size other than -1 (:issue:`46156`)
+- Bug in :meth:`DataFrame.loc` raising when slicing a :class:`MultiIndex` with a negative step size and slicing a non-int labeled index level (:issue:`46156`)
+- Bug in :meth:`Series.to_numpy` where multiindexed Series could not be converted to numpy arrays when an ``na_value`` was supplied (:issue:`45774`)
+- Bug in :class:`MultiIndex.equals` not commutative when only one side has extension array dtype (:issue:`46026`)
+- Bug in :meth:`MultiIndex.from_tuples` cannot construct Index of empty tuples (:issue:`45608`)
+
+I/O
+^^^
+- Bug in :meth:`DataFrame.to_stata` where no error is raised if the :class:`DataFrame` contains ``-np.inf`` (:issue:`45350`)
+- Bug in :func:`read_excel` results in an infinite loop with certain ``skiprows`` callables (:issue:`45585`)
+- Bug in :meth:`DataFrame.info` where a new line at the end of the output is omitted when called on an empty :class:`DataFrame` (:issue:`45494`)
+- Bug in :func:`read_csv` not recognizing line break for ``on_bad_lines="warn"`` for ``engine="c"`` (:issue:`41710`)
+- Bug in :meth:`DataFrame.to_csv` not respecting ``float_format`` for ``Float64`` dtype (:issue:`45991`)
+- Bug in :func:`read_csv` not respecting a specified converter to index columns in all cases (:issue:`40589`)
+- Bug in :func:`read_csv` interpreting second row as :class:`Index` names even when ``index_col=False`` (:issue:`46569`)
+- Bug in :func:`read_parquet` when ``engine="pyarrow"`` which caused partial write to disk when column of unsupported datatype was passed (:issue:`44914`)
+- Bug in :func:`DataFrame.to_excel` and :class:`ExcelWriter` would raise when writing an empty DataFrame to a ``.ods`` file (:issue:`45793`)
+- Bug in :func:`read_csv` ignoring non-existing header row for ``engine="python"`` (:issue:`47400`)
+- Bug in :func:`read_excel` raising uncontrolled ``IndexError`` when ``header`` references non-existing rows (:issue:`43143`)
+- Bug in :func:`read_html` where elements surrounding ``<br>`` were joined without a space between them (:issue:`29528`)
+- Bug in :func:`read_csv` when data is longer than header leading to issues with callables in ``usecols`` expecting strings (:issue:`46997`)
+- Bug in Parquet roundtrip for Interval dtype with ``datetime64[ns]`` subtype (:issue:`45881`)
+- Bug in :func:`read_excel` when reading a ``.ods`` file with newlines between xml elements (:issue:`45598`)
+- Bug in :func:`read_parquet` when ``engine="fastparquet"`` where the file was not closed on error (:issue:`46555`)
+- :meth:`to_html` now excludes the ``border`` attribute from ``<table>`` elements when ``border`` keyword is set to ``False``.
+- Bug in :func:`read_sas` with certain types of compressed SAS7BDAT files (:issue:`35545`)
+- Bug in :func:`read_excel` not forward filling :class:`MultiIndex` when no names were given (:issue:`47487`)
+- Bug in :func:`read_sas` returned ``None`` rather than an empty DataFrame for SAS7BDAT files with zero rows (:issue:`18198`)
+- Bug in :meth:`DataFrame.to_string` using wrong missing value with extension arrays in :class:`MultiIndex` (:issue:`47986`)
+- Bug in :class:`StataWriter` where value labels were always written with default encoding (:issue:`46750`)
+- Bug in :class:`StataWriterUTF8` where some valid characters were removed from variable names (:issue:`47276`)
+- Bug in :meth:`DataFrame.to_excel` when writing an empty dataframe with :class:`MultiIndex` (:issue:`19543`)
+- Bug in :func:`read_sas` with RLE-compressed SAS7BDAT files that contain 0x40 control bytes (:issue:`31243`)
+- Bug in :func:`read_sas` that scrambled column names (:issue:`31243`)
+- Bug in :func:`read_sas` with RLE-compressed SAS7BDAT files that contain 0x00 control bytes (:issue:`47099`)
+- Bug in :func:`read_parquet` with ``use_nullable_dtypes=True`` where ``float64`` dtype was returned instead of nullable ``Float64`` dtype (:issue:`45694`)
+- Bug in :meth:`DataFrame.to_json` where ``PeriodDtype`` would not make the serialization roundtrip when read back with :meth:`read_json` (:issue:`44720`)
+- Bug in :func:`read_xml` when reading XML files with Chinese character tags and would raise ``XMLSyntaxError`` (:issue:`47902`)
+
+Period
+^^^^^^
+- Bug in subtraction of :class:`Period` from :class:`.PeriodArray` returning wrong results (:issue:`45999`)
+- Bug in :meth:`Period.strftime` and :meth:`PeriodIndex.strftime`, directives ``%l`` and ``%u`` were giving wrong results (:issue:`46252`)
+- Bug in inferring an incorrect ``freq`` when passing a string to :class:`Period` microseconds that are a multiple of 1000 (:issue:`46811`)
+- Bug in constructing a :class:`Period` from a :class:`Timestamp` or ``np.datetime64`` object with non-zero nanoseconds and ``freq="ns"`` incorrectly truncating the nanoseconds (:issue:`46811`)
+- Bug in adding ``np.timedelta64("NaT", "ns")`` to a :class:`Period` with a timedelta-like freq incorrectly raising ``IncompatibleFrequency`` instead of returning ``NaT`` (:issue:`47196`)
+- Bug in adding an array of integers to an array with :class:`PeriodDtype` giving incorrect results when ``dtype.freq.n > 1`` (:issue:`47209`)
+- Bug in subtracting a :class:`Period` from an array with :class:`PeriodDtype` returning incorrect results instead of raising ``OverflowError`` when the operation overflows (:issue:`47538`)
+-
+
+Plotting
+^^^^^^^^
+- Bug in :meth:`DataFrame.plot.barh` that prevented labeling the x-axis and ``xlabel`` updating the y-axis label (:issue:`45144`)
+- Bug in :meth:`DataFrame.plot.box` that prevented labeling the x-axis (:issue:`45463`)
+- Bug in :meth:`DataFrame.boxplot` that prevented passing in ``xlabel`` and ``ylabel`` (:issue:`45463`)
+- Bug in :meth:`DataFrame.boxplot` that prevented specifying ``vert=False`` (:issue:`36918`)
+- Bug in :meth:`DataFrame.plot.scatter` that prevented specifying ``norm`` (:issue:`45809`)
+- Fix showing "None" as ylabel in :meth:`Series.plot` when not setting ylabel (:issue:`46129`)
+- Bug in :meth:`DataFrame.plot` that led to xticks and vertical grids being improperly placed when plotting a quarterly series (:issue:`47602`)
+- Bug in :meth:`DataFrame.plot` that prevented setting y-axis label, limits and ticks for a secondary y-axis (:issue:`47753`)
+
+Groupby/resample/rolling
+^^^^^^^^^^^^^^^^^^^^^^^^
+- Bug in :meth:`DataFrame.resample` ignoring ``closed="right"`` on :class:`TimedeltaIndex` (:issue:`45414`)
+- Bug in :meth:`.DataFrameGroupBy.transform` fails when ``func="size"`` and the input DataFrame has multiple columns (:issue:`27469`)
+- Bug in :meth:`.DataFrameGroupBy.size` and :meth:`.DataFrameGroupBy.transform` with ``func="size"`` produced incorrect results when ``axis=1`` (:issue:`45715`)
+- Bug in :meth:`.ExponentialMovingWindow.mean` with ``axis=1`` and ``engine='numba'`` when the :class:`DataFrame` has more columns than rows (:issue:`46086`)
+- Bug when using ``engine="numba"`` would return the same jitted function when modifying ``engine_kwargs`` (:issue:`46086`)
+- Bug in :meth:`.DataFrameGroupBy.transform` fails when ``axis=1`` and ``func`` is ``"first"`` or ``"last"`` (:issue:`45986`)
+- Bug in :meth:`DataFrameGroupBy.cumsum` with ``skipna=False`` giving incorrect results (:issue:`46216`)
+- Bug in :meth:`.GroupBy.sum`, :meth:`.GroupBy.prod` and :meth:`.GroupBy.cumsum` with integer dtypes losing precision (:issue:`37493`)
+- Bug in :meth:`.GroupBy.cumsum` with ``timedelta64[ns]`` dtype failing to recognize ``NaT`` as a null value (:issue:`46216`)
+- Bug in :meth:`.GroupBy.cumsum` with integer dtypes causing overflows when sum was bigger than maximum of dtype (:issue:`37493`)
+- Bug in :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` with nullable dtypes incorrectly altering the original data in place (:issue:`46220`)
+- Bug in :meth:`DataFrame.groupby` raising error when ``None`` is in first level of :class:`MultiIndex` (:issue:`47348`)
+- Bug in :meth:`.GroupBy.cummax` with ``int64`` dtype with leading value being the smallest possible int64 (:issue:`46382`)
+- Bug in :meth:`.GroupBy.cumprod` ``NaN`` influences calculation in different columns with ``skipna=False`` (:issue:`48064`)
+- Bug in :meth:`.GroupBy.max` with empty groups and ``uint64`` dtype incorrectly raising ``RuntimeError`` (:issue:`46408`)
+- Bug in :meth:`.GroupBy.apply` would fail when ``func`` was a string and args or kwargs were supplied (:issue:`46479`)
+- Bug in :meth:`SeriesGroupBy.apply` would incorrectly name its result when there was a unique group (:issue:`46369`)
+- Bug in :meth:`.Rolling.sum` and :meth:`.Rolling.mean` would give incorrect result with window of same values (:issue:`42064`, :issue:`46431`)
+- Bug in :meth:`.Rolling.var` and :meth:`.Rolling.std` would give non-zero result with window of same values (:issue:`42064`)
+- Bug in :meth:`.Rolling.skew` and :meth:`.Rolling.kurt` would give NaN with window of same values (:issue:`30993`)
+- Bug in :meth:`.Rolling.var` would segfault calculating weighted variance when window size was larger than data size (:issue:`46760`)
+- Bug in :meth:`Grouper.__repr__` where ``dropna`` was not included. Now it is (:issue:`46754`)
+- Bug in :meth:`DataFrame.rolling` gives ValueError when center=True, axis=1 and win_type is specified (:issue:`46135`)
+- Bug in :meth:`.DataFrameGroupBy.describe` and :meth:`.SeriesGroupBy.describe` produces inconsistent results for empty datasets (:issue:`41575`)
+- Bug in :meth:`DataFrame.resample` reduction methods when used with ``on`` would attempt to aggregate the provided column (:issue:`47079`)
+- Bug in :meth:`DataFrame.groupby` and :meth:`Series.groupby` would not respect ``dropna=False`` when the input DataFrame/Series had a NaN values in a :class:`MultiIndex` (:issue:`46783`)
+- Bug in :meth:`DataFrameGroupBy.resample` raises ``KeyError`` when getting the result from a key list which misses the resample key (:issue:`47362`)
+- Bug in :meth:`DataFrame.groupby` would lose index columns when the DataFrame is empty for transforms, like fillna (:issue:`47787`)
+- Bug in :meth:`DataFrame.groupby` and :meth:`Series.groupby` with ``dropna=False`` and ``sort=False`` would put any null groups at the end instead the order that they are encountered (:issue:`46584`)
+-
+
+Reshaping
+^^^^^^^^^
+- Bug in :func:`concat` between a :class:`Series` with integer dtype and another with :class:`CategoricalDtype` with integer categories and containing ``NaN`` values casting to object dtype instead of ``float64`` (:issue:`45359`)
+- Bug in :func:`get_dummies` that selected object and categorical dtypes but not string (:issue:`44965`)
+- Bug in :meth:`DataFrame.align` when aligning a :class:`MultiIndex` to a :class:`Series` with another :class:`MultiIndex` (:issue:`46001`)
+- Bug in concatenation with ``IntegerDtype``, or ``FloatingDtype`` arrays where the resulting dtype did not mirror the behavior of the non-nullable dtypes (:issue:`46379`)
+- Bug in :func:`concat` losing dtype of columns when ``join="outer"`` and ``sort=True`` (:issue:`47329`)
+- Bug in :func:`concat` not sorting the column names when ``None`` is included (:issue:`47331`)
+- Bug in :func:`concat` with identical key leads to error when indexing :class:`MultiIndex` (:issue:`46519`)
+- Bug in :func:`pivot_table` raising ``TypeError`` when ``dropna=True`` and aggregation column has extension array dtype (:issue:`47477`)
+- Bug in :func:`merge` raising error for ``how="cross"`` when using ``FIPS`` mode in ssl library (:issue:`48024`)
+- Bug in :meth:`DataFrame.join` with a list when using suffixes to join DataFrames with duplicate column names (:issue:`46396`)
+- Bug in :meth:`DataFrame.pivot_table` with ``sort=False`` results in sorted index (:issue:`17041`)
+- Bug in :meth:`concat` when ``axis=1`` and ``sort=False`` where the resulting Index was a :class:`Int64Index` instead of a :class:`RangeIndex` (:issue:`46675`)
+- Bug in :meth:`wide_to_long` raises when ``stubnames`` is missing in columns and ``i`` contains string dtype column (:issue:`46044`)
+- Bug in :meth:`DataFrame.join` with categorical index results in unexpected reordering (:issue:`47812`)
+
+Sparse
+^^^^^^
+- Bug in :meth:`Series.where` and :meth:`DataFrame.where` with ``SparseDtype`` failing to retain the array's ``fill_value`` (:issue:`45691`)
+- Bug in :meth:`SparseArray.unique` fails to keep original elements order (:issue:`47809`)
+
+ExtensionArray
+^^^^^^^^^^^^^^
+- Bug in :meth:`IntegerArray.searchsorted` and :meth:`FloatingArray.searchsorted` returning inconsistent results when acting on ``np.nan`` (:issue:`45255`)
+
+Styler
+^^^^^^
+- Bug when attempting to apply styling functions to an empty DataFrame subset (:issue:`45313`)
+- Bug in :class:`CSSToExcelConverter` leading to ``TypeError`` when border color provided without border style for ``xlsxwriter`` engine (:issue:`42276`)
+- Bug in :meth:`Styler.set_sticky` leading to white text on white background in dark mode (:issue:`46984`)
+- Bug in :meth:`Styler.to_latex` causing ``UnboundLocalError`` when ``clines="all;data"`` and the ``DataFrame`` has no rows. (:issue:`47203`)
+- Bug in :meth:`Styler.to_excel` when using ``vertical-align: middle;`` with ``xlsxwriter`` engine (:issue:`30107`)
+- Bug when applying styles to a DataFrame with boolean column labels (:issue:`47838`)
+
+Metadata
+^^^^^^^^
+- Fixed metadata propagation in :meth:`DataFrame.melt` (:issue:`28283`)
+- Fixed metadata propagation in :meth:`DataFrame.explode` (:issue:`28283`)
+
+Other
+^^^^^
+
+.. ***DO NOT USE THIS SECTION***
+
+- Bug in :func:`.assert_index_equal` with ``names=True`` and ``check_order=False`` not checking names (:issue:`47328`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_150.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.4.4..v1.5.0
diff --git a/doc/source/whatsnew/v1.5.1.rst b/doc/source/whatsnew/v1.5.1.rst
new file mode 100644
index 0000000000000..bcd8ddb9cbc0b
--- /dev/null
+++ b/doc/source/whatsnew/v1.5.1.rst
@@ -0,0 +1,122 @@
+.. _whatsnew_151:
+
+What's new in 1.5.1 (October 19, 2022)
+--------------------------------------
+
+These are the changes in pandas 1.5.1. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_151.groupby_categorical_regr:
+
+Behavior of ``groupby`` with categorical groupers (:issue:`48645`)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In versions of pandas prior to 1.5, ``groupby`` with ``dropna=False`` would still drop
+NA values when the grouper was a categorical dtype. A fix for this was attempted in
+1.5, however it introduced a regression where passing ``observed=False`` and
+``dropna=False`` to ``groupby`` would result in only observed categories. It was found
+that the patch fixing the ``dropna=False`` bug is incompatible with ``observed=False``,
+and decided that the best resolution is to restore the correct ``observed=False``
+behavior at the cost of reintroducing the ``dropna=False`` bug.
+
+.. ipython:: python
+
+   df = pd.DataFrame(
+       {
+           "x": pd.Categorical([1, None], categories=[1, 2, 3]),
+           "y": [3, 4],
+       }
+   )
+   df
+
+*1.5.0 behavior*:
+
+.. code-block:: ipython
+
+   In [3]: # Correct behavior, NA values are not dropped
+           df.groupby("x", observed=True, dropna=False).sum()
+   Out[3]:
+        y
+   x
+   1    3
+   NaN  4
+
+
+   In [4]: # Incorrect behavior, only observed categories present
+           df.groupby("x", observed=False, dropna=False).sum()
+   Out[4]:
+        y
+   x
+   1    3
+   NaN  4
+
+
+*1.5.1 behavior*:
+
+.. ipython:: python
+
+   # Incorrect behavior, NA values are dropped
+   df.groupby("x", observed=True, dropna=False).sum()
+
+   # Correct behavior, unobserved categories present (NA values still dropped)
+   df.groupby("x", observed=False, dropna=False).sum()
+
+.. _whatsnew_151.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed Regression in :meth:`Series.__setitem__` casting ``None`` to ``NaN`` for object dtype (:issue:`48665`)
+- Fixed Regression in :meth:`DataFrame.loc` when setting values as a :class:`DataFrame` with all ``True`` indexer (:issue:`48701`)
+- Regression in :func:`.read_csv` causing an ``EmptyDataError`` when using an UTF-8 file handle that was already read from (:issue:`48646`)
+- Regression in :func:`to_datetime` when ``utc=True`` and ``arg`` contained timezone naive and aware arguments raised a ``ValueError`` (:issue:`48678`)
+- Fixed regression in :meth:`DataFrame.loc` raising ``FutureWarning`` when setting an empty :class:`DataFrame` (:issue:`48480`)
+- Fixed regression in :meth:`DataFrame.describe` raising ``TypeError`` when result contains ``NA`` (:issue:`48778`)
+- Fixed regression in :meth:`DataFrame.plot` ignoring invalid ``colormap`` for ``kind="scatter"`` (:issue:`48726`)
+- Fixed regression in :meth:`MultiIndex.values` resetting ``freq`` attribute of underlying :class:`Index` object (:issue:`49054`)
+- Fixed performance regression in :func:`factorize` when ``na_sentinel`` is not ``None`` and ``sort=False`` (:issue:`48620`)
+- Fixed regression causing an ``AttributeError`` during warning emitted if the provided table name in :meth:`DataFrame.to_sql` and the table name actually used in the database do not match (:issue:`48733`)
+- Fixed regression in :func:`to_datetime` when ``arg`` was a date string with nanosecond and ``format`` contained ``%f`` would raise a ``ValueError`` (:issue:`48767`)
+- Fixed regression in :func:`testing.assert_frame_equal` raising for :class:`MultiIndex` with :class:`Categorical` and ``check_like=True`` (:issue:`48975`)
+- Fixed regression in :meth:`DataFrame.fillna` replacing wrong values for ``datetime64[ns]`` dtype and ``inplace=True`` (:issue:`48863`)
+- Fixed :meth:`.DataFrameGroupBy.size` not returning a Series when ``axis=1`` (:issue:`48738`)
+- Fixed Regression in :meth:`.DataFrameGroupBy.apply` when user defined function is called on an empty dataframe (:issue:`47985`)
+- Fixed regression in :meth:`DataFrame.apply` when passing non-zero ``axis`` via keyword argument (:issue:`48656`)
+- Fixed regression in :meth:`Series.groupby` and :meth:`DataFrame.groupby` when the grouper is a nullable data type (e.g. :class:`Int64`) or a PyArrow-backed string array, contains null values, and ``dropna=False`` (:issue:`48794`)
+- Fixed performance regression in :meth:`Series.isin` with mismatching dtypes (:issue:`49162`)
+- Fixed regression in :meth:`DataFrame.to_parquet` raising when file name was specified as ``bytes`` (:issue:`48944`)
+- Fixed regression in :class:`ExcelWriter` where the ``book`` attribute could no longer be set; however setting this attribute is now deprecated and this ability will be removed in a future version of pandas (:issue:`48780`)
+- Fixed regression in :meth:`DataFrame.corrwith` when computing correlation on tied data with ``method="spearman"`` (:issue:`48826`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_151.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Bug in :meth:`Series.__getitem__` not falling back to positional for integer keys and boolean :class:`Index` (:issue:`48653`)
+- Bug in :meth:`DataFrame.to_hdf` raising ``AssertionError`` with boolean index (:issue:`48667`)
+- Bug in :func:`testing.assert_index_equal` for extension arrays with non matching ``NA`` raising ``ValueError`` (:issue:`48608`)
+- Bug in :meth:`DataFrame.pivot_table` raising unexpected ``FutureWarning`` when setting datetime column as index (:issue:`48683`)
+- Bug in :meth:`DataFrame.sort_values` emitting unnecessary ``FutureWarning`` when called on :class:`DataFrame` with boolean sparse columns (:issue:`48784`)
+- Bug in :class:`.arrays.ArrowExtensionArray` with a comparison operator to an invalid object would not raise a ``NotImplementedError`` (:issue:`48833`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_151.other:
+
+Other
+~~~~~
+- Avoid showing deprecated signatures when introspecting functions with warnings about arguments becoming keyword-only (:issue:`48692`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_151.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.5.0..v1.5.1
diff --git a/doc/source/whatsnew/v1.5.2.rst b/doc/source/whatsnew/v1.5.2.rst
new file mode 100644
index 0000000000000..6397016d827f2
--- /dev/null
+++ b/doc/source/whatsnew/v1.5.2.rst
@@ -0,0 +1,46 @@
+.. _whatsnew_152:
+
+What's new in 1.5.2 (November 21, 2022)
+---------------------------------------
+
+These are the changes in pandas 1.5.2. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_152.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed regression in :meth:`MultiIndex.join` for extension array dtypes (:issue:`49277`)
+- Fixed regression in :meth:`Series.replace` raising ``RecursionError`` with numeric dtype and when specifying ``value=None`` (:issue:`45725`)
+- Fixed regression in arithmetic operations for :class:`DataFrame` with :class:`MultiIndex` columns with different dtypes (:issue:`49769`)
+- Fixed regression in :meth:`DataFrame.plot` preventing :class:`~matplotlib.colors.Colormap` instance
+  from being passed using the ``colormap`` argument if Matplotlib 3.6+ is used (:issue:`49374`)
+- Fixed regression in :func:`date_range` returning an invalid set of periods for ``CustomBusinessDay`` frequency and ``start`` date with timezone (:issue:`49441`)
+- Fixed performance regression in groupby operations (:issue:`49676`)
+- Fixed regression in :class:`Timedelta` constructor returning object of wrong type when subclassing ``Timedelta`` (:issue:`49579`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_152.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Bug in the Copy-on-Write implementation losing track of views in certain chained indexing cases (:issue:`48996`)
+- Fixed memory leak in :meth:`.Styler.to_excel` (:issue:`49751`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_152.other:
+
+Other
+~~~~~
+- Reverted ``color`` as an alias for ``c`` and ``size`` as an alias for ``s`` in function :meth:`DataFrame.plot.scatter` (:issue:`49732`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_152.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.5.1..v1.5.2|HEAD
diff --git a/doc/source/whatsnew/v1.5.3.rst b/doc/source/whatsnew/v1.5.3.rst
new file mode 100644
index 0000000000000..97c4c73f08c37
--- /dev/null
+++ b/doc/source/whatsnew/v1.5.3.rst
@@ -0,0 +1,59 @@
+.. _whatsnew_153:
+
+What's new in 1.5.3 (January 18, 2023)
+--------------------------------------
+
+These are the changes in pandas 1.5.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_153.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed performance regression in :meth:`Series.isin` when ``values`` is empty (:issue:`49839`)
+- Fixed regression in :meth:`DataFrame.memory_usage` showing unnecessary ``FutureWarning`` when :class:`DataFrame` is empty (:issue:`50066`)
+- Fixed regression in :meth:`.DataFrameGroupBy.transform` when used with ``as_index=False`` (:issue:`49834`)
+- Enforced reversion of ``color`` as an alias for ``c`` and ``size`` as an alias for ``s`` in function :meth:`DataFrame.plot.scatter` (:issue:`49732`)
+- Fixed regression in :meth:`.SeriesGroupBy.apply` setting a ``name`` attribute on the result if the result was a :class:`DataFrame` (:issue:`49907`)
+- Fixed performance regression in setting with the :meth:`~DataFrame.at` indexer (:issue:`49771`)
+- Fixed regression in the methods ``apply``, ``agg``, and ``transform`` when used with NumPy functions that informed users to supply ``numeric_only=True`` if the operation failed on non-numeric dtypes; such columns must be dropped prior to using these methods (:issue:`50538`)
+- Fixed regression in :func:`to_datetime` raising ``ValueError`` when parsing array of ``float`` containing ``np.nan`` (:issue:`50237`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_153.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Bug in the Copy-on-Write implementation losing track of views when indexing a :class:`DataFrame` with another :class:`DataFrame` (:issue:`50630`)
+- Bug in :meth:`.Styler.to_excel` leading to error when unrecognized ``border-style`` (e.g. ``"hair"``) provided to Excel writers (:issue:`48649`)
+- Bug in :meth:`Series.quantile` emitting warning from NumPy when :class:`Series` has only ``NA`` values (:issue:`50681`)
+- Bug when chaining several :meth:`.Styler.concat` calls, only the last styler was concatenated (:issue:`49207`)
+- Fixed bug when instantiating a :class:`DataFrame` subclass inheriting from ``typing.Generic`` that triggered a ``UserWarning`` on python 3.11 (:issue:`49649`)
+- Bug in :func:`pivot_table` with NumPy 1.24 or greater when the :class:`DataFrame` columns has nested elements (:issue:`50342`)
+- Bug in :func:`pandas.testing.assert_series_equal` (and equivalent ``assert_`` functions) when having nested data and using numpy >= 1.25 (:issue:`50360`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_153.other:
+
+Other
+~~~~~
+
+.. note::
+
+    If you are using :meth:`DataFrame.to_sql`, :func:`read_sql`, :func:`read_sql_table`, or :func:`read_sql_query` with SQLAlchemy 1.4.46 or greater,
+    you may see a ``sqlalchemy.exc.RemovedIn20Warning``. These warnings can be safely ignored for the SQLAlchemy 1.4.x releases
+    as pandas works toward compatibility with SQLAlchemy 2.0.
+
+- Reverted deprecation (:issue:`45324`) of behavior of :meth:`Series.__getitem__` and :meth:`Series.__setitem__` slicing with an integer :class:`Index`; this will remain positional (:issue:`49612`)
+- A ``FutureWarning`` raised when attempting to set values inplace with :meth:`DataFrame.loc` or :meth:`DataFrame.iloc` has been changed to a ``DeprecationWarning`` (:issue:`48673`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_153.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.5.2..v1.5.3|HEAD
diff --git a/doc/sphinxext/README.rst b/doc/sphinxext/README.rst
index 8f0f4a8b2636d..ef52433e5e869 100644
--- a/doc/sphinxext/README.rst
+++ b/doc/sphinxext/README.rst
@@ -1,17 +1,5 @@
 sphinxext
 =========
 
-This directory contains copies of different sphinx extensions in use in the
-pandas documentation. These copies originate from other projects:
-
-- ``numpydoc`` - Numpy's Sphinx extensions: this can be found at its own
-  repository: https://github.com/numpy/numpydoc
-- ``ipython_directive`` and ``ipython_console_highlighting`` in the folder
-  ``ipython_sphinxext`` - Sphinx extensions from IPython: these are included
-  in IPython: https://github.com/ipython/ipython/tree/master/IPython/sphinxext
-
-.. note::
-
-    These copies are maintained at the respective projects, so fixes should,
-    to the extent possible, be pushed upstream instead of only adapting our
-    local copy to avoid divergence between the local and upstream version.
+This directory contains custom sphinx extensions in use in the pandas
+documentation.
diff --git a/environment.yml b/environment.yml
index bf317d24122ae..20f839db9ad60 100644
--- a/environment.yml
+++ b/environment.yml
@@ -1,128 +1,132 @@
+# Local development dependencies including docs building, website upload, ASV benchmark
 name: pandas-dev
 channels:
   - conda-forge
 dependencies:
-  # required
-  - numpy>=1.18.5, <1.22.0
   - python=3.8
-  - python-dateutil>=2.8.1
+
+  # test dependencies
+  - cython=0.29.32
+  - pytest>=6.0
+  - pytest-cov
+  - pytest-xdist>=1.31
+  - psutil
+  - pytest-asyncio>=0.17
+  - boto3
+
+  # required dependencies
+  - python-dateutil
+  - numpy
   - pytz
 
+  # optional dependencies
+  - beautifulsoup4
+  - blosc
+  - brotlipy
+  - bottleneck
+  - fastparquet
+  - fsspec
+  - html5lib
+  - hypothesis
+  - gcsfs
+  - jinja2
+  - lxml
+  - matplotlib>=3.6.1
+  - numba>=0.53.1
+  - numexpr>=2.8.0  # pin for "Run checks on imported code" job
+  - openpyxl
+  - odfpy
+  - pandas-gbq
+  - psycopg2
+  - pyarrow<10
+  - pymysql
+  - pyreadstat
+  - pytables
+  - python-snappy
+  - pyxlsb
+  - s3fs>=2021.08.0
+  - scipy
+  - sqlalchemy<1.4.46
+  - tabulate
+  - tzdata>=2022a
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - zstandard
+
+  # downstream packages
+  - aiobotocore<2.0.0  # GH#44311 pinned to fix docbuild
+  - botocore
+  - cftime
+  - dask
+  - ipython
+  - geopandas-base
+  - seaborn
+  - scikit-learn
+  - statsmodels
+  - coverage
+  - pandas-datareader
+  - pyyaml
+  - py
+  - pytorch
+
+  # local testing dependencies
+  - moto
+  - flask
+
   # benchmarks
   - asv
 
-  # building
   # The compiler packages are meta-packages and install the correct compiler (activation) packages on the respective platforms.
   - c-compiler
   - cxx-compiler
-  - cython>=0.29.24
 
   # code checks
-  - black=21.5b2
+  - black=22.3.0
   - cpplint
-  - flake8=4.0.1
-  - flake8-bugbear=21.3.2  # used by flake8, find likely bugs
-  - flake8-comprehensions=3.7.0  # used by flake8, linting of unnecessary comprehensions
+  - flake8=5.0.4
+  - flake8-bugbear=22.7.1 # used by flake8, find likely bugs
   - isort>=5.2.1  # check that imports are in the right order
-  - mypy=0.930
-  - pre-commit>=2.9.2
+  - mypy=0.971
+  - pre-commit>=2.15.0
   - pycodestyle  # used by flake8
   - pyupgrade
 
   # documentation
   - gitpython  # obtain contributors from git for whatsnew
   - gitdb
+  - natsort  # DataFrame.sort_values doctest
+  - numpydoc
+  - pandas-dev-flaker=0.5.0
+  - pydata-sphinx-theme<0.11
+  - pytest-cython  # doctest
   - sphinx
   - sphinx-panels
-  - numpydoc < 1.2  # 2021-02-09 1.2dev breaking CI
+  - sphinx-copybutton
   - types-python-dateutil
   - types-PyMySQL
   - types-pytz
   - types-setuptools
 
   # documentation (jupyter notebooks)
-  - nbconvert>=5.4.1
+  - nbconvert>=6.4.5
   - nbsphinx
   - pandoc
-
-  # Dask and its dependencies (that dont install with dask)
-  - dask-core
-  - toolz>=0.7.3
-  - partd>=0.3.10
-  - cloudpickle>=0.2.1
-
-  # web (jinja2 is also needed, but it's also an optional pandas dependency)
-  - markdown
-  - feedparser
-  - pyyaml
-  - requests
-
-  # testing
-  - boto3
-  - botocore>=1.11
-  - hypothesis>=5.5.3
-  - moto  # mock S3
-  - flask
-  - pytest>=6.0
-  - pytest-cov
-  - pytest-xdist>=1.31
-  - pytest-asyncio
-  - pytest-instafail
-
-  # downstream tests
-  - seaborn
-  - statsmodels
-
-  # unused (required indirectly may be?)
   - ipywidgets
   - nbformat
   - notebook>=6.0.3
-  - pip
-
-  # optional
-  - blosc
-  - bottleneck>=1.3.1
   - ipykernel
-  - ipython>=7.11.1
-  - jinja2  # pandas.Styler
-  - matplotlib>=3.3.2  # pandas.plotting, Series.plot, DataFrame.plot
-  - numexpr>=2.7.1
-  - scipy>=1.4.1
-  - numba>=0.50.1
 
-  # optional for io
-  # ---------------
-  # pd.read_html
-  - beautifulsoup4>=4.8.2
-  - html5lib
-  - lxml
-
-  # pd.read_excel, DataFrame.to_excel, pd.ExcelWriter, pd.ExcelFile
-  - openpyxl
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - odfpy
-
-  - fastparquet>=0.4.0  # pandas.read_parquet, DataFrame.to_parquet
-  - pyarrow>2.0.1  # pandas.read_parquet, DataFrame.to_parquet, pandas.read_feather, DataFrame.to_feather
-  - python-snappy  # required by pyarrow
+  # web
+  - jinja2  # in optional dependencies, but documented here as needed
+  - markdown
+  - feedparser
+  - pyyaml
+  - requests
 
-  - pytables>=3.6.1  # pandas.read_hdf, DataFrame.to_hdf
-  - s3fs>=0.4.0  # file IO when using 's3://...' path
-  - aiobotocore<2.0.0  # GH#44311 pinned to fix docbuild
-  - fsspec>=0.7.4  # for generic remote file operations
-  - gcsfs>=0.6.0  # file IO when using 'gcs://...' path
-  - sqlalchemy  # pandas.read_sql, DataFrame.to_sql
-  - xarray<0.19  # DataFrame.to_xarray
-  - cftime  # Needed for downstream xarray.CFTimeIndex test
-  - pyreadstat  # pandas.read_spss
-  - tabulate>=0.8.3  # DataFrame.to_markdown
-  - natsort  # DataFrame.sort_values
+  # build the interactive terminal
+  - jupyterlab >=3.4,<4
   - pip:
-      #issue with building environment in conda on windows. Issue: https://github.com/pandas-dev/pandas/issues/45123
-      #issue with pydata-sphix-theme on windows. Issue: https://github.com/pydata/pydata-sphinx-theme/issues/523
-      #using previous stable version as workaround
-    - git+https://github.com/pydata/pydata-sphinx-theme.git@41764f5
-    - pandas-dev-flaker==0.2.0
-    - pytest-cython
+      - jupyterlite==0.1.0b10
+      - sphinx-toggleprompt
diff --git a/pandas/__init__.py b/pandas/__init__.py
index 1b18af0f69cf2..5016bde000c3b 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -1,35 +1,35 @@
-# flake8: noqa
+from __future__ import annotations
 
 __docformat__ = "restructuredtext"
 
 # Let users know if they're missing any of our hard dependencies
-hard_dependencies = ("numpy", "pytz", "dateutil")
-missing_dependencies = []
+_hard_dependencies = ("numpy", "pytz", "dateutil")
+_missing_dependencies = []
 
-for dependency in hard_dependencies:
+for _dependency in _hard_dependencies:
     try:
-        __import__(dependency)
-    except ImportError as e:
-        missing_dependencies.append(f"{dependency}: {e}")
+        __import__(_dependency)
+    except ImportError as _e:
+        _missing_dependencies.append(f"{_dependency}: {_e}")
 
-if missing_dependencies:
+if _missing_dependencies:
     raise ImportError(
-        "Unable to import required dependencies:\n" + "\n".join(missing_dependencies)
+        "Unable to import required dependencies:\n" + "\n".join(_missing_dependencies)
     )
-del hard_dependencies, dependency, missing_dependencies
+del _hard_dependencies, _dependency, _missing_dependencies
 
 # numpy compat
-from pandas.compat import is_numpy_dev as _is_numpy_dev
+from pandas.compat import is_numpy_dev as _is_numpy_dev  # pyright: ignore # noqa:F401
 
 try:
     from pandas._libs import hashtable as _hashtable, lib as _lib, tslib as _tslib
-except ImportError as err:  # pragma: no cover
-    module = err.name
+except ImportError as _err:  # pragma: no cover
+    _module = _err.name
     raise ImportError(
-        f"C extension: {module} not built. If you want to import "
+        f"C extension: {_module} not built. If you want to import "
         "pandas from the source directory, you may need to run "
         "'python setup.py build_ext --force' to build the C extensions first."
-    ) from err
+    ) from _err
 else:
     del _tslib, _lib, _hashtable
 
@@ -43,10 +43,11 @@
 )
 
 # let init-time option registration happen
-import pandas.core.config_init
+import pandas.core.config_init  # pyright: ignore # noqa:F401
 
 from pandas.core.api import (
     # dtype
+    ArrowDtype,
     Int8Dtype,
     Int16Dtype,
     Int32Dtype,
@@ -128,11 +129,13 @@
     pivot,
     pivot_table,
     get_dummies,
+    from_dummies,
     cut,
     qcut,
 )
 
-from pandas import api, arrays, errors, io, plotting, testing, tseries
+from pandas import api, arrays, errors, io, plotting, tseries
+from pandas import testing  # noqa:PDF015
 from pandas.util._print_versions import show_versions
 
 from pandas.io.api import (
@@ -184,7 +187,7 @@
 __deprecated_num_index_names = ["Float64Index", "Int64Index", "UInt64Index"]
 
 
-def __dir__():
+def __dir__() -> list[str]:
     # GH43028
     # Int64Index etc. are deprecated, but we still want them to be available in the dir.
     # Remove in Pandas 2.0, when we remove Int64Index etc. from the code base.
@@ -306,6 +309,7 @@ def __getattr__(name):
 # Pandas is not (yet) a py.typed library: the public API is determined
 # based on the documentation.
 __all__ = [
+    "ArrowDtype",
     "BooleanDtype",
     "Categorical",
     "CategoricalDtype",
@@ -361,6 +365,7 @@ def __getattr__(name):
     "eval",
     "factorize",
     "get_dummies",
+    "from_dummies",
     "get_option",
     "infer_freq",
     "interval_range",
diff --git a/pandas/_config/__init__.py b/pandas/_config/__init__.py
index 65936a9fcdbf3..929f8a5af6b3f 100644
--- a/pandas/_config/__init__.py
+++ b/pandas/_config/__init__.py
@@ -16,7 +16,7 @@
     "options",
 ]
 from pandas._config import config
-from pandas._config import dates  # noqa:F401
+from pandas._config import dates  # pyright: ignore # noqa:F401
 from pandas._config.config import (
     describe_option,
     get_option,
diff --git a/pandas/_config/config.py b/pandas/_config/config.py
index 5a0f58266c203..b4b06c819431f 100644
--- a/pandas/_config/config.py
+++ b/pandas/_config/config.py
@@ -58,13 +58,19 @@
 from typing import (
     Any,
     Callable,
+    Generic,
     Iterable,
+    Iterator,
     NamedTuple,
     cast,
 )
 import warnings
 
-from pandas._typing import F
+from pandas._typing import (
+    F,
+    T,
+)
+from pandas.util._exceptions import find_stack_level
 
 
 class DeprecatedOption(NamedTuple):
@@ -97,8 +103,9 @@ class RegisteredOption(NamedTuple):
 
 class OptionError(AttributeError, KeyError):
     """
-    Exception for pandas.options, backwards compatible with KeyError
-    checks.
+    Exception raised for pandas.options.
+
+    Backwards compatible with KeyError checks.
     """
 
 
@@ -124,7 +131,7 @@ def _get_single_key(pat: str, silent: bool) -> str:
     return key
 
 
-def _get_option(pat: str, silent: bool = False):
+def _get_option(pat: str, silent: bool = False) -> Any:
     key = _get_single_key(pat, silent)
 
     # walk the nested dict
@@ -164,7 +171,7 @@ def _set_option(*args, **kwargs) -> None:
                 o.cb(key)
 
 
-def _describe_option(pat: str = "", _print_desc: bool = True):
+def _describe_option(pat: str = "", _print_desc: bool = True) -> str | None:
 
     keys = _select_options(pat)
     if len(keys) == 0:
@@ -174,8 +181,8 @@ def _describe_option(pat: str = "", _print_desc: bool = True):
 
     if _print_desc:
         print(s)
-    else:
-        return s
+        return None
+    return s
 
 
 def _reset_option(pat: str, silent: bool = False) -> None:
@@ -204,7 +211,7 @@ def get_default_val(pat: str):
 class DictWrapper:
     """provide attribute-style access to a nested dict"""
 
-    def __init__(self, d: dict[str, Any], prefix: str = ""):
+    def __init__(self, d: dict[str, Any], prefix: str = "") -> None:
         object.__setattr__(self, "d", d)
         object.__setattr__(self, "prefix", prefix)
 
@@ -247,16 +254,17 @@ def __dir__(self) -> Iterable[str]:
 # of options, and option descriptions.
 
 
-class CallableDynamicDoc:
-    def __init__(self, func, doc_tmpl):
+class CallableDynamicDoc(Generic[T]):
+    def __init__(self, func: Callable[..., T], doc_tmpl: str) -> None:
         self.__doc_tmpl__ = doc_tmpl
         self.__func__ = func
 
-    def __call__(self, *args, **kwds):
+    def __call__(self, *args, **kwds) -> T:
         return self.__func__(*args, **kwds)
 
+    # error: Signature of "__doc__" incompatible with supertype "object"
     @property
-    def __doc__(self):
+    def __doc__(self) -> str:  # type: ignore[override]
         opts_desc = _describe_option("all", _print_desc=False)
         opts_list = pp_options_list(list(_registered_options.keys()))
         return self.__doc_tmpl__.format(opts_desc=opts_desc, opts_list=opts_list)
@@ -289,6 +297,8 @@ def __doc__(self):
 
 Notes
 -----
+Please reference the :ref:`User Guide <options>` for more information.
+
 The available options with its descriptions:
 
 {opts_desc}
@@ -323,6 +333,8 @@ def __doc__(self):
 
 Notes
 -----
+Please reference the :ref:`User Guide <options>` for more information.
+
 The available options with its descriptions:
 
 {opts_desc}
@@ -355,6 +367,8 @@ def __doc__(self):
 
 Notes
 -----
+Please reference the :ref:`User Guide <options>` for more information.
+
 The available options with its descriptions:
 
 {opts_desc}
@@ -385,6 +399,8 @@ def __doc__(self):
 
 Notes
 -----
+Please reference the :ref:`User Guide <options>` for more information.
+
 The available options with its descriptions:
 
 {opts_desc}
@@ -414,7 +430,7 @@ class option_context(ContextDecorator):
     ...     pass
     """
 
-    def __init__(self, *args):
+    def __init__(self, *args) -> None:
         if len(args) % 2 != 0 or len(args) < 2:
             raise ValueError(
                 "Need to invoke as option_context(pat, val, [(pat, val), ...])."
@@ -422,13 +438,13 @@ def __init__(self, *args):
 
         self.ops = list(zip(args[::2], args[1::2]))
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         self.undo = [(pat, _get_option(pat, silent=True)) for pat, val in self.ops]
 
         for pat, val in self.ops:
             _set_option(pat, val, silent=True)
 
-    def __exit__(self, *args):
+    def __exit__(self, *args) -> None:
         if self.undo:
             for pat, val in self.undo:
                 _set_option(pat, val, silent=True)
@@ -642,7 +658,11 @@ def _warn_if_deprecated(key: str) -> bool:
     d = _get_deprecated_option(key)
     if d:
         if d.msg:
-            warnings.warn(d.msg, FutureWarning)
+            warnings.warn(
+                d.msg,
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
         else:
             msg = f"'{key}' is deprecated"
             if d.removal_ver:
@@ -652,7 +672,7 @@ def _warn_if_deprecated(key: str) -> bool:
             else:
                 msg += ", please refrain from using it."
 
-            warnings.warn(msg, FutureWarning)
+            warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
         return True
     return False
 
@@ -720,7 +740,7 @@ def pp(name: str, ks: Iterable[str]) -> list[str]:
 
 
 @contextmanager
-def config_prefix(prefix):
+def config_prefix(prefix) -> Iterator[None]:
     """
     contextmanager for multiple invocations of API with a common prefix
 
diff --git a/pandas/_config/dates.py b/pandas/_config/dates.py
index 5bf2b49ce5904..b37831f96eb73 100644
--- a/pandas/_config/dates.py
+++ b/pandas/_config/dates.py
@@ -1,6 +1,8 @@
 """
 config for datetime formatting
 """
+from __future__ import annotations
+
 from pandas._config import config as cf
 
 pc_date_dayfirst_doc = """
diff --git a/pandas/_config/localization.py b/pandas/_config/localization.py
index 2a487fa4b6877..c4355e954c67c 100644
--- a/pandas/_config/localization.py
+++ b/pandas/_config/localization.py
@@ -39,13 +39,14 @@ def set_locale(
     particular locale, without globally setting the locale. This probably isn't
     thread-safe.
     """
-    current_locale = locale.getlocale()
+    # getlocale is not always compliant with setlocale, use setlocale. GH#46595
+    current_locale = locale.setlocale(lc_var)
 
     try:
         locale.setlocale(lc_var, new_locale)
-        normalized_locale = locale.getlocale()
-        if all(x is not None for x in normalized_locale):
-            yield ".".join(normalized_locale)
+        normalized_code, normalized_encoding = locale.getlocale()
+        if normalized_code is not None and normalized_encoding is not None:
+            yield f"{normalized_code}.{normalized_encoding}"
         else:
             yield new_locale
     finally:
diff --git a/pandas/_libs/algos.pxd b/pandas/_libs/algos.pxd
index fdeff2ed11805..c3b83b9bd40cb 100644
--- a/pandas/_libs/algos.pxd
+++ b/pandas/_libs/algos.pxd
@@ -1,4 +1,7 @@
-from pandas._libs.dtypes cimport numeric_t
+from pandas._libs.dtypes cimport (
+    numeric_object_t,
+    numeric_t,
+)
 
 
 cdef numeric_t kth_smallest_c(numeric_t* arr, Py_ssize_t k, Py_ssize_t n) nogil
@@ -10,3 +13,10 @@ cdef enum TiebreakEnumType:
     TIEBREAK_FIRST
     TIEBREAK_FIRST_DESCENDING
     TIEBREAK_DENSE
+
+
+cdef numeric_object_t get_rank_nan_fill_val(
+    bint rank_nans_highest,
+    numeric_object_t val,
+    bint is_datetimelike=*,
+)
diff --git a/pandas/_libs/algos.pyi b/pandas/_libs/algos.pyi
index df8ac3f3b0696..5a2005722c85c 100644
--- a/pandas/_libs/algos.pyi
+++ b/pandas/_libs/algos.pyi
@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from typing import Any
 
 import numpy as np
@@ -42,7 +40,7 @@ def groupsort_indexer(
     np.ndarray,  # ndarray[int64_t, ndim=1]
 ]: ...
 def kth_smallest(
-    a: np.ndarray,  # numeric[:]
+    arr: np.ndarray,  # numeric[:]
     k: int,
 ) -> Any: ...  # numeric
 
@@ -61,52 +59,39 @@ def nancorr_spearman(
 
 # ----------------------------------------------------------------------
 
-# ctypedef fused algos_t:
-#    float64_t
-#    float32_t
-#    object
-#    int64_t
-#    int32_t
-#    int16_t
-#    int8_t
-#    uint64_t
-#    uint32_t
-#    uint16_t
-#    uint8_t
-
 def validate_limit(nobs: int | None, limit=...) -> int: ...
 def pad(
-    old: np.ndarray,  # ndarray[algos_t]
-    new: np.ndarray,  # ndarray[algos_t]
+    old: np.ndarray,  # ndarray[numeric_object_t]
+    new: np.ndarray,  # ndarray[numeric_object_t]
     limit=...,
 ) -> npt.NDArray[np.intp]: ...  # np.ndarray[np.intp, ndim=1]
 def pad_inplace(
-    values: np.ndarray,  # algos_t[:]
+    values: np.ndarray,  # numeric_object_t[:]
     mask: np.ndarray,  # uint8_t[:]
     limit=...,
 ) -> None: ...
 def pad_2d_inplace(
-    values: np.ndarray,  # algos_t[:, :]
+    values: np.ndarray,  # numeric_object_t[:, :]
     mask: np.ndarray,  # const uint8_t[:, :]
     limit=...,
 ) -> None: ...
 def backfill(
-    old: np.ndarray,  # ndarray[algos_t]
-    new: np.ndarray,  # ndarray[algos_t]
+    old: np.ndarray,  # ndarray[numeric_object_t]
+    new: np.ndarray,  # ndarray[numeric_object_t]
     limit=...,
 ) -> npt.NDArray[np.intp]: ...  # np.ndarray[np.intp, ndim=1]
 def backfill_inplace(
-    values: np.ndarray,  # algos_t[:]
+    values: np.ndarray,  # numeric_object_t[:]
     mask: np.ndarray,  # uint8_t[:]
     limit=...,
 ) -> None: ...
 def backfill_2d_inplace(
-    values: np.ndarray,  # algos_t[:, :]
+    values: np.ndarray,  # numeric_object_t[:, :]
     mask: np.ndarray,  # const uint8_t[:, :]
     limit=...,
 ) -> None: ...
 def is_monotonic(
-    arr: np.ndarray,  # ndarray[algos_t, ndim=1]
+    arr: np.ndarray,  # ndarray[numeric_object_t, ndim=1]
     timelike: bool,
 ) -> tuple[bool, bool, bool]: ...
 
@@ -114,23 +99,18 @@ def is_monotonic(
 # rank_1d, rank_2d
 # ----------------------------------------------------------------------
 
-# ctypedef fused rank_t:
-#    object
-#    float64_t
-#    uint64_t
-#    int64_t
-
 def rank_1d(
-    values: np.ndarray,  # ndarray[rank_t, ndim=1]
+    values: np.ndarray,  # ndarray[numeric_object_t, ndim=1]
     labels: np.ndarray | None = ...,  # const int64_t[:]=None
     is_datetimelike: bool = ...,
     ties_method=...,
     ascending: bool = ...,
     pct: bool = ...,
     na_option=...,
+    mask: npt.NDArray[np.bool_] | None = ...,
 ) -> np.ndarray: ...  # np.ndarray[float64_t, ndim=1]
 def rank_2d(
-    in_arr: np.ndarray,  # ndarray[rank_t, ndim=2]
+    in_arr: np.ndarray,  # ndarray[numeric_object_t, ndim=2]
     axis: int = ...,
     is_datetimelike: bool = ...,
     ties_method=...,
@@ -147,17 +127,11 @@ def diff_2d(
 ) -> None: ...
 def ensure_platform_int(arr: object) -> npt.NDArray[np.intp]: ...
 def ensure_object(arr: object) -> npt.NDArray[np.object_]: ...
-def ensure_complex64(arr: object, copy=...) -> npt.NDArray[np.complex64]: ...
-def ensure_complex128(arr: object, copy=...) -> npt.NDArray[np.complex128]: ...
 def ensure_float64(arr: object, copy=...) -> npt.NDArray[np.float64]: ...
-def ensure_float32(arr: object, copy=...) -> npt.NDArray[np.float32]: ...
 def ensure_int8(arr: object, copy=...) -> npt.NDArray[np.int8]: ...
 def ensure_int16(arr: object, copy=...) -> npt.NDArray[np.int16]: ...
 def ensure_int32(arr: object, copy=...) -> npt.NDArray[np.int32]: ...
 def ensure_int64(arr: object, copy=...) -> npt.NDArray[np.int64]: ...
-def ensure_uint8(arr: object, copy=...) -> npt.NDArray[np.uint8]: ...
-def ensure_uint16(arr: object, copy=...) -> npt.NDArray[np.uint16]: ...
-def ensure_uint32(arr: object, copy=...) -> npt.NDArray[np.uint32]: ...
 def ensure_uint64(arr: object, copy=...) -> npt.NDArray[np.uint64]: ...
 def take_1d_int8_int8(
     values: np.ndarray, indexer: npt.NDArray[np.intp], out: np.ndarray, fill_value=...
diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx
index 3d099a53163bc..c05d6a300ccf0 100644
--- a/pandas/_libs/algos.pyx
+++ b/pandas/_libs/algos.pyx
@@ -1,6 +1,5 @@
-import cython
-from cython import Py_ssize_t
-
+cimport cython
+from cython cimport Py_ssize_t
 from libc.math cimport (
     fabs,
     sqrt,
@@ -46,7 +45,6 @@ cnp.import_array()
 
 cimport pandas._libs.util as util
 from pandas._libs.dtypes cimport (
-    iu_64_floating_obj_t,
     numeric_object_t,
     numeric_t,
 )
@@ -182,6 +180,8 @@ def is_lexsorted(list_of_arrays: list) -> bint:
                 else:
                     result = False
                     break
+            if not result:
+                break
     free(vecs)
     return result
 
@@ -324,17 +324,14 @@ def kth_smallest(numeric_t[::1] arr, Py_ssize_t k) -> numeric_t:
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
+@cython.cdivision(True)
 def nancorr(const float64_t[:, :] mat, bint cov=False, minp=None):
     cdef:
         Py_ssize_t i, j, xi, yi, N, K
         bint minpv
         float64_t[:, ::1] result
-        # Initialize to None since we only use in the no missing value case
-        float64_t[::1] means=None, ssqds=None
         ndarray[uint8_t, ndim=2] mask
-        bint no_nans
         int64_t nobs = 0
-        float64_t mean, ssqd, val
         float64_t vx, vy, dx, dy, meanx, meany, divisor, ssqdmx, ssqdmy, covxy
 
     N, K = (<object>mat).shape
@@ -346,57 +343,25 @@ def nancorr(const float64_t[:, :] mat, bint cov=False, minp=None):
 
     result = np.empty((K, K), dtype=np.float64)
     mask = np.isfinite(mat).view(np.uint8)
-    no_nans = mask.all()
-
-    # Computing the online means and variances is expensive - so if possible we can
-    # precompute these and avoid repeating the computations each time we handle
-    # an (xi, yi) pair
-    if no_nans:
-        means = np.empty(K, dtype=np.float64)
-        ssqds = np.empty(K, dtype=np.float64)
-
-        with nogil:
-            for j in range(K):
-                ssqd = mean = 0
-                for i in range(N):
-                    val = mat[i, j]
-                    dx = val - mean
-                    mean += 1 / (i + 1) * dx
-                    ssqd += (val - mean) * dx
-
-                means[j] = mean
-                ssqds[j] = ssqd
 
     with nogil:
         for xi in range(K):
             for yi in range(xi + 1):
-                covxy = 0
-                if no_nans:
-                    for i in range(N):
+                # Welford's method for the variance-calculation
+                # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+                nobs = ssqdmx = ssqdmy = covxy = meanx = meany = 0
+                for i in range(N):
+                    if mask[i, xi] and mask[i, yi]:
                         vx = mat[i, xi]
                         vy = mat[i, yi]
-                        covxy += (vx - means[xi]) * (vy - means[yi])
-
-                    ssqdmx = ssqds[xi]
-                    ssqdmy = ssqds[yi]
-                    nobs = N
-
-                else:
-                    nobs = ssqdmx = ssqdmy = covxy = meanx = meany = 0
-                    for i in range(N):
-                        # Welford's method for the variance-calculation
-                        # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
-                        if mask[i, xi] and mask[i, yi]:
-                            vx = mat[i, xi]
-                            vy = mat[i, yi]
-                            nobs += 1
-                            dx = vx - meanx
-                            dy = vy - meany
-                            meanx += 1 / nobs * dx
-                            meany += 1 / nobs * dy
-                            ssqdmx += (vx - meanx) * dx
-                            ssqdmy += (vy - meany) * dy
-                            covxy += (vx - meanx) * dy
+                        nobs += 1
+                        dx = vx - meanx
+                        dy = vy - meany
+                        meanx += 1. / nobs * dx
+                        meany += 1. / nobs * dy
+                        ssqdmx += (vx - meanx) * dx
+                        ssqdmy += (vy - meany) * dy
+                        covxy += (vx - meanx) * dy
 
                 if nobs < minpv:
                     result[xi, yi] = result[yi, xi] = NaN
@@ -787,7 +752,7 @@ def is_monotonic(ndarray[numeric_object_t, ndim=1] arr, bint timelike):
     n = len(arr)
 
     if n == 1:
-        if arr[0] != arr[0] or (timelike and <int64_t>arr[0] == NPY_NAT):
+        if arr[0] != arr[0] or (numeric_object_t is int64_t and timelike and arr[0] == NPY_NAT):
             # single value is NaN
             return False, False, True
         else:
@@ -857,30 +822,61 @@ def is_monotonic(ndarray[numeric_object_t, ndim=1] arr, bint timelike):
 # rank_1d, rank_2d
 # ----------------------------------------------------------------------
 
-cdef iu_64_floating_obj_t get_rank_nan_fill_val(
-        bint rank_nans_highest,
-        iu_64_floating_obj_t[:] _=None
+cdef numeric_object_t get_rank_nan_fill_val(
+    bint rank_nans_highest,
+    numeric_object_t val,
+    bint is_datetimelike=False,
 ):
     """
     Return the value we'll use to represent missing values when sorting depending
     on if we'd like missing values to end up at the top/bottom. (The second parameter
     is unused, but needed for fused type specialization)
     """
+    if numeric_object_t is int64_t and is_datetimelike and not rank_nans_highest:
+        return NPY_NAT + 1
+
     if rank_nans_highest:
-        if iu_64_floating_obj_t is object:
+        if numeric_object_t is object:
             return Infinity()
-        elif iu_64_floating_obj_t is int64_t:
+        elif numeric_object_t is int64_t:
             return util.INT64_MAX
-        elif iu_64_floating_obj_t is uint64_t:
+        elif numeric_object_t is int32_t:
+            return util.INT32_MAX
+        elif numeric_object_t is int16_t:
+            return util.INT16_MAX
+        elif numeric_object_t is int8_t:
+            return util.INT8_MAX
+        elif numeric_object_t is uint64_t:
             return util.UINT64_MAX
+        elif numeric_object_t is uint32_t:
+            return util.UINT32_MAX
+        elif numeric_object_t is uint16_t:
+            return util.UINT16_MAX
+        elif numeric_object_t is uint8_t:
+            return util.UINT8_MAX
         else:
             return np.inf
     else:
-        if iu_64_floating_obj_t is object:
+        if numeric_object_t is object:
             return NegInfinity()
-        elif iu_64_floating_obj_t is int64_t:
+        elif numeric_object_t is int64_t:
+            # Note(jbrockmendel) 2022-03-15 for reasons unknown, using util.INT64_MIN
+            #  instead of NPY_NAT here causes build warnings and failure in
+            #  test_cummax_i8_at_implementation_bound
             return NPY_NAT
-        elif iu_64_floating_obj_t is uint64_t:
+        elif numeric_object_t is int32_t:
+            return util.INT32_MIN
+        elif numeric_object_t is int16_t:
+            return util.INT16_MIN
+        elif numeric_object_t is int8_t:
+            return util.INT8_MIN
+        elif numeric_object_t is uint64_t:
+            return 0
+        elif numeric_object_t is uint32_t:
+            return 0
+        elif numeric_object_t is uint16_t:
+            return 0
+        elif numeric_object_t is uint8_t:
             return 0
         else:
             return -np.inf
@@ -889,20 +885,21 @@ cdef iu_64_floating_obj_t get_rank_nan_fill_val(
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def rank_1d(
-    ndarray[iu_64_floating_obj_t, ndim=1] values,
+    ndarray[numeric_object_t, ndim=1] values,
     const intp_t[:] labels=None,
     bint is_datetimelike=False,
     ties_method="average",
     bint ascending=True,
     bint pct=False,
     na_option="keep",
+    const uint8_t[:] mask=None,
 ):
     """
     Fast NaN-friendly version of ``scipy.stats.rankdata``.
 
     Parameters
     ----------
-    values : array of iu_64_floating_obj_t values to be ranked
+    values : array of numeric_object_t values to be ranked
     labels : np.ndarray[np.intp] or None
         Array containing unique label for each group, with its ordering
         matching up to the corresponding record in `values`. If not called
@@ -925,6 +922,8 @@ def rank_1d(
         * keep: leave NA values where they are
         * top: smallest rank if ascending
         * bottom: smallest rank if descending
+    mask : np.ndarray[bool], optional, default None
+        Specify locations to be treated as NA, for e.g. Categorical.
     """
     cdef:
         TiebreakEnumType tiebreak
@@ -932,11 +931,10 @@ def rank_1d(
         int64_t[::1] grp_sizes
         intp_t[:] lexsort_indexer
         float64_t[::1] out
-        ndarray[iu_64_floating_obj_t, ndim=1] masked_vals
-        iu_64_floating_obj_t[:] masked_vals_memview
-        uint8_t[:] mask
+        ndarray[numeric_object_t, ndim=1] masked_vals
+        numeric_object_t[:] masked_vals_memview
         bint keep_na, nans_rank_highest, check_labels, check_mask
-        iu_64_floating_obj_t nan_fill_val
+        numeric_object_t nan_fill_val
 
     tiebreak = tiebreakers[ties_method]
     if tiebreak == TIEBREAK_FIRST:
@@ -957,22 +955,29 @@ def rank_1d(
     check_labels = labels is not None
 
     # For cases where a mask is not possible, we can avoid mask checks
-    check_mask = not (iu_64_floating_obj_t is uint64_t or
-                      (iu_64_floating_obj_t is int64_t and not is_datetimelike))
+    check_mask = (
+        numeric_object_t is float32_t
+        or numeric_object_t is float64_t
+        or numeric_object_t is object
+        or (numeric_object_t is int64_t and is_datetimelike)
+    )
+    check_mask = check_mask or mask is not None
 
     # Copy values into new array in order to fill missing data
     # with mask, without obfuscating location of missing data
     # in values array
-    if iu_64_floating_obj_t is object and values.dtype != np.object_:
+    if numeric_object_t is object and values.dtype != np.object_:
         masked_vals = values.astype('O')
     else:
         masked_vals = values.copy()
 
-    if iu_64_floating_obj_t is object:
+    if mask is not None:
+        pass
+    elif numeric_object_t is object:
         mask = missing.isnaobj(masked_vals)
-    elif iu_64_floating_obj_t is int64_t and is_datetimelike:
+    elif numeric_object_t is int64_t and is_datetimelike:
         mask = (masked_vals == NPY_NAT).astype(np.uint8)
-    elif iu_64_floating_obj_t is float64_t:
+    elif numeric_object_t is float64_t or numeric_object_t is float32_t:
         mask = np.isnan(masked_vals).astype(np.uint8)
     else:
         mask = np.zeros(shape=len(masked_vals), dtype=np.uint8)
@@ -984,7 +989,7 @@ def rank_1d(
     # will flip the ordering to still end up with lowest rank.
     # Symmetric logic applies to `na_option == 'bottom'`
     nans_rank_highest = ascending ^ (na_option == 'top')
-    nan_fill_val = get_rank_nan_fill_val[iu_64_floating_obj_t](nans_rank_highest)
+    nan_fill_val = get_rank_nan_fill_val(nans_rank_highest, <numeric_object_t>0)
     if nans_rank_highest:
         order = [masked_vals, mask]
     else:
@@ -1030,8 +1035,8 @@ cdef void rank_sorted_1d(
     float64_t[::1] out,
     int64_t[::1] grp_sizes,
     const intp_t[:] sort_indexer,
-    # Can make const with cython3 (https://github.com/cython/cython/issues/3222)
-    iu_64_floating_obj_t[:] masked_vals,
+    # TODO(cython3): make const (https://github.com/cython/cython/issues/3222)
+    numeric_object_t[:] masked_vals,
     const uint8_t[:] mask,
     bint check_mask,
     Py_ssize_t N,
@@ -1055,7 +1060,7 @@ cdef void rank_sorted_1d(
         if labels is None.
     sort_indexer : intp_t[:]
         Array of indices which sorts masked_vals
-    masked_vals : iu_64_floating_obj_t[:]
+    masked_vals : numeric_object_t[:]
         The values input to rank_1d, with missing values replaced by fill values
     mask : uint8_t[:]
         Array where entries are True if the value is missing, False otherwise.
@@ -1087,7 +1092,7 @@ cdef void rank_sorted_1d(
     # that sorted value for retrieval back from the original
     # values / masked_vals arrays
     # TODO(cython3): de-duplicate once cython supports conditional nogil
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         with gil:
             for i in range(N):
                 at_end = i == N - 1
@@ -1295,7 +1300,7 @@ cdef void rank_sorted_1d(
 
 
 def rank_2d(
-    ndarray[iu_64_floating_obj_t, ndim=2] in_arr,
+    ndarray[numeric_object_t, ndim=2] in_arr,
     int axis=0,
     bint is_datetimelike=False,
     ties_method="average",
@@ -1310,13 +1315,13 @@ def rank_2d(
         Py_ssize_t k, n, col
         float64_t[::1, :] out  # Column-major so columns are contiguous
         int64_t[::1] grp_sizes
-        ndarray[iu_64_floating_obj_t, ndim=2] values
-        iu_64_floating_obj_t[:, :] masked_vals
+        ndarray[numeric_object_t, ndim=2] values
+        numeric_object_t[:, :] masked_vals
         intp_t[:, :] sort_indexer
         uint8_t[:, :] mask
         TiebreakEnumType tiebreak
         bint check_mask, keep_na, nans_rank_highest
-        iu_64_floating_obj_t nan_fill_val
+        numeric_object_t nan_fill_val
 
     tiebreak = tiebreakers[ties_method]
     if tiebreak == TIEBREAK_FIRST:
@@ -1326,29 +1331,32 @@ def rank_2d(
     keep_na = na_option == 'keep'
 
     # For cases where a mask is not possible, we can avoid mask checks
-    check_mask = not (iu_64_floating_obj_t is uint64_t or
-                      (iu_64_floating_obj_t is int64_t and not is_datetimelike))
+    check_mask = (
+        numeric_object_t is float32_t
+        or numeric_object_t is float64_t
+        or numeric_object_t is object
+        or (numeric_object_t is int64_t and is_datetimelike)
+    )
 
     if axis == 1:
         values = np.asarray(in_arr).T.copy()
     else:
         values = np.asarray(in_arr).copy()
 
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         if values.dtype != np.object_:
             values = values.astype('O')
 
     nans_rank_highest = ascending ^ (na_option == 'top')
     if check_mask:
-        nan_fill_val = get_rank_nan_fill_val[iu_64_floating_obj_t](nans_rank_highest)
+        nan_fill_val = get_rank_nan_fill_val(nans_rank_highest, <numeric_object_t>0)
 
-        if iu_64_floating_obj_t is object:
+        if numeric_object_t is object:
             mask = missing.isnaobj2d(values).view(np.uint8)
-        elif iu_64_floating_obj_t is float64_t:
+        elif numeric_object_t is float64_t or numeric_object_t is float32_t:
             mask = np.isnan(values).view(np.uint8)
-
-        # int64 and datetimelike
         else:
+            # i.e. int64 and datetimelike
             mask = (values == NPY_NAT).view(np.uint8)
         np.putmask(values, mask, nan_fill_val)
     else:
diff --git a/pandas/_libs/algos_common_helper.pxi.in b/pandas/_libs/algos_common_helper.pxi.in
index c6338216eb7a2..ce2e1ffbb5870 100644
--- a/pandas/_libs/algos_common_helper.pxi.in
+++ b/pandas/_libs/algos_common_helper.pxi.in
@@ -41,12 +41,12 @@ dtypes = [('float64', 'FLOAT64', 'float64'),
           ('int16', 'INT16', 'int16'),
           ('int32', 'INT32', 'int32'),
           ('int64', 'INT64', 'int64'),
+          ('uint64', 'UINT64', 'uint64'),
           # Disabling uint and complex dtypes because we do not use them
-          #  (and compiling them increases wheel size)
+          #  (and compiling them increases wheel size) (except uint64)
           # ('uint8', 'UINT8', 'uint8'),
           # ('uint16', 'UINT16', 'uint16'),
           # ('uint32', 'UINT32', 'uint32'),
-          # ('uint64', 'UINT64', 'uint64'),
           # ('complex64', 'COMPLEX64', 'complex64'),
           # ('complex128', 'COMPLEX128', 'complex128')
 ]
@@ -65,7 +65,8 @@ def ensure_{{name}}(object arr, copy=True):
         if (<ndarray>arr).descr.type_num == NPY_{{c_type}}:
             return arr
         else:
-            return arr.astype(np.{{dtype}}, copy=copy)
+            # equiv: arr.astype(np.{{dtype}}, copy=copy)
+            return cnp.PyArray_Cast(<ndarray>arr, cnp.NPY_{{c_type}})
     else:
         return np.array(arr, dtype=np.{{dtype}})
 
diff --git a/pandas/_libs/arrays.pyx b/pandas/_libs/arrays.pyx
index 8895a2bcfca89..f63d16e819c92 100644
--- a/pandas/_libs/arrays.pyx
+++ b/pandas/_libs/arrays.pyx
@@ -157,7 +157,7 @@ cdef class NDArrayBacked:
         return self._from_backing_data(res_values)
 
     # TODO: pass NPY_MAXDIMS equiv to axis=None?
-    def repeat(self, repeats, axis: int = 0):
+    def repeat(self, repeats, axis: int | np.integer = 0):
         if axis is None:
             axis = 0
         res_values = cnp.PyArray_Repeat(self._ndarray, repeats, <int>axis)
diff --git a/pandas/_libs/dtypes.pxd b/pandas/_libs/dtypes.pxd
index f87a1525b15fd..ccfb2d2ef4a23 100644
--- a/pandas/_libs/dtypes.pxd
+++ b/pandas/_libs/dtypes.pxd
@@ -34,15 +34,3 @@ ctypedef fused numeric_t:
 ctypedef fused numeric_object_t:
     numeric_t
     object
-
-# i64 + u64 + all float types
-ctypedef fused iu_64_floating_t:
-    float64_t
-    float32_t
-    int64_t
-    uint64_t
-
-# i64 + u64 + all float types + object
-ctypedef fused iu_64_floating_obj_t:
-    iu_64_floating_t
-    object
diff --git a/pandas/_libs/groupby.pyi b/pandas/_libs/groupby.pyi
index 8eccd0eec8a1c..04db0c9b90bc5 100644
--- a/pandas/_libs/groupby.pyi
+++ b/pandas/_libs/groupby.pyi
@@ -20,12 +20,14 @@ def group_cumprod_float64(
     skipna: bool = ...,
 ) -> None: ...
 def group_cumsum(
-    out: np.ndarray,  # numeric[:, ::1]
-    values: np.ndarray,  # ndarray[numeric, ndim=2]
+    out: np.ndarray,  # int64float_t[:, ::1]
+    values: np.ndarray,  # ndarray[int64float_t, ndim=2]
     labels: np.ndarray,  # const int64_t[:]
     ngroups: int,
     is_datetimelike: bool,
     skipna: bool = ...,
+    mask: np.ndarray | None = ...,
+    result_mask: np.ndarray | None = ...,
 ) -> None: ...
 def group_shift_indexer(
     out: np.ndarray,  # int64_t[::1]
@@ -50,19 +52,23 @@ def group_any_all(
     val_test: Literal["any", "all"],
     skipna: bool,
 ) -> None: ...
-def group_add(
-    out: np.ndarray,  # complexfloating_t[:, ::1]
+def group_sum(
+    out: np.ndarray,  # complexfloatingintuint_t[:, ::1]
     counts: np.ndarray,  # int64_t[::1]
-    values: np.ndarray,  # ndarray[complexfloating_t, ndim=2]
+    values: np.ndarray,  # ndarray[complexfloatingintuint_t, ndim=2]
     labels: np.ndarray,  # const intp_t[:]
+    mask: np.ndarray | None,
+    result_mask: np.ndarray | None = ...,
     min_count: int = ...,
-    datetimelike: bool = ...,
+    is_datetimelike: bool = ...,
 ) -> None: ...
 def group_prod(
-    out: np.ndarray,  # floating[:, ::1]
+    out: np.ndarray,  # int64float_t[:, ::1]
     counts: np.ndarray,  # int64_t[::1]
-    values: np.ndarray,  # ndarray[floating, ndim=2]
+    values: np.ndarray,  # ndarray[int64float_t, ndim=2]
     labels: np.ndarray,  # const intp_t[:]
+    mask: np.ndarray | None,
+    result_mask: np.ndarray | None = ...,
     min_count: int = ...,
 ) -> None: ...
 def group_var(
@@ -84,11 +90,13 @@ def group_mean(
     result_mask: np.ndarray | None = ...,
 ) -> None: ...
 def group_ohlc(
-    out: np.ndarray,  # floating[:, ::1]
+    out: np.ndarray,  # floatingintuint_t[:, ::1]
     counts: np.ndarray,  # int64_t[::1]
-    values: np.ndarray,  # ndarray[floating, ndim=2]
+    values: np.ndarray,  # ndarray[floatingintuint_t, ndim=2]
     labels: np.ndarray,  # const intp_t[:]
     min_count: int = ...,
+    mask: np.ndarray | None = ...,
+    result_mask: np.ndarray | None = ...,
 ) -> None: ...
 def group_quantile(
     out: npt.NDArray[np.float64],
@@ -104,15 +112,21 @@ def group_last(
     counts: np.ndarray,  # int64_t[::1]
     values: np.ndarray,  # ndarray[rank_t, ndim=2]
     labels: np.ndarray,  # const int64_t[:]
+    mask: npt.NDArray[np.bool_] | None,
+    result_mask: npt.NDArray[np.bool_] | None = ...,
     min_count: int = ...,  # Py_ssize_t
+    is_datetimelike: bool = ...,
 ) -> None: ...
 def group_nth(
     out: np.ndarray,  # rank_t[:, ::1]
     counts: np.ndarray,  # int64_t[::1]
     values: np.ndarray,  # ndarray[rank_t, ndim=2]
     labels: np.ndarray,  # const int64_t[:]
+    mask: npt.NDArray[np.bool_] | None,
+    result_mask: npt.NDArray[np.bool_] | None = ...,
     min_count: int = ...,  # int64_t
     rank: int = ...,  # int64_t
+    is_datetimelike: bool = ...,
 ) -> None: ...
 def group_rank(
     out: np.ndarray,  # float64_t[:, ::1]
@@ -120,10 +134,11 @@ def group_rank(
     labels: np.ndarray,  # const int64_t[:]
     ngroups: int,
     is_datetimelike: bool,
-    ties_method: Literal["aveage", "min", "max", "first", "dense"] = ...,
+    ties_method: Literal["average", "min", "max", "first", "dense"] = ...,
     ascending: bool = ...,
     pct: bool = ...,
     na_option: Literal["keep", "top", "bottom"] = ...,
+    mask: npt.NDArray[np.bool_] | None = ...,
 ) -> None: ...
 def group_max(
     out: np.ndarray,  # groupby_t[:, ::1]
@@ -131,6 +146,7 @@ def group_max(
     values: np.ndarray,  # ndarray[groupby_t, ndim=2]
     labels: np.ndarray,  # const int64_t[:]
     min_count: int = ...,
+    is_datetimelike: bool = ...,
     mask: np.ndarray | None = ...,
     result_mask: np.ndarray | None = ...,
 ) -> None: ...
@@ -140,6 +156,7 @@ def group_min(
     values: np.ndarray,  # ndarray[groupby_t, ndim=2]
     labels: np.ndarray,  # const int64_t[:]
     min_count: int = ...,
+    is_datetimelike: bool = ...,
     mask: np.ndarray | None = ...,
     result_mask: np.ndarray | None = ...,
 ) -> None: ...
@@ -149,6 +166,9 @@ def group_cummin(
     labels: np.ndarray,  # const int64_t[:]
     ngroups: int,
     is_datetimelike: bool,
+    mask: np.ndarray | None = ...,
+    result_mask: np.ndarray | None = ...,
+    skipna: bool = ...,
 ) -> None: ...
 def group_cummax(
     out: np.ndarray,  # groupby_t[:, ::1]
@@ -156,4 +176,7 @@ def group_cummax(
     labels: np.ndarray,  # const int64_t[:]
     ngroups: int,
     is_datetimelike: bool,
+    mask: np.ndarray | None = ...,
+    result_mask: np.ndarray | None = ...,
+    skipna: bool = ...,
 ) -> None: ...
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index c0d1405e92518..299dfdf177d91 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -1,7 +1,8 @@
-import cython
-from cython import Py_ssize_t
-
-from cython cimport floating
+cimport cython
+from cython cimport (
+    Py_ssize_t,
+    floating,
+)
 from libc.stdlib cimport (
     free,
     malloc,
@@ -30,8 +31,11 @@ from numpy.math cimport NAN
 
 cnp.import_array()
 
-from pandas._libs.algos cimport kth_smallest_c
-from pandas._libs.util cimport get_nat
+from pandas._libs cimport util
+from pandas._libs.algos cimport (
+    get_rank_nan_fill_val,
+    kth_smallest_c,
+)
 
 from pandas._libs.algos import (
     ensure_platform_int,
@@ -41,14 +45,13 @@ from pandas._libs.algos import (
 )
 
 from pandas._libs.dtypes cimport (
-    iu_64_floating_obj_t,
-    iu_64_floating_t,
+    numeric_object_t,
     numeric_t,
 )
 from pandas._libs.missing cimport checknull
 
 
-cdef int64_t NPY_NAT = get_nat()
+cdef int64_t NPY_NAT = util.get_nat()
 _int64_max = np.iinfo(np.int64).max
 
 cdef float64_t NaN = <float64_t>np.NaN
@@ -104,11 +107,13 @@ cdef inline float64_t median_linear(float64_t* a, int n) nogil:
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_median_float64(ndarray[float64_t, ndim=2] out,
-                         ndarray[int64_t] counts,
-                         ndarray[float64_t, ndim=2] values,
-                         ndarray[intp_t] labels,
-                         Py_ssize_t min_count=-1) -> None:
+def group_median_float64(
+    ndarray[float64_t, ndim=2] out,
+    ndarray[int64_t] counts,
+    ndarray[float64_t, ndim=2] values,
+    ndarray[intp_t] labels,
+    Py_ssize_t min_count=-1,
+) -> None:
     """
     Only aggregates on axis=0
     """
@@ -119,7 +124,7 @@ def group_median_float64(ndarray[float64_t, ndim=2] out,
         ndarray[intp_t] indexer
         float64_t* ptr
 
-    assert min_count == -1, "'min_count' only used in add and prod"
+    assert min_count == -1, "'min_count' only used in sum and prod"
 
     ngroups = len(counts)
     N, K = (<object>values).shape
@@ -145,12 +150,14 @@ def group_median_float64(ndarray[float64_t, ndim=2] out,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_cumprod_float64(float64_t[:, ::1] out,
-                          const float64_t[:, :] values,
-                          const intp_t[::1] labels,
-                          int ngroups,
-                          bint is_datetimelike,
-                          bint skipna=True) -> None:
+def group_cumprod_float64(
+    float64_t[:, ::1] out,
+    const float64_t[:, :] values,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    bint skipna=True,
+) -> None:
     """
     Cumulative product of columns of `values`, in row groups `labels`.
 
@@ -197,17 +204,27 @@ def group_cumprod_float64(float64_t[:, ::1] out,
                     out[i, j] = NaN
                     if not skipna:
                         accum[lab, j] = NaN
-                        break
+
+
+ctypedef fused int64float_t:
+    int64_t
+    uint64_t
+    float32_t
+    float64_t
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_cumsum(numeric_t[:, ::1] out,
-                 ndarray[numeric_t, ndim=2] values,
-                 const intp_t[::1] labels,
-                 int ngroups,
-                 is_datetimelike,
-                 bint skipna=True) -> None:
+def group_cumsum(
+    int64float_t[:, ::1] out,
+    ndarray[int64float_t, ndim=2] values,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    bint skipna=True,
+    const uint8_t[:, :] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+) -> None:
     """
     Cumulative sum of columns of `values`, in row groups `labels`.
 
@@ -225,6 +242,10 @@ def group_cumsum(numeric_t[:, ::1] out,
         True if `values` contains datetime-like entries.
     skipna : bool
         If true, ignore nans in `values`.
+    mask: np.ndarray[uint8], optional
+        Mask of values
+    result_mask: np.ndarray[int8], optional
+        Mask of out array
 
     Notes
     -----
@@ -232,14 +253,23 @@ def group_cumsum(numeric_t[:, ::1] out,
     """
     cdef:
         Py_ssize_t i, j, N, K, size
-        numeric_t val, y, t
-        numeric_t[:, ::1] accum, compensation
+        int64float_t val, y, t, na_val
+        int64float_t[:, ::1] accum, compensation
+        uint8_t[:, ::1] accum_mask
         intp_t lab
+        bint isna_entry, isna_prev = False
+        bint uses_mask = mask is not None
 
     N, K = (<object>values).shape
+
+    if uses_mask:
+        accum_mask = np.zeros((ngroups, K), dtype="uint8")
+
     accum = np.zeros((ngroups, K), dtype=np.asarray(values).dtype)
     compensation = np.zeros((ngroups, K), dtype=np.asarray(values).dtype)
 
+    na_val = _get_na_val(<int64float_t>0, is_datetimelike)
+
     with nogil:
         for i in range(N):
             lab = labels[i]
@@ -249,30 +279,63 @@ def group_cumsum(numeric_t[:, ::1] out,
             for j in range(K):
                 val = values[i, j]
 
-                # For floats, use Kahan summation to reduce floating-point
-                # error (https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
-                if numeric_t == float32_t or numeric_t == float64_t:
-                    if val == val:
+                if uses_mask:
+                    isna_entry = mask[i, j]
+                else:
+                    isna_entry = _treat_as_na(val, is_datetimelike)
+
+                if not skipna:
+                    if uses_mask:
+                        isna_prev = accum_mask[lab, j]
+                    else:
+                        isna_prev = _treat_as_na(accum[lab, j], is_datetimelike)
+
+                    if isna_prev:
+                        if uses_mask:
+                            result_mask[i, j] = True
+                            # Be deterministic, out was initialized as empty
+                            out[i, j] = 0
+                        else:
+                            out[i, j] = na_val
+                        continue
+
+                if isna_entry:
+
+                    if uses_mask:
+                        result_mask[i, j] = True
+                        # Be deterministic, out was initialized as empty
+                        out[i, j] = 0
+                    else:
+                        out[i, j] = na_val
+
+                    if not skipna:
+                        if uses_mask:
+                            accum_mask[lab, j] = True
+                        else:
+                            accum[lab, j] = na_val
+
+                else:
+                    # For floats, use Kahan summation to reduce floating-point
+                    # error (https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
+                    if int64float_t == float32_t or int64float_t == float64_t:
                         y = val - compensation[lab, j]
                         t = accum[lab, j] + y
                         compensation[lab, j] = t - accum[lab, j] - y
-                        accum[lab, j] = t
-                        out[i, j] = t
                     else:
-                        out[i, j] = NaN
-                        if not skipna:
-                            accum[lab, j] = NaN
-                            break
-                else:
-                    t = val + accum[lab, j]
+                        t = val + accum[lab, j]
+
                     accum[lab, j] = t
                     out[i, j] = t
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_shift_indexer(int64_t[::1] out, const intp_t[::1] labels,
-                        int ngroups, int periods) -> None:
+def group_shift_indexer(
+    int64_t[::1] out,
+    const intp_t[::1] labels,
+    int ngroups,
+    int periods,
+) -> None:
     cdef:
         Py_ssize_t N, i, j, ii, lab
         int offset = 0, sign
@@ -323,10 +386,15 @@ def group_shift_indexer(int64_t[::1] out, const intp_t[::1] labels,
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_fillna_indexer(ndarray[intp_t] out, ndarray[intp_t] labels,
-                         ndarray[intp_t] sorted_labels,
-                         ndarray[uint8_t] mask, str direction,
-                         int64_t limit, bint dropna) -> None:
+def group_fillna_indexer(
+    ndarray[intp_t] out,
+    ndarray[intp_t] labels,
+    ndarray[intp_t] sorted_labels,
+    ndarray[uint8_t] mask,
+    str direction,
+    int64_t limit,
+    bint dropna,
+) -> None:
     """
     Indexes how to fill values forwards or backwards within a group.
 
@@ -388,13 +456,15 @@ def group_fillna_indexer(ndarray[intp_t] out, ndarray[intp_t] labels,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_any_all(int8_t[:, ::1] out,
-                  const int8_t[:, :] values,
-                  const intp_t[::1] labels,
-                  const uint8_t[:, :] mask,
-                  str val_test,
-                  bint skipna,
-                  bint nullable) -> None:
+def group_any_all(
+    int8_t[:, ::1] out,
+    const int8_t[:, :] values,
+    const intp_t[::1] labels,
+    const uint8_t[:, :] mask,
+    str val_test,
+    bint skipna,
+    bint nullable,
+) -> None:
     """
     Aggregated boolean values to show truthfulness of group elements. If the
     input is a nullable type (nullable=True), the result will be computed
@@ -472,40 +542,45 @@ def group_any_all(int8_t[:, ::1] out,
 
 
 # ----------------------------------------------------------------------
-# group_add, group_prod, group_var, group_mean, group_ohlc
+# group_sum, group_prod, group_var, group_mean, group_ohlc
 # ----------------------------------------------------------------------
 
-ctypedef fused add_t:
-    float64_t
-    float32_t
-    complex64_t
-    complex128_t
-    object
-
 ctypedef fused mean_t:
     float64_t
     float32_t
     complex64_t
     complex128_t
 
+ctypedef fused sum_t:
+    mean_t
+    int64_t
+    uint64_t
+    object
+
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_add(add_t[:, ::1] out,
-              int64_t[::1] counts,
-              ndarray[add_t, ndim=2] values,
-              const intp_t[::1] labels,
-              Py_ssize_t min_count=0,
-              bint datetimelike=False) -> None:
+def group_sum(
+    sum_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[sum_t, ndim=2] values,
+    const intp_t[::1] labels,
+    const uint8_t[:, :] mask,
+    uint8_t[:, ::1] result_mask=None,
+    Py_ssize_t min_count=0,
+    bint is_datetimelike=False,
+) -> None:
     """
     Only aggregates on axis=0 using Kahan summation
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        add_t val, t, y
-        add_t[:, ::1] sumx, compensation
+        sum_t val, t, y
+        sum_t[:, ::1] sumx, compensation
         int64_t[:, ::1] nobs
         Py_ssize_t len_values = len(values), len_labels = len(labels)
+        bint uses_mask = mask is not None
+        bint isna_entry
 
     if len_values != len_labels:
         raise ValueError("len(index) != len(labels)")
@@ -517,7 +592,7 @@ def group_add(add_t[:, ::1] out,
 
     N, K = (<object>values).shape
 
-    if add_t is object:
+    if sum_t is object:
         # NB: this does not use 'compensation' like the non-object track does.
         for i in range(N):
             lab = labels[i]
@@ -543,7 +618,8 @@ def group_add(add_t[:, ::1] out,
         for i in range(ncounts):
             for j in range(K):
                 if nobs[i, j] < min_count:
-                    out[i, j] = NAN
+                    out[i, j] = None
+
                 else:
                     out[i, j] = sumx[i, j]
     else:
@@ -559,13 +635,20 @@ def group_add(add_t[:, ::1] out,
 
                     # not nan
                     # With dt64/td64 values, values have been cast to float64
-                    #  instead if int64 for group_add, but the logic
+                    #  instead if int64 for group_sum, but the logic
                     #  is otherwise the same as in _treat_as_na
-                    if val == val and not (
-                        add_t is float64_t
-                        and datetimelike
-                        and val == <float64_t>NPY_NAT
-                    ):
+                    if uses_mask:
+                        isna_entry = mask[i, j]
+                    elif (sum_t is float32_t or sum_t is float64_t
+                        or sum_t is complex64_t or sum_t is complex64_t):
+                        # avoid warnings because of equality comparison
+                        isna_entry = not val == val
+                    elif sum_t is int64_t and is_datetimelike and val == NPY_NAT:
+                        isna_entry = True
+                    else:
+                        isna_entry = False
+
+                    if not isna_entry:
                         nobs[lab, j] += 1
                         y = val - compensation[lab, j]
                         t = sumx[lab, j] + y
@@ -575,27 +658,48 @@ def group_add(add_t[:, ::1] out,
             for i in range(ncounts):
                 for j in range(K):
                     if nobs[i, j] < min_count:
-                        out[i, j] = NAN
+                        # if we are integer dtype, not is_datetimelike, and
+                        #  not uses_mask, then getting here implies that
+                        #  counts[i] < min_count, which means we will
+                        #  be cast to float64 and masked at the end
+                        #  of WrappedCythonOp._call_cython_op. So we can safely
+                        #  set a placeholder value in out[i, j].
+                        if uses_mask:
+                            result_mask[i, j] = True
+                        elif (sum_t is float32_t or sum_t is float64_t
+                            or sum_t is complex64_t or sum_t is complex64_t):
+                            out[i, j] = NAN
+                        elif sum_t is int64_t:
+                            out[i, j] = NPY_NAT
+                        else:
+                            # placeholder, see above
+                            out[i, j] = 0
+
                     else:
                         out[i, j] = sumx[i, j]
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_prod(floating[:, ::1] out,
-               int64_t[::1] counts,
-               ndarray[floating, ndim=2] values,
-               const intp_t[::1] labels,
-               Py_ssize_t min_count=0) -> None:
+def group_prod(
+    int64float_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[int64float_t, ndim=2] values,
+    const intp_t[::1] labels,
+    const uint8_t[:, ::1] mask,
+    uint8_t[:, ::1] result_mask=None,
+    Py_ssize_t min_count=0,
+) -> None:
     """
     Only aggregates on axis=0
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        floating val, count
-        floating[:, ::1] prodx
+        int64float_t val, count
+        int64float_t[:, ::1] prodx
         int64_t[:, ::1] nobs
         Py_ssize_t len_values = len(values), len_labels = len(labels)
+        bint isna_entry, uses_mask = mask is not None
 
     if len_values != len_labels:
         raise ValueError("len(index) != len(labels)")
@@ -615,15 +719,32 @@ def group_prod(floating[:, ::1] out,
             for j in range(K):
                 val = values[i, j]
 
-                # not nan
-                if val == val:
+                if uses_mask:
+                    isna_entry = mask[i, j]
+                elif int64float_t is float32_t or int64float_t is float64_t:
+                    isna_entry = not val == val
+                else:
+                    isna_entry = False
+
+                if not isna_entry:
                     nobs[lab, j] += 1
                     prodx[lab, j] *= val
 
         for i in range(ncounts):
             for j in range(K):
                 if nobs[i, j] < min_count:
-                    out[i, j] = NAN
+
+                    # else case is not possible
+                    if uses_mask:
+                        result_mask[i, j] = True
+                        # Be deterministic, out was initialized as empty
+                        out[i, j] = 0
+                    elif int64float_t is float32_t or int64float_t is float64_t:
+                        out[i, j] = NAN
+                    else:
+                        # we only get here when < mincount which gets handled later
+                        pass
+
                 else:
                     out[i, j] = prodx[i, j]
 
@@ -631,12 +752,14 @@ def group_prod(floating[:, ::1] out,
 @cython.wraparound(False)
 @cython.boundscheck(False)
 @cython.cdivision(True)
-def group_var(floating[:, ::1] out,
-              int64_t[::1] counts,
-              ndarray[floating, ndim=2] values,
-              const intp_t[::1] labels,
-              Py_ssize_t min_count=-1,
-              int64_t ddof=1) -> None:
+def group_var(
+    floating[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[floating, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    int64_t ddof=1,
+) -> None:
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
         floating val, ct, oldmean
@@ -644,7 +767,7 @@ def group_var(floating[:, ::1] out,
         int64_t[:, ::1] nobs
         Py_ssize_t len_values = len(values), len_labels = len(labels)
 
-    assert min_count == -1, "'min_count' only used in add and prod"
+    assert min_count == -1, "'min_count' only used in sum and prod"
 
     if len_values != len_labels:
         raise ValueError("len(index) != len(labels)")
@@ -685,15 +808,16 @@ def group_var(floating[:, ::1] out,
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_mean(mean_t[:, ::1] out,
-               int64_t[::1] counts,
-               ndarray[mean_t, ndim=2] values,
-               const intp_t[::1] labels,
-               Py_ssize_t min_count=-1,
-               bint is_datetimelike=False,
-               const uint8_t[:, ::1] mask=None,
-               uint8_t[:, ::1] result_mask=None
-               ) -> None:
+def group_mean(
+    mean_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[mean_t, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    bint is_datetimelike=False,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+) -> None:
     """
     Compute the mean per label given a label assignment for each value.
     NaN values are ignored.
@@ -711,7 +835,7 @@ def group_mean(mean_t[:, ::1] out,
         Array containing unique label for each group, with its
         ordering matching up to the corresponding record in `values`.
     min_count : Py_ssize_t
-        Only used in add and prod. Always -1.
+        Only used in sum and prod. Always -1.
     is_datetimelike : bool
         True if `values` contains datetime-like entries.
     mask : ndarray[bool, ndim=2], optional
@@ -732,7 +856,7 @@ def group_mean(mean_t[:, ::1] out,
         int64_t[:, ::1] nobs
         Py_ssize_t len_values = len(values), len_labels = len(labels)
 
-    assert min_count == -1, "'min_count' only used in add and prod"
+    assert min_count == -1, "'min_count' only used in sum and prod"
 
     if len_values != len_labels:
         raise ValueError("len(index) != len(labels)")
@@ -773,19 +897,25 @@ def group_mean(mean_t[:, ::1] out,
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_ohlc(floating[:, ::1] out,
-               int64_t[::1] counts,
-               ndarray[floating, ndim=2] values,
-               const intp_t[::1] labels,
-               Py_ssize_t min_count=-1) -> None:
+def group_ohlc(
+    int64float_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[int64float_t, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+) -> None:
     """
     Only aggregates on axis=0
     """
     cdef:
         Py_ssize_t i, j, N, K, lab
-        floating val
+        int64float_t val
+        uint8_t[::1] first_element_set
+        bint isna_entry, uses_mask = not mask is None
 
-    assert min_count == -1, "'min_count' only used in add and prod"
+    assert min_count == -1, "'min_count' only used in sum and prod"
 
     if len(labels) == 0:
         return
@@ -797,7 +927,15 @@ def group_ohlc(floating[:, ::1] out,
 
     if K > 1:
         raise NotImplementedError("Argument 'values' must have only one dimension")
-    out[:] = np.nan
+
+    if int64float_t is float32_t or int64float_t is float64_t:
+        out[:] = np.nan
+    else:
+        out[:] = 0
+
+    first_element_set = np.zeros((<object>counts).shape, dtype=np.uint8)
+    if uses_mask:
+        result_mask[:] = True
 
     with nogil:
         for i in range(N):
@@ -807,11 +945,22 @@ def group_ohlc(floating[:, ::1] out,
 
             counts[lab] += 1
             val = values[i, 0]
-            if val != val:
+
+            if uses_mask:
+                isna_entry = mask[i, 0]
+            elif int64float_t is float32_t or int64float_t is float64_t:
+                isna_entry = val != val
+            else:
+                isna_entry = False
+
+            if isna_entry:
                 continue
 
-            if out[lab, 0] != out[lab, 0]:
+            if not first_element_set[lab]:
                 out[lab, 0] = out[lab, 1] = out[lab, 2] = out[lab, 3] = val
+                first_element_set[lab] = True
+                if uses_mask:
+                    result_mask[lab] = False
             else:
                 out[lab, 1] = max(out[lab, 1], val)
                 out[lab, 2] = min(out[lab, 2], val)
@@ -820,13 +969,15 @@ def group_ohlc(floating[:, ::1] out,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_quantile(ndarray[float64_t, ndim=2] out,
-                   ndarray[numeric_t, ndim=1] values,
-                   ndarray[intp_t] labels,
-                   ndarray[uint8_t] mask,
-                   const intp_t[:] sort_indexer,
-                   const float64_t[:] qs,
-                   str interpolation) -> None:
+def group_quantile(
+    ndarray[float64_t, ndim=2] out,
+    ndarray[numeric_t, ndim=1] values,
+    ndarray[intp_t] labels,
+    ndarray[uint8_t] mask,
+    const intp_t[:] sort_indexer,
+    const float64_t[:] qs,
+    str interpolation,
+) -> None:
     """
     Calculate the quantile per group.
 
@@ -937,39 +1088,71 @@ def group_quantile(ndarray[float64_t, ndim=2] out,
 # group_nth, group_last, group_rank
 # ----------------------------------------------------------------------
 
-cdef inline bint _treat_as_na(iu_64_floating_obj_t val, bint is_datetimelike) nogil:
-    if iu_64_floating_obj_t is object:
+cdef inline bint _treat_as_na(numeric_object_t val, bint is_datetimelike) nogil:
+    if numeric_object_t is object:
         # Should never be used, but we need to avoid the `val != val` below
         #  or else cython will raise about gil acquisition.
         raise NotImplementedError
 
-    elif iu_64_floating_obj_t is int64_t:
+    elif numeric_object_t is int64_t:
         return is_datetimelike and val == NPY_NAT
-    elif iu_64_floating_obj_t is uint64_t:
-        # There is no NA value for uint64
+    elif numeric_object_t is float32_t or numeric_object_t is float64_t:
+        return val != val
+    else:
+        # non-datetimelike integer
         return False
+
+
+cdef numeric_object_t _get_min_or_max(numeric_object_t val, bint compute_max, bint is_datetimelike):
+    """
+    Find either the min or the max supported by numeric_object_t; 'val' is a
+    placeholder to effectively make numeric_object_t an argument.
+    """
+    return get_rank_nan_fill_val(
+        not compute_max,
+        val=val,
+        is_datetimelike=is_datetimelike,
+    )
+
+
+cdef numeric_t _get_na_val(numeric_t val, bint is_datetimelike):
+    cdef:
+        numeric_t na_val
+
+    if numeric_t == float32_t or numeric_t == float64_t:
+        na_val = NaN
+    elif numeric_t is int64_t and is_datetimelike:
+        na_val = NPY_NAT
     else:
-        return val != val
+        # Used in case of masks
+        na_val = 0
+    return na_val
 
 
-# GH#31710 use memorviews once cython 0.30 is released so we can
-#  use `const iu_64_floating_obj_t[:, :] values`
+# TODO(cython3): GH#31710 use memorviews once cython 0.30 is released so we can
+#  use `const numeric_object_t[:, :] values`
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_last(iu_64_floating_obj_t[:, ::1] out,
-               int64_t[::1] counts,
-               ndarray[iu_64_floating_obj_t, ndim=2] values,
-               const intp_t[::1] labels,
-               Py_ssize_t min_count=-1) -> None:
+def group_last(
+    numeric_object_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[numeric_object_t, ndim=2] values,
+    const intp_t[::1] labels,
+    const uint8_t[:, :] mask,
+    uint8_t[:, ::1] result_mask=None,
+    Py_ssize_t min_count=-1,
+    bint is_datetimelike=False,
+) -> None:
     """
     Only aggregates on axis=0
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        iu_64_floating_obj_t val
-        ndarray[iu_64_floating_obj_t, ndim=2] resx
+        numeric_object_t val
+        ndarray[numeric_object_t, ndim=2] resx
         ndarray[int64_t, ndim=2] nobs
-        bint runtime_error = False
+        bint uses_mask = mask is not None
+        bint isna_entry
 
     # TODO(cython3):
     # Instead of `labels.shape[0]` use `len(labels)`
@@ -978,14 +1161,14 @@ def group_last(iu_64_floating_obj_t[:, ::1] out,
 
     min_count = max(min_count, 1)
     nobs = np.zeros((<object>out).shape, dtype=np.int64)
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         resx = np.empty((<object>out).shape, dtype=object)
     else:
         resx = np.empty_like(out)
 
     N, K = (<object>values).shape
 
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         # TODO(cython3): De-duplicate once conditional-nogil is available
         for i in range(N):
             lab = labels[i]
@@ -996,7 +1179,12 @@ def group_last(iu_64_floating_obj_t[:, ::1] out,
             for j in range(K):
                 val = values[i, j]
 
-                if not checknull(val):
+                if uses_mask:
+                    isna_entry = mask[i, j]
+                else:
+                    isna_entry = checknull(val)
+
+                if not isna_entry:
                     # NB: use _treat_as_na here once
                     #  conditional-nogil is available.
                     nobs[lab, j] += 1
@@ -1019,51 +1207,66 @@ def group_last(iu_64_floating_obj_t[:, ::1] out,
                 for j in range(K):
                     val = values[i, j]
 
-                    if not _treat_as_na(val, True):
-                        # TODO: Sure we always want is_datetimelike=True?
+                    if uses_mask:
+                        isna_entry = mask[i, j]
+                    else:
+                        isna_entry = _treat_as_na(val, is_datetimelike)
+
+                    if not isna_entry:
                         nobs[lab, j] += 1
                         resx[lab, j] = val
 
             for i in range(ncounts):
                 for j in range(K):
+                    # TODO(cython3): the entire next block can be shared
+                    #  across 3 places once conditional-nogil is available
                     if nobs[i, j] < min_count:
-                        if iu_64_floating_obj_t is int64_t:
+                        # if we are integer dtype, not is_datetimelike, and
+                        #  not uses_mask, then getting here implies that
+                        #  counts[i] < min_count, which means we will
+                        #  be cast to float64 and masked at the end
+                        #  of WrappedCythonOp._call_cython_op. So we can safely
+                        #  set a placeholder value in out[i, j].
+                        if uses_mask:
+                            result_mask[i, j] = True
+                        elif numeric_object_t is float32_t or numeric_object_t is float64_t:
+                            out[i, j] = NAN
+                        elif numeric_object_t is int64_t:
+                            # Per above, this is a placeholder in
+                            #  non-is_datetimelike cases.
                             out[i, j] = NPY_NAT
-                        elif iu_64_floating_obj_t is uint64_t:
-                            runtime_error = True
-                            break
                         else:
-                            out[i, j] = NAN
-
+                            # placeholder, see above
+                            out[i, j] = 0
                     else:
                         out[i, j] = resx[i, j]
 
-    if runtime_error:
-        # We cannot raise directly above because that is within a nogil
-        #  block.
-        raise RuntimeError("empty group with uint64_t")
 
-
-# GH#31710 use memorviews once cython 0.30 is released so we can
-#  use `const iu_64_floating_obj_t[:, :] values`
+# TODO(cython3): GH#31710 use memorviews once cython 0.30 is released so we can
+#  use `const numeric_object_t[:, :] values`
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_nth(iu_64_floating_obj_t[:, ::1] out,
-              int64_t[::1] counts,
-              ndarray[iu_64_floating_obj_t, ndim=2] values,
-              const intp_t[::1] labels,
-              int64_t min_count=-1,
-              int64_t rank=1,
-              ) -> None:
+def group_nth(
+    numeric_object_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[numeric_object_t, ndim=2] values,
+    const intp_t[::1] labels,
+    const uint8_t[:, :] mask,
+    uint8_t[:, ::1] result_mask=None,
+    int64_t min_count=-1,
+    int64_t rank=1,
+    bint is_datetimelike=False,
+) -> None:
     """
     Only aggregates on axis=0
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        iu_64_floating_obj_t val
-        ndarray[iu_64_floating_obj_t, ndim=2] resx
+        numeric_object_t val
+        ndarray[numeric_object_t, ndim=2] resx
         ndarray[int64_t, ndim=2] nobs
-        bint runtime_error = False
+        bint uses_mask = mask is not None
+        bint isna_entry
 
     # TODO(cython3):
     # Instead of `labels.shape[0]` use `len(labels)`
@@ -1072,14 +1275,14 @@ def group_nth(iu_64_floating_obj_t[:, ::1] out,
 
     min_count = max(min_count, 1)
     nobs = np.zeros((<object>out).shape, dtype=np.int64)
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         resx = np.empty((<object>out).shape, dtype=object)
     else:
         resx = np.empty_like(out)
 
     N, K = (<object>values).shape
 
-    if iu_64_floating_obj_t is object:
+    if numeric_object_t is object:
         # TODO(cython3): De-duplicate once conditional-nogil is available
         for i in range(N):
             lab = labels[i]
@@ -1090,7 +1293,12 @@ def group_nth(iu_64_floating_obj_t[:, ::1] out,
             for j in range(K):
                 val = values[i, j]
 
-                if not checknull(val):
+                if uses_mask:
+                    isna_entry = mask[i, j]
+                else:
+                    isna_entry = checknull(val)
+
+                if not isna_entry:
                     # NB: use _treat_as_na here once
                     #  conditional-nogil is available.
                     nobs[lab, j] += 1
@@ -1115,39 +1323,60 @@ def group_nth(iu_64_floating_obj_t[:, ::1] out,
                 for j in range(K):
                     val = values[i, j]
 
-                    if not _treat_as_na(val, True):
-                        # TODO: Sure we always want is_datetimelike=True?
+                    if uses_mask:
+                        isna_entry = mask[i, j]
+                    else:
+                        isna_entry = _treat_as_na(val, is_datetimelike)
+
+                    if not isna_entry:
                         nobs[lab, j] += 1
                         if nobs[lab, j] == rank:
                             resx[lab, j] = val
 
+            # TODO: de-dup this whole block with group_last?
             for i in range(ncounts):
                 for j in range(K):
                     if nobs[i, j] < min_count:
-                        if iu_64_floating_obj_t is int64_t:
+                        # if we are integer dtype, not is_datetimelike, and
+                        #  not uses_mask, then getting here implies that
+                        #  counts[i] < min_count, which means we will
+                        #  be cast to float64 and masked at the end
+                        #  of WrappedCythonOp._call_cython_op. So we can safely
+                        #  set a placeholder value in out[i, j].
+                        if uses_mask:
+                            result_mask[i, j] = True
+                            # set out[i, j] to 0 to be deterministic, as
+                            #  it was initialized with np.empty. Also ensures
+                            #  we can downcast out if appropriate.
+                            out[i, j] = 0
+                        elif numeric_object_t is float32_t or numeric_object_t is float64_t:
+                            out[i, j] = NAN
+                        elif numeric_object_t is int64_t:
+                            # Per above, this is a placeholder in
+                            #  non-is_datetimelike cases.
                             out[i, j] = NPY_NAT
-                        elif iu_64_floating_obj_t is uint64_t:
-                            runtime_error = True
-                            break
                         else:
-                            out[i, j] = NAN
+                            # placeholder, see above
+                            out[i, j] = 0
+
                     else:
                         out[i, j] = resx[i, j]
 
-    if runtime_error:
-        # We cannot raise directly above because that is within a nogil
-        #  block.
-        raise RuntimeError("empty group with uint64_t")
-
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_rank(float64_t[:, ::1] out,
-               ndarray[iu_64_floating_obj_t, ndim=2] values,
-               const intp_t[::1] labels,
-               int ngroups,
-               bint is_datetimelike, str ties_method="average",
-               bint ascending=True, bint pct=False, str na_option="keep") -> None:
+def group_rank(
+    float64_t[:, ::1] out,
+    ndarray[numeric_object_t, ndim=2] values,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    str ties_method="average",
+    bint ascending=True,
+    bint pct=False,
+    str na_option="keep",
+    const uint8_t[:, :] mask=None,
+) -> None:
     """
     Provides the rank of values within each group.
 
@@ -1155,7 +1384,7 @@ def group_rank(float64_t[:, ::1] out,
     ----------
     out : np.ndarray[np.float64, ndim=2]
         Values to which this method will write its results.
-    values : np.ndarray of iu_64_floating_obj_t values to be ranked
+    values : np.ndarray of numeric_object_t values to be ranked
     labels : np.ndarray[np.intp]
         Array containing unique label for each group, with its ordering
         matching up to the corresponding record in `values`
@@ -1179,6 +1408,7 @@ def group_rank(float64_t[:, ::1] out,
         * keep: leave NA values where they are
         * top: smallest rank if ascending
         * bottom: smallest rank if descending
+    mask : np.ndarray[bool] or None, default None
 
     Notes
     -----
@@ -1187,10 +1417,16 @@ def group_rank(float64_t[:, ::1] out,
     cdef:
         Py_ssize_t i, k, N
         ndarray[float64_t, ndim=1] result
+        const uint8_t[:] sub_mask
 
     N = values.shape[1]
 
     for k in range(N):
+        if mask is None:
+            sub_mask = None
+        else:
+            sub_mask = mask[:, k]
+
         result = rank_1d(
             values=values[:, k],
             labels=labels,
@@ -1198,36 +1434,38 @@ def group_rank(float64_t[:, ::1] out,
             ties_method=ties_method,
             ascending=ascending,
             pct=pct,
-            na_option=na_option
+            na_option=na_option,
+            mask=sub_mask,
         )
         for i in range(len(result)):
-            # TODO: why can't we do out[:, k] = result?
-            out[i, k] = result[i]
+            if labels[i] >= 0:
+                out[i, k] = result[i]
 
 
 # ----------------------------------------------------------------------
 # group_min, group_max
 # ----------------------------------------------------------------------
 
-# TODO: consider implementing for more dtypes
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cdef group_min_max(iu_64_floating_t[:, ::1] out,
-                   int64_t[::1] counts,
-                   ndarray[iu_64_floating_t, ndim=2] values,
-                   const intp_t[::1] labels,
-                   Py_ssize_t min_count=-1,
-                   bint is_datetimelike=False,
-                   bint compute_max=True,
-                   const uint8_t[:, ::1] mask=None,
-                   uint8_t[:, ::1] result_mask=None):
+cdef group_min_max(
+    numeric_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[numeric_t, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    bint is_datetimelike=False,
+    bint compute_max=True,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+):
     """
     Compute minimum/maximum  of columns of `values`, in row groups `labels`.
 
     Parameters
     ----------
-    out : np.ndarray[iu_64_floating_t, ndim=2]
+    out : np.ndarray[numeric_t, ndim=2]
         Array to store result in.
     counts : np.ndarray[int64]
         Input as a zeroed array, populated by group sizes during algorithm
@@ -1256,9 +1494,8 @@ cdef group_min_max(iu_64_floating_t[:, ::1] out,
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ngroups = len(counts)
-        iu_64_floating_t val, nan_val
-        ndarray[iu_64_floating_t, ndim=2] group_min_or_max
-        bint runtime_error = False
+        numeric_t val
+        ndarray[numeric_t, ndim=2] group_min_or_max
         int64_t[:, ::1] nobs
         bint uses_mask = mask is not None
         bint isna_entry
@@ -1272,17 +1509,7 @@ cdef group_min_max(iu_64_floating_t[:, ::1] out,
     nobs = np.zeros((<object>out).shape, dtype=np.int64)
 
     group_min_or_max = np.empty_like(out)
-    if iu_64_floating_t is int64_t:
-        group_min_or_max[:] = -_int64_max if compute_max else _int64_max
-        nan_val = NPY_NAT
-    elif iu_64_floating_t is uint64_t:
-        # NB: We do not define nan_val because there is no such thing
-        # for uint64_t.  We carefully avoid having to reference it in this
-        # case.
-        group_min_or_max[:] = 0 if compute_max else np.iinfo(np.uint64).max
-    else:
-        group_min_or_max[:] = -np.inf if compute_max else np.inf
-        nan_val = NAN
+    group_min_or_max[:] = _get_min_or_max(<numeric_t>0, compute_max, is_datetimelike)
 
     N, K = (<object>values).shape
 
@@ -1313,33 +1540,43 @@ cdef group_min_max(iu_64_floating_t[:, ::1] out,
         for i in range(ngroups):
             for j in range(K):
                 if nobs[i, j] < min_count:
-                    if iu_64_floating_t is uint64_t:
-                        runtime_error = True
-                        break
+                    # if we are integer dtype, not is_datetimelike, and
+                    #  not uses_mask, then getting here implies that
+                    #  counts[i] < min_count, which means we will
+                    #  be cast to float64 and masked at the end
+                    #  of WrappedCythonOp._call_cython_op. So we can safely
+                    #  set a placeholder value in out[i, j].
+                    if uses_mask:
+                        result_mask[i, j] = True
+                        # set out[i, j] to 0 to be deterministic, as
+                        #  it was initialized with np.empty. Also ensures
+                        #  we can downcast out if appropriate.
+                        out[i, j] = 0
+                    elif numeric_t is float32_t or numeric_t is float64_t:
+                        out[i, j] = NAN
+                    elif numeric_t is int64_t:
+                        # Per above, this is a placeholder in
+                        #  non-is_datetimelike cases.
+                        out[i, j] = NPY_NAT
                     else:
-                        if uses_mask:
-                            result_mask[i, j] = True
-                        else:
-                            out[i, j] = nan_val
+                        # placeholder, see above
+                        out[i, j] = 0
                 else:
                     out[i, j] = group_min_or_max[i, j]
 
-    if runtime_error:
-        # We cannot raise directly above because that is within a nogil
-        #  block.
-        raise RuntimeError("empty group with uint64_t")
-
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_max(iu_64_floating_t[:, ::1] out,
-              int64_t[::1] counts,
-              ndarray[iu_64_floating_t, ndim=2] values,
-              const intp_t[::1] labels,
-              Py_ssize_t min_count=-1,
-              bint is_datetimelike=False,
-              const uint8_t[:, ::1] mask=None,
-              uint8_t[:, ::1] result_mask=None) -> None:
+def group_max(
+    numeric_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[numeric_t, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    bint is_datetimelike=False,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+) -> None:
     """See group_min_max.__doc__"""
     group_min_max(
         out,
@@ -1356,14 +1593,16 @@ def group_max(iu_64_floating_t[:, ::1] out,
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def group_min(iu_64_floating_t[:, ::1] out,
-              int64_t[::1] counts,
-              ndarray[iu_64_floating_t, ndim=2] values,
-              const intp_t[::1] labels,
-              Py_ssize_t min_count=-1,
-              bint is_datetimelike=False,
-              const uint8_t[:, ::1] mask=None,
-              uint8_t[:, ::1] result_mask=None) -> None:
+def group_min(
+    numeric_t[:, ::1] out,
+    int64_t[::1] counts,
+    ndarray[numeric_t, ndim=2] values,
+    const intp_t[::1] labels,
+    Py_ssize_t min_count=-1,
+    bint is_datetimelike=False,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+) -> None:
     """See group_min_max.__doc__"""
     group_min_max(
         out,
@@ -1380,26 +1619,32 @@ def group_min(iu_64_floating_t[:, ::1] out,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef group_cummin_max(iu_64_floating_t[:, ::1] out,
-                      ndarray[iu_64_floating_t, ndim=2] values,
-                      uint8_t[:, ::1] mask,
-                      const intp_t[::1] labels,
-                      int ngroups,
-                      bint is_datetimelike,
-                      bint skipna,
-                      bint compute_max):
+cdef group_cummin_max(
+    numeric_t[:, ::1] out,
+    ndarray[numeric_t, ndim=2] values,
+    const uint8_t[:, ::1] mask,
+    uint8_t[:, ::1] result_mask,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    bint skipna,
+    bint compute_max,
+):
     """
     Cumulative minimum/maximum of columns of `values`, in row groups `labels`.
 
     Parameters
     ----------
-    out : np.ndarray[iu_64_floating_t, ndim=2]
+    out : np.ndarray[numeric_t, ndim=2]
         Array to store cummin/max in.
-    values : np.ndarray[iu_64_floating_t, ndim=2]
+    values : np.ndarray[numeric_t, ndim=2]
         Values to take cummin/max of.
     mask : np.ndarray[bool] or None
         If not None, indices represent missing values,
         otherwise the mask will not be used
+    result_mask : ndarray[bool, ndim=2], optional
+        If not None, these specify locations in the output that are NA.
+        Modified in-place.
     labels : np.ndarray[np.intp]
         Labels to group by.
     ngroups : int
@@ -1417,51 +1662,30 @@ cdef group_cummin_max(iu_64_floating_t[:, ::1] out,
     This method modifies the `out` parameter, rather than returning an object.
     """
     cdef:
-        iu_64_floating_t[:, ::1] accum
-
-    accum = np.empty((ngroups, (<object>values).shape[1]), dtype=values.dtype)
-    if iu_64_floating_t is int64_t:
-        accum[:] = -_int64_max if compute_max else _int64_max
-    elif iu_64_floating_t is uint64_t:
-        accum[:] = 0 if compute_max else np.iinfo(np.uint64).max
-    else:
-        accum[:] = -np.inf if compute_max else np.inf
-
-    if mask is not None:
-        masked_cummin_max(out, values, mask, labels, accum, skipna, compute_max)
-    else:
-        cummin_max(out, values, labels, accum, skipna, is_datetimelike, compute_max)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef cummin_max(iu_64_floating_t[:, ::1] out,
-                ndarray[iu_64_floating_t, ndim=2] values,
-                const intp_t[::1] labels,
-                iu_64_floating_t[:, ::1] accum,
-                bint skipna,
-                bint is_datetimelike,
-                bint compute_max):
-    """
-    Compute the cumulative minimum/maximum of columns of `values`, in row groups
-    `labels`.
-    """
-    cdef:
+        numeric_t[:, ::1] accum
         Py_ssize_t i, j, N, K
-        iu_64_floating_t val, mval, na_val
+        numeric_t val, mval, na_val
         uint8_t[:, ::1] seen_na
         intp_t lab
         bint na_possible
+        bint uses_mask = mask is not None
+        bint isna_entry
 
-    if iu_64_floating_t is float64_t or iu_64_floating_t is float32_t:
-        na_val = NaN
+    accum = np.empty((ngroups, (<object>values).shape[1]), dtype=values.dtype)
+    accum[:] = _get_min_or_max(<numeric_t>0, compute_max, is_datetimelike)
+
+    na_val = _get_na_val(<numeric_t>0, is_datetimelike)
+
+    if uses_mask:
+        na_possible = True
+        # Will never be used, just to avoid uninitialized warning
+        na_val = 0
+    elif numeric_t is float64_t or numeric_t is float32_t:
         na_possible = True
     elif is_datetimelike:
-        na_val = NPY_NAT
         na_possible = True
-    # Will never be used, just to avoid uninitialized warning
     else:
-        na_val = 0
+        # Will never be used, just to avoid uninitialized warning
         na_possible = False
 
     if na_possible:
@@ -1474,56 +1698,25 @@ cdef cummin_max(iu_64_floating_t[:, ::1] out,
             if lab < 0:
                 continue
             for j in range(K):
+
                 if not skipna and na_possible and seen_na[lab, j]:
-                    out[i, j] = na_val
+                    if uses_mask:
+                        result_mask[i, j] = 1
+                        # Set to 0 ensures that we are deterministic and can
+                        #  downcast if appropriate
+                        out[i, j] = 0
+
+                    else:
+                        out[i, j] = na_val
                 else:
                     val = values[i, j]
-                    if not _treat_as_na(val, is_datetimelike):
-                        mval = accum[lab, j]
-                        if compute_max:
-                            if val > mval:
-                                accum[lab, j] = mval = val
-                        else:
-                            if val < mval:
-                                accum[lab, j] = mval = val
-                        out[i, j] = mval
-                    else:
-                        seen_na[lab, j] = 1
-                        out[i, j] = val
-
 
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef masked_cummin_max(iu_64_floating_t[:, ::1] out,
-                       ndarray[iu_64_floating_t, ndim=2] values,
-                       uint8_t[:, ::1] mask,
-                       const intp_t[::1] labels,
-                       iu_64_floating_t[:, ::1] accum,
-                       bint skipna,
-                       bint compute_max):
-    """
-    Compute the cumulative minimum/maximum of columns of `values`, in row groups
-    `labels` with a masked algorithm.
-    """
-    cdef:
-        Py_ssize_t i, j, N, K
-        iu_64_floating_t val, mval
-        uint8_t[:, ::1] seen_na
-        intp_t lab
+                    if uses_mask:
+                        isna_entry = mask[i, j]
+                    else:
+                        isna_entry = _treat_as_na(val, is_datetimelike)
 
-    N, K = (<object>values).shape
-    seen_na = np.zeros((<object>accum).shape, dtype=np.uint8)
-    with nogil:
-        for i in range(N):
-            lab = labels[i]
-            if lab < 0:
-                continue
-            for j in range(K):
-                if not skipna and seen_na[lab, j]:
-                    mask[i, j] = 1
-                else:
-                    if not mask[i, j]:
-                        val = values[i, j]
+                    if not isna_entry:
                         mval = accum[lab, j]
                         if compute_max:
                             if val > mval:
@@ -1534,47 +1727,56 @@ cdef masked_cummin_max(iu_64_floating_t[:, ::1] out,
                         out[i, j] = mval
                     else:
                         seen_na[lab, j] = 1
+                        out[i, j] = val
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_cummin(iu_64_floating_t[:, ::1] out,
-                 ndarray[iu_64_floating_t, ndim=2] values,
-                 const intp_t[::1] labels,
-                 int ngroups,
-                 bint is_datetimelike,
-                 uint8_t[:, ::1] mask=None,
-                 bint skipna=True) -> None:
+def group_cummin(
+    numeric_t[:, ::1] out,
+    ndarray[numeric_t, ndim=2] values,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+    bint skipna=True,
+) -> None:
     """See group_cummin_max.__doc__"""
     group_cummin_max(
-        out,
-        values,
-        mask,
-        labels,
-        ngroups,
-        is_datetimelike,
-        skipna,
-        compute_max=False
+        out=out,
+        values=values,
+        mask=mask,
+        result_mask=result_mask,
+        labels=labels,
+        ngroups=ngroups,
+        is_datetimelike=is_datetimelike,
+        skipna=skipna,
+        compute_max=False,
     )
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def group_cummax(iu_64_floating_t[:, ::1] out,
-                 ndarray[iu_64_floating_t, ndim=2] values,
-                 const intp_t[::1] labels,
-                 int ngroups,
-                 bint is_datetimelike,
-                 uint8_t[:, ::1] mask=None,
-                 bint skipna=True) -> None:
+def group_cummax(
+    numeric_t[:, ::1] out,
+    ndarray[numeric_t, ndim=2] values,
+    const intp_t[::1] labels,
+    int ngroups,
+    bint is_datetimelike,
+    const uint8_t[:, ::1] mask=None,
+    uint8_t[:, ::1] result_mask=None,
+    bint skipna=True,
+) -> None:
     """See group_cummin_max.__doc__"""
     group_cummin_max(
-        out,
-        values,
-        mask,
-        labels,
-        ngroups,
-        is_datetimelike,
-        skipna,
-        compute_max=True
+        out=out,
+        values=values,
+        mask=mask,
+        result_mask=result_mask,
+        labels=labels,
+        ngroups=ngroups,
+        is_datetimelike=is_datetimelike,
+        skipna=skipna,
+        compute_max=True,
     )
diff --git a/pandas/_libs/hashing.pyx b/pandas/_libs/hashing.pyx
index 39caf04ddf2f8..9ea0fa73cbc9f 100644
--- a/pandas/_libs/hashing.pyx
+++ b/pandas/_libs/hashing.pyx
@@ -1,8 +1,7 @@
 # Translated from the reference implementation
 # at https://github.com/veorq/SipHash
 
-import cython
-
+cimport cython
 from libc.stdlib cimport (
     free,
     malloc,
@@ -22,9 +21,6 @@ import_array()
 
 from pandas._libs.util cimport is_nan
 
-DEF cROUNDS = 2
-DEF dROUNDS = 4
-
 
 @cython.boundscheck(False)
 def hash_object_array(
@@ -53,7 +49,7 @@ def hash_object_array(
     """
     cdef:
         Py_ssize_t i, n
-        uint64_t[:] result
+        uint64_t[::1] result
         bytes data, k
         uint8_t *kb
         uint64_t *lens
@@ -163,6 +159,8 @@ cdef uint64_t low_level_siphash(uint8_t* data, size_t datalen,
     cdef uint8_t* end = data + datalen - (datalen % sizeof(uint64_t))
     cdef int left = datalen & 7
     cdef int left_byte
+    cdef int cROUNDS = 2
+    cdef int dROUNDS = 4
 
     b = (<uint64_t>datalen) << 56
     v3 ^= k1
diff --git a/pandas/_libs/hashtable.pyi b/pandas/_libs/hashtable.pyi
index f4b90648a8dc8..8500fdf2f602e 100644
--- a/pandas/_libs/hashtable.pyi
+++ b/pandas/_libs/hashtable.pyi
@@ -39,72 +39,72 @@ class Int64Factorizer(Factorizer):
     ) -> npt.NDArray[np.intp]: ...
 
 class Int64Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.int64]: ...
 
 class Int32Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.int32]: ...
 
 class Int16Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.int16]: ...
 
 class Int8Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.int8]: ...
 
 class UInt64Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.uint64]: ...
 
 class UInt32Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.uint32]: ...
 
 class UInt16Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.uint16]: ...
 
 class UInt8Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.uint8]: ...
 
 class Float64Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.float64]: ...
 
 class Float32Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.float32]: ...
 
 class Complex128Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.complex128]: ...
 
 class Complex64Vector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.complex64]: ...
 
 class StringVector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.object_]: ...
 
 class ObjectVector:
-    def __init__(self): ...
+    def __init__(self, *args): ...
     def __len__(self) -> int: ...
     def to_array(self) -> npt.NDArray[np.object_]: ...
 
@@ -120,12 +120,6 @@ class HashTable:
     # TODO: `item` type is subclass-specific
     def get_item(self, item): ...  # TODO: return type?
     def set_item(self, item) -> None: ...
-    # FIXME: we don't actually have this for StringHashTable or ObjectHashTable?
-    def map(
-        self,
-        keys: np.ndarray,  # np.ndarray[subclass-specific]
-        values: np.ndarray,  # const int64_t[:]
-    ) -> None: ...
     def map_locations(
         self,
         values: np.ndarray,  # np.ndarray[subclass-specific]
@@ -150,26 +144,13 @@ class HashTable:
         np.ndarray,  # np.ndarray[subclass-specific]
         npt.NDArray[np.intp],
     ] | np.ndarray: ...  # np.ndarray[subclass-specific]
-    def _unique(
-        self,
-        values: np.ndarray,  # np.ndarray[subclass-specific]
-        uniques,  # FooVector
-        count_prior: int = ...,
-        na_sentinel: int = ...,
-        na_value: object = ...,
-        ignore_na: bool = ...,
-        return_inverse: bool = ...,
-    ) -> tuple[
-        np.ndarray,  # np.ndarray[subclass-specific]
-        npt.NDArray[np.intp],
-    ] | np.ndarray: ...  # np.ndarray[subclass-specific]
     def factorize(
         self,
         values: np.ndarray,  # np.ndarray[subclass-specific]
         na_sentinel: int = ...,
         na_value: object = ...,
         mask=...,
-    ) -> tuple[np.ndarray, npt.NDArray[np.intp],]: ...  # np.ndarray[subclass-specific]
+    ) -> tuple[np.ndarray, npt.NDArray[np.intp]]: ...  # np.ndarray[subclass-specific]
 
 class Complex128HashTable(HashTable): ...
 class Complex64HashTable(HashTable): ...
@@ -177,11 +158,16 @@ class Float64HashTable(HashTable): ...
 class Float32HashTable(HashTable): ...
 
 class Int64HashTable(HashTable):
-    # Only Int64HashTable has get_labels_groupby
+    # Only Int64HashTable has get_labels_groupby, map_keys_to_values
     def get_labels_groupby(
         self,
-        values: np.ndarray,  # const int64_t[:]
-    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64],]: ...
+        values: npt.NDArray[np.int64],  # const int64_t[:]
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64]]: ...
+    def map_keys_to_values(
+        self,
+        keys: npt.NDArray[np.int64],
+        values: npt.NDArray[np.int64],  # const int64_t[:]
+    ) -> None: ...
 
 class Int32HashTable(HashTable): ...
 class Int16HashTable(HashTable): ...
@@ -198,11 +184,14 @@ def duplicated(
     values: np.ndarray,
     keep: Literal["last", "first", False] = ...,
 ) -> npt.NDArray[np.bool_]: ...
-def mode(values: np.ndarray, dropna: bool) -> np.ndarray: ...
+def mode(
+    values: np.ndarray, dropna: bool, mask: npt.NDArray[np.bool_] | None = ...
+) -> np.ndarray: ...
 def value_count(
     values: np.ndarray,
     dropna: bool,
-) -> tuple[np.ndarray, npt.NDArray[np.int64],]: ...  # np.ndarray[same-as-values]
+    mask: npt.NDArray[np.bool_] | None = ...,
+) -> tuple[np.ndarray, npt.NDArray[np.int64]]: ...  # np.ndarray[same-as-values]
 
 # arr and values should have same dtype
 def ismember(
diff --git a/pandas/_libs/hashtable.pyx b/pandas/_libs/hashtable.pyx
index 6e97c13c644cf..bbc17c4cb5415 100644
--- a/pandas/_libs/hashtable.pyx
+++ b/pandas/_libs/hashtable.pyx
@@ -27,6 +27,7 @@ cnp.import_array()
 
 
 from pandas._libs cimport util
+from pandas._libs.dtypes cimport numeric_object_t
 from pandas._libs.khash cimport (
     KHASH_TRACE_DOMAIN,
     are_equivalent_float32_t,
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index 0446b675e07d7..54260a9a90964 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -435,6 +435,7 @@ cdef class {{name}}HashTable(HashTable):
         }
 
     cpdef get_item(self, {{dtype}}_t val):
+        # Used in core.sorting, IndexEngine.get_loc
         cdef:
             khiter_t k
             {{c_type}} cval
@@ -446,6 +447,7 @@ cdef class {{name}}HashTable(HashTable):
             raise KeyError(val)
 
     cpdef set_item(self, {{dtype}}_t key, Py_ssize_t val):
+        # Used in libjoin
         cdef:
             khiter_t k
             int ret = 0
@@ -457,8 +459,13 @@ cdef class {{name}}HashTable(HashTable):
         else:
             raise KeyError(key)
 
+    {{if dtype == "int64" }}
+    # We only use this for int64, can reduce build size and make .pyi
+    #  more accurate by only implementing it for int64
     @cython.boundscheck(False)
-    def map(self, const {{dtype}}_t[:] keys, const int64_t[:] values) -> None:
+    def map_keys_to_values(
+        self, const {{dtype}}_t[:] keys, const int64_t[:] values
+    ) -> None:
         cdef:
             Py_ssize_t i, n = len(values)
             int ret = 0
@@ -470,9 +477,11 @@ cdef class {{name}}HashTable(HashTable):
                 key = {{to_c_type}}(keys[i])
                 k = kh_put_{{dtype}}(self.table, key, &ret)
                 self.table.vals[k] = <Py_ssize_t>values[i]
+    {{endif}}
 
     @cython.boundscheck(False)
     def map_locations(self, const {{dtype}}_t[:] values) -> None:
+        # Used in libindex, safe_sort
         cdef:
             Py_ssize_t i, n = len(values)
             int ret = 0
@@ -488,12 +497,13 @@ cdef class {{name}}HashTable(HashTable):
     @cython.boundscheck(False)
     def lookup(self, const {{dtype}}_t[:] values) -> ndarray:
         # -> np.ndarray[np.intp]
+        # Used in safe_sort, IndexEngine.get_indexer
         cdef:
             Py_ssize_t i, n = len(values)
             int ret = 0
             {{c_type}} val
             khiter_t k
-            intp_t[:] locs = np.empty(n, dtype=np.intp)
+            intp_t[::1] locs = np.empty(n, dtype=np.intp)
 
         with nogil:
             for i in range(n):
@@ -511,7 +521,7 @@ cdef class {{name}}HashTable(HashTable):
     def _unique(self, const {{dtype}}_t[:] values, {{name}}Vector uniques,
                 Py_ssize_t count_prior=0, Py_ssize_t na_sentinel=-1,
                 object na_value=None, bint ignore_na=False,
-                object mask=None, bint return_inverse=False):
+                object mask=None, bint return_inverse=False, bint use_result_mask=False):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -541,6 +551,9 @@ cdef class {{name}}HashTable(HashTable):
         return_inverse : bool, default False
             Whether the mapping of the original array values to their location
             in the vector of uniques should be returned.
+        use_result_mask: bool, default False
+            Whether to create a result mask for the unique values. Not supported
+            with return_inverse=True.
 
         Returns
         -------
@@ -548,15 +561,19 @@ cdef class {{name}}HashTable(HashTable):
             Unique values of input, not sorted
         labels : ndarray[intp_t] (if return_inverse=True)
             The labels from values to uniques
+        result_mask: ndarray[bool], if use_result_mask is true
+            The mask for the result values.
         """
         cdef:
             Py_ssize_t i, idx, count = count_prior, n = len(values)
-            intp_t[:] labels
+            intp_t[::1] labels
             int ret = 0
             {{c_type}} val, na_value2
             khiter_t k
             {{name}}VectorData *ud
-            bint use_na_value, use_mask
+            UInt8Vector result_mask
+            UInt8VectorData *rmd
+            bint use_na_value, use_mask, seen_na = False
             uint8_t[:] mask_values
 
         if return_inverse:
@@ -564,6 +581,14 @@ cdef class {{name}}HashTable(HashTable):
         ud = uniques.data
         use_na_value = na_value is not None
         use_mask = mask is not None
+        if not use_mask and use_result_mask:
+            raise NotImplementedError  # pragma: no cover
+
+        if use_result_mask and return_inverse:
+            raise NotImplementedError  # pragma: no cover
+
+        result_mask = UInt8Vector()
+        rmd = result_mask.data
 
         if use_mask:
             mask_values = mask.view("uint8")
@@ -595,6 +620,27 @@ cdef class {{name}}HashTable(HashTable):
                     # and replace the corresponding label with na_sentinel
                     labels[i] = na_sentinel
                     continue
+                elif not ignore_na and use_result_mask:
+                    if mask_values[i]:
+                        if seen_na:
+                            continue
+
+                        seen_na = True
+                        if needs_resize(ud):
+                            with gil:
+                                if uniques.external_view_exists:
+                                    raise ValueError("external reference to "
+                                                     "uniques held, but "
+                                                     "Vector.resize() needed")
+                                uniques.resize()
+                                if result_mask.external_view_exists:
+                                    raise ValueError("external reference to "
+                                                     "result_mask held, but "
+                                                     "Vector.resize() needed")
+                                result_mask.resize()
+                        append_data_{{dtype}}(ud, val)
+                        append_data_uint8(rmd, 1)
+                        continue
 
                 k = kh_get_{{dtype}}(self.table, val)
 
@@ -609,7 +655,16 @@ cdef class {{name}}HashTable(HashTable):
                                                  "uniques held, but "
                                                  "Vector.resize() needed")
                             uniques.resize()
+                            if use_result_mask:
+                                if result_mask.external_view_exists:
+                                    raise ValueError("external reference to "
+                                                     "result_mask held, but "
+                                                     "Vector.resize() needed")
+                                result_mask.resize()
                     append_data_{{dtype}}(ud, val)
+                    if use_result_mask:
+                        append_data_uint8(rmd, 0)
+
                     if return_inverse:
                         self.table.vals[k] = count
                         labels[i] = count
@@ -622,9 +677,11 @@ cdef class {{name}}HashTable(HashTable):
 
         if return_inverse:
             return uniques.to_array(), labels.base  # .base -> underlying ndarray
+        if use_result_mask:
+            return uniques.to_array(), result_mask.to_array()
         return uniques.to_array()
 
-    def unique(self, const {{dtype}}_t[:] values, bint return_inverse=False):
+    def unique(self, const {{dtype}}_t[:] values, bint return_inverse=False, object mask=None):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -635,6 +692,9 @@ cdef class {{name}}HashTable(HashTable):
         return_inverse : bool, default False
             Whether the mapping of the original array values to their location
             in the vector of uniques should be returned.
+        mask : ndarray[bool], optional
+            If not None, the mask is used as indicator for missing values
+            (True = missing, False = valid) instead of `na_value` or
 
         Returns
         -------
@@ -642,13 +702,16 @@ cdef class {{name}}HashTable(HashTable):
             Unique values of input, not sorted
         labels : ndarray[intp_t] (if return_inverse)
             The labels from values to uniques
+        result_mask: ndarray[bool], if mask is given as input
+            The mask for the result values.
         """
         uniques = {{name}}Vector()
+        use_result_mask = True if mask is not None else False
         return self._unique(values, uniques, ignore_na=False,
-                            return_inverse=return_inverse)
+                            return_inverse=return_inverse, mask=mask, use_result_mask=use_result_mask)
 
     def factorize(self, const {{dtype}}_t[:] values, Py_ssize_t na_sentinel=-1,
-                  object na_value=None, object mask=None):
+                  object na_value=None, object mask=None, ignore_na=True):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -680,7 +743,7 @@ cdef class {{name}}HashTable(HashTable):
         """
         uniques_vector = {{name}}Vector()
         return self._unique(values, uniques_vector, na_sentinel=na_sentinel,
-                            na_value=na_value, ignore_na=True, mask=mask,
+                            na_value=na_value, ignore_na=ignore_na, mask=mask,
                             return_inverse=True)
 
     def get_labels(self, const {{dtype}}_t[:] values, {{name}}Vector uniques,
@@ -700,7 +763,7 @@ cdef class {{name}}HashTable(HashTable):
         # tuple[np.ndarray[np.intp], np.ndarray[{{dtype}}]]
         cdef:
             Py_ssize_t i, n = len(values)
-            intp_t[:] labels
+            intp_t[::1] labels
             Py_ssize_t idx, count = 0
             int ret = 0
             {{c_type}} val
@@ -838,7 +901,7 @@ cdef class StringHashTable(HashTable):
             object val
             const char *v
             khiter_t k
-            intp_t[:] locs = np.empty(n, dtype=np.intp)
+            intp_t[::1] locs = np.empty(n, dtype=np.intp)
 
         # these by-definition *must* be strings
         vecs = <const char **>malloc(n * sizeof(char *))
@@ -936,8 +999,8 @@ cdef class StringHashTable(HashTable):
         """
         cdef:
             Py_ssize_t i, idx, count = count_prior, n = len(values)
-            intp_t[:] labels
-            int64_t[:] uindexer
+            intp_t[::1] labels
+            int64_t[::1] uindexer
             int ret = 0
             object val
             const char *v
@@ -1003,7 +1066,7 @@ cdef class StringHashTable(HashTable):
             return uniques.to_array(), labels.base  # .base -> underlying ndarray
         return uniques.to_array()
 
-    def unique(self, ndarray[object] values, bint return_inverse=False):
+    def unique(self, ndarray[object] values, bint return_inverse=False, object mask=None):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -1014,6 +1077,8 @@ cdef class StringHashTable(HashTable):
         return_inverse : bool, default False
             Whether the mapping of the original array values to their location
             in the vector of uniques should be returned.
+        mask : ndarray[bool], optional
+            Not yet implemented for StringHashTable
 
         Returns
         -------
@@ -1027,7 +1092,7 @@ cdef class StringHashTable(HashTable):
                             return_inverse=return_inverse)
 
     def factorize(self, ndarray[object] values, Py_ssize_t na_sentinel=-1,
-                  object na_value=None, object mask=None):
+                  object na_value=None, object mask=None, ignore_na=True):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -1057,7 +1122,7 @@ cdef class StringHashTable(HashTable):
         """
         uniques_vector = ObjectVector()
         return self._unique(values, uniques_vector, na_sentinel=na_sentinel,
-                            na_value=na_value, ignore_na=True,
+                            na_value=na_value, ignore_na=ignore_na,
                             return_inverse=True)
 
     def get_labels(self, ndarray[object] values, ObjectVector uniques,
@@ -1158,7 +1223,7 @@ cdef class PyObjectHashTable(HashTable):
             int ret = 0
             object val
             khiter_t k
-            intp_t[:] locs = np.empty(n, dtype=np.intp)
+            intp_t[::1] locs = np.empty(n, dtype=np.intp)
 
         for i in range(n):
             val = values[i]
@@ -1213,7 +1278,7 @@ cdef class PyObjectHashTable(HashTable):
         """
         cdef:
             Py_ssize_t i, idx, count = count_prior, n = len(values)
-            intp_t[:] labels
+            intp_t[::1] labels
             int ret = 0
             object val
             khiter_t k
@@ -1256,7 +1321,7 @@ cdef class PyObjectHashTable(HashTable):
             return uniques.to_array(), labels.base  # .base -> underlying ndarray
         return uniques.to_array()
 
-    def unique(self, ndarray[object] values, bint return_inverse=False):
+    def unique(self, ndarray[object] values, bint return_inverse=False, object mask=None):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -1267,6 +1332,8 @@ cdef class PyObjectHashTable(HashTable):
         return_inverse : bool, default False
             Whether the mapping of the original array values to their location
             in the vector of uniques should be returned.
+        mask : ndarray[bool], optional
+            Not yet implemented for PyObjectHashTable
 
         Returns
         -------
@@ -1280,7 +1347,7 @@ cdef class PyObjectHashTable(HashTable):
                             return_inverse=return_inverse)
 
     def factorize(self, ndarray[object] values, Py_ssize_t na_sentinel=-1,
-                  object na_value=None, object mask=None):
+                  object na_value=None, object mask=None, ignore_na=True):
         """
         Calculate unique values and labels (no sorting!)
 
@@ -1310,7 +1377,7 @@ cdef class PyObjectHashTable(HashTable):
         """
         uniques_vector = ObjectVector()
         return self._unique(values, uniques_vector, na_sentinel=na_sentinel,
-                            na_value=na_value, ignore_na=True,
+                            na_value=na_value, ignore_na=ignore_na,
                             return_inverse=True)
 
     def get_labels(self, ndarray[object] values, ObjectVector uniques,
diff --git a/pandas/_libs/hashtable_func_helper.pxi.in b/pandas/_libs/hashtable_func_helper.pxi.in
index e5e64f8dc7b5f..f7c41b32864be 100644
--- a/pandas/_libs/hashtable_func_helper.pxi.in
+++ b/pandas/_libs/hashtable_func_helper.pxi.in
@@ -17,7 +17,7 @@ dtypes = [('Complex128', 'complex128', 'complex128',
           ('UInt32', 'uint32', 'uint32', 'uint32_t', ''),
           ('UInt16', 'uint16', 'uint16', 'uint16_t', ''),
           ('UInt8', 'uint8', 'uint8', 'uint8_t', ''),
-          ('Object', 'object', 'pymap', 'object', ''),
+          ('Object', 'object', 'pymap', 'object', '<PyObject*>'),
           ('Int64', 'int64', 'int64', 'int64_t', ''),
           ('Int32', 'int32', 'int32', 'int32_t', ''),
           ('Int16', 'int16', 'int16', 'int16_t', ''),
@@ -31,9 +31,9 @@ dtypes = [('Complex128', 'complex128', 'complex128',
 @cython.wraparound(False)
 @cython.boundscheck(False)
 {{if dtype == 'object'}}
-cdef value_count_{{dtype}}(ndarray[{{dtype}}] values, bint dropna):
+cdef value_count_{{dtype}}(ndarray[{{dtype}}] values, bint dropna, const uint8_t[:] mask=None):
 {{else}}
-cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
+cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna, const uint8_t[:] mask=None):
 {{endif}}
     cdef:
         Py_ssize_t i = 0
@@ -46,6 +46,11 @@ cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
         {{c_type}} val
 
         int ret = 0
+        bint uses_mask = mask is not None
+        bint isna_entry = False
+
+    if uses_mask and not dropna:
+        raise NotImplementedError("uses_mask not implemented with dropna=False")
 
     # we track the order in which keys are first seen (GH39009),
     # khash-map isn't insertion-ordered, thus:
@@ -56,16 +61,19 @@ cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
     table = kh_init_{{ttype}}()
 
     {{if dtype == 'object'}}
+    if uses_mask:
+        raise NotImplementedError("uses_mask not implemented with object dtype")
+
     kh_resize_{{ttype}}(table, n // 10)
 
     for i in range(n):
         val = values[i]
         if not dropna or not checknull(val):
-            k = kh_get_{{ttype}}(table, <PyObject*>val)
+            k = kh_get_{{ttype}}(table, {{to_c_type}}val)
             if k != table.n_buckets:
                 table.vals[k] += 1
             else:
-                k = kh_put_{{ttype}}(table, <PyObject*>val, &ret)
+                k = kh_put_{{ttype}}(table, {{to_c_type}}val, &ret)
                 table.vals[k] = 1
                 result_keys.append(val)
     {{else}}
@@ -74,7 +82,13 @@ cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
     for i in range(n):
         val = {{to_c_type}}(values[i])
 
-        if not is_nan_{{c_type}}(val) or not dropna:
+        if dropna:
+            if uses_mask:
+                isna_entry = mask[i]
+            else:
+                isna_entry = is_nan_{{c_type}}(val)
+
+        if not dropna or not isna_entry:
             k = kh_get_{{ttype}}(table, val)
             if k != table.n_buckets:
                 table.vals[k] += 1
@@ -85,7 +99,9 @@ cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
     {{endif}}
 
     # collect counts in the order corresponding to result_keys:
-    cdef int64_t[:] result_counts = np.empty(table.size, dtype=np.int64)
+    cdef:
+        int64_t[::1] result_counts = np.empty(table.size, dtype=np.int64)
+
     for i in range(table.size):
         {{if dtype == 'object'}}
         k = kh_get_{{ttype}}(table, result_keys.data[i])
@@ -110,6 +126,8 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
         int ret = 0
         {{if dtype != 'object'}}
         {{c_type}} value
+        {{else}}
+        PyObject* value
         {{endif}}
         Py_ssize_t i, n = len(values)
         khiter_t k
@@ -123,44 +141,33 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
 
     if keep == 'last':
         {{if dtype == 'object'}}
-        for i in range(n - 1, -1, -1):
-            # equivalent: range(n)[::-1], which cython doesn't like in nogil
-            kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
-            out[i] = ret == 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n - 1, -1, -1):
                 # equivalent: range(n)[::-1], which cython doesn't like in nogil
                 value = {{to_c_type}}(values[i])
                 kh_put_{{ttype}}(table, value, &ret)
                 out[i] = ret == 0
-        {{endif}}
+
     elif keep == 'first':
         {{if dtype == 'object'}}
-        for i in range(n):
-            kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
-            out[i] = ret == 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n):
                 value = {{to_c_type}}(values[i])
                 kh_put_{{ttype}}(table, value, &ret)
                 out[i] = ret == 0
-        {{endif}}
+
     else:
         {{if dtype == 'object'}}
-        for i in range(n):
-            value = values[i]
-            k = kh_get_{{ttype}}(table, <PyObject*>value)
-            if k != table.n_buckets:
-                out[table.vals[k]] = 1
-                out[i] = 1
-            else:
-                k = kh_put_{{ttype}}(table, <PyObject*>value, &ret)
-                table.vals[k] = i
-                out[i] = 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n):
                 value = {{to_c_type}}(values[i])
                 k = kh_get_{{ttype}}(table, value)
@@ -171,7 +178,7 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
                     k = kh_put_{{ttype}}(table, value, &ret)
                     table.vals[k] = i
                     out[i] = 0
-        {{endif}}
+
     kh_destroy_{{ttype}}(table)
     return out
 
@@ -199,14 +206,20 @@ cdef ismember_{{dtype}}(const {{dtype}}_t[:] arr, const {{dtype}}_t[:] values):
 
     Returns
     -------
-    boolean ndarry len of (arr)
+    boolean ndarray len of (arr)
     """
     cdef:
         Py_ssize_t i, n
         khiter_t k
         int ret = 0
         ndarray[uint8_t] result
+
+        {{if dtype == "object"}}
+        PyObject* val
+        {{else}}
         {{c_type}} val
+        {{endif}}
+
         kh_{{ttype}}_t *table = kh_init_{{ttype}}()
 
     # construct the table
@@ -214,31 +227,27 @@ cdef ismember_{{dtype}}(const {{dtype}}_t[:] arr, const {{dtype}}_t[:] values):
     kh_resize_{{ttype}}(table, n)
 
     {{if dtype == 'object'}}
-    for i in range(n):
-        kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
+    if True:
     {{else}}
     with nogil:
+    {{endif}}
         for i in range(n):
             val = {{to_c_type}}(values[i])
             kh_put_{{ttype}}(table, val, &ret)
-    {{endif}}
 
     # test membership
     n = len(arr)
     result = np.empty(n, dtype=np.uint8)
 
     {{if dtype == 'object'}}
-    for i in range(n):
-        val = arr[i]
-        k = kh_get_{{ttype}}(table, <PyObject*>val)
-        result[i] = (k != table.n_buckets)
+    if True:
     {{else}}
     with nogil:
+    {{endif}}
         for i in range(n):
             val = {{to_c_type}}(arr[i])
             k = kh_get_{{ttype}}(table, val)
             result[i] = (k != table.n_buckets)
-    {{endif}}
 
     kh_destroy_{{ttype}}(table)
     return result.view(np.bool_)
@@ -247,113 +256,46 @@ cdef ismember_{{dtype}}(const {{dtype}}_t[:] arr, const {{dtype}}_t[:] values):
 # Mode Computations
 # ----------------------------------------------------------------------
 
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-{{if dtype == 'object'}}
-cdef mode_{{dtype}}(ndarray[{{dtype}}] values, bint dropna):
-{{else}}
-cdef mode_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
-{{endif}}
-    cdef:
-        {{if dtype == 'object'}}
-        ndarray[{{dtype}}] keys
-        ndarray[{{dtype}}] modes
-        {{else}}
-        {{dtype}}_t[:] keys
-        ndarray[{{dtype}}_t] modes
-        {{endif}}
-        int64_t[:] counts
-        int64_t count, max_count = -1
-        Py_ssize_t k, j = 0
-
-    keys, counts = value_count_{{dtype}}(values, dropna)
-
-    {{if dtype == 'object'}}
-    modes = np.empty(len(keys), dtype=np.object_)
-    {{else}}
-    modes = np.empty(len(keys), dtype=np.{{dtype}})
-    {{endif}}
-
-    {{if dtype != 'object'}}
-    with nogil:
-        for k in range(len(keys)):
-            count = counts[k]
-            if count == max_count:
-                j += 1
-            elif count > max_count:
-                max_count = count
-                j = 0
-            else:
-                continue
-
-            modes[j] = keys[k]
-    {{else}}
-    for k in range(len(keys)):
-        count = counts[k]
-        if count == max_count:
-            j += 1
-        elif count > max_count:
-            max_count = count
-            j = 0
-        else:
-            continue
-
-        modes[j] = keys[k]
-    {{endif}}
-
-    return modes[:j + 1]
-
 {{endfor}}
 
 
 ctypedef fused htfunc_t:
+    numeric_object_t
     complex128_t
     complex64_t
-    float64_t
-    float32_t
-    uint64_t
-    uint32_t
-    uint16_t
-    uint8_t
-    int64_t
-    int32_t
-    int16_t
-    int8_t
-    object
-
-
-cpdef value_count(ndarray[htfunc_t] values, bint dropna):
+
+
+cpdef value_count(ndarray[htfunc_t] values, bint dropna, const uint8_t[:] mask=None):
     if htfunc_t is object:
-        return value_count_object(values, dropna)
+        return value_count_object(values, dropna, mask=mask)
 
     elif htfunc_t is int8_t:
-        return value_count_int8(values, dropna)
+        return value_count_int8(values, dropna, mask=mask)
     elif htfunc_t is int16_t:
-        return value_count_int16(values, dropna)
+        return value_count_int16(values, dropna, mask=mask)
     elif htfunc_t is int32_t:
-        return value_count_int32(values, dropna)
+        return value_count_int32(values, dropna, mask=mask)
     elif htfunc_t is int64_t:
-        return value_count_int64(values, dropna)
+        return value_count_int64(values, dropna, mask=mask)
 
     elif htfunc_t is uint8_t:
-        return value_count_uint8(values, dropna)
+        return value_count_uint8(values, dropna, mask=mask)
     elif htfunc_t is uint16_t:
-        return value_count_uint16(values, dropna)
+        return value_count_uint16(values, dropna, mask=mask)
     elif htfunc_t is uint32_t:
-        return value_count_uint32(values, dropna)
+        return value_count_uint32(values, dropna, mask=mask)
     elif htfunc_t is uint64_t:
-        return value_count_uint64(values, dropna)
+        return value_count_uint64(values, dropna, mask=mask)
 
     elif htfunc_t is float64_t:
-        return value_count_float64(values, dropna)
+        return value_count_float64(values, dropna, mask=mask)
     elif htfunc_t is float32_t:
-        return value_count_float32(values, dropna)
+        return value_count_float32(values, dropna, mask=mask)
 
     elif htfunc_t is complex128_t:
-        return value_count_complex128(values, dropna)
+        return value_count_complex128(values, dropna, mask=mask)
     elif htfunc_t is complex64_t:
-        return value_count_complex64(values, dropna)
+        return value_count_complex64(values, dropna, mask=mask)
 
     else:
         raise TypeError(values.dtype)
@@ -431,40 +373,51 @@ cpdef ismember(ndarray[htfunc_t] arr, ndarray[htfunc_t] values):
         raise TypeError(values.dtype)
 
 
-cpdef mode(ndarray[htfunc_t] values, bint dropna):
-    if htfunc_t is object:
-        return mode_object(values, dropna)
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def mode(ndarray[htfunc_t] values, bint dropna, const uint8_t[:] mask=None):
+    # TODO(cython3): use const htfunct_t[:]
 
-    elif htfunc_t is int8_t:
-        return mode_int8(values, dropna)
-    elif htfunc_t is int16_t:
-        return mode_int16(values, dropna)
-    elif htfunc_t is int32_t:
-        return mode_int32(values, dropna)
-    elif htfunc_t is int64_t:
-        return mode_int64(values, dropna)
+    cdef:
+        ndarray[htfunc_t] keys
+        ndarray[htfunc_t] modes
 
-    elif htfunc_t is uint8_t:
-        return mode_uint8(values, dropna)
-    elif htfunc_t is uint16_t:
-        return mode_uint16(values, dropna)
-    elif htfunc_t is uint32_t:
-        return mode_uint32(values, dropna)
-    elif htfunc_t is uint64_t:
-        return mode_uint64(values, dropna)
+        int64_t[::1] counts
+        int64_t count, max_count = -1
+        Py_ssize_t nkeys, k, j = 0
 
-    elif htfunc_t is float64_t:
-        return mode_float64(values, dropna)
-    elif htfunc_t is float32_t:
-        return mode_float32(values, dropna)
+    keys, counts = value_count(values, dropna, mask=mask)
+    nkeys = len(keys)
 
-    elif htfunc_t is complex128_t:
-        return mode_complex128(values, dropna)
-    elif htfunc_t is complex64_t:
-        return mode_complex64(values, dropna)
+    modes = np.empty(nkeys, dtype=values.dtype)
+
+    if htfunc_t is not object:
+        with nogil:
+            for k in range(nkeys):
+                count = counts[k]
+                if count == max_count:
+                    j += 1
+                elif count > max_count:
+                    max_count = count
+                    j = 0
+                else:
+                    continue
 
+                modes[j] = keys[k]
     else:
-        raise TypeError(values.dtype)
+        for k in range(nkeys):
+            count = counts[k]
+            if count == max_count:
+                j += 1
+            elif count > max_count:
+                max_count = count
+                j = 0
+            else:
+                continue
+
+            modes[j] = keys[k]
+
+    return modes[:j + 1]
 
 
 {{py:
diff --git a/pandas/_libs/index.pyi b/pandas/_libs/index.pyi
index 446a980487cde..575f83847b1b6 100644
--- a/pandas/_libs/index.pyi
+++ b/pandas/_libs/index.pyi
@@ -3,6 +3,7 @@ import numpy as np
 from pandas._typing import npt
 
 from pandas import MultiIndex
+from pandas.core.arrays import ExtensionArray
 
 class IndexEngine:
     over_size_threshold: bool
@@ -29,6 +30,8 @@ class IndexEngine:
 
 class Float64Engine(IndexEngine): ...
 class Float32Engine(IndexEngine): ...
+class Complex128Engine(IndexEngine): ...
+class Complex64Engine(IndexEngine): ...
 class Int64Engine(IndexEngine): ...
 class Int32Engine(IndexEngine): ...
 class Int16Engine(IndexEngine): ...
@@ -41,6 +44,7 @@ class ObjectEngine(IndexEngine): ...
 class DatetimeEngine(Int64Engine): ...
 class TimedeltaEngine(DatetimeEngine): ...
 class PeriodEngine(Int64Engine): ...
+class BoolEngine(UInt8Engine): ...
 
 class BaseMultiIndexCodesEngine:
     levels: list[np.ndarray]
@@ -63,3 +67,21 @@ class BaseMultiIndexCodesEngine:
         method: str,
         limit: int | None,
     ) -> npt.NDArray[np.intp]: ...
+
+class ExtensionEngine:
+    def __init__(self, values: ExtensionArray): ...
+    def __contains__(self, val: object) -> bool: ...
+    def get_loc(self, val: object) -> int | slice | np.ndarray: ...
+    def get_indexer(self, values: np.ndarray) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self,
+        targets: np.ndarray,
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+    @property
+    def is_unique(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    @property
+    def is_monotonic_decreasing(self) -> bool: ...
+    def sizeof(self, deep: bool = ...) -> int: ...
+    def clear_mapping(self): ...
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index c3b86165e6d2c..617760c2981c4 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -128,10 +128,12 @@ cdef class IndexEngine:
         self._np_type = values.dtype.type
 
     def __contains__(self, val: object) -> bool:
-        # We assume before we get here:
-        #  - val is hashable
-        self._ensure_mapping_populated()
-        return val in self.mapping
+        hash(val)
+        try:
+            self.get_loc(val)
+        except KeyError:
+            return False
+        return True
 
     cpdef get_loc(self, object val):
         # -> Py_ssize_t | slice | ndarray[bool]
@@ -141,7 +143,7 @@ cdef class IndexEngine:
         if is_definitely_invalid_key(val):
             raise TypeError(f"'{val}' is an invalid key")
 
-        self._check_type(val)
+        val = self._check_type(val)
 
         if self.over_size_threshold and self.is_monotonic_increasing:
             if not self.is_unique:
@@ -270,6 +272,7 @@ cdef class IndexEngine:
 
     cdef _check_type(self, object val):
         hash(val)
+        return val
 
     @property
     def is_mapping_populated(self) -> bool:
@@ -797,3 +800,281 @@ cdef class BaseMultiIndexCodesEngine:
 
 # Generated from template.
 include "index_class_helper.pxi"
+
+
+cdef class BoolEngine(UInt8Engine):
+    cdef _check_type(self, object val):
+        if not util.is_bool_object(val):
+            raise KeyError(val)
+        return <uint8_t>val
+
+
+@cython.internal
+@cython.freelist(32)
+cdef class SharedEngine:
+    cdef readonly:
+        object values  # ExtensionArray
+        bint over_size_threshold
+
+    cdef:
+        bint unique, monotonic_inc, monotonic_dec
+        bint need_monotonic_check, need_unique_check
+
+    def __contains__(self, val: object) -> bool:
+        # We assume before we get here:
+        #  - val is hashable
+        try:
+            self.get_loc(val)
+            return True
+        except KeyError:
+            return False
+
+    def clear_mapping(self):
+        # for compat with IndexEngine
+        pass
+
+    @property
+    def is_unique(self) -> bool:
+        if self.need_unique_check:
+            arr = self.values.unique()
+            self.unique = len(arr) == len(self.values)
+
+            self.need_unique_check = False
+        return self.unique
+
+    cdef _do_monotonic_check(self):
+        raise NotImplementedError
+
+    @property
+    def is_monotonic_increasing(self) -> bool:
+        if self.need_monotonic_check:
+            self._do_monotonic_check()
+
+        return self.monotonic_inc == 1
+
+    @property
+    def is_monotonic_decreasing(self) -> bool:
+        if self.need_monotonic_check:
+            self._do_monotonic_check()
+
+        return self.monotonic_dec == 1
+
+    cdef _call_monotonic(self, values):
+        return algos.is_monotonic(values, timelike=False)
+
+    def sizeof(self, deep: bool = False) -> int:
+        """ return the sizeof our mapping """
+        return 0
+
+    def __sizeof__(self) -> int:
+        return self.sizeof()
+
+    cdef _check_type(self, object obj):
+        raise NotImplementedError
+
+    cpdef get_loc(self, object val):
+        # -> Py_ssize_t | slice | ndarray[bool]
+        cdef:
+            Py_ssize_t loc
+
+        if is_definitely_invalid_key(val):
+            raise TypeError(f"'{val}' is an invalid key")
+
+        self._check_type(val)
+
+        if self.over_size_threshold and self.is_monotonic_increasing:
+            if not self.is_unique:
+                return self._get_loc_duplicates(val)
+
+            values = self.values
+
+            loc = self._searchsorted_left(val)
+            if loc >= len(values):
+                raise KeyError(val)
+            if values[loc] != val:
+                raise KeyError(val)
+            return loc
+
+        if not self.unique:
+            return self._get_loc_duplicates(val)
+
+        return self._get_loc_duplicates(val)
+
+    cdef inline _get_loc_duplicates(self, object val):
+        # -> Py_ssize_t | slice | ndarray[bool]
+        cdef:
+            Py_ssize_t diff
+
+        if self.is_monotonic_increasing:
+            values = self.values
+            try:
+                left = values.searchsorted(val, side='left')
+                right = values.searchsorted(val, side='right')
+            except TypeError:
+                # e.g. GH#29189 get_loc(None) with a Float64Index
+                raise KeyError(val)
+
+            diff = right - left
+            if diff == 0:
+                raise KeyError(val)
+            elif diff == 1:
+                return left
+            else:
+                return slice(left, right)
+
+        return self._maybe_get_bool_indexer(val)
+
+    cdef Py_ssize_t _searchsorted_left(self, val) except? -1:
+        """
+        See ObjectEngine._searchsorted_left.__doc__.
+        """
+        try:
+            loc = self.values.searchsorted(val, side="left")
+        except TypeError as err:
+            # GH#35788 e.g. val=None with float64 values
+            raise KeyError(val)
+        return loc
+
+    cdef ndarray _get_bool_indexer(self, val):
+        raise NotImplementedError
+
+    cdef _maybe_get_bool_indexer(self, object val):
+        # Returns ndarray[bool] or int
+        cdef:
+            ndarray[uint8_t, ndim=1, cast=True] indexer
+
+        indexer = self._get_bool_indexer(val)
+        return _unpack_bool_indexer(indexer, val)
+
+    def get_indexer(self, values) -> np.ndarray:
+        # values : type(self.values)
+        # Note: we only get here with self.is_unique
+        cdef:
+            Py_ssize_t i, N = len(values)
+
+        res = np.empty(N, dtype=np.intp)
+
+        for i in range(N):
+            val = values[i]
+            try:
+                loc = self.get_loc(val)
+                # Because we are unique, loc should always be an integer
+            except KeyError:
+                loc = -1
+            else:
+                assert util.is_integer_object(loc), (loc, val)
+            res[i] = loc
+
+        return res
+
+    def get_indexer_non_unique(self, targets):
+        """
+        Return an indexer suitable for taking from a non unique index
+        return the labels in the same order as the target
+        and a missing indexer into the targets (which correspond
+        to the -1 indices in the results
+        Parameters
+        ----------
+        targets : type(self.values)
+        Returns
+        -------
+        indexer : np.ndarray[np.intp]
+        missing : np.ndarray[np.intp]
+        """
+        cdef:
+            Py_ssize_t i, N = len(targets)
+
+        indexer = []
+        missing = []
+
+        # See also IntervalIndex.get_indexer_pointwise
+        for i in range(N):
+            val = targets[i]
+
+            try:
+                locs = self.get_loc(val)
+            except KeyError:
+                locs = np.array([-1], dtype=np.intp)
+                missing.append(i)
+            else:
+                if isinstance(locs, slice):
+                    # Only needed for get_indexer_non_unique
+                    locs = np.arange(locs.start, locs.stop, locs.step, dtype=np.intp)
+                elif util.is_integer_object(locs):
+                    locs = np.array([locs], dtype=np.intp)
+                else:
+                    assert locs.dtype.kind == "b"
+                    locs = locs.nonzero()[0]
+
+            indexer.append(locs)
+
+        try:
+            indexer = np.concatenate(indexer, dtype=np.intp)
+        except TypeError:
+            # numpy<1.20 doesn't accept dtype keyword
+            indexer = np.concatenate(indexer).astype(np.intp, copy=False)
+        missing = np.array(missing, dtype=np.intp)
+
+        return indexer, missing
+
+
+cdef class ExtensionEngine(SharedEngine):
+    def __init__(self, values: "ExtensionArray"):
+        self.values = values
+
+        self.over_size_threshold = len(values) >= _SIZE_CUTOFF
+        self.need_unique_check = True
+        self.need_monotonic_check = True
+        self.need_unique_check = True
+
+    cdef _do_monotonic_check(self):
+        cdef:
+            bint is_unique
+
+        values = self.values
+        if values._hasna:
+            self.monotonic_inc = 0
+            self.monotonic_dec = 0
+
+            nunique = len(values.unique())
+            self.unique = nunique == len(values)
+            self.need_unique_check = 0
+            return
+
+        try:
+            ranks = values._rank()
+
+        except TypeError:
+            self.monotonic_inc = 0
+            self.monotonic_dec = 0
+            is_unique = 0
+        else:
+            self.monotonic_inc, self.monotonic_dec, is_unique = \
+                self._call_monotonic(ranks)
+
+        self.need_monotonic_check = 0
+
+        # we can only be sure of uniqueness if is_unique=1
+        if is_unique:
+            self.unique = 1
+            self.need_unique_check = 0
+
+    cdef ndarray _get_bool_indexer(self, val):
+        if checknull(val):
+            return self.values.isna()
+
+        try:
+            return self.values == val
+        except TypeError:
+            # e.g. if __eq__ returns a BooleanArray instead of ndarray[bool]
+            try:
+                return (self.values == val).to_numpy(dtype=bool, na_value=False)
+            except (TypeError, AttributeError) as err:
+                # e.g. (self.values == val) returned a bool
+                #  see test_get_loc_generator[string[pyarrow]]
+                # e.g. self.value == val raises TypeError bc generator has no len
+                #  see test_get_loc_generator[string[python]]
+                raise KeyError from err
+
+    cdef _check_type(self, object val):
+        hash(val)
diff --git a/pandas/_libs/index_class_helper.pxi.in b/pandas/_libs/index_class_helper.pxi.in
index 7a2bbec96e413..b9c02ba64f69c 100644
--- a/pandas/_libs/index_class_helper.pxi.in
+++ b/pandas/_libs/index_class_helper.pxi.in
@@ -21,6 +21,8 @@ dtypes = [('Float64', 'float64'),
           ('UInt32', 'uint32'),
           ('UInt16', 'uint16'),
           ('UInt8', 'uint8'),
+          ('Complex64', 'complex64'),
+          ('Complex128', 'complex128'),
           ]
 }}
 
@@ -33,19 +35,31 @@ cdef class {{name}}Engine(IndexEngine):
         return _hash.{{name}}HashTable(n)
 
     cdef _check_type(self, object val):
-    {{if name not in {'Float64', 'Float32'} }}
+    {{if name not in {'Float64', 'Float32', 'Complex64', 'Complex128'} }}
         if not util.is_integer_object(val):
+            if util.is_float_object(val):
+                # Make sure Int64Index.get_loc(2.0) works
+                if val.is_integer():
+                    return int(val)
             raise KeyError(val)
         {{if name.startswith("U")}}
         if val < 0:
             # cannot have negative values with unsigned int dtype
             raise KeyError(val)
         {{endif}}
-    {{else}}
+    {{elif name not in {'Complex64', 'Complex128'} }}
         if not util.is_integer_object(val) and not util.is_float_object(val):
             # in particular catch bool and avoid casting True -> 1.0
             raise KeyError(val)
+    {{else}}
+        if (not util.is_integer_object(val)
+            and not util.is_float_object(val)
+            and not util.is_complex_object(val)
+        ):
+            # in particular catch bool and avoid casting True -> 1.0
+            raise KeyError(val)
     {{endif}}
+        return val
 
 
 {{endfor}}
diff --git a/pandas/_libs/indexing.pyi b/pandas/_libs/indexing.pyi
new file mode 100644
index 0000000000000..b219f991f2362
--- /dev/null
+++ b/pandas/_libs/indexing.pyi
@@ -0,0 +1,17 @@
+from typing import (
+    Generic,
+    TypeVar,
+)
+
+from pandas.core.indexing import IndexingMixin
+
+_IndexingMixinT = TypeVar("_IndexingMixinT", bound=IndexingMixin)
+
+class NDFrameIndexerBase(Generic[_IndexingMixinT]):
+    name: str
+    # in practise obj is either a DataFrame or a Series
+    obj: _IndexingMixinT
+
+    def __init__(self, name: str, obj: _IndexingMixinT) -> None: ...
+    @property
+    def ndim(self) -> int: ...
diff --git a/pandas/_libs/indexing.pyx b/pandas/_libs/indexing.pyx
index 181de174c53fb..c274b28b7559a 100644
--- a/pandas/_libs/indexing.pyx
+++ b/pandas/_libs/indexing.pyx
@@ -2,21 +2,24 @@ cdef class NDFrameIndexerBase:
     """
     A base class for _NDFrameIndexer for fast instantiation and attribute access.
     """
+    cdef:
+        Py_ssize_t _ndim
+
     cdef public:
         str name
-        object obj, _ndim
+        object obj
 
     def __init__(self, name: str, obj):
         self.obj = obj
         self.name = name
-        self._ndim = None
+        self._ndim = -1
 
     @property
     def ndim(self) -> int:
         # Delay `ndim` instantiation until required as reading it
         # from `obj` isn't entirely cheap.
         ndim = self._ndim
-        if ndim is None:
+        if ndim == -1:
             ndim = self._ndim = self.obj.ndim
             if ndim > 2:
                 raise ValueError(  # pragma: no cover
diff --git a/pandas/_libs/internals.pyi b/pandas/_libs/internals.pyi
index 6a90fbc729580..201c7b7b565cc 100644
--- a/pandas/_libs/internals.pyi
+++ b/pandas/_libs/internals.pyi
@@ -32,7 +32,7 @@ def update_blklocs_and_blknos(
     loc: int,
     nblocks: int,
 ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
-
+@final
 class BlockPlacement:
     def __init__(self, val: int | slice | np.ndarray): ...
     @property
diff --git a/pandas/_libs/internals.pyx b/pandas/_libs/internals.pyx
index ac423ef6c0ca2..ded161c70f121 100644
--- a/pandas/_libs/internals.pyx
+++ b/pandas/_libs/internals.pyx
@@ -1,9 +1,9 @@
 from collections import defaultdict
+import weakref
 
-import cython
-from cython import Py_ssize_t
-
+cimport cython
 from cpython.slice cimport PySlice_GetIndicesEx
+from cython cimport Py_ssize_t
 
 
 cdef extern from "Python.h":
@@ -470,12 +470,14 @@ def get_blkno_indexers(
 
     n = blknos.shape[0]
     result = list()
+
+    if n == 0:
+        return result
+
     start = 0
     cur_blkno = blknos[start]
 
-    if n == 0:
-        pass
-    elif group is False:
+    if group is False:
         for i in range(1, n):
             if blknos[i] != cur_blkno:
                 result.append((cur_blkno, slice(start, i)))
@@ -544,7 +546,7 @@ cpdef update_blklocs_and_blknos(
     """
     cdef:
         Py_ssize_t i
-        cnp.npy_intp length = len(blklocs) + 1
+        cnp.npy_intp length = blklocs.shape[0] + 1
         ndarray[intp_t, ndim=1] new_blklocs, new_blknos
 
     # equiv: new_blklocs = np.empty(length, dtype=np.intp)
@@ -673,8 +675,10 @@ cdef class BlockManager:
         public list axes
         public bint _known_consolidated, _is_consolidated
         public ndarray _blknos, _blklocs
+        public list refs
+        public object parent
 
-    def __cinit__(self, blocks=None, axes=None, verify_integrity=True):
+    def __cinit__(self, blocks=None, axes=None, refs=None, parent=None, verify_integrity=True):
         # None as defaults for unpickling GH#42345
         if blocks is None:
             # This adds 1-2 microseconds to DataFrame(np.array([]))
@@ -686,6 +690,8 @@ cdef class BlockManager:
 
         self.blocks = blocks
         self.axes = axes.copy()  # copy to make sure we are not remotely-mutable
+        self.refs = refs
+        self.parent = parent
 
         # Populate known_consolidate, blknos, and blklocs lazily
         self._known_consolidated = False
@@ -794,12 +800,16 @@ cdef class BlockManager:
             ndarray blknos, blklocs
 
         nbs = []
+        nrefs = []
         for blk in self.blocks:
             nb = blk.getitem_block_index(slobj)
             nbs.append(nb)
+            nrefs.append(weakref.ref(blk))
 
         new_axes = [self.axes[0], self.axes[1]._getitem_slice(slobj)]
-        mgr = type(self)(tuple(nbs), new_axes, verify_integrity=False)
+        mgr = type(self)(
+            tuple(nbs), new_axes, nrefs, parent=self, verify_integrity=False
+        )
 
         # We can avoid having to rebuild blklocs/blknos
         blklocs = self._blklocs
@@ -812,7 +822,7 @@ cdef class BlockManager:
     def get_slice(self, slobj: slice, axis: int = 0) -> BlockManager:
 
         if axis == 0:
-            new_blocks = self._slice_take_blocks_ax0(slobj)
+            new_blocks, new_refs = self._slice_take_blocks_ax0(slobj)
         elif axis == 1:
             return self._get_index_slice(slobj)
         else:
@@ -821,4 +831,6 @@ cdef class BlockManager:
         new_axes = list(self.axes)
         new_axes[axis] = new_axes[axis]._getitem_slice(slobj)
 
-        return type(self)(tuple(new_blocks), new_axes, verify_integrity=False)
+        return type(self)(
+            tuple(new_blocks), new_axes, new_refs, parent=self, verify_integrity=False
+        )
diff --git a/pandas/_libs/interval.pyi b/pandas/_libs/interval.pyi
new file mode 100644
index 0000000000000..4c36246e04d23
--- /dev/null
+++ b/pandas/_libs/interval.pyi
@@ -0,0 +1,174 @@
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+
+from pandas._typing import (
+    IntervalClosedType,
+    Timedelta,
+    Timestamp,
+)
+
+VALID_CLOSED: frozenset[str]
+
+_OrderableScalarT = TypeVar("_OrderableScalarT", int, float)
+_OrderableTimesT = TypeVar("_OrderableTimesT", Timestamp, Timedelta)
+_OrderableT = TypeVar("_OrderableT", int, float, Timestamp, Timedelta)
+
+class _LengthDescriptor:
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableScalarT], owner: Any
+    ) -> _OrderableScalarT: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> Timedelta: ...
+
+class _MidDescriptor:
+    @overload
+    def __get__(self, instance: Interval[_OrderableScalarT], owner: Any) -> float: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> _OrderableTimesT: ...
+
+class IntervalMixin:
+    @property
+    def closed_left(self) -> bool: ...
+    @property
+    def closed_right(self) -> bool: ...
+    @property
+    def open_left(self) -> bool: ...
+    @property
+    def open_right(self) -> bool: ...
+    @property
+    def is_empty(self) -> bool: ...
+    def _check_closed_matches(self, other: IntervalMixin, name: str = ...) -> None: ...
+
+class Interval(IntervalMixin, Generic[_OrderableT]):
+    @property
+    def left(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def right(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def closed(self) -> IntervalClosedType: ...
+    mid: _MidDescriptor
+    length: _LengthDescriptor
+    def __init__(
+        self,
+        left: _OrderableT,
+        right: _OrderableT,
+        closed: IntervalClosedType = ...,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __contains__(
+        self: Interval[Timedelta], key: Timedelta | Interval[Timedelta]
+    ) -> bool: ...
+    @overload
+    def __contains__(
+        self: Interval[Timestamp], key: Timestamp | Interval[Timestamp]
+    ) -> bool: ...
+    @overload
+    def __contains__(
+        self: Interval[_OrderableScalarT],
+        key: _OrderableScalarT | Interval[_OrderableScalarT],
+    ) -> bool: ...
+    @overload
+    def __add__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __add__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __add__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __radd__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __radd__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __radd__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __sub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __sub__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __sub__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __rsub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __rsub__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __rsub__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __mul__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __mul__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __rmul__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __rmul__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __truediv__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __truediv__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __floordiv__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __floordiv__(self: Interval[float], y: float) -> Interval[float]: ...
+    def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ...
+
+def intervals_to_interval_bounds(
+    intervals: np.ndarray, validate_closed: bool = ...
+) -> tuple[np.ndarray, np.ndarray, str]: ...
+
+class IntervalTree(IntervalMixin):
+    def __init__(
+        self,
+        left: np.ndarray,
+        right: np.ndarray,
+        closed: IntervalClosedType = ...,
+        leaf_size: int = ...,
+    ) -> None: ...
+    @property
+    def mid(self) -> np.ndarray: ...
+    @property
+    def length(self) -> np.ndarray: ...
+    def get_indexer(self, target) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self, target
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+    _na_count: int
+    @property
+    def is_overlapping(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    def clear_mapping(self) -> None: ...
diff --git a/pandas/_libs/interval.pyx b/pandas/_libs/interval.pyx
index aba635e19995a..67c92a0f5df23 100644
--- a/pandas/_libs/interval.pyx
+++ b/pandas/_libs/interval.pyx
@@ -1,3 +1,4 @@
+import inspect
 import numbers
 from operator import (
     le,
@@ -5,12 +6,13 @@ from operator import (
 )
 
 from cpython.datetime cimport (
-    PyDateTime_IMPORT,
     PyDelta_Check,
+    import_datetime,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
+cimport cython
 from cpython.object cimport (
     Py_EQ,
     Py_GE,
@@ -20,9 +22,8 @@ from cpython.object cimport (
     Py_NE,
     PyObject_RichCompare,
 )
+from cython cimport Py_ssize_t
 
-import cython
-from cython import Py_ssize_t
 import numpy as np
 
 cimport numpy as cnp
@@ -95,7 +96,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            True if the Interval is closed on the left-side.
+            True if the Interval is not closed on the left-side.
         """
         return not self.closed_left
 
@@ -109,7 +110,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            True if the Interval is closed on the left-side.
+            True if the Interval is not closed on the left-side.
         """
         return not self.closed_right
 
@@ -259,10 +260,12 @@ cdef class Interval(IntervalMixin):
     >>> iv
     Interval(0, 5, closed='right')
 
-    You can check if an element belongs to it
+    You can check if an element belongs to it, or if it contains another interval:
 
     >>> 2.5 in iv
     True
+    >>> pd.Interval(left=2, right=5, closed='both') in iv
+    True
 
     You can test the bounds (``closed='right'``, so ``0 < x <= 5``):
 
@@ -314,8 +317,9 @@ cdef class Interval(IntervalMixin):
 
     cdef readonly str closed
     """
-    Whether the interval is closed on the left-side, right-side, both or
-    neither.
+    String describing the inclusive side the intervals.
+
+    Either ``left``, ``right``, ``both`` or ``neither``.
     """
 
     def __init__(self, left, right, str closed='right'):
@@ -350,7 +354,17 @@ cdef class Interval(IntervalMixin):
 
     def __contains__(self, key) -> bool:
         if _interval_like(key):
-            raise TypeError("__contains__ not defined for two intervals")
+            key_closed_left = key.closed in ('left', 'both')
+            key_closed_right = key.closed in ('right', 'both')
+            if self.open_left and key_closed_left:
+                left_contained = self.left < key.left
+            else:
+                left_contained = self.left <= key.left
+            if self.open_right and key_closed_right:
+                right_contained = key.right < self.right
+            else:
+                right_contained = key.right <= self.right
+            return left_contained and right_contained
         return ((self.left < key if self.open_left else self.left <= key) and
                 (key < self.right if self.open_right else key <= self.right))
 
@@ -404,6 +418,8 @@ cdef class Interval(IntervalMixin):
         ):
             return Interval(self.left + y, self.right + y, closed=self.closed)
         elif (
+            # __radd__ pattern
+            # TODO(cython3): remove this
             isinstance(y, Interval)
             and (
                 isinstance(self, numbers.Number)
@@ -414,6 +430,15 @@ cdef class Interval(IntervalMixin):
             return Interval(y.left + self, y.right + self, closed=y.closed)
         return NotImplemented
 
+    def __radd__(self, other):
+        if (
+                isinstance(other, numbers.Number)
+                or PyDelta_Check(other)
+                or is_timedelta64_object(other)
+        ):
+            return Interval(self.left + other, self.right + other, closed=self.closed)
+        return NotImplemented
+
     def __sub__(self, y):
         if (
             isinstance(y, numbers.Number)
@@ -427,9 +452,16 @@ cdef class Interval(IntervalMixin):
         if isinstance(y, numbers.Number):
             return Interval(self.left * y, self.right * y, closed=self.closed)
         elif isinstance(y, Interval) and isinstance(self, numbers.Number):
+            # __radd__ semantics
+            # TODO(cython3): remove this
             return Interval(y.left * self, y.right * self, closed=y.closed)
         return NotImplemented
 
+    def __rmul__(self, other):
+        if isinstance(other, numbers.Number):
+            return Interval(self.left * other, self.right * other, closed=self.closed)
+        return NotImplemented
+
     def __truediv__(self, y):
         if isinstance(y, numbers.Number):
             return Interval(self.left / y, self.right / y, closed=self.closed)
diff --git a/pandas/_libs/intervaltree.pxi.in b/pandas/_libs/intervaltree.pxi.in
index 547fcc0b8aa07..e7a310513d2fa 100644
--- a/pandas/_libs/intervaltree.pxi.in
+++ b/pandas/_libs/intervaltree.pxi.in
@@ -324,6 +324,13 @@ cdef class {{dtype_title}}Closed{{closed_title}}IntervalNode(IntervalNode):
             # calculate a pivot so we can create child nodes
             self.is_leaf_node = False
             self.pivot = np.median(left / 2 + right / 2)
+            if np.isinf(self.pivot):
+                self.pivot = cython.cast({{dtype}}_t, 0)
+                if self.pivot > np.max(right):
+                    self.pivot = np.max(left)
+                if self.pivot < np.min(left):
+                    self.pivot = np.min(right)
+
             left_set, right_set, center_set = self.classify_intervals(
                 left, right)
 
diff --git a/pandas/_libs/join.pyi b/pandas/_libs/join.pyi
index a5e91e2ce83eb..11b65b859095f 100644
--- a/pandas/_libs/join.pyi
+++ b/pandas/_libs/join.pyi
@@ -55,7 +55,8 @@ def asof_join_backward_on_X_by_Y(
     left_by_values: np.ndarray,  # by_t[:]
     right_by_values: np.ndarray,  # by_t[:]
     allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
 ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
 def asof_join_forward_on_X_by_Y(
     left_values: np.ndarray,  # asof_t[:]
@@ -63,7 +64,8 @@ def asof_join_forward_on_X_by_Y(
     left_by_values: np.ndarray,  # by_t[:]
     right_by_values: np.ndarray,  # by_t[:]
     allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
 ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
 def asof_join_nearest_on_X_by_Y(
     left_values: np.ndarray,  # asof_t[:]
@@ -71,23 +73,6 @@ def asof_join_nearest_on_X_by_Y(
     left_by_values: np.ndarray,  # by_t[:]
     right_by_values: np.ndarray,  # by_t[:]
     allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
-def asof_join_backward(
-    left_values: np.ndarray,  # asof_t[:]
-    right_values: np.ndarray,  # asof_t[:]
-    allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
-def asof_join_forward(
-    left_values: np.ndarray,  # asof_t[:]
-    right_values: np.ndarray,  # asof_t[:]
-    allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
-def asof_join_nearest(
-    left_values: np.ndarray,  # asof_t[:]
-    right_values: np.ndarray,  # asof_t[:]
-    allow_exact_matches: bool = ...,
-    tolerance: np.number | int | float | None = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
 ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
diff --git a/pandas/_libs/join.pyx b/pandas/_libs/join.pyx
index b908fa2c65e4d..cc7d863bf326c 100644
--- a/pandas/_libs/join.pyx
+++ b/pandas/_libs/join.pyx
@@ -1,5 +1,5 @@
-import cython
-from cython import Py_ssize_t
+cimport cython
+from cython cimport Py_ssize_t
 import numpy as np
 
 cimport numpy as cnp
@@ -93,10 +93,13 @@ def left_outer_join(const intp_t[:] left, const intp_t[:] right,
     with nogil:
         # First pass, determine size of result set, do not use the NA group
         for i in range(1, max_groups + 1):
-            if right_count[i] > 0:
-                count += left_count[i] * right_count[i]
+            lc = left_count[i]
+            rc = right_count[i]
+
+            if rc > 0:
+                count += lc * rc
             else:
-                count += left_count[i]
+                count += lc
 
     left_indexer = np.empty(count, dtype=np.intp)
     right_indexer = np.empty(count, dtype=np.intp)
@@ -230,6 +233,8 @@ cdef void _get_result_indexer(intp_t[::1] sorter, intp_t[::1] indexer) nogil:
         indexer[:] = -1
 
 
+@cython.wraparound(False)
+@cython.boundscheck(False)
 def ffill_indexer(const intp_t[:] indexer) -> np.ndarray:
     cdef:
         Py_ssize_t i, n = len(indexer)
@@ -679,7 +684,8 @@ def asof_join_backward_on_X_by_Y(numeric_t[:] left_values,
                                  by_t[:] left_by_values,
                                  by_t[:] right_by_values,
                                  bint allow_exact_matches=True,
-                                 tolerance=None):
+                                 tolerance=None,
+                                 bint use_hashtable=True):
 
     cdef:
         Py_ssize_t left_pos, right_pos, left_size, right_size, found_right_pos
@@ -701,12 +707,13 @@ def asof_join_backward_on_X_by_Y(numeric_t[:] left_values,
     left_indexer = np.empty(left_size, dtype=np.intp)
     right_indexer = np.empty(left_size, dtype=np.intp)
 
-    if by_t is object:
-        hash_table = PyObjectHashTable(right_size)
-    elif by_t is int64_t:
-        hash_table = Int64HashTable(right_size)
-    elif by_t is uint64_t:
-        hash_table = UInt64HashTable(right_size)
+    if use_hashtable:
+        if by_t is object:
+            hash_table = PyObjectHashTable(right_size)
+        elif by_t is int64_t:
+            hash_table = Int64HashTable(right_size)
+        elif by_t is uint64_t:
+            hash_table = UInt64HashTable(right_size)
 
     right_pos = 0
     for left_pos in range(left_size):
@@ -718,19 +725,25 @@ def asof_join_backward_on_X_by_Y(numeric_t[:] left_values,
         if allow_exact_matches:
             while (right_pos < right_size and
                    right_values[right_pos] <= left_values[left_pos]):
-                hash_table.set_item(right_by_values[right_pos], right_pos)
+                if use_hashtable:
+                    hash_table.set_item(right_by_values[right_pos], right_pos)
                 right_pos += 1
         else:
             while (right_pos < right_size and
                    right_values[right_pos] < left_values[left_pos]):
-                hash_table.set_item(right_by_values[right_pos], right_pos)
+                if use_hashtable:
+                    hash_table.set_item(right_by_values[right_pos], right_pos)
                 right_pos += 1
         right_pos -= 1
 
         # save positions as the desired index
-        by_value = left_by_values[left_pos]
-        found_right_pos = (hash_table.get_item(by_value)
-                           if by_value in hash_table else -1)
+        if use_hashtable:
+            by_value = left_by_values[left_pos]
+            found_right_pos = (hash_table.get_item(by_value)
+                               if by_value in hash_table else -1)
+        else:
+            found_right_pos = right_pos
+
         left_indexer[left_pos] = left_pos
         right_indexer[left_pos] = found_right_pos
 
@@ -748,7 +761,8 @@ def asof_join_forward_on_X_by_Y(numeric_t[:] left_values,
                                 by_t[:] left_by_values,
                                 by_t[:] right_by_values,
                                 bint allow_exact_matches=1,
-                                tolerance=None):
+                                tolerance=None,
+                                bint use_hashtable=True):
 
     cdef:
         Py_ssize_t left_pos, right_pos, left_size, right_size, found_right_pos
@@ -770,12 +784,13 @@ def asof_join_forward_on_X_by_Y(numeric_t[:] left_values,
     left_indexer = np.empty(left_size, dtype=np.intp)
     right_indexer = np.empty(left_size, dtype=np.intp)
 
-    if by_t is object:
-        hash_table = PyObjectHashTable(right_size)
-    elif by_t is int64_t:
-        hash_table = Int64HashTable(right_size)
-    elif by_t is uint64_t:
-        hash_table = UInt64HashTable(right_size)
+    if use_hashtable:
+        if by_t is object:
+            hash_table = PyObjectHashTable(right_size)
+        elif by_t is int64_t:
+            hash_table = Int64HashTable(right_size)
+        elif by_t is uint64_t:
+            hash_table = UInt64HashTable(right_size)
 
     right_pos = right_size - 1
     for left_pos in range(left_size - 1, -1, -1):
@@ -787,19 +802,26 @@ def asof_join_forward_on_X_by_Y(numeric_t[:] left_values,
         if allow_exact_matches:
             while (right_pos >= 0 and
                    right_values[right_pos] >= left_values[left_pos]):
-                hash_table.set_item(right_by_values[right_pos], right_pos)
+                if use_hashtable:
+                    hash_table.set_item(right_by_values[right_pos], right_pos)
                 right_pos -= 1
         else:
             while (right_pos >= 0 and
                    right_values[right_pos] > left_values[left_pos]):
-                hash_table.set_item(right_by_values[right_pos], right_pos)
+                if use_hashtable:
+                    hash_table.set_item(right_by_values[right_pos], right_pos)
                 right_pos -= 1
         right_pos += 1
 
         # save positions as the desired index
-        by_value = left_by_values[left_pos]
-        found_right_pos = (hash_table.get_item(by_value)
-                           if by_value in hash_table else -1)
+        if use_hashtable:
+            by_value = left_by_values[left_pos]
+            found_right_pos = (hash_table.get_item(by_value)
+                               if by_value in hash_table else -1)
+        else:
+            found_right_pos = (right_pos
+                               if right_pos != right_size else -1)
+
         left_indexer[left_pos] = left_pos
         right_indexer[left_pos] = found_right_pos
 
@@ -817,18 +839,15 @@ def asof_join_nearest_on_X_by_Y(numeric_t[:] left_values,
                                 by_t[:] left_by_values,
                                 by_t[:] right_by_values,
                                 bint allow_exact_matches=True,
-                                tolerance=None):
+                                tolerance=None,
+                                bint use_hashtable=True):
 
     cdef:
-        Py_ssize_t left_size, right_size, i
-        ndarray[intp_t] left_indexer, right_indexer, bli, bri, fli, fri
-        numeric_t bdiff, fdiff
-
-    left_size = len(left_values)
-    right_size = len(right_values)
+        ndarray[intp_t] bli, bri, fli, fri
 
-    left_indexer = np.empty(left_size, dtype=np.intp)
-    right_indexer = np.empty(left_size, dtype=np.intp)
+        ndarray[intp_t] left_indexer, right_indexer
+        Py_ssize_t left_size, i
+        numeric_t bdiff, fdiff
 
     # search both forward and backward
     bli, bri = asof_join_backward_on_X_by_Y(
@@ -838,6 +857,7 @@ def asof_join_nearest_on_X_by_Y(numeric_t[:] left_values,
         right_by_values,
         allow_exact_matches,
         tolerance,
+        use_hashtable
     )
     fli, fri = asof_join_forward_on_X_by_Y(
         left_values,
@@ -846,153 +866,14 @@ def asof_join_nearest_on_X_by_Y(numeric_t[:] left_values,
         right_by_values,
         allow_exact_matches,
         tolerance,
+        use_hashtable
     )
 
-    for i in range(len(bri)):
-        # choose timestamp from right with smaller difference
-        if bri[i] != -1 and fri[i] != -1:
-            bdiff = left_values[bli[i]] - right_values[bri[i]]
-            fdiff = right_values[fri[i]] - left_values[fli[i]]
-            right_indexer[i] = bri[i] if bdiff <= fdiff else fri[i]
-        else:
-            right_indexer[i] = bri[i] if bri[i] != -1 else fri[i]
-        left_indexer[i] = bli[i]
-
-    return left_indexer, right_indexer
-
-
-# ----------------------------------------------------------------------
-# asof_join
-# ----------------------------------------------------------------------
-
-def asof_join_backward(numeric_t[:] left_values,
-                       numeric_t[:] right_values,
-                       bint allow_exact_matches=True,
-                       tolerance=None):
-
-    cdef:
-        Py_ssize_t left_pos, right_pos, left_size, right_size
-        ndarray[intp_t] left_indexer, right_indexer
-        bint has_tolerance = False
-        numeric_t tolerance_ = 0
-        numeric_t diff = 0
-
-    # if we are using tolerance, set our objects
-    if tolerance is not None:
-        has_tolerance = True
-        tolerance_ = tolerance
-
+    # choose the smaller timestamp
     left_size = len(left_values)
-    right_size = len(right_values)
-
     left_indexer = np.empty(left_size, dtype=np.intp)
     right_indexer = np.empty(left_size, dtype=np.intp)
 
-    right_pos = 0
-    for left_pos in range(left_size):
-        # restart right_pos if it went negative in a previous iteration
-        if right_pos < 0:
-            right_pos = 0
-
-        # find last position in right whose value is less than left's
-        if allow_exact_matches:
-            while (right_pos < right_size and
-                   right_values[right_pos] <= left_values[left_pos]):
-                right_pos += 1
-        else:
-            while (right_pos < right_size and
-                   right_values[right_pos] < left_values[left_pos]):
-                right_pos += 1
-        right_pos -= 1
-
-        # save positions as the desired index
-        left_indexer[left_pos] = left_pos
-        right_indexer[left_pos] = right_pos
-
-        # if needed, verify that tolerance is met
-        if has_tolerance and right_pos != -1:
-            diff = left_values[left_pos] - right_values[right_pos]
-            if diff > tolerance_:
-                right_indexer[left_pos] = -1
-
-    return left_indexer, right_indexer
-
-
-def asof_join_forward(numeric_t[:] left_values,
-                      numeric_t[:] right_values,
-                      bint allow_exact_matches=True,
-                      tolerance=None):
-
-    cdef:
-        Py_ssize_t left_pos, right_pos, left_size, right_size
-        ndarray[intp_t] left_indexer, right_indexer
-        bint has_tolerance = False
-        numeric_t tolerance_ = 0
-        numeric_t diff = 0
-
-    # if we are using tolerance, set our objects
-    if tolerance is not None:
-        has_tolerance = True
-        tolerance_ = tolerance
-
-    left_size = len(left_values)
-    right_size = len(right_values)
-
-    left_indexer = np.empty(left_size, dtype=np.intp)
-    right_indexer = np.empty(left_size, dtype=np.intp)
-
-    right_pos = right_size - 1
-    for left_pos in range(left_size - 1, -1, -1):
-        # restart right_pos if it went over in a previous iteration
-        if right_pos == right_size:
-            right_pos = right_size - 1
-
-        # find first position in right whose value is greater than left's
-        if allow_exact_matches:
-            while (right_pos >= 0 and
-                   right_values[right_pos] >= left_values[left_pos]):
-                right_pos -= 1
-        else:
-            while (right_pos >= 0 and
-                   right_values[right_pos] > left_values[left_pos]):
-                right_pos -= 1
-        right_pos += 1
-
-        # save positions as the desired index
-        left_indexer[left_pos] = left_pos
-        right_indexer[left_pos] = (right_pos
-                                   if right_pos != right_size else -1)
-
-        # if needed, verify that tolerance is met
-        if has_tolerance and right_pos != right_size:
-            diff = right_values[right_pos] - left_values[left_pos]
-            if diff > tolerance_:
-                right_indexer[left_pos] = -1
-
-    return left_indexer, right_indexer
-
-
-def asof_join_nearest(numeric_t[:] left_values,
-                      numeric_t[:] right_values,
-                      bint allow_exact_matches=True,
-                      tolerance=None):
-
-    cdef:
-        Py_ssize_t left_size, i
-        ndarray[intp_t] left_indexer, right_indexer, bli, bri, fli, fri
-        numeric_t bdiff, fdiff
-
-    left_size = len(left_values)
-
-    left_indexer = np.empty(left_size, dtype=np.intp)
-    right_indexer = np.empty(left_size, dtype=np.intp)
-
-    # search both forward and backward
-    bli, bri = asof_join_backward(left_values, right_values,
-                                  allow_exact_matches, tolerance)
-    fli, fri = asof_join_forward(left_values, right_values,
-                                 allow_exact_matches, tolerance)
-
     for i in range(len(bri)):
         # choose timestamp from right with smaller difference
         if bri[i] != -1 and fri[i] != -1:
diff --git a/pandas/_libs/json.pyi b/pandas/_libs/json.pyi
new file mode 100644
index 0000000000000..8e7ba60ccce24
--- /dev/null
+++ b/pandas/_libs/json.pyi
@@ -0,0 +1,23 @@
+from typing import (
+    Any,
+    Callable,
+)
+
+def dumps(
+    obj: Any,
+    ensure_ascii: bool = ...,
+    double_precision: int = ...,
+    indent: int = ...,
+    orient: str = ...,
+    date_unit: str = ...,
+    iso_dates: bool = ...,
+    default_handler: None
+    | Callable[[Any], str | float | bool | list | dict | None] = ...,
+) -> str: ...
+def loads(
+    s: str,
+    precise_float: bool = ...,
+    numpy: bool = ...,
+    dtype: None = ...,
+    labelled: bool = ...,
+) -> Any: ...
diff --git a/pandas/_libs/lib.pyi b/pandas/_libs/lib.pyi
index a7ebd9d0c77ad..77d3cbe92bef9 100644
--- a/pandas/_libs/lib.pyi
+++ b/pandas/_libs/lib.pyi
@@ -4,6 +4,7 @@
 from typing import (
     Any,
     Callable,
+    Final,
     Generator,
     Hashable,
     Literal,
@@ -23,9 +24,11 @@ ndarray_obj_2d = np.ndarray
 
 from enum import Enum
 
-class NoDefault(Enum): ...
+class _NoDefault(Enum):
+    no_default = ...
 
-no_default: NoDefault
+no_default: Final = _NoDefault.no_default
+NoDefault = Literal[_NoDefault.no_default]
 
 i8max: int
 u8max: int
@@ -157,10 +160,9 @@ def ensure_string_array(
 def infer_datetimelike_array(
     arr: npt.NDArray[np.object_],
 ) -> tuple[str, bool]: ...
-def astype_intsafe(
+def convert_nans_to_NA(
     arr: npt.NDArray[np.object_],
-    new_dtype: np.dtype,
-) -> np.ndarray: ...
+) -> npt.NDArray[np.object_]: ...
 def fast_zip(ndarrays: list) -> npt.NDArray[np.object_]: ...
 
 # TODO: can we be more specific about rows?
@@ -211,7 +213,7 @@ def count_level_2d(
 def get_level_sorter(
     label: np.ndarray,  # const int64_t[:]
     starts: np.ndarray,  # const intp_t[:]
-) -> np.ndarray: ...  #  np.ndarray[np.intp, ndim=1]
+) -> np.ndarray: ...  # np.ndarray[np.intp, ndim=1]
 def generate_bins_dt64(
     values: npt.NDArray[np.int64],
     binner: np.ndarray,  # const int64_t[:]
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 950277ce608eb..d2c2697c05812 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -1,23 +1,26 @@
 from collections import abc
 from decimal import Decimal
 from enum import Enum
+from typing import (
+    Literal,
+    _GenericAlias,
+)
 import warnings
 
-import cython
-from cython import Py_ssize_t
-
+cimport cython
 from cpython.datetime cimport (
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     PyDelta_Check,
     PyTime_Check,
+    import_datetime,
 )
 from cpython.iterator cimport PyIter_Check
 from cpython.number cimport PyNumber_Check
 from cpython.object cimport (
     Py_EQ,
     PyObject_RichCompareBool,
+    PyTypeObject,
 )
 from cpython.ref cimport Py_INCREF
 from cpython.sequence cimport PySequence_Check
@@ -25,9 +28,14 @@ from cpython.tuple cimport (
     PyTuple_New,
     PyTuple_SET_ITEM,
 )
-from cython cimport floating
+from cython cimport (
+    Py_ssize_t,
+    floating,
+)
 
-PyDateTime_IMPORT
+from pandas.util._exceptions import find_stack_level
+
+import_datetime()
 
 import numpy as np
 
@@ -52,6 +60,11 @@ from numpy cimport (
 
 cnp.import_array()
 
+cdef extern from "Python.h":
+    # Note: importing extern-style allows us to declare these as nogil
+    # functions, whereas `from cpython cimport` does not.
+    bint PyObject_TypeCheck(object obj, PyTypeObject* type) nogil
+
 cdef extern from "numpy/arrayobject.h":
     # cython's numpy.dtype specification is incorrect, which leads to
     # errors in issubclass(self.dtype.type, np.bool_), so we directly
@@ -69,6 +82,9 @@ cdef extern from "numpy/arrayobject.h":
             object fields
             tuple names
 
+    PyTypeObject PySignedIntegerArrType_Type
+    PyTypeObject PyUnsignedIntegerArrType_Type
+
 cdef extern from "numpy/ndarrayobject.h":
     bint PyArray_CheckScalar(obj) nogil
 
@@ -97,7 +113,6 @@ from pandas._libs.missing cimport (
     is_matching_na,
     is_null_datetime64,
     is_null_timedelta64,
-    isnaobj,
 )
 from pandas._libs.tslibs.conversion cimport convert_to_tsobject
 from pandas._libs.tslibs.nattype cimport (
@@ -342,6 +357,7 @@ def fast_unique_multiple(list arrays, sort: bool = True):
                 "The values in the array are unorderable. "
                 "Pass `sort=False` to suppress this warning.",
                 RuntimeWarning,
+                stacklevel=find_stack_level(),
             )
             pass
 
@@ -649,24 +665,38 @@ def array_equivalent_object(left: object[:], right: object[:]) -> bool:
     return True
 
 
+ctypedef fused ndarr_object:
+    ndarray[object, ndim=1]
+    ndarray[object, ndim=2]
+
+# TODO: get rid of this in StringArray and modify
+#  and go through ensure_string_array instead
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def astype_intsafe(ndarray[object] arr, cnp.dtype new_dtype) -> ndarray:
+def convert_nans_to_NA(ndarr_object arr) -> ndarray:
+    """
+    Helper for StringArray that converts null values that
+    are not pd.NA(e.g. np.nan, None) to pd.NA. Assumes elements
+    have already been validated as null.
+    """
     cdef:
-        Py_ssize_t i, n = len(arr)
+        Py_ssize_t i, m, n
         object val
-        bint is_datelike
-        ndarray result
-
-    is_datelike = new_dtype == 'm8[ns]'
-    result = np.empty(n, dtype=new_dtype)
-    for i in range(n):
-        val = arr[i]
-        if is_datelike and checknull(val):
-            result[i] = NPY_NAT
-        else:
-            result[i] = val
-
+        ndarr_object result
+    result = np.asarray(arr, dtype="object")
+    if arr.ndim == 2:
+        m, n = arr.shape[0], arr.shape[1]
+        for i in range(m):
+            for j in range(n):
+                val = arr[i, j]
+                if not isinstance(val, str):
+                    result[i, j] = <object>C_NA
+    else:
+        n = len(arr)
+        for i in range(n):
+            val = arr[i]
+            if not isinstance(val, str):
+                result[i] = <object>C_NA
     return result
 
 
@@ -714,7 +744,7 @@ cpdef ndarray[object] ensure_string_array(
             return out
 
         arr = arr.to_numpy()
-    elif not isinstance(arr, np.ndarray):
+    elif not util.is_array(arr):
         arr = np.array(arr, dtype="object")
 
     result = np.asarray(arr, dtype="object")
@@ -729,7 +759,7 @@ cpdef ndarray[object] ensure_string_array(
             continue
 
         if not checknull(val):
-            if not isinstance(val, np.floating):
+            if not util.is_float_object(val):
                 # f"{val}" is faster than str(val)
                 result[i] = f"{val}"
             else:
@@ -859,7 +889,7 @@ def get_level_sorter(
     """
     cdef:
         Py_ssize_t i, l, r
-        ndarray[intp_t, ndim=1] out = np.empty(len(codes), dtype=np.intp)
+        ndarray[intp_t, ndim=1] out = cnp.PyArray_EMPTY(1, codes.shape, cnp.NPY_INTP, 0)
 
     for i in range(len(starts) - 1):
         l, r = starts[i], starts[i + 1]
@@ -1109,7 +1139,8 @@ cdef inline bint c_is_list_like(object obj, bint allow_sets) except -1:
         # equiv: `isinstance(obj, abc.Iterable)`
         getattr(obj, "__iter__", None) is not None and not isinstance(obj, type)
         # we do not count strings/unicode/bytes as list-like
-        and not isinstance(obj, (str, bytes))
+        # exclude Generic types that have __iter__
+        and not isinstance(obj, (str, bytes, _GenericAlias))
         # exclude zero-dimensional duck-arrays, effectively scalars
         and not (hasattr(obj, "ndim") and obj.ndim == 0)
         # exclude sets if allow_sets is False
@@ -1268,9 +1299,9 @@ cdef class Seen:
         In addition to setting a flag that an integer was seen, we
         also set two flags depending on the type of integer seen:
 
-        1) sint_ : a negative (signed) number in the
+        1) sint_ : a signed numpy integer type or a negative (signed) number in the
                    range of [-2**63, 0) was encountered
-        2) uint_ : a positive number in the range of
+        2) uint_ : an unsigned numpy integer type or a positive number in the range of
                    [2**63, 2**64) was encountered
 
         Parameters
@@ -1279,8 +1310,18 @@ cdef class Seen:
             Value with which to set the flags.
         """
         self.int_ = True
-        self.sint_ = self.sint_ or (oINT64_MIN <= val < 0)
-        self.uint_ = self.uint_ or (oINT64_MAX < val <= oUINT64_MAX)
+        self.sint_ = (
+            self.sint_
+            or (oINT64_MIN <= val < 0)
+            # Cython equivalent of `isinstance(val, np.signedinteger)`
+            or PyObject_TypeCheck(val, &PySignedIntegerArrType_Type)
+        )
+        self.uint_ = (
+            self.uint_
+            or (oINT64_MAX < val <= oUINT64_MAX)
+            # Cython equivalent of `isinstance(val, np.unsignedinteger)`
+            or PyObject_TypeCheck(val, &PyUnsignedIntegerArrType_Type)
+        )
 
     @property
     def numeric_(self):
@@ -1313,8 +1354,7 @@ cdef object _try_infer_map(object dtype):
 
 def infer_dtype(value: object, skipna: bool = True) -> str:
     """
-    Efficiently infer the type of a passed val, or list-like
-    array of values. Return a string describing the type.
+    Return a string label of the type of a scalar or list-like of values.
 
     Parameters
     ----------
@@ -1420,6 +1460,7 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
         ndarray values
         bint seen_pdnat = False
         bint seen_val = False
+        flatiter it
 
     if util.is_array(value):
         values = value
@@ -1443,6 +1484,8 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
     else:
         if not isinstance(value, list):
             value = list(value)
+        if not value:
+            return "empty"
 
         from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
         values = construct_1d_object_array_from_listlike(value)
@@ -1457,24 +1500,22 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
         # This should not be reached
         values = values.astype(object)
 
-    # for f-contiguous array 1000 x 1000, passing order="K" gives 5000x speedup
-    values = values.ravel(order="K")
-
-    if skipna:
-        values = values[~isnaobj(values)]
-
     n = cnp.PyArray_SIZE(values)
     if n == 0:
         return "empty"
 
     # Iterate until we find our first valid value. We will use this
     #  value to decide which of the is_foo_array functions to call.
+    it = PyArray_IterNew(values)
     for i in range(n):
-        val = values[i]
+        # The PyArray_GETITEM and PyArray_ITER_NEXT are faster
+        #  equivalents to `val = values[i]`
+        val = PyArray_GETITEM(values, PyArray_ITER_DATA(it))
+        PyArray_ITER_NEXT(it)
 
         # do not use checknull to keep
         # np.datetime64('nat') and np.timedelta64('nat')
-        if val is None or util.is_nan(val):
+        if val is None or util.is_nan(val) or val is C_NA:
             pass
         elif val is NaT:
             seen_pdnat = True
@@ -1486,23 +1527,25 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
     if seen_val is False and seen_pdnat is True:
         return "datetime"
         # float/object nan is handled in latter logic
+    if seen_val is False and skipna:
+        return "empty"
 
     if util.is_datetime64_object(val):
-        if is_datetime64_array(values):
+        if is_datetime64_array(values, skipna=skipna):
             return "datetime64"
 
     elif is_timedelta(val):
-        if is_timedelta_or_timedelta64_array(values):
+        if is_timedelta_or_timedelta64_array(values, skipna=skipna):
             return "timedelta"
 
     elif util.is_integer_object(val):
         # ordering matters here; this check must come after the is_timedelta
         #  check otherwise numpy timedelta64 objects would come through here
 
-        if is_integer_array(values):
+        if is_integer_array(values, skipna=skipna):
             return "integer"
-        elif is_integer_float_array(values):
-            if is_integer_na_array(values):
+        elif is_integer_float_array(values, skipna=skipna):
+            if is_integer_na_array(values, skipna=skipna):
                 return "integer-na"
             else:
                 return "mixed-integer-float"
@@ -1523,7 +1566,7 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
             return "time"
 
     elif is_decimal(val):
-        if is_decimal_array(values):
+        if is_decimal_array(values, skipna=skipna):
             return "decimal"
 
     elif util.is_complex_object(val):
@@ -1533,8 +1576,8 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
     elif util.is_float_object(val):
         if is_float_array(values):
             return "floating"
-        elif is_integer_float_array(values):
-            if is_integer_na_array(values):
+        elif is_integer_float_array(values, skipna=skipna):
+            if is_integer_na_array(values, skipna=skipna):
                 return "integer-na"
             else:
                 return "mixed-integer-float"
@@ -1552,15 +1595,18 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
             return "bytes"
 
     elif is_period_object(val):
-        if is_period_array(values):
+        if is_period_array(values, skipna=skipna):
             return "period"
 
     elif is_interval(val):
         if is_interval_array(values):
             return "interval"
 
+    cnp.PyArray_ITER_RESET(it)
     for i in range(n):
-        val = values[i]
+        val = PyArray_GETITEM(values, PyArray_ITER_DATA(it))
+        PyArray_ITER_NEXT(it)
+
         if util.is_integer_object(val):
             return "mixed-integer"
 
@@ -1789,10 +1835,11 @@ cdef class IntegerValidator(Validator):
 
 
 # Note: only python-exposed for tests
-cpdef bint is_integer_array(ndarray values):
+cpdef bint is_integer_array(ndarray values, bint skipna=True):
     cdef:
         IntegerValidator validator = IntegerValidator(len(values),
-                                                      values.dtype)
+                                                      values.dtype,
+                                                      skipna=skipna)
     return validator.validate(values)
 
 
@@ -1803,10 +1850,10 @@ cdef class IntegerNaValidator(Validator):
                 or (util.is_nan(value) and util.is_float_object(value)))
 
 
-cdef bint is_integer_na_array(ndarray values):
+cdef bint is_integer_na_array(ndarray values, bint skipna=True):
     cdef:
         IntegerNaValidator validator = IntegerNaValidator(len(values),
-                                                          values.dtype)
+                                                          values.dtype, skipna=skipna)
     return validator.validate(values)
 
 
@@ -1819,10 +1866,11 @@ cdef class IntegerFloatValidator(Validator):
         return issubclass(self.dtype.type, np.integer)
 
 
-cdef bint is_integer_float_array(ndarray values):
+cdef bint is_integer_float_array(ndarray values, bint skipna=True):
     cdef:
         IntegerFloatValidator validator = IntegerFloatValidator(len(values),
-                                                                values.dtype)
+                                                                values.dtype,
+                                                                skipna=skipna)
     return validator.validate(values)
 
 
@@ -1866,9 +1914,11 @@ cdef class DecimalValidator(Validator):
         return is_decimal(value)
 
 
-cdef bint is_decimal_array(ndarray values):
+cdef bint is_decimal_array(ndarray values, bint skipna=False):
     cdef:
-        DecimalValidator validator = DecimalValidator(len(values), values.dtype)
+        DecimalValidator validator = DecimalValidator(
+            len(values), values.dtype, skipna=skipna
+        )
     return validator.validate(values)
 
 
@@ -1880,10 +1930,6 @@ cdef class StringValidator(Validator):
     cdef inline bint is_array_typed(self) except -1:
         return issubclass(self.dtype.type, np.str_)
 
-    cdef bint is_valid_null(self, object value) except -1:
-        # We deliberately exclude None / NaN here since StringArray uses NA
-        return value is C_NA
-
 
 cpdef bint is_string_array(ndarray values, bint skipna=False):
     cdef:
@@ -1967,10 +2013,10 @@ cdef class Datetime64Validator(DatetimeValidator):
 
 
 # Note: only python-exposed for tests
-cpdef bint is_datetime64_array(ndarray values):
+cpdef bint is_datetime64_array(ndarray values, bint skipna=True):
     cdef:
         Datetime64Validator validator = Datetime64Validator(len(values),
-                                                            skipna=True)
+                                                            skipna=skipna)
     return validator.validate(values)
 
 
@@ -1982,10 +2028,10 @@ cdef class AnyDatetimeValidator(DatetimeValidator):
         )
 
 
-cdef bint is_datetime_or_datetime64_array(ndarray values):
+cdef bint is_datetime_or_datetime64_array(ndarray values, bint skipna=True):
     cdef:
         AnyDatetimeValidator validator = AnyDatetimeValidator(len(values),
-                                                              skipna=True)
+                                                              skipna=skipna)
     return validator.validate(values)
 
 
@@ -2039,13 +2085,13 @@ cdef class AnyTimedeltaValidator(TimedeltaValidator):
 
 
 # Note: only python-exposed for tests
-cpdef bint is_timedelta_or_timedelta64_array(ndarray values):
+cpdef bint is_timedelta_or_timedelta64_array(ndarray values, bint skipna=True):
     """
     Infer with timedeltas and/or nat/none.
     """
     cdef:
         AnyTimedeltaValidator validator = AnyTimedeltaValidator(len(values),
-                                                                skipna=True)
+                                                                skipna=skipna)
     return validator.validate(values)
 
 
@@ -2075,20 +2121,28 @@ cpdef bint is_time_array(ndarray values, bint skipna=False):
     return validator.validate(values)
 
 
-cdef bint is_period_array(ndarray[object] values):
+# FIXME: actually use skipna
+cdef bint is_period_array(ndarray values, bint skipna=True):
     """
     Is this an ndarray of Period objects (or NaT) with a single `freq`?
     """
+    # values should be object-dtype, but ndarray[object] assumes 1D, while
+    #  this _may_ be 2D.
     cdef:
-        Py_ssize_t i, n = len(values)
+        Py_ssize_t i, N = values.size
         int dtype_code = -10000  # i.e. c_FreqGroup.FR_UND
         object val
+        flatiter it
 
-    if len(values) == 0:
+    if N == 0:
         return False
 
-    for i in range(n):
-        val = values[i]
+    it = PyArray_IterNew(values)
+    for i in range(N):
+        # The PyArray_GETITEM and PyArray_ITER_NEXT are faster
+        #  equivalents to `val = values[i]`
+        val = PyArray_GETITEM(values, PyArray_ITER_DATA(it))
+        PyArray_ITER_NEXT(it)
 
         if is_period_object(val):
             if dtype_code == -10000:
@@ -2229,11 +2283,11 @@ def maybe_convert_numeric(
         int status, maybe_int
         Py_ssize_t i, n = values.size
         Seen seen = Seen(coerce_numeric)
-        ndarray[float64_t, ndim=1] floats = np.empty(n, dtype='f8')
-        ndarray[complex128_t, ndim=1] complexes = np.empty(n, dtype='c16')
-        ndarray[int64_t, ndim=1] ints = np.empty(n, dtype='i8')
-        ndarray[uint64_t, ndim=1] uints = np.empty(n, dtype='u8')
-        ndarray[uint8_t, ndim=1] bools = np.empty(n, dtype='u1')
+        ndarray[float64_t, ndim=1] floats = cnp.PyArray_EMPTY(1, values.shape, cnp.NPY_FLOAT64, 0)
+        ndarray[complex128_t, ndim=1] complexes = cnp.PyArray_EMPTY(1, values.shape, cnp.NPY_COMPLEX128, 0)
+        ndarray[int64_t, ndim=1] ints = cnp.PyArray_EMPTY(1, values.shape, cnp.NPY_INT64, 0)
+        ndarray[uint64_t, ndim=1] uints = cnp.PyArray_EMPTY(1, values.shape, cnp.NPY_UINT64, 0)
+        ndarray[uint8_t, ndim=1] bools = cnp.PyArray_EMPTY(1, values.shape, cnp.NPY_UINT8, 0)
         ndarray[uint8_t, ndim=1] mask = np.zeros(n, dtype="u1")
         float64_t fval
         bint allow_null_in_int = convert_to_masked_nullable
@@ -2445,19 +2499,19 @@ def maybe_convert_objects(ndarray[object] objects,
         ndarray[int64_t] ints
         ndarray[uint64_t] uints
         ndarray[uint8_t] bools
-        int64_t[:]  idatetimes
-        int64_t[:] itimedeltas
+        int64_t[::1]  idatetimes
+        int64_t[::1] itimedeltas
         Seen seen = Seen()
         object val
         float64_t fval, fnan = np.nan
 
     n = len(objects)
 
-    floats = np.empty(n, dtype='f8')
-    complexes = np.empty(n, dtype='c16')
-    ints = np.empty(n, dtype='i8')
-    uints = np.empty(n, dtype='u8')
-    bools = np.empty(n, dtype=np.uint8)
+    floats = cnp.PyArray_EMPTY(1, objects.shape, cnp.NPY_FLOAT64, 0)
+    complexes = cnp.PyArray_EMPTY(1, objects.shape, cnp.NPY_COMPLEX128, 0)
+    ints = cnp.PyArray_EMPTY(1, objects.shape, cnp.NPY_INT64, 0)
+    uints = cnp.PyArray_EMPTY(1, objects.shape, cnp.NPY_UINT64, 0)
+    bools = cnp.PyArray_EMPTY(1, objects.shape, cnp.NPY_UINT8, 0)
     mask = np.full(n, False)
 
     if convert_datetime:
@@ -2515,7 +2569,6 @@ def maybe_convert_objects(ndarray[object] objects,
             floats[i] = <float64_t>val
             complexes[i] = <double complex>val
             if not seen.null_:
-                val = int(val)
                 seen.saw_int(val)
 
                 if ((seen.uint_ and seen.sint_) or
@@ -2759,13 +2812,13 @@ cdef _infer_all_nats(dtype, ndarray datetimes, ndarray timedeltas):
     else:
         # ExtensionDtype
         cls = dtype.construct_array_type()
-        i8vals = np.empty(len(datetimes), dtype="i8")
+        i8vals = cnp.PyArray_EMPTY(1, datetimes.shape, cnp.NPY_INT64, 0)
         i8vals.fill(NPY_NAT)
         result = cls(i8vals, dtype=dtype)
     return result
 
 
-class NoDefault(Enum):
+class _NoDefault(Enum):
     # We make this an Enum
     # 1) because it round-trips through pickle correctly (see GH#40397)
     # 2) because mypy does not understand singletons
@@ -2776,7 +2829,8 @@ class NoDefault(Enum):
 
 
 # Note: no_default is exported to the public API in pandas.api.extensions
-no_default = NoDefault.no_default  # Sentinel indicating the default value.
+no_default = _NoDefault.no_default  # Sentinel indicating the default value.
+NoDefault = Literal[_NoDefault.no_default]
 
 
 @cython.boundscheck(False)
@@ -2862,7 +2916,7 @@ def map_infer(
         object val
 
     n = len(arr)
-    result = np.empty(n, dtype=object)
+    result = cnp.PyArray_EMPTY(1, arr.shape, cnp.NPY_OBJECT, 0)
     for i in range(n):
         if ignore_na and checknull(arr[i]):
             result[i] = arr[i]
@@ -3057,7 +3111,7 @@ cpdef ndarray eq_NA_compat(ndarray[object] arr, object key):
     key is assumed to have `not isna(key)`
     """
     cdef:
-        ndarray[uint8_t, cast=True] result = np.empty(len(arr), dtype=bool)
+        ndarray[uint8_t, cast=True] result = cnp.PyArray_EMPTY(arr.ndim, arr.shape, cnp.NPY_BOOL, 0)
         Py_ssize_t i
         object item
 
diff --git a/pandas/_libs/missing.pyi b/pandas/_libs/missing.pyi
index ab6841e7ddf35..27f227558dee5 100644
--- a/pandas/_libs/missing.pyi
+++ b/pandas/_libs/missing.pyi
@@ -1,7 +1,8 @@
 import numpy as np
 from numpy import typing as npt
 
-class NAType: ...
+class NAType:
+    def __new__(cls, *args, **kwargs): ...
 
 NA: NAType
 
@@ -14,3 +15,4 @@ def checknull(val: object, inf_as_na: bool = ...) -> bool: ...
 def isnaobj(arr: np.ndarray, inf_as_na: bool = ...) -> npt.NDArray[np.bool_]: ...
 def isnaobj2d(arr: np.ndarray, inf_as_na: bool = ...) -> npt.NDArray[np.bool_]: ...
 def is_numeric_na(values: np.ndarray) -> npt.NDArray[np.bool_]: ...
+def is_float_nan(values: np.ndarray) -> npt.NDArray[np.bool_]: ...
diff --git a/pandas/_libs/missing.pyx b/pandas/_libs/missing.pyx
index 585b535775397..9b470e95dc22b 100644
--- a/pandas/_libs/missing.pyx
+++ b/pandas/_libs/missing.pyx
@@ -2,8 +2,8 @@ from decimal import Decimal
 import numbers
 from sys import maxsize
 
-import cython
-from cython import Py_ssize_t
+cimport cython
+from cython cimport Py_ssize_t
 import numpy as np
 
 cimport numpy as cnp
@@ -248,6 +248,31 @@ cdef bint checknull_with_nat_and_na(object obj):
     return checknull_with_nat(obj) or obj is C_NA
 
 
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def is_float_nan(values: ndarray) -> ndarray:
+    """
+    True for elements which correspond to a float nan
+
+    Returns
+    -------
+    ndarray[bool]
+    """
+    cdef:
+        ndarray[uint8_t] result
+        Py_ssize_t i, N
+        object val
+
+    N = len(values)
+    result = np.zeros(N, dtype=np.uint8)
+
+    for i in range(N):
+        val = values[i]
+        if util.is_nan(val):
+            result[i] = True
+    return result.view(bool)
+
+
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def is_numeric_na(values: ndarray) -> ndarray:
@@ -287,7 +312,7 @@ def _create_binary_propagating_op(name, is_divmod=False):
     def method(self, other):
         if (other is C_NA or isinstance(other, str)
                 or isinstance(other, (numbers.Number, np.bool_))
-                or isinstance(other, np.ndarray) and not other.shape):
+                or util.is_array(other) and not other.shape):
             # Need the other.shape clause to handle NumPy scalars,
             # since we do a setitem on `out` below, which
             # won't work for NumPy scalars.
@@ -296,7 +321,7 @@ def _create_binary_propagating_op(name, is_divmod=False):
             else:
                 return NA
 
-        elif isinstance(other, np.ndarray):
+        elif util.is_array(other):
             out = np.empty(other.shape, dtype=object)
             out[:] = NA
 
@@ -408,7 +433,7 @@ class NAType(C_NAType):
                 return type(other)(1)
             else:
                 return NA
-        elif isinstance(other, np.ndarray):
+        elif util.is_array(other):
             return np.where(other == 0, other.dtype.type(1), NA)
 
         return NotImplemented
@@ -421,7 +446,7 @@ class NAType(C_NAType):
                 return other
             else:
                 return NA
-        elif isinstance(other, np.ndarray):
+        elif util.is_array(other):
             return np.where(other == 1, other, NA)
         return NotImplemented
 
diff --git a/pandas/_libs/ops.pyx b/pandas/_libs/ops.pyx
index ac8a7f2cc57f7..308756e378dde 100644
--- a/pandas/_libs/ops.pyx
+++ b/pandas/_libs/ops.pyx
@@ -1,5 +1,6 @@
 import operator
 
+cimport cython
 from cpython.object cimport (
     Py_EQ,
     Py_GE,
@@ -9,9 +10,8 @@ from cpython.object cimport (
     Py_NE,
     PyObject_RichCompareBool,
 )
+from cython cimport Py_ssize_t
 
-import cython
-from cython import Py_ssize_t
 import numpy as np
 
 from numpy cimport (
@@ -194,7 +194,7 @@ def scalar_binop(object[:] values, object val, object op) -> ndarray:
     """
     cdef:
         Py_ssize_t i, n = len(values)
-        object[:] result
+        object[::1] result
         object x
 
     result = np.empty(n, dtype=object)
@@ -231,7 +231,7 @@ def vec_binop(object[:] left, object[:] right, object op) -> ndarray:
     """
     cdef:
         Py_ssize_t i, n = len(left)
-        object[:] result
+        object[::1] result
 
     if n != <Py_ssize_t>len(right):
         raise ValueError(f'Arrays were different lengths: {n} vs {len(right)}')
diff --git a/pandas/_libs/parsers.pyi b/pandas/_libs/parsers.pyi
index 01f5d5802ccd5..6b0bbf183f07e 100644
--- a/pandas/_libs/parsers.pyi
+++ b/pandas/_libs/parsers.pyi
@@ -63,7 +63,6 @@ class TextReader:
         skip_blank_lines: bool = ...,
         encoding_errors: bytes | str = ...,
     ): ...
-    def set_error_bad_lines(self, status: int) -> None: ...
     def set_noconvert(self, i: int) -> None: ...
     def remove_noconvert(self, i: int) -> None: ...
     def close(self) -> None: ...
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 08c885fba172a..c391a82d30c4a 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -1,25 +1,21 @@
 # Copyright (c) 2012, Lambda Foundry, Inc.
 # See LICENSE for the license
+from base64 import decode
+from collections import defaultdict
 from csv import (
     QUOTE_MINIMAL,
     QUOTE_NONE,
     QUOTE_NONNUMERIC,
 )
 from errno import ENOENT
+import inspect
 import sys
 import time
 import warnings
 
-from libc.stdlib cimport free
-from libc.string cimport (
-    strcasecmp,
-    strlen,
-    strncpy,
-)
-
-import cython
-from cython import Py_ssize_t
+from pandas.util._exceptions import find_stack_level
 
+cimport cython
 from cpython.bytes cimport (
     PyBytes_AsString,
     PyBytes_FromString,
@@ -38,6 +34,13 @@ from cpython.unicode cimport (
     PyUnicode_Decode,
     PyUnicode_DecodeUTF8,
 )
+from cython cimport Py_ssize_t
+from libc.stdlib cimport free
+from libc.string cimport (
+    strcasecmp,
+    strlen,
+    strncpy,
+)
 
 
 cdef extern from "Python.h":
@@ -839,7 +842,9 @@ cdef class TextReader:
             status = tokenize_nrows(self.parser, nrows, self.encoding_errors)
 
         if self.parser.warn_msg != NULL:
-            print(self.parser.warn_msg, file=sys.stderr)
+            print(PyUnicode_DecodeUTF8(
+                self.parser.warn_msg, strlen(self.parser.warn_msg),
+                self.encoding_errors), file=sys.stderr)
             free(self.parser.warn_msg)
             self.parser.warn_msg = NULL
 
@@ -868,7 +873,9 @@ cdef class TextReader:
                 status = tokenize_all_rows(self.parser, self.encoding_errors)
 
             if self.parser.warn_msg != NULL:
-                print(self.parser.warn_msg, file=sys.stderr)
+                print(PyUnicode_DecodeUTF8(
+                    self.parser.warn_msg, strlen(self.parser.warn_msg),
+                    self.encoding_errors), file=sys.stderr)
                 free(self.parser.warn_msg)
                 self.parser.warn_msg = NULL
 
@@ -954,11 +961,13 @@ cdef class TextReader:
                     "Defining usecols with out of bounds indices is deprecated "
                     "and will raise a ParserError in a future version.",
                     FutureWarning,
-                    stacklevel=6,
+                    stacklevel=find_stack_level(),
                 )
 
         results = {}
         nused = 0
+        is_default_dict_dtype = isinstance(self.dtype, defaultdict)
+
         for i in range(self.table_width):
             if i < self.leading_cols:
                 # Pass through leading columns always
@@ -989,6 +998,8 @@ cdef class TextReader:
                         col_dtype = self.dtype[name]
                     elif i in self.dtype:
                         col_dtype = self.dtype[i]
+                    elif is_default_dict_dtype:
+                        col_dtype = self.dtype[name]
                 else:
                     if self.dtype.names:
                         # structured array
@@ -1001,7 +1012,7 @@ cdef class TextReader:
                     warnings.warn((f"Both a converter and dtype were specified "
                                    f"for column {name} - only the converter will "
                                    f"be used."), ParserWarning,
-                                  stacklevel=5)
+                                  stacklevel=find_stack_level())
                 results[i] = _apply_converter(conv, self.parser, i, start, end)
                 continue
 
@@ -1296,8 +1307,10 @@ cdef class TextReader:
             if self.header is not None:
                 j = i - self.leading_cols
                 # generate extra (bogus) headers if there are more columns than headers
+                # These should be strings, not integers, because otherwise we might get
+                # issues with callables as usecols GH#46997
                 if j >= len(self.header[0]):
-                    return j
+                    return str(j)
                 elif self.has_mi_columns:
                     return tuple(header_row[j] for header_row in self.header)
                 else:
@@ -1308,7 +1321,7 @@ cdef class TextReader:
 
 # Factor out code common to TextReader.__dealloc__ and TextReader.close
 # It cannot be a class method, since calling self.close() in __dealloc__
-# which causes a class attribute lookup and violates best parctices
+# which causes a class attribute lookup and violates best practices
 # https://cython.readthedocs.io/en/latest/src/userguide/special_methods.html#finalization-method-dealloc
 cdef _close(TextReader reader):
     # also preemptively free all allocated memory
@@ -1452,7 +1465,7 @@ cdef _categorical_convert(parser_t *parser, int64_t col,
         const char *word = NULL
 
         int64_t NA = -1
-        int64_t[:] codes
+        int64_t[::1] codes
         int64_t current_category = 0
 
         char *errors = "strict"
diff --git a/pandas/_libs/properties.pyi b/pandas/_libs/properties.pyi
index b2ba55aefb8a5..595e3bd706f1d 100644
--- a/pandas/_libs/properties.pyi
+++ b/pandas/_libs/properties.pyi
@@ -1,9 +1,28 @@
-# pyright: reportIncompleteStub = false
-from typing import Any
+from typing import (
+    Sequence,
+    overload,
+)
+
+from pandas._typing import (
+    AnyArrayLike,
+    DataFrame,
+    Index,
+    Series,
+)
 
 # note: this is a lie to make type checkers happy (they special
 # case property). cache_readonly uses attribute names similar to
 # property (fget) but it does not provide fset and fdel.
 cache_readonly = property
 
-def __getattr__(name: str) -> Any: ...  # incomplete
+class AxisProperty:
+
+    axis: int
+    def __init__(self, axis: int = ..., doc: str = ...) -> None: ...
+    @overload
+    def __get__(self, obj: DataFrame | Series, type) -> Index: ...
+    @overload
+    def __get__(self, obj: None, type) -> AxisProperty: ...
+    def __set__(
+        self, obj: DataFrame | Series, value: AnyArrayLike | Sequence
+    ) -> None: ...
diff --git a/pandas/_libs/properties.pyx b/pandas/_libs/properties.pyx
index 0ae29a6a641a7..3354290a5f535 100644
--- a/pandas/_libs/properties.pyx
+++ b/pandas/_libs/properties.pyx
@@ -1,10 +1,9 @@
-from cython import Py_ssize_t
-
 from cpython.dict cimport (
     PyDict_Contains,
     PyDict_GetItem,
     PyDict_SetItem,
 )
+from cython cimport Py_ssize_t
 
 
 cdef class CachedProperty:
diff --git a/pandas/_libs/reduction.pyi b/pandas/_libs/reduction.pyi
new file mode 100644
index 0000000000000..ad73e94137583
--- /dev/null
+++ b/pandas/_libs/reduction.pyi
@@ -0,0 +1,8 @@
+from typing import Any
+
+import numpy as np
+
+from pandas._typing import ExtensionDtype
+
+def check_result_array(obj: object, dtype: np.dtype | ExtensionDtype) -> None: ...
+def extract_result(res: object) -> Any: ...
diff --git a/pandas/_libs/reshape.pyx b/pandas/_libs/reshape.pyx
index 924a7ad9a0751..a012bd92cd573 100644
--- a/pandas/_libs/reshape.pyx
+++ b/pandas/_libs/reshape.pyx
@@ -1,6 +1,5 @@
-import cython
-from cython import Py_ssize_t
-
+cimport cython
+from cython cimport Py_ssize_t
 from numpy cimport (
     int64_t,
     ndarray,
diff --git a/pandas/_libs/sparse.pyi b/pandas/_libs/sparse.pyi
index aa5388025f6f2..be5d251b2aea6 100644
--- a/pandas/_libs/sparse.pyi
+++ b/pandas/_libs/sparse.pyi
@@ -7,7 +7,7 @@ import numpy as np
 
 from pandas._typing import npt
 
-SparseIndexT = TypeVar("SparseIndexT", bound="SparseIndex")
+_SparseIndexT = TypeVar("_SparseIndexT", bound=SparseIndex)
 
 class SparseIndex:
     length: int
@@ -24,8 +24,8 @@ class SparseIndex:
     def lookup_array(self, indexer: npt.NDArray[np.int32]) -> npt.NDArray[np.int32]: ...
     def to_int_index(self) -> IntIndex: ...
     def to_block_index(self) -> BlockIndex: ...
-    def intersect(self: SparseIndexT, y_: SparseIndex) -> SparseIndexT: ...
-    def make_union(self: SparseIndexT, y_: SparseIndex) -> SparseIndexT: ...
+    def intersect(self: _SparseIndexT, y_: SparseIndex) -> _SparseIndexT: ...
+    def make_union(self: _SparseIndexT, y_: SparseIndex) -> _SparseIndexT: ...
 
 class IntIndex(SparseIndex):
     indices: npt.NDArray[np.int32]
diff --git a/pandas/_libs/sparse.pyx b/pandas/_libs/sparse.pyx
index 9b5ad010cc71f..6c10b394b91aa 100644
--- a/pandas/_libs/sparse.pyx
+++ b/pandas/_libs/sparse.pyx
@@ -1,4 +1,4 @@
-import cython
+cimport cython
 import numpy as np
 
 cimport numpy as cnp
diff --git a/pandas/_libs/src/headers/cmath b/pandas/_libs/src/headers/cmath
deleted file mode 100644
index 9e7540cfefc13..0000000000000
--- a/pandas/_libs/src/headers/cmath
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef _PANDAS_MATH_H_
-#define _PANDAS_MATH_H_
-
-// MSVC 2017 has a bug where `x == x` can be true for NaNs.
-// MSC_VER from https://stackoverflow.com/a/70630/1889400
-// Place upper bound on this check once a fixed MSVC is released.
-#if defined(_MSC_VER) && (_MSC_VER < 1800)
-#include <cmath>
-// In older versions of Visual Studio there wasn't a std::signbit defined
-// This defines it using _copysign
-namespace std {
-   __inline int isnan(double x) { return _isnan(x); }
-   __inline int signbit(double num) { return _copysign(1.0, num) < 0; }
-   __inline int notnan(double x) { return !isnan(x); }
-}
-#elif defined(_MSC_VER) && (_MSC_VER >= 1900)
-#include <cmath>
-namespace std {
-  __inline int isnan(double x) { return _isnan(x); }
-  __inline int notnan(double x) { return !isnan(x); }
-}
-#elif defined(_MSC_VER)
-#include <cmath>
-namespace std {
-  __inline int isnan(double x) { return _isnan(x); }
-  __inline int notnan(double x) { return x == x; }
-}
-#elif defined(__MVS__)
-#include <cmath>
-
-#define _signbit signbit
-#undef signbit
-#undef isnan
-
-namespace std {
-  __inline int notnan(double x) { return x == x; }
-  __inline int signbit(double num) { return _signbit(num); }
-  __inline int isnan(double x) { return isnan(x); }
-}
-#else
-#include <cmath>
-
-namespace std {
-  __inline int notnan(double x) { return x == x; }
-}
-
-#endif
-#endif
diff --git a/pandas/_libs/src/headers/ms_inttypes.h b/pandas/_libs/src/headers/ms_inttypes.h
deleted file mode 100644
index 1be380337b07f..0000000000000
--- a/pandas/_libs/src/headers/ms_inttypes.h
+++ /dev/null
@@ -1,305 +0,0 @@
-// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
-//  Copyright (c) 2006 Alexander Chemeris
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-//
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-//
-//   3. The name of the author may be used to endorse or promote products
-//      derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_INTTYPES_H_ // [
-#define _MSC_INTTYPES_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-#include "ms_stdint.h"
-
-// 7.8 Format conversion of integer types
-
-typedef struct {
-   intmax_t quot;
-   intmax_t rem;
-} imaxdiv_t;
-
-// 7.8.1 Macros for format specifiers
-
-#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
-
-// The fprintf macros for signed integers are:
-#define PRId8       "d"
-#define PRIi8       "i"
-#define PRIdLEAST8  "d"
-#define PRIiLEAST8  "i"
-#define PRIdFAST8   "d"
-#define PRIiFAST8   "i"
-
-#define PRId16       "hd"
-#define PRIi16       "hi"
-#define PRIdLEAST16  "hd"
-#define PRIiLEAST16  "hi"
-#define PRIdFAST16   "hd"
-#define PRIiFAST16   "hi"
-
-#define PRId32       "I32d"
-#define PRIi32       "I32i"
-#define PRIdLEAST32  "I32d"
-#define PRIiLEAST32  "I32i"
-#define PRIdFAST32   "I32d"
-#define PRIiFAST32   "I32i"
-
-#define PRId64       "I64d"
-#define PRIi64       "I64i"
-#define PRIdLEAST64  "I64d"
-#define PRIiLEAST64  "I64i"
-#define PRIdFAST64   "I64d"
-#define PRIiFAST64   "I64i"
-
-#define PRIdMAX     "I64d"
-#define PRIiMAX     "I64i"
-
-#define PRIdPTR     "Id"
-#define PRIiPTR     "Ii"
-
-// The fprintf macros for unsigned integers are:
-#define PRIo8       "o"
-#define PRIu8       "u"
-#define PRIx8       "x"
-#define PRIX8       "X"
-#define PRIoLEAST8  "o"
-#define PRIuLEAST8  "u"
-#define PRIxLEAST8  "x"
-#define PRIXLEAST8  "X"
-#define PRIoFAST8   "o"
-#define PRIuFAST8   "u"
-#define PRIxFAST8   "x"
-#define PRIXFAST8   "X"
-
-#define PRIo16       "ho"
-#define PRIu16       "hu"
-#define PRIx16       "hx"
-#define PRIX16       "hX"
-#define PRIoLEAST16  "ho"
-#define PRIuLEAST16  "hu"
-#define PRIxLEAST16  "hx"
-#define PRIXLEAST16  "hX"
-#define PRIoFAST16   "ho"
-#define PRIuFAST16   "hu"
-#define PRIxFAST16   "hx"
-#define PRIXFAST16   "hX"
-
-#define PRIo32       "I32o"
-#define PRIu32       "I32u"
-#define PRIx32       "I32x"
-#define PRIX32       "I32X"
-#define PRIoLEAST32  "I32o"
-#define PRIuLEAST32  "I32u"
-#define PRIxLEAST32  "I32x"
-#define PRIXLEAST32  "I32X"
-#define PRIoFAST32   "I32o"
-#define PRIuFAST32   "I32u"
-#define PRIxFAST32   "I32x"
-#define PRIXFAST32   "I32X"
-
-#define PRIo64       "I64o"
-#define PRIu64       "I64u"
-#define PRIx64       "I64x"
-#define PRIX64       "I64X"
-#define PRIoLEAST64  "I64o"
-#define PRIuLEAST64  "I64u"
-#define PRIxLEAST64  "I64x"
-#define PRIXLEAST64  "I64X"
-#define PRIoFAST64   "I64o"
-#define PRIuFAST64   "I64u"
-#define PRIxFAST64   "I64x"
-#define PRIXFAST64   "I64X"
-
-#define PRIoMAX     "I64o"
-#define PRIuMAX     "I64u"
-#define PRIxMAX     "I64x"
-#define PRIXMAX     "I64X"
-
-#define PRIoPTR     "Io"
-#define PRIuPTR     "Iu"
-#define PRIxPTR     "Ix"
-#define PRIXPTR     "IX"
-
-// The fscanf macros for signed integers are:
-#define SCNd8       "d"
-#define SCNi8       "i"
-#define SCNdLEAST8  "d"
-#define SCNiLEAST8  "i"
-#define SCNdFAST8   "d"
-#define SCNiFAST8   "i"
-
-#define SCNd16       "hd"
-#define SCNi16       "hi"
-#define SCNdLEAST16  "hd"
-#define SCNiLEAST16  "hi"
-#define SCNdFAST16   "hd"
-#define SCNiFAST16   "hi"
-
-#define SCNd32       "ld"
-#define SCNi32       "li"
-#define SCNdLEAST32  "ld"
-#define SCNiLEAST32  "li"
-#define SCNdFAST32   "ld"
-#define SCNiFAST32   "li"
-
-#define SCNd64       "I64d"
-#define SCNi64       "I64i"
-#define SCNdLEAST64  "I64d"
-#define SCNiLEAST64  "I64i"
-#define SCNdFAST64   "I64d"
-#define SCNiFAST64   "I64i"
-
-#define SCNdMAX     "I64d"
-#define SCNiMAX     "I64i"
-
-#ifdef _WIN64 // [
-#  define SCNdPTR     "I64d"
-#  define SCNiPTR     "I64i"
-#else  // _WIN64 ][
-#  define SCNdPTR     "ld"
-#  define SCNiPTR     "li"
-#endif  // _WIN64 ]
-
-// The fscanf macros for unsigned integers are:
-#define SCNo8       "o"
-#define SCNu8       "u"
-#define SCNx8       "x"
-#define SCNX8       "X"
-#define SCNoLEAST8  "o"
-#define SCNuLEAST8  "u"
-#define SCNxLEAST8  "x"
-#define SCNXLEAST8  "X"
-#define SCNoFAST8   "o"
-#define SCNuFAST8   "u"
-#define SCNxFAST8   "x"
-#define SCNXFAST8   "X"
-
-#define SCNo16       "ho"
-#define SCNu16       "hu"
-#define SCNx16       "hx"
-#define SCNX16       "hX"
-#define SCNoLEAST16  "ho"
-#define SCNuLEAST16  "hu"
-#define SCNxLEAST16  "hx"
-#define SCNXLEAST16  "hX"
-#define SCNoFAST16   "ho"
-#define SCNuFAST16   "hu"
-#define SCNxFAST16   "hx"
-#define SCNXFAST16   "hX"
-
-#define SCNo32       "lo"
-#define SCNu32       "lu"
-#define SCNx32       "lx"
-#define SCNX32       "lX"
-#define SCNoLEAST32  "lo"
-#define SCNuLEAST32  "lu"
-#define SCNxLEAST32  "lx"
-#define SCNXLEAST32  "lX"
-#define SCNoFAST32   "lo"
-#define SCNuFAST32   "lu"
-#define SCNxFAST32   "lx"
-#define SCNXFAST32   "lX"
-
-#define SCNo64       "I64o"
-#define SCNu64       "I64u"
-#define SCNx64       "I64x"
-#define SCNX64       "I64X"
-#define SCNoLEAST64  "I64o"
-#define SCNuLEAST64  "I64u"
-#define SCNxLEAST64  "I64x"
-#define SCNXLEAST64  "I64X"
-#define SCNoFAST64   "I64o"
-#define SCNuFAST64   "I64u"
-#define SCNxFAST64   "I64x"
-#define SCNXFAST64   "I64X"
-
-#define SCNoMAX     "I64o"
-#define SCNuMAX     "I64u"
-#define SCNxMAX     "I64x"
-#define SCNXMAX     "I64X"
-
-#ifdef _WIN64 // [
-#  define SCNoPTR     "I64o"
-#  define SCNuPTR     "I64u"
-#  define SCNxPTR     "I64x"
-#  define SCNXPTR     "I64X"
-#else  // _WIN64 ][
-#  define SCNoPTR     "lo"
-#  define SCNuPTR     "lu"
-#  define SCNxPTR     "lx"
-#  define SCNXPTR     "lX"
-#endif  // _WIN64 ]
-
-#endif // __STDC_FORMAT_MACROS ]
-
-// 7.8.2 Functions for greatest-width integer types
-
-// 7.8.2.1 The imaxabs function
-#define imaxabs _abs64
-
-// 7.8.2.2 The imaxdiv function
-
-// This is modified version of div() function from Microsoft's div.c found
-// in %MSVC.NET%\crt\src\div.c
-#ifdef STATIC_IMAXDIV // [
-static
-#else // STATIC_IMAXDIV ][
-_inline
-#endif // STATIC_IMAXDIV ]
-imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
-{
-   imaxdiv_t result;
-
-   result.quot = numer / denom;
-   result.rem = numer % denom;
-
-   if (numer < 0 && result.rem > 0) {
-      // did division wrong; must fix up
-      ++result.quot;
-      result.rem -= denom;
-   }
-
-   return result;
-}
-
-// 7.8.2.3 The strtoimax and strtoumax functions
-#define strtoimax _strtoi64
-#define strtoumax _strtoui64
-
-// 7.8.2.4 The wcstoimax and wcstoumax functions
-#define wcstoimax _wcstoi64
-#define wcstoumax _wcstoui64
-
-
-#endif // _MSC_INTTYPES_H_ ]
diff --git a/pandas/_libs/src/headers/ms_stdint.h b/pandas/_libs/src/headers/ms_stdint.h
deleted file mode 100644
index c66fbb817c0d1..0000000000000
--- a/pandas/_libs/src/headers/ms_stdint.h
+++ /dev/null
@@ -1,247 +0,0 @@
-// ISO C9x  compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
-//  Copyright (c) 2006-2008 Alexander Chemeris
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-//
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-//
-//   3. The name of the author may be used to endorse or promote products
-//      derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_STDINT_H_ // [
-#define _MSC_STDINT_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-#include <limits.h>
-
-// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
-// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
-// or compiler give many errors like this:
-//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
-#ifdef __cplusplus
-extern "C" {
-#endif
-#  include <wchar.h>
-#ifdef __cplusplus
-}
-#endif
-
-// Define _W64 macros to mark types changing their size, like intptr_t.
-#ifndef _W64
-#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
-#     define _W64 __w64
-#  else
-#     define _W64
-#  endif
-#endif
-
-
-// 7.18.1 Integer types
-
-// 7.18.1.1 Exact-width integer types
-
-// Visual Studio 6 and Embedded Visual C++ 4 doesn't
-// realize that, e.g. char has the same size as __int8
-// so we give up on __intX for them.
-#if (_MSC_VER < 1300)
-   typedef signed char       int8_t;
-   typedef signed short      int16_t;
-   typedef signed int        int32_t;
-   typedef unsigned char     uint8_t;
-   typedef unsigned short    uint16_t;
-   typedef unsigned int      uint32_t;
-#else
-   typedef signed __int8     int8_t;
-   typedef signed __int16    int16_t;
-   typedef signed __int32    int32_t;
-   typedef unsigned __int8   uint8_t;
-   typedef unsigned __int16  uint16_t;
-   typedef unsigned __int32  uint32_t;
-#endif
-typedef signed __int64       int64_t;
-typedef unsigned __int64     uint64_t;
-
-
-// 7.18.1.2 Minimum-width integer types
-typedef int8_t    int_least8_t;
-typedef int16_t   int_least16_t;
-typedef int32_t   int_least32_t;
-typedef int64_t   int_least64_t;
-typedef uint8_t   uint_least8_t;
-typedef uint16_t  uint_least16_t;
-typedef uint32_t  uint_least32_t;
-typedef uint64_t  uint_least64_t;
-
-// 7.18.1.3 Fastest minimum-width integer types
-typedef int8_t    int_fast8_t;
-typedef int16_t   int_fast16_t;
-typedef int32_t   int_fast32_t;
-typedef int64_t   int_fast64_t;
-typedef uint8_t   uint_fast8_t;
-typedef uint16_t  uint_fast16_t;
-typedef uint32_t  uint_fast32_t;
-typedef uint64_t  uint_fast64_t;
-
-// 7.18.1.4 Integer types capable of holding object pointers
-#ifdef _WIN64 // [
-   typedef signed __int64    intptr_t;
-   typedef unsigned __int64  uintptr_t;
-#else // _WIN64 ][
-   typedef _W64 signed int   intptr_t;
-   typedef _W64 unsigned int uintptr_t;
-#endif // _WIN64 ]
-
-// 7.18.1.5 Greatest-width integer types
-typedef int64_t   intmax_t;
-typedef uint64_t  uintmax_t;
-
-
-// 7.18.2 Limits of specified-width integer types
-
-#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
-
-// 7.18.2.1 Limits of exact-width integer types
-#define INT8_MIN     ((int8_t)_I8_MIN)
-#define INT8_MAX     _I8_MAX
-#define INT16_MIN    ((int16_t)_I16_MIN)
-#define INT16_MAX    _I16_MAX
-#define INT32_MIN    ((int32_t)_I32_MIN)
-#define INT32_MAX    _I32_MAX
-#define INT64_MIN    ((int64_t)_I64_MIN)
-#define INT64_MAX    _I64_MAX
-#define UINT8_MAX    _UI8_MAX
-#define UINT16_MAX   _UI16_MAX
-#define UINT32_MAX   _UI32_MAX
-#define UINT64_MAX   _UI64_MAX
-
-// 7.18.2.2 Limits of minimum-width integer types
-#define INT_LEAST8_MIN    INT8_MIN
-#define INT_LEAST8_MAX    INT8_MAX
-#define INT_LEAST16_MIN   INT16_MIN
-#define INT_LEAST16_MAX   INT16_MAX
-#define INT_LEAST32_MIN   INT32_MIN
-#define INT_LEAST32_MAX   INT32_MAX
-#define INT_LEAST64_MIN   INT64_MIN
-#define INT_LEAST64_MAX   INT64_MAX
-#define UINT_LEAST8_MAX   UINT8_MAX
-#define UINT_LEAST16_MAX  UINT16_MAX
-#define UINT_LEAST32_MAX  UINT32_MAX
-#define UINT_LEAST64_MAX  UINT64_MAX
-
-// 7.18.2.3 Limits of fastest minimum-width integer types
-#define INT_FAST8_MIN    INT8_MIN
-#define INT_FAST8_MAX    INT8_MAX
-#define INT_FAST16_MIN   INT16_MIN
-#define INT_FAST16_MAX   INT16_MAX
-#define INT_FAST32_MIN   INT32_MIN
-#define INT_FAST32_MAX   INT32_MAX
-#define INT_FAST64_MIN   INT64_MIN
-#define INT_FAST64_MAX   INT64_MAX
-#define UINT_FAST8_MAX   UINT8_MAX
-#define UINT_FAST16_MAX  UINT16_MAX
-#define UINT_FAST32_MAX  UINT32_MAX
-#define UINT_FAST64_MAX  UINT64_MAX
-
-// 7.18.2.4 Limits of integer types capable of holding object pointers
-#ifdef _WIN64 // [
-#  define INTPTR_MIN   INT64_MIN
-#  define INTPTR_MAX   INT64_MAX
-#  define UINTPTR_MAX  UINT64_MAX
-#else // _WIN64 ][
-#  define INTPTR_MIN   INT32_MIN
-#  define INTPTR_MAX   INT32_MAX
-#  define UINTPTR_MAX  UINT32_MAX
-#endif // _WIN64 ]
-
-// 7.18.2.5 Limits of greatest-width integer types
-#define INTMAX_MIN   INT64_MIN
-#define INTMAX_MAX   INT64_MAX
-#define UINTMAX_MAX  UINT64_MAX
-
-// 7.18.3 Limits of other integer types
-
-#ifdef _WIN64 // [
-#  define PTRDIFF_MIN  _I64_MIN
-#  define PTRDIFF_MAX  _I64_MAX
-#else  // _WIN64 ][
-#  define PTRDIFF_MIN  _I32_MIN
-#  define PTRDIFF_MAX  _I32_MAX
-#endif  // _WIN64 ]
-
-#define SIG_ATOMIC_MIN  INT_MIN
-#define SIG_ATOMIC_MAX  INT_MAX
-
-#ifndef SIZE_MAX // [
-#  ifdef _WIN64 // [
-#     define SIZE_MAX  _UI64_MAX
-#  else // _WIN64 ][
-#     define SIZE_MAX  _UI32_MAX
-#  endif // _WIN64 ]
-#endif // SIZE_MAX ]
-
-// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
-#ifndef WCHAR_MIN // [
-#  define WCHAR_MIN  0
-#endif  // WCHAR_MIN ]
-#ifndef WCHAR_MAX // [
-#  define WCHAR_MAX  _UI16_MAX
-#endif  // WCHAR_MAX ]
-
-#define WINT_MIN  0
-#define WINT_MAX  _UI16_MAX
-
-#endif // __STDC_LIMIT_MACROS ]
-
-
-// 7.18.4 Limits of other integer types
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-#define INTMAX_C   INT64_C
-#define UINTMAX_C  UINT64_C
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-
-#endif // _MSC_STDINT_H_ ]
diff --git a/pandas/_libs/src/headers/stdint.h b/pandas/_libs/src/headers/stdint.h
deleted file mode 100644
index 8746bf132d0f7..0000000000000
--- a/pandas/_libs/src/headers/stdint.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef _PANDAS_STDINT_H_
-#define _PANDAS_STDINT_H_
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#include "ms_stdint.h"
-#else
-#include <stdint.h>
-#endif
-
-#endif
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index ade4d4aa4a206..c337c3eaf1318 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -649,7 +649,7 @@ static int parser_buffer_bytes(parser_t *self, size_t nbytes,
 #define END_LINE() END_LINE_STATE(START_RECORD)
 
 #define IS_TERMINATOR(c)                            \
-    (c == line_terminator)
+    (c == lineterminator)
 
 #define IS_QUOTE(c) ((c == self->quotechar && self->quoting != QUOTE_NONE))
 
@@ -718,7 +718,7 @@ int tokenize_bytes(parser_t *self,
     char *stream;
     char *buf = self->data + self->datapos;
 
-    const char line_terminator = (self->lineterminator == '\0') ?
+    const char lineterminator = (self->lineterminator == '\0') ?
             '\n' : self->lineterminator;
 
     // 1000 is something that couldn't fit in "char"
diff --git a/pandas/_libs/src/parser/tokenizer.h b/pandas/_libs/src/parser/tokenizer.h
index d403435cfca9e..eea9bfd4828d6 100644
--- a/pandas/_libs/src/parser/tokenizer.h
+++ b/pandas/_libs/src/parser/tokenizer.h
@@ -19,7 +19,7 @@ See LICENSE for the license
 #define ERROR_OVERFLOW 2
 #define ERROR_INVALID_CHARS 3
 
-#include "../headers/stdint.h"
+#include <stdint.h>
 #include "../inline_helper.h"
 #include "../headers/portable.h"
 
diff --git a/pandas/_libs/src/ujson/lib/ultrajson.h b/pandas/_libs/src/ujson/lib/ultrajson.h
index 5b5995a671b2c..71df0c5a186b7 100644
--- a/pandas/_libs/src/ujson/lib/ultrajson.h
+++ b/pandas/_libs/src/ujson/lib/ultrajson.h
@@ -29,7 +29,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 https://github.com/client9/stringencoders
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/pandas/_libs/src/ujson/lib/ultrajsondec.c b/pandas/_libs/src/ujson/lib/ultrajsondec.c
index fee552672b8b6..c7779b8b428ae 100644
--- a/pandas/_libs/src/ujson/lib/ultrajsondec.c
+++ b/pandas/_libs/src/ujson/lib/ultrajsondec.c
@@ -32,7 +32,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/pandas/_libs/src/ujson/lib/ultrajsonenc.c b/pandas/_libs/src/ujson/lib/ultrajsonenc.c
index 4469631b7b3f7..5d90710441a94 100644
--- a/pandas/_libs/src/ujson/lib/ultrajsonenc.c
+++ b/pandas/_libs/src/ujson/lib/ultrajsonenc.c
@@ -32,7 +32,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/pandas/_libs/src/ujson/python/JSONtoObj.c b/pandas/_libs/src/ujson/python/JSONtoObj.c
index 14683f4c28cbe..c58f25b8f99ea 100644
--- a/pandas/_libs/src/ujson/python/JSONtoObj.c
+++ b/pandas/_libs/src/ujson/python/JSONtoObj.c
@@ -29,7 +29,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 https://github.com/client9/stringencoders
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/pandas/_libs/src/ujson/python/date_conversions.c b/pandas/_libs/src/ujson/python/date_conversions.c
index 0744c6af74480..86cb68f869cb0 100644
--- a/pandas/_libs/src/ujson/python/date_conversions.c
+++ b/pandas/_libs/src/ujson/python/date_conversions.c
@@ -54,8 +54,8 @@ char *int64ToIso(int64_t value, NPY_DATETIMEUNIT base, size_t *len) {
         PyErr_NoMemory();
         return NULL;
     }
-
-    ret_code = make_iso_8601_datetime(&dts, result, *len, base);
+    // datetime64 is always naive
+    ret_code = make_iso_8601_datetime(&dts, result, *len, 0, base);
     if (ret_code != 0) {
         PyErr_SetString(PyExc_ValueError,
                         "Could not convert datetime value to string");
@@ -90,7 +90,19 @@ char *PyDateTimeToIso(PyObject *obj, NPY_DATETIMEUNIT base,
 
     *len = (size_t)get_datetime_iso_8601_strlen(0, base);
     char *result = PyObject_Malloc(*len);
-    ret = make_iso_8601_datetime(&dts, result, *len, base);
+    // Check to see if PyDateTime has a timezone.
+    // Don't convert to UTC if it doesn't.
+    int is_tz_aware = 0;
+    if (PyObject_HasAttrString(obj, "tzinfo")) {
+        PyObject *offset = extract_utc_offset(obj);
+        if (offset == NULL) {
+            PyObject_Free(result);
+            return NULL;
+        }
+        is_tz_aware = offset != Py_None;
+        Py_DECREF(offset);
+    }
+    ret = make_iso_8601_datetime(&dts, result, *len, is_tz_aware, base);
 
     if (ret != 0) {
         PyErr_SetString(PyExc_ValueError,
diff --git a/pandas/_libs/src/ujson/python/objToJSON.c b/pandas/_libs/src/ujson/python/objToJSON.c
index 06c3d823f72d2..260f1ffb6165f 100644
--- a/pandas/_libs/src/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/ujson/python/objToJSON.c
@@ -30,7 +30,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
@@ -221,14 +221,27 @@ static PyObject *get_values(PyObject *obj) {
         // The special cases to worry about are dt64tz and category[dt64tz].
         //  In both cases we want the UTC-localized datetime64 ndarray,
         //  without going through and object array of Timestamps.
+        if (PyObject_HasAttrString(obj, "tz")) {
+            PyObject *tz = PyObject_GetAttrString(obj, "tz");
+            if (tz != Py_None) {
+                // Go through object array if we have dt64tz, since tz info will
+                // be lost if values is used directly.
+                Py_DECREF(tz);
+                values = PyObject_CallMethod(obj, "__array__", NULL);
+                return values;
+            }
+            Py_DECREF(tz);
+        }
         values = PyObject_GetAttrString(obj, "values");
-
         if (values == NULL) {
             // Clear so we can subsequently try another method
             PyErr_Clear();
         } else if (PyObject_HasAttrString(values, "__array__")) {
             // We may have gotten a Categorical or Sparse array so call np.array
-            values = PyObject_CallMethod(values, "__array__", NULL);
+            PyObject *array_values = PyObject_CallMethod(values, "__array__",
+                                                         NULL);
+            Py_DECREF(values);
+            values = array_values;
         } else if (!PyArray_CheckExact(values)) {
             // Didn't get a numpy array, so keep trying
             Py_DECREF(values);
diff --git a/pandas/_libs/src/ujson/python/ujson.c b/pandas/_libs/src/ujson/python/ujson.c
index a8fdb4f55bfca..5d4a5693c0ff6 100644
--- a/pandas/_libs/src/ujson/python/ujson.c
+++ b/pandas/_libs/src/ujson/python/ujson.c
@@ -29,7 +29,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 https://github.com/client9/stringencoders
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
@@ -43,7 +43,7 @@ Numeric decoder derived from from TCL library
 
 /* objToJSON */
 PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs);
-void initObjToJSON(void);
+void *initObjToJSON(void);
 
 /* JSONToObj */
 PyObject *JSONToObj(PyObject *self, PyObject *args, PyObject *kwargs);
diff --git a/pandas/_libs/src/ujson/python/version.h b/pandas/_libs/src/ujson/python/version.h
index 3f38642b6df87..15c55309d6270 100644
--- a/pandas/_libs/src/ujson/python/version.h
+++ b/pandas/_libs/src/ujson/python/version.h
@@ -29,7 +29,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 https://github.com/client9/stringencoders
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
-Numeric decoder derived from from TCL library
+Numeric decoder derived from TCL library
 https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
diff --git a/pandas/_libs/testing.pyx b/pandas/_libs/testing.pyx
index cfe9f40f12452..11d8fe6ebd29a 100644
--- a/pandas/_libs/testing.pyx
+++ b/pandas/_libs/testing.pyx
@@ -179,6 +179,10 @@ cpdef assert_almost_equal(a, b,
         # nan / None comparison
         return True
 
+    if isna(a) and not isna(b) or not isna(a) and isna(b):
+        # boolean value of pd.NA is ambigous
+        raise AssertionError(f"{a} != {b}")
+
     if a == b:
         # object comparison
         return True
diff --git a/pandas/_libs/tslib.pyi b/pandas/_libs/tslib.pyi
index 4b02235ac9925..2212f8db8ea1e 100644
--- a/pandas/_libs/tslib.pyi
+++ b/pandas/_libs/tslib.pyi
@@ -9,6 +9,7 @@ def format_array_from_datetime(
     tz: tzinfo | None = ...,
     format: str | None = ...,
     na_rep: object = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.object_]: ...
 def array_with_unit_to_datetime(
     values: np.ndarray,
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 2883c910b3833..a24a07b423eda 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -1,17 +1,18 @@
 import warnings
 
-import cython
-
+cimport cython
 from cpython.datetime cimport (
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     datetime,
+    import_datetime,
     tzinfo,
 )
 
+from pandas.util._exceptions import find_stack_level
+
 # import datetime C API
-PyDateTime_IMPORT
+import_datetime()
 
 
 cimport numpy as cnp
@@ -28,14 +29,16 @@ cnp.import_array()
 import pytz
 
 from pandas._libs.tslibs.np_datetime cimport (
-    _string_to_dts,
+    NPY_DATETIMEUNIT,
+    NPY_FR_ns,
     check_dts_bounds,
-    dt64_to_dtstruct,
     dtstruct_to_dt64,
     get_datetime64_value,
     npy_datetimestruct,
+    pandas_datetime_to_datetimestruct,
     pydate_to_dt64,
     pydatetime_to_dt64,
+    string_to_dts,
 )
 from pandas._libs.util cimport (
     is_datetime64_object,
@@ -59,7 +62,12 @@ from pandas._libs.tslibs.nattype cimport (
     c_nat_strings as nat_strings,
 )
 from pandas._libs.tslibs.timestamps cimport _Timestamp
+from pandas._libs.tslibs.timezones cimport tz_compare
 
+from pandas._libs.tslibs import (
+    Resolution,
+    get_resolution,
+)
 from pandas._libs.tslibs.timestamps import Timestamp
 
 # Note: this is the only non-tslibs intra-pandas dependency here
@@ -76,6 +84,7 @@ def _test_parse_iso8601(ts: str):
     cdef:
         _TSObject obj
         int out_local = 0, out_tzoffset = 0
+        NPY_DATETIMEUNIT out_bestunit
 
     obj = _TSObject()
 
@@ -84,7 +93,7 @@ def _test_parse_iso8601(ts: str):
     elif ts == 'today':
         return Timestamp.now().normalize()
 
-    _string_to_dts(ts, &obj.dts, &out_local, &out_tzoffset, True)
+    string_to_dts(ts, &obj.dts, &out_bestunit, &out_local, &out_tzoffset, True)
     obj.value = dtstruct_to_dt64(&obj.dts)
     check_dts_bounds(&obj.dts)
     if out_local == 1:
@@ -98,10 +107,11 @@ def _test_parse_iso8601(ts: str):
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def format_array_from_datetime(
-    ndarray[int64_t] values,
+    ndarray values,
     tzinfo tz=None,
     str format=None,
-    object na_rep=None
+    object na_rep=None,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
 ) -> np.ndarray:
     """
     return a np object array of the string formatted values
@@ -114,46 +124,71 @@ def format_array_from_datetime(
           a strftime capable string
     na_rep : optional, default is None
           a nat format
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
     np.ndarray[object]
     """
     cdef:
-        int64_t val, ns, N = len(values)
-        ndarray[int64_t] consider_values
+        int64_t val, ns, N = values.size
         bint show_ms = False, show_us = False, show_ns = False
-        bint basic_format = False
-        ndarray[object] result = np.empty(N, dtype=object)
-        object ts, res
+        bint basic_format = False, basic_format_day = False
+        _Timestamp ts
+        object res
         npy_datetimestruct dts
 
+        # Note that `result` (and thus `result_flat`) is C-order and
+        #  `it` iterates C-order as well, so the iteration matches
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        ndarray result = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_OBJECT, 0)
+        object[::1] res_flat = result.ravel()     # should NOT be a copy
+        cnp.flatiter it = cnp.PyArray_IterNew(values)
+
     if na_rep is None:
         na_rep = 'NaT'
 
-    # if we don't have a format nor tz, then choose
-    # a format based on precision
-    basic_format = format is None and tz is None
-    if basic_format:
-        consider_values = values[values != NPY_NAT]
-        show_ns = (consider_values % 1000).any()
+    if tz is None:
+        # if we don't have a format nor tz, then choose
+        # a format based on precision
+        basic_format = format is None
+        if basic_format:
+            reso_obj = get_resolution(values, tz=tz, reso=reso)
+            show_ns = reso_obj == Resolution.RESO_NS
+            show_us = reso_obj == Resolution.RESO_US
+            show_ms = reso_obj == Resolution.RESO_MS
+
+        elif format == "%Y-%m-%d %H:%M:%S":
+            # Same format as default, but with hardcoded precision (s)
+            basic_format = True
+            show_ns = show_us = show_ms = False
+
+        elif format == "%Y-%m-%d %H:%M:%S.%f":
+            # Same format as default, but with hardcoded precision (us)
+            basic_format = show_us = True
+            show_ns = show_ms = False
 
-        if not show_ns:
-            consider_values //= 1000
-            show_us = (consider_values % 1000).any()
+        elif format == "%Y-%m-%d":
+            # Default format for dates
+            basic_format_day = True
 
-            if not show_ms:
-                consider_values //= 1000
-                show_ms = (consider_values % 1000).any()
+    assert not (basic_format_day and basic_format)
 
     for i in range(N):
-        val = values[i]
+        # Analogous to: utc_val = values[i]
+        val = (<int64_t*>cnp.PyArray_ITER_DATA(it))[0]
 
         if val == NPY_NAT:
-            result[i] = na_rep
+            res = na_rep
+        elif basic_format_day:
+
+            pandas_datetime_to_datetimestruct(val, reso, &dts)
+            res = f'{dts.year}-{dts.month:02d}-{dts.day:02d}'
+
         elif basic_format:
 
-            dt64_to_dtstruct(val, &dts)
+            pandas_datetime_to_datetimestruct(val, reso, &dts)
             res = (f'{dts.year}-{dts.month:02d}-{dts.day:02d} '
                    f'{dts.hour:02d}:{dts.min:02d}:{dts.sec:02d}')
 
@@ -165,21 +200,32 @@ def format_array_from_datetime(
             elif show_ms:
                 res += f'.{dts.us // 1000:03d}'
 
-            result[i] = res
-
         else:
 
-            ts = Timestamp(val, tz=tz)
+            ts = Timestamp._from_value_and_reso(val, reso=reso, tz=tz)
             if format is None:
-                result[i] = str(ts)
+                # Use datetime.str, that returns ts.isoformat(sep=' ')
+                res = str(ts)
             else:
 
                 # invalid format string
                 # requires dates > 1900
                 try:
-                    result[i] = ts.strftime(format)
+                    # Note: dispatches to pydatetime
+                    res = ts.strftime(format)
                 except ValueError:
-                    result[i] = str(ts)
+                    # Use datetime.str, that returns ts.isoformat(sep=' ')
+                    res = str(ts)
+
+        # Note: we can index result directly instead of using PyArray_MultiIter_DATA
+        #  like we do for the other functions because result is known C-contiguous
+        #  and is the first argument to PyArray_MultiIterNew2.  The usual pattern
+        #  does not seem to work with object dtype.
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        res_flat[i] = res
+
+        cnp.PyArray_ITER_NEXT(it)
 
     return result
 
@@ -219,7 +265,7 @@ def array_with_unit_to_datetime(
     """
     cdef:
         Py_ssize_t i, j, n=len(values)
-        int64_t m
+        int64_t mult
         int prec = 0
         ndarray[float64_t] fvalues
         bint is_ignore = errors=='ignore'
@@ -243,7 +289,7 @@ def array_with_unit_to_datetime(
             )
         return result, tz
 
-    m, p = precision_from_unit(unit)
+    mult, _ = precision_from_unit(unit)
 
     if is_raise:
         # try a quick conversion to i8/f8
@@ -255,7 +301,7 @@ def array_with_unit_to_datetime(
             # fill missing values by comparing to NPY_NAT
             mask = iresult == NPY_NAT
             iresult[mask] = 0
-            fvalues = iresult.astype("f8") * m
+            fvalues = iresult.astype("f8") * mult
             need_to_iterate = False
 
         if not need_to_iterate:
@@ -266,10 +312,10 @@ def array_with_unit_to_datetime(
                 raise OutOfBoundsDatetime(f"cannot convert input with unit '{unit}'")
 
             if values.dtype.kind in ["i", "u"]:
-                result = (iresult * m).astype("M8[ns]")
+                result = (iresult * mult).astype("M8[ns]")
 
             elif values.dtype.kind == "f":
-                fresult = (values * m).astype("f8")
+                fresult = (values * mult).astype("f8")
                 fresult[mask] = 0
                 if prec:
                     fresult = round(fresult, prec)
@@ -350,7 +396,7 @@ def array_with_unit_to_datetime(
     # and are in ignore mode
     # redo as object
 
-    oresult = np.empty(n, dtype=object)
+    oresult = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_OBJECT, 0)
     for i in range(n):
         val = values[i]
 
@@ -425,10 +471,11 @@ cpdef array_to_datetime(
     """
     cdef:
         Py_ssize_t i, n = len(values)
-        object val, py_dt, tz, tz_out = None
+        object val, tz
         ndarray[int64_t] iresult
         ndarray[object] oresult
         npy_datetimestruct dts
+        NPY_DATETIMEUNIT out_bestunit
         bint utc_convert = bool(utc)
         bint seen_integer = False
         bint seen_string = False
@@ -444,6 +491,9 @@ cpdef array_to_datetime(
         float offset_seconds, tz_offset
         set out_tzoffset_vals = set()
         bint string_to_dts_failed
+        datetime py_dt
+        tzinfo tz_out = None
+        bint found_tz = False, found_naive = False
 
     # specify error conditions
     assert is_raise or is_ignore or is_coerce
@@ -462,18 +512,34 @@ cpdef array_to_datetime(
                 elif PyDateTime_Check(val):
                     seen_datetime = True
                     if val.tzinfo is not None:
+                        found_tz = True
                         if utc_convert:
                             _ts = convert_datetime_to_tsobject(val, None)
                             iresult[i] = _ts.value
-                        else:
+                        elif found_naive:
+                            raise ValueError('Tz-aware datetime.datetime '
+                                             'cannot be converted to '
+                                             'datetime64 unless utc=True')
+                        elif tz_out is not None and not tz_compare(tz_out, val.tzinfo):
                             raise ValueError('Tz-aware datetime.datetime '
                                              'cannot be converted to '
                                              'datetime64 unless utc=True')
-                    elif isinstance(val, _Timestamp):
-                        iresult[i] = val.value
+                        else:
+                            found_tz = True
+                            tz_out = val.tzinfo
+                            _ts = convert_datetime_to_tsobject(val, None)
+                            iresult[i] = _ts.value
+
                     else:
-                        iresult[i] = pydatetime_to_dt64(val, &dts)
-                        check_dts_bounds(&dts)
+                        found_naive = True
+                        if found_tz and not utc_convert:
+                            raise ValueError('Cannot mix tz-aware with '
+                                             'tz-naive values')
+                        if isinstance(val, _Timestamp):
+                            iresult[i] = val.value
+                        else:
+                            iresult[i] = pydatetime_to_dt64(val, &dts)
+                            check_dts_bounds(&dts)
 
                 elif PyDate_Check(val):
                     seen_datetime = True
@@ -506,13 +572,16 @@ cpdef array_to_datetime(
                 elif isinstance(val, str):
                     # string
                     seen_string = True
+                    if type(val) is not str:
+                        # GH#32264 np.str_ object
+                        val = str(val)
 
                     if len(val) == 0 or val in nat_strings:
                         iresult[i] = NPY_NAT
                         continue
 
-                    string_to_dts_failed = _string_to_dts(
-                        val, &dts, &out_local,
+                    string_to_dts_failed = string_to_dts(
+                        val, &dts, &out_bestunit, &out_local,
                         &out_tzoffset, False
                     )
                     if string_to_dts_failed:
@@ -528,7 +597,7 @@ cpdef array_to_datetime(
                                 continue
                             elif is_raise:
                                 raise ValueError(
-                                    f"time data {val} doesn't match format specified"
+                                    f"time data \"{val}\" at position {i} doesn't match format specified"
                                 )
                             return values, tz_out
 
@@ -544,7 +613,7 @@ cpdef array_to_datetime(
                             if is_coerce:
                                 iresult[i] = NPY_NAT
                                 continue
-                            raise TypeError("invalid string coercion to datetime")
+                            raise TypeError(f"invalid string coercion to datetime for \"{val}\" at position {i}")
 
                         if tz is not None:
                             seen_datetime_offset = True
@@ -585,7 +654,8 @@ cpdef array_to_datetime(
                     else:
                         raise TypeError(f"{type(val)} is not convertible to datetime")
 
-            except OutOfBoundsDatetime:
+            except OutOfBoundsDatetime as ex:
+                ex.args = (str(ex) + f" present at position {i}", )
                 if is_coerce:
                     iresult[i] = NPY_NAT
                     continue
@@ -645,6 +715,8 @@ cpdef array_to_datetime(
     return result, tz_out
 
 
+@cython.wraparound(False)
+@cython.boundscheck(False)
 cdef ndarray[object] ignore_errors_out_of_bounds_fallback(ndarray[object] values):
     """
     Fallback for array_to_datetime if an OutOfBoundsDatetime is raised
@@ -662,7 +734,7 @@ cdef ndarray[object] ignore_errors_out_of_bounds_fallback(ndarray[object] values
         Py_ssize_t i, n = len(values)
         object val
 
-    oresult = np.empty(n, dtype=object)
+    oresult = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_OBJECT, 0)
 
     for i in range(n):
         val = values[i]
@@ -724,17 +796,22 @@ cdef _array_to_datetime_object(
 
     assert is_raise or is_ignore or is_coerce
 
-    oresult = np.empty(n, dtype=object)
+    oresult = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_OBJECT, 0)
 
     # We return an object array and only attempt to parse:
     # 1) NaT or NaT-like values
     # 2) datetime strings, which we return as datetime.datetime
+    # 3) special strings - "now" & "today"
     for i in range(n):
         val = values[i]
         if checknull_with_nat_and_na(val) or PyDateTime_Check(val):
             # GH 25978. No need to parse NaT-like or datetime-like vals
             oresult[i] = val
         elif isinstance(val, str):
+            if type(val) is not str:
+                # GH#32264 np.str_ objects
+                val = str(val)
+
             if len(val) == 0 or val in nat_strings:
                 oresult[i] = 'NaT'
                 continue
@@ -743,7 +820,8 @@ cdef _array_to_datetime_object(
                                                    yearfirst=yearfirst)
                 pydatetime_to_dt64(oresult[i], &dts)
                 check_dts_bounds(&dts)
-            except (ValueError, OverflowError):
+            except (ValueError, OverflowError) as ex:
+                ex.args = (f"{ex} present at position {i}", )
                 if is_coerce:
                     oresult[i] = <object>NaT
                     continue
@@ -769,7 +847,7 @@ cdef inline bint _parse_today_now(str val, int64_t* iresult, bint utc):
                 "deprecated. In a future version, this will match Timestamp('now') "
                 "and Timestamp.now()",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
 
         return True
diff --git a/pandas/_libs/tslibs/__init__.py b/pandas/_libs/tslibs/__init__.py
index 11de4e60f202d..47143b32d6dbe 100644
--- a/pandas/_libs/tslibs/__init__.py
+++ b/pandas/_libs/tslibs/__init__.py
@@ -20,25 +20,40 @@
     "get_resolution",
     "Timestamp",
     "tz_convert_from_utc_single",
+    "tz_convert_from_utc",
     "to_offset",
     "Tick",
     "BaseOffset",
     "tz_compare",
+    "is_unitless",
+    "astype_overflowsafe",
+    "get_unit_from_dtype",
+    "periods_per_day",
+    "periods_per_second",
+    "is_supported_unit",
 ]
 
 from pandas._libs.tslibs import dtypes
-from pandas._libs.tslibs.conversion import (
-    OutOfBoundsTimedelta,
-    localize_pydatetime,
+from pandas._libs.tslibs.conversion import localize_pydatetime
+from pandas._libs.tslibs.dtypes import (
+    Resolution,
+    is_supported_unit,
+    periods_per_day,
+    periods_per_second,
 )
-from pandas._libs.tslibs.dtypes import Resolution
 from pandas._libs.tslibs.nattype import (
     NaT,
     NaTType,
     iNaT,
     nat_strings,
 )
-from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+    astype_overflowsafe,
+    is_unitless,
+    py_get_unit_from_dtype as get_unit_from_dtype,
+)
 from pandas._libs.tslibs.offsets import (
     BaseOffset,
     Tick,
@@ -62,4 +77,5 @@
     ints_to_pydatetime,
     is_date_array_normalized,
     normalize_i8_timestamps,
+    tz_convert_from_utc,
 )
diff --git a/pandas/_libs/tslibs/ccalendar.pxd b/pandas/_libs/tslibs/ccalendar.pxd
index 511c9f94a47d8..341f2176f5eb4 100644
--- a/pandas/_libs/tslibs/ccalendar.pxd
+++ b/pandas/_libs/tslibs/ccalendar.pxd
@@ -15,8 +15,6 @@ cpdef int32_t get_day_of_year(int year, int month, int day) nogil
 cpdef int get_lastbday(int year, int month) nogil
 cpdef int get_firstbday(int year, int month) nogil
 
-cdef int64_t DAY_NANOS
-cdef int64_t HOUR_NANOS
 cdef dict c_MONTH_NUMBERS
 
 cdef int32_t* month_offset
diff --git a/pandas/_libs/tslibs/ccalendar.pyx b/pandas/_libs/tslibs/ccalendar.pyx
index 2aa049559d9e9..00ee15b73f551 100644
--- a/pandas/_libs/tslibs/ccalendar.pyx
+++ b/pandas/_libs/tslibs/ccalendar.pyx
@@ -3,8 +3,7 @@
 Cython implementations of functions resembling the stdlib calendar module
 """
 
-import cython
-
+cimport cython
 from numpy cimport (
     int32_t,
     int64_t,
@@ -48,11 +47,6 @@ DAYS_FULL = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
 int_to_weekday = {num: name for num, name in enumerate(DAYS)}
 weekday_to_int = {int_to_weekday[key]: key for key in int_to_weekday}
 
-DAY_SECONDS = 86400
-HOUR_SECONDS = 3600
-
-cdef int64_t DAY_NANOS = DAY_SECONDS * 1_000_000_000
-cdef int64_t HOUR_NANOS = HOUR_SECONDS * 1_000_000_000
 
 # ----------------------------------------------------------------------
 
diff --git a/pandas/_libs/tslibs/conversion.pxd b/pandas/_libs/tslibs/conversion.pxd
index 5b80193c1f27a..637a84998751f 100644
--- a/pandas/_libs/tslibs/conversion.pxd
+++ b/pandas/_libs/tslibs/conversion.pxd
@@ -8,23 +8,27 @@ from numpy cimport (
     ndarray,
 )
 
-from pandas._libs.tslibs.np_datetime cimport npy_datetimestruct
+from pandas._libs.tslibs.np_datetime cimport (
+    NPY_DATETIMEUNIT,
+    npy_datetimestruct,
+)
 
 
 cdef class _TSObject:
-    cdef:
+    cdef readonly:
         npy_datetimestruct dts      # npy_datetimestruct
         int64_t value               # numpy dt64
-        object tzinfo
+        tzinfo tzinfo
         bint fold
 
 
-cdef convert_to_tsobject(object ts, tzinfo tz, str unit,
-                         bint dayfirst, bint yearfirst,
-                         int32_t nanos=*)
+cdef _TSObject convert_to_tsobject(object ts, tzinfo tz, str unit,
+                                   bint dayfirst, bint yearfirst,
+                                   int32_t nanos=*)
 
 cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
-                                            int32_t nanos=*)
+                                            int32_t nanos=*,
+                                            NPY_DATETIMEUNIT reso=*)
 
 cdef int64_t get_datetime64_nanos(object val) except? -1
 
@@ -32,4 +36,4 @@ cpdef datetime localize_pydatetime(datetime dt, tzinfo tz)
 cdef int64_t cast_from_unit(object ts, str unit) except? -1
 cpdef (int64_t, int) precision_from_unit(str unit)
 
-cdef int64_t normalize_i8_stamp(int64_t local_val) nogil
+cdef maybe_localize_tso(_TSObject obj, tzinfo tz, NPY_DATETIMEUNIT reso)
diff --git a/pandas/_libs/tslibs/conversion.pyi b/pandas/_libs/tslibs/conversion.pyi
index 3d0288160e386..d564d767f7f05 100644
--- a/pandas/_libs/tslibs/conversion.pyi
+++ b/pandas/_libs/tslibs/conversion.pyi
@@ -5,25 +5,10 @@ from datetime import (
 
 import numpy as np
 
-from pandas._typing import npt
-
 DT64NS_DTYPE: np.dtype
 TD64NS_DTYPE: np.dtype
 
-class OutOfBoundsTimedelta(ValueError): ...
-
 def precision_from_unit(
     unit: str,
-) -> tuple[int, int,]: ...  # (int64_t, _)
-def ensure_datetime64ns(
-    arr: np.ndarray,  # np.ndarray[datetime64[ANY]]
-    copy: bool = ...,
-) -> np.ndarray: ...  # np.ndarray[datetime64ns]
-def ensure_timedelta64ns(
-    arr: np.ndarray,  # np.ndarray[timedelta64[ANY]]
-    copy: bool = ...,
-) -> np.ndarray: ...  # np.ndarray[timedelta64ns]
-def datetime_to_datetime64(
-    values: npt.NDArray[np.object_],
-) -> tuple[np.ndarray, tzinfo | None,]: ...  # (np.ndarray[dt64ns], _)
+) -> tuple[int, int]: ...  # (int64_t, _)
 def localize_pydatetime(dt: datetime, tz: tzinfo | None) -> datetime: ...
diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index a6dc8cc16b229..519bc656488c0 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -1,7 +1,13 @@
-import cython
+cimport cython
+
+import warnings
+
 import numpy as np
 
+from pandas.util._exceptions import find_stack_level
+
 cimport numpy as cnp
+from cpython.object cimport PyObject
 from numpy cimport (
     int32_t,
     int64_t,
@@ -18,37 +24,45 @@ import pytz
 from cpython.datetime cimport (
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     datetime,
+    import_datetime,
     time,
     tzinfo,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
 from pandas._libs.tslibs.base cimport ABCTimestamp
+from pandas._libs.tslibs.dtypes cimport (
+    abbrev_to_npy_unit,
+    periods_per_second,
+)
 from pandas._libs.tslibs.np_datetime cimport (
     NPY_DATETIMEUNIT,
     NPY_FR_ns,
-    _string_to_dts,
+    astype_overflowsafe,
     check_dts_bounds,
-    dt64_to_dtstruct,
     dtstruct_to_dt64,
     get_datetime64_unit,
     get_datetime64_value,
+    get_implementation_bounds,
+    get_unit_from_dtype,
     npy_datetime,
     npy_datetimestruct,
+    npy_datetimestruct_to_datetime,
     pandas_datetime_to_datetimestruct,
     pydatetime_to_dt64,
+    pydatetime_to_dtstruct,
+    string_to_dts,
 )
 
-from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+)
 
 from pandas._libs.tslibs.timezones cimport (
-    get_dst_info,
     get_utcoffset,
-    is_fixed_offset,
-    is_tzlocal,
     is_utc,
     maybe_get_tz,
     tz_compare,
@@ -69,7 +83,7 @@ from pandas._libs.tslibs.nattype cimport (
     checknull_with_nat,
 )
 from pandas._libs.tslibs.tzconversion cimport (
-    tz_convert_utc_to_tzlocal,
+    Localizer,
     tz_localize_to_utc_single,
 )
 
@@ -80,15 +94,6 @@ DT64NS_DTYPE = np.dtype('M8[ns]')
 TD64NS_DTYPE = np.dtype('m8[ns]')
 
 
-class OutOfBoundsTimedelta(ValueError):
-    """
-    Raised when encountering a timedelta value that cannot be represented
-    as a timedelta64[ns].
-    """
-    # Timedelta analogue to OutOfBoundsDatetime
-    pass
-
-
 # ----------------------------------------------------------------------
 # Unit Conversion Helpers
 
@@ -138,35 +143,40 @@ cpdef inline (int64_t, int) precision_from_unit(str unit):
     cdef:
         int64_t m
         int p
+        NPY_DATETIMEUNIT reso = abbrev_to_npy_unit(unit)
 
-    if unit == "Y":
+    if reso == NPY_DATETIMEUNIT.NPY_FR_Y:
+        # each 400 years we have 97 leap years, for an average of 97/400=.2425
+        #  extra days each year. We get 31556952 by writing
+        #  3600*24*365.2425=31556952
         m = 1_000_000_000 * 31556952
         p = 9
-    elif unit == "M":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_M:
+        # 2629746 comes from dividing the "Y" case by 12.
         m = 1_000_000_000 * 2629746
         p = 9
-    elif unit == "W":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_W:
         m = 1_000_000_000 * 3600 * 24 * 7
         p = 9
-    elif unit == "D" or unit == "d":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_D:
         m = 1_000_000_000 * 3600 * 24
         p = 9
-    elif unit == "h":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_h:
         m = 1_000_000_000 * 3600
         p = 9
-    elif unit == "m":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_m:
         m = 1_000_000_000 * 60
         p = 9
-    elif unit == "s":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_s:
         m = 1_000_000_000
         p = 9
-    elif unit == "ms":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_ms:
         m = 1_000_000
         p = 6
-    elif unit == "us":
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_us:
         m = 1000
         p = 3
-    elif unit == "ns" or unit is None:
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_ns or reso == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
         m = 1
         p = 0
     else:
@@ -198,170 +208,6 @@ cdef inline int64_t get_datetime64_nanos(object val) except? -1:
     return ival
 
 
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def ensure_datetime64ns(arr: ndarray, copy: bool = True):
-    """
-    Ensure a np.datetime64 array has dtype specifically 'datetime64[ns]'
-
-    Parameters
-    ----------
-    arr : ndarray
-    copy : bool, default True
-
-    Returns
-    -------
-    ndarray with dtype datetime64[ns]
-    """
-    cdef:
-        Py_ssize_t i, n = arr.size
-        const int64_t[:] ivalues
-        int64_t[:] iresult
-        NPY_DATETIMEUNIT unit
-        npy_datetimestruct dts
-
-    shape = (<object>arr).shape
-
-    if (<object>arr).dtype.byteorder == ">":
-        # GH#29684 we incorrectly get OutOfBoundsDatetime if we dont swap
-        dtype = arr.dtype
-        arr = arr.astype(dtype.newbyteorder("<"))
-
-    if arr.size == 0:
-        result = arr.view(DT64NS_DTYPE)
-        if copy:
-            result = result.copy()
-        return result
-
-    unit = get_datetime64_unit(arr.flat[0])
-    if unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
-        # without raising explicitly here, we end up with a SystemError
-        # built-in function ensure_datetime64ns returned a result with an error
-        raise ValueError("datetime64/timedelta64 must have a unit specified")
-
-    if unit == NPY_FR_ns:
-        # Check this before allocating result for perf, might save some memory
-        if copy:
-            return arr.copy()
-        return arr
-
-    ivalues = arr.view(np.int64).ravel("K")
-
-    result = np.empty_like(arr, dtype=DT64NS_DTYPE)
-    iresult = result.ravel("K").view(np.int64)
-
-    for i in range(n):
-        if ivalues[i] != NPY_NAT:
-            pandas_datetime_to_datetimestruct(ivalues[i], unit, &dts)
-            iresult[i] = dtstruct_to_dt64(&dts)
-            check_dts_bounds(&dts)
-        else:
-            iresult[i] = NPY_NAT
-
-    return result
-
-
-def ensure_timedelta64ns(arr: ndarray, copy: bool = True):
-    """
-    Ensure a np.timedelta64 array has dtype specifically 'timedelta64[ns]'
-
-    Parameters
-    ----------
-    arr : ndarray
-    copy : bool, default True
-
-    Returns
-    -------
-    ndarray[timedelta64[ns]]
-    """
-    assert arr.dtype.kind == "m", arr.dtype
-
-    if arr.dtype == TD64NS_DTYPE:
-        return arr.copy() if copy else arr
-
-    # Re-use the datetime64 machinery to do an overflow-safe `astype`
-    dtype = arr.dtype.str.replace("m8", "M8")
-    dummy = arr.view(dtype)
-    try:
-        dt64_result = ensure_datetime64ns(dummy, copy)
-    except OutOfBoundsDatetime as err:
-        # Re-write the exception in terms of timedelta64 instead of dt64
-
-        # Find the value that we are going to report as causing an overflow
-        tdmin = arr.min()
-        tdmax = arr.max()
-        if np.abs(tdmin) >= np.abs(tdmax):
-            bad_val = tdmin
-        else:
-            bad_val = tdmax
-
-        msg = f"Out of bounds for nanosecond {arr.dtype.name} {str(bad_val)}"
-        raise OutOfBoundsTimedelta(msg)
-
-    return dt64_result.view(TD64NS_DTYPE)
-
-
-# ----------------------------------------------------------------------
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def datetime_to_datetime64(ndarray[object] values):
-    """
-    Convert ndarray of datetime-like objects to int64 array representing
-    nanosecond timestamps.
-
-    Parameters
-    ----------
-    values : ndarray[object]
-
-    Returns
-    -------
-    result : ndarray[datetime64ns]
-    inferred_tz : tzinfo or None
-    """
-    cdef:
-        Py_ssize_t i, n = len(values)
-        object val
-        int64_t[:] iresult
-        npy_datetimestruct dts
-        _TSObject _ts
-        bint found_naive = False
-        tzinfo inferred_tz = None
-
-    result = np.empty(n, dtype='M8[ns]')
-    iresult = result.view('i8')
-    for i in range(n):
-        val = values[i]
-        if checknull_with_nat(val):
-            iresult[i] = NPY_NAT
-        elif PyDateTime_Check(val):
-            if val.tzinfo is not None:
-                if found_naive:
-                    raise ValueError('Cannot mix tz-aware with '
-                                     'tz-naive values')
-                if inferred_tz is not None:
-                    if not tz_compare(val.tzinfo, inferred_tz):
-                        raise ValueError('Array must be all same time zone')
-                else:
-                    inferred_tz = val.tzinfo
-
-                _ts = convert_datetime_to_tsobject(val, None)
-                iresult[i] = _ts.value
-                check_dts_bounds(&_ts.dts)
-            else:
-                found_naive = True
-                if inferred_tz is not None:
-                    raise ValueError('Cannot mix tz-aware with '
-                                     'tz-naive values')
-                iresult[i] = pydatetime_to_dt64(val, &dts)
-                check_dts_bounds(&dts)
-        else:
-            raise TypeError(f'Unrecognized value type: {type(val)}')
-
-    return result, inferred_tz
-
-
 # ----------------------------------------------------------------------
 # _TSObject Conversion
 
@@ -370,21 +216,16 @@ cdef class _TSObject:
     # cdef:
     #    npy_datetimestruct dts      # npy_datetimestruct
     #    int64_t value               # numpy dt64
-    #    object tzinfo
+    #    tzinfo tzinfo
     #    bint fold
 
     def __cinit__(self):
         # GH 25057. As per PEP 495, set fold to 0 by default
         self.fold = 0
 
-    @property
-    def value(self):
-        # This is needed in order for `value` to be accessible in lib.pyx
-        return self.value
-
 
-cdef convert_to_tsobject(object ts, tzinfo tz, str unit,
-                         bint dayfirst, bint yearfirst, int32_t nanos=0):
+cdef _TSObject convert_to_tsobject(object ts, tzinfo tz, str unit,
+                                   bint dayfirst, bint yearfirst, int32_t nanos=0):
     """
     Extract datetime and int64 from any of:
         - np.int64 (with unit providing a possible modifier)
@@ -412,7 +253,7 @@ cdef convert_to_tsobject(object ts, tzinfo tz, str unit,
     elif is_datetime64_object(ts):
         obj.value = get_datetime64_nanos(ts)
         if obj.value != NPY_NAT:
-            dt64_to_dtstruct(obj.value, &obj.dts)
+            pandas_datetime_to_datetimestruct(obj.value, NPY_FR_ns, &obj.dts)
     elif is_integer_object(ts):
         try:
             ts = <int64_t>ts
@@ -422,16 +263,38 @@ cdef convert_to_tsobject(object ts, tzinfo tz, str unit,
         if ts == NPY_NAT:
             obj.value = NPY_NAT
         else:
+            if unit in ["Y", "M"]:
+                # GH#47266 cast_from_unit leads to weird results e.g. with "Y"
+                #  and 150 we'd get 2120-01-01 09:00:00
+                ts = np.datetime64(ts, unit)
+                return convert_to_tsobject(ts, tz, None, False, False)
+
             ts = ts * cast_from_unit(None, unit)
             obj.value = ts
-            dt64_to_dtstruct(ts, &obj.dts)
+            pandas_datetime_to_datetimestruct(ts, NPY_FR_ns, &obj.dts)
     elif is_float_object(ts):
         if ts != ts or ts == NPY_NAT:
             obj.value = NPY_NAT
         else:
+            if unit in ["Y", "M"]:
+                if ts == int(ts):
+                    # GH#47266 Avoid cast_from_unit, which would give weird results
+                    #  e.g. with "Y" and 150.0 we'd get 2120-01-01 09:00:00
+                    return convert_to_tsobject(int(ts), tz, unit, False, False)
+                else:
+                    # GH#47267 it is clear that 2 "M" corresponds to 1970-02-01,
+                    #  but not clear what 2.5 "M" corresponds to, so we will
+                    #  disallow that case.
+                    warnings.warn(
+                        "Conversion of non-round float with unit={unit} is ambiguous "
+                        "and will raise in a future version.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+
             ts = cast_from_unit(ts, unit)
             obj.value = ts
-            dt64_to_dtstruct(ts, &obj.dts)
+            pandas_datetime_to_datetimestruct(ts, NPY_FR_ns, &obj.dts)
     elif PyDateTime_Check(ts):
         return convert_datetime_to_tsobject(ts, tz, nanos)
     elif PyDate_Check(ts):
@@ -446,18 +309,26 @@ cdef convert_to_tsobject(object ts, tzinfo tz, str unit,
         raise TypeError(f'Cannot convert input [{ts}] of type {type(ts)} to '
                         f'Timestamp')
 
+    maybe_localize_tso(obj, tz, NPY_FR_ns)
+    return obj
+
+
+cdef maybe_localize_tso(_TSObject obj, tzinfo tz, NPY_DATETIMEUNIT reso):
     if tz is not None:
-        _localize_tso(obj, tz)
+        _localize_tso(obj, tz, reso)
 
     if obj.value != NPY_NAT:
         # check_overflows needs to run after _localize_tso
-        check_dts_bounds(&obj.dts)
-        check_overflows(obj)
-    return obj
+        check_dts_bounds(&obj.dts, reso)
+        check_overflows(obj, reso)
 
 
-cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
-                                            int32_t nanos=0):
+cdef _TSObject convert_datetime_to_tsobject(
+    datetime ts,
+    tzinfo tz,
+    int32_t nanos=0,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+):
     """
     Convert a datetime (or Timestamp) input `ts`, along with optional timezone
     object `tz` to a _TSObject.
@@ -473,6 +344,7 @@ cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
         timezone for the timezone-aware output
     nanos : int32_t, default is 0
         nanoseconds supplement the precision of the datetime input ts
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
@@ -480,6 +352,7 @@ cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
     """
     cdef:
         _TSObject obj = _TSObject()
+        int64_t pps
 
     obj.fold = ts.fold
     if tz is not None:
@@ -488,34 +361,35 @@ cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
         if ts.tzinfo is not None:
             # Convert the current timezone to the passed timezone
             ts = ts.astimezone(tz)
-            obj.value = pydatetime_to_dt64(ts, &obj.dts)
+            pydatetime_to_dtstruct(ts, &obj.dts)
             obj.tzinfo = ts.tzinfo
         elif not is_utc(tz):
             ts = _localize_pydatetime(ts, tz)
-            obj.value = pydatetime_to_dt64(ts, &obj.dts)
+            pydatetime_to_dtstruct(ts, &obj.dts)
             obj.tzinfo = ts.tzinfo
         else:
             # UTC
-            obj.value = pydatetime_to_dt64(ts, &obj.dts)
+            pydatetime_to_dtstruct(ts, &obj.dts)
             obj.tzinfo = tz
     else:
-        obj.value = pydatetime_to_dt64(ts, &obj.dts)
+        pydatetime_to_dtstruct(ts, &obj.dts)
         obj.tzinfo = ts.tzinfo
 
-    if obj.tzinfo is not None and not is_utc(obj.tzinfo):
-        offset = get_utcoffset(obj.tzinfo, ts)
-        obj.value -= int(offset.total_seconds() * 1e9)
-
     if isinstance(ts, ABCTimestamp):
-        obj.value += <int64_t>ts.nanosecond
         obj.dts.ps = ts.nanosecond * 1000
 
     if nanos:
-        obj.value += nanos
         obj.dts.ps = nanos * 1000
 
-    check_dts_bounds(&obj.dts)
-    check_overflows(obj)
+    obj.value = npy_datetimestruct_to_datetime(reso, &obj.dts)
+
+    if obj.tzinfo is not None and not is_utc(obj.tzinfo):
+        offset = get_utcoffset(obj.tzinfo, ts)
+        pps = periods_per_second(reso)
+        obj.value -= int(offset.total_seconds() * pps)
+
+    check_dts_bounds(&obj.dts, reso)
+    check_overflows(obj, reso)
     return obj
 
 
@@ -540,29 +414,28 @@ cdef _TSObject _create_tsobject_tz_using_offset(npy_datetimestruct dts,
         _TSObject obj = _TSObject()
         int64_t value  # numpy dt64
         datetime dt
-        ndarray[int64_t] trans
-        int64_t[:] deltas
+        Py_ssize_t pos
 
     value = dtstruct_to_dt64(&dts)
     obj.dts = dts
     obj.tzinfo = pytz.FixedOffset(tzoffset)
     obj.value = tz_localize_to_utc_single(value, obj.tzinfo)
     if tz is None:
-        check_overflows(obj)
+        check_overflows(obj, NPY_FR_ns)
         return obj
 
+    cdef:
+        Localizer info = Localizer(tz, NPY_FR_ns)
+
     # Infer fold from offset-adjusted obj.value
     # see PEP 495 https://www.python.org/dev/peps/pep-0495/#the-fold-attribute
-    if is_utc(tz):
+    if info.use_utc:
         pass
-    elif is_tzlocal(tz):
-        tz_convert_utc_to_tzlocal(obj.value, tz, &obj.fold)
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-
-        if typ == 'dateutil':
-            pos = trans.searchsorted(obj.value, side='right') - 1
-            obj.fold = _infer_tsobject_fold(obj, trans, deltas, pos)
+    elif info.use_tzlocal:
+        info.utc_val_to_local_val(obj.value, &pos, &obj.fold)
+    elif info.use_dst and not info.use_pytz:
+        # i.e. dateutil
+        info.utc_val_to_local_val(obj.value, &pos, &obj.fold)
 
     # Keep the converter same as PyDateTime's
     dt = datetime(obj.dts.year, obj.dts.month, obj.dts.day,
@@ -603,64 +476,73 @@ cdef _TSObject _convert_str_to_tsobject(object ts, tzinfo tz, str unit,
     """
     cdef:
         npy_datetimestruct dts
-        int out_local = 0, out_tzoffset = 0
-        bint do_parse_datetime_string = False
+        int out_local = 0, out_tzoffset = 0, string_to_dts_failed
+        datetime dt
+        int64_t ival
+        NPY_DATETIMEUNIT out_bestunit
 
     if len(ts) == 0 or ts in nat_strings:
         ts = NaT
+        obj = _TSObject()
+        obj.value = NPY_NAT
+        obj.tzinfo = tz
+        return obj
     elif ts == 'now':
         # Issue 9000, we short-circuit rather than going
         # into np_datetime_strings which returns utc
-        ts = datetime.now(tz)
+        dt = datetime.now(tz)
     elif ts == 'today':
         # Issue 9000, we short-circuit rather than going
         # into np_datetime_strings which returns a normalized datetime
-        ts = datetime.now(tz)
+        dt = datetime.now(tz)
         # equiv: datetime.today().replace(tzinfo=tz)
     else:
-        string_to_dts_failed = _string_to_dts(
-            ts, &dts, &out_local,
+        string_to_dts_failed = string_to_dts(
+            ts, &dts, &out_bestunit, &out_local,
             &out_tzoffset, False
         )
-        try:
-            if not string_to_dts_failed:
+        if not string_to_dts_failed:
+            try:
                 check_dts_bounds(&dts)
                 if out_local == 1:
                     return _create_tsobject_tz_using_offset(dts,
                                                             out_tzoffset, tz)
                 else:
-                    ts = dtstruct_to_dt64(&dts)
+                    ival = dtstruct_to_dt64(&dts)
                     if tz is not None:
                         # shift for _localize_tso
-                        ts = tz_localize_to_utc_single(ts, tz,
-                                                       ambiguous="raise")
+                        ival = tz_localize_to_utc_single(ival, tz,
+                                                         ambiguous="raise")
 
-        except OutOfBoundsDatetime:
-            # GH#19382 for just-barely-OutOfBounds falling back to dateutil
-            # parser will return incorrect result because it will ignore
-            # nanoseconds
-            raise
+                    return convert_to_tsobject(ival, tz, None, False, False)
 
-        except ValueError:
-            do_parse_datetime_string = True
+            except OutOfBoundsDatetime:
+                # GH#19382 for just-barely-OutOfBounds falling back to dateutil
+                # parser will return incorrect result because it will ignore
+                # nanoseconds
+                raise
 
-        if string_to_dts_failed or do_parse_datetime_string:
-            try:
-                ts = parse_datetime_string(ts, dayfirst=dayfirst,
-                                           yearfirst=yearfirst)
-            except (ValueError, OverflowError):
-                raise ValueError("could not convert string to Timestamp")
+            except ValueError:
+                # Fall through to parse_datetime_string
+                pass
+
+        try:
+            dt = parse_datetime_string(ts, dayfirst=dayfirst,
+                                       yearfirst=yearfirst)
+        except (ValueError, OverflowError):
+            raise ValueError("could not convert string to Timestamp")
 
-    return convert_to_tsobject(ts, tz, unit, dayfirst, yearfirst)
+    return convert_datetime_to_tsobject(dt, tz)
 
 
-cdef inline check_overflows(_TSObject obj):
+cdef inline check_overflows(_TSObject obj, NPY_DATETIMEUNIT reso=NPY_FR_ns):
     """
     Check that we haven't silently overflowed in timezone conversion
 
     Parameters
     ----------
     obj : _TSObject
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
@@ -671,7 +553,12 @@ cdef inline check_overflows(_TSObject obj):
     OutOfBoundsDatetime
     """
     # GH#12677
-    if obj.dts.year == 1677:
+    cdef:
+        npy_datetimestruct lb, ub
+
+    get_implementation_bounds(reso, &lb, &ub)
+
+    if obj.dts.year == lb.year:
         if not (obj.value < 0):
             from pandas._libs.tslibs.timestamps import Timestamp
             fmt = (f"{obj.dts.year}-{obj.dts.month:02d}-{obj.dts.day:02d} "
@@ -679,7 +566,7 @@ cdef inline check_overflows(_TSObject obj):
             raise OutOfBoundsDatetime(
                 f"Converting {fmt} underflows past {Timestamp.min}"
             )
-    elif obj.dts.year == 2262:
+    elif obj.dts.year == ub.year:
         if not (obj.value > 0):
             from pandas._libs.tslibs.timestamps import Timestamp
             fmt = (f"{obj.dts.year}-{obj.dts.month:02d}-{obj.dts.day:02d} "
@@ -691,7 +578,7 @@ cdef inline check_overflows(_TSObject obj):
 # ----------------------------------------------------------------------
 # Localization
 
-cdef inline void _localize_tso(_TSObject obj, tzinfo tz):
+cdef inline void _localize_tso(_TSObject obj, tzinfo tz, NPY_DATETIMEUNIT reso):
     """
     Given the UTC nanosecond timestamp in obj.value, find the wall-clock
     representation of that timestamp in the given timezone.
@@ -700,6 +587,7 @@ cdef inline void _localize_tso(_TSObject obj, tzinfo tz):
     ----------
     obj : _TSObject
     tz : tzinfo
+    reso : NPY_DATETIMEUNIT
 
     Returns
     -------
@@ -710,91 +598,27 @@ cdef inline void _localize_tso(_TSObject obj, tzinfo tz):
     Sets obj.tzinfo inplace, alters obj.dts inplace.
     """
     cdef:
-        ndarray[int64_t] trans
-        int64_t[:] deltas
         int64_t local_val
-        Py_ssize_t pos
-        str typ
+        Py_ssize_t outpos = -1
+        Localizer info = Localizer(tz, reso)
 
     assert obj.tzinfo is None
 
-    if is_utc(tz):
+    if info.use_utc:
         pass
     elif obj.value == NPY_NAT:
         pass
-    elif is_tzlocal(tz):
-        local_val = tz_convert_utc_to_tzlocal(obj.value, tz, &obj.fold)
-        dt64_to_dtstruct(local_val, &obj.dts)
     else:
-        # Adjust datetime64 timestamp, recompute datetimestruct
-        trans, deltas, typ = get_dst_info(tz)
-
-        if is_fixed_offset(tz):
-            # static/fixed tzinfo; in this case we know len(deltas) == 1
-            # This can come back with `typ` of either "fixed" or None
-            dt64_to_dtstruct(obj.value + deltas[0], &obj.dts)
-        elif typ == 'pytz':
-            # i.e. treat_tz_as_pytz(tz)
-            pos = trans.searchsorted(obj.value, side='right') - 1
-            tz = tz._tzinfos[tz._transition_info[pos]]
-            dt64_to_dtstruct(obj.value + deltas[pos], &obj.dts)
-        elif typ == 'dateutil':
-            # i.e. treat_tz_as_dateutil(tz)
-            pos = trans.searchsorted(obj.value, side='right') - 1
-            dt64_to_dtstruct(obj.value + deltas[pos], &obj.dts)
-            # dateutil supports fold, so we infer fold from value
-            obj.fold = _infer_tsobject_fold(obj, trans, deltas, pos)
-        else:
-            # Note: as of 2018-07-17 all tzinfo objects that are _not_
-            # either pytz or dateutil have is_fixed_offset(tz) == True,
-            # so this branch will never be reached.
-            pass
-
-    obj.tzinfo = tz
-
+        local_val = info.utc_val_to_local_val(obj.value, &outpos, &obj.fold)
 
-cdef inline bint _infer_tsobject_fold(
-    _TSObject obj,
-    const int64_t[:] trans,
-    const int64_t[:] deltas,
-    int32_t pos,
-):
-    """
-    Infer _TSObject fold property from value by assuming 0 and then setting
-    to 1 if necessary.
-
-    Parameters
-    ----------
-    obj : _TSObject
-    trans : ndarray[int64_t]
-        ndarray of offset transition points in nanoseconds since epoch.
-    deltas : int64_t[:]
-        array of offsets corresponding to transition points in trans.
-    pos : int32_t
-        Position of the last transition point before taking fold into account.
-
-    Returns
-    -------
-    bint
-        Due to daylight saving time, one wall clock time can occur twice
-        when shifting from summer to winter time; fold describes whether the
-        datetime-like corresponds  to the first (0) or the second time (1)
-        the wall clock hits the ambiguous time
+        if info.use_pytz:
+            # infer we went through a pytz path, will have outpos!=-1
+            tz = tz._tzinfos[tz._transition_info[outpos]]
 
-    References
-    ----------
-    .. [1] "PEP 495 - Local Time Disambiguation"
-           https://www.python.org/dev/peps/pep-0495/#the-fold-attribute
-    """
-    cdef:
-        bint fold = 0
+        pandas_datetime_to_datetimestruct(local_val, reso, &obj.dts)
 
-    if pos > 0:
-        fold_delta = deltas[pos - 1] - deltas[pos]
-        if obj.value - fold_delta < trans[pos]:
-            fold = 1
+    obj.tzinfo = tz
 
-    return fold
 
 cdef inline datetime _localize_pydatetime(datetime dt, tzinfo tz):
     """
@@ -828,31 +652,4 @@ cpdef inline datetime localize_pydatetime(datetime dt, tzinfo tz):
         return dt
     elif isinstance(dt, ABCTimestamp):
         return dt.tz_localize(tz)
-    elif is_utc(tz):
-        return _localize_pydatetime(dt, tz)
-    try:
-        # datetime.replace with pytz may be incorrect result
-        return tz.localize(dt)
-    except AttributeError:
-        return dt.replace(tzinfo=tz)
-
-
-# ----------------------------------------------------------------------
-# Normalization
-
-@cython.cdivision(False)
-cdef inline int64_t normalize_i8_stamp(int64_t local_val) nogil:
-    """
-    Round the localized nanosecond timestamp down to the previous midnight.
-
-    Parameters
-    ----------
-    local_val : int64_t
-
-    Returns
-    -------
-    int64_t
-    """
-    cdef:
-        int64_t day_nanos = 24 * 3600 * 1_000_000_000
-    return local_val - (local_val % day_nanos)
+    return _localize_pydatetime(dt, tz)
diff --git a/pandas/_libs/tslibs/dtypes.pxd b/pandas/_libs/tslibs/dtypes.pxd
index 71b4eeabbaaf5..352680143113d 100644
--- a/pandas/_libs/tslibs/dtypes.pxd
+++ b/pandas/_libs/tslibs/dtypes.pxd
@@ -1,7 +1,18 @@
+from numpy cimport int64_t
+
+from pandas._libs.tslibs.np_datetime cimport NPY_DATETIMEUNIT
+
+
+cpdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit)
+cdef NPY_DATETIMEUNIT abbrev_to_npy_unit(str abbrev)
+cdef NPY_DATETIMEUNIT freq_group_code_to_npy_unit(int freq) nogil
+cpdef int64_t periods_per_day(NPY_DATETIMEUNIT reso=*) except? -1
+cpdef int64_t periods_per_second(NPY_DATETIMEUNIT reso) except? -1
+
 cdef dict attrname_to_abbrevs
 
 cdef enum c_FreqGroup:
-    # Mirrors FreqGroup in the .pxy file
+    # Mirrors FreqGroup in the .pyx file
     FR_ANN = 1000
     FR_QTR = 2000
     FR_MTH = 3000
@@ -17,6 +28,20 @@ cdef enum c_FreqGroup:
     FR_UND = -10000  # undefined
 
 
+cdef enum c_Resolution:
+    # Mirrors Resolution in the .pyx file
+    RESO_NS = 0
+    RESO_US = 1
+    RESO_MS = 2
+    RESO_SEC = 3
+    RESO_MIN = 4
+    RESO_HR = 5
+    RESO_DAY = 6
+    RESO_MTH = 7
+    RESO_QTR = 8
+    RESO_YR = 9
+
+
 cdef enum PeriodDtypeCode:
     # Annual freqs with various fiscal year ends.
     # eg, 2005 for A_FEB runs Mar 1, 2004 to Feb 28, 2005
@@ -74,3 +99,5 @@ cdef enum PeriodDtypeCode:
 cdef class PeriodDtypeBase:
     cdef readonly:
         PeriodDtypeCode _dtype_code
+
+    cpdef int _get_to_timestamp_base(self)
diff --git a/pandas/_libs/tslibs/dtypes.pyi b/pandas/_libs/tslibs/dtypes.pyi
index 8e47993e9d85f..82f62e16c4205 100644
--- a/pandas/_libs/tslibs/dtypes.pyi
+++ b/pandas/_libs/tslibs/dtypes.pyi
@@ -1,21 +1,27 @@
 from enum import Enum
 
-from pandas._libs.tslibs.offsets import BaseOffset
-
+# These are not public API, but are exposed in the .pyi file because they
+#  are imported in tests.
 _attrname_to_abbrevs: dict[str, str]
 _period_code_map: dict[str, int]
 
+def periods_per_day(reso: int) -> int: ...
+def periods_per_second(reso: int) -> int: ...
+def is_supported_unit(reso: int) -> bool: ...
+def npy_unit_to_abbrev(reso: int) -> str: ...
+
 class PeriodDtypeBase:
     _dtype_code: int  # PeriodDtypeCode
 
     # actually __cinit__
     def __new__(cls, code: int): ...
-    def freq_group_code(self) -> int: ...
-    def date_offset(self) -> BaseOffset: ...
-    @classmethod
-    def from_date_offset(cls, offset: BaseOffset) -> PeriodDtypeBase: ...
     @property
-    def resolution(self) -> Resolution: ...
+    def _freq_group_code(self) -> int: ...
+    @property
+    def _resolution_obj(self) -> Resolution: ...
+    def _get_to_timestamp_base(self) -> int: ...
+    @property
+    def _freqstr(self) -> str: ...
 
 class FreqGroup(Enum):
     FR_ANN: int
@@ -32,7 +38,7 @@ class FreqGroup(Enum):
     FR_NS: int
     FR_UND: int
     @staticmethod
-    def get_freq_group(code: int) -> FreqGroup: ...
+    def from_period_dtype_code(code: int) -> FreqGroup: ...
 
 class Resolution(Enum):
     RESO_NS: int
@@ -48,10 +54,26 @@ class Resolution(Enum):
     def __lt__(self, other: Resolution) -> bool: ...
     def __ge__(self, other: Resolution) -> bool: ...
     @property
-    def freq_group(self) -> FreqGroup: ...
-    @property
     def attrname(self) -> str: ...
     @classmethod
     def from_attrname(cls, attrname: str) -> Resolution: ...
     @classmethod
-    def get_reso_from_freq(cls, freq: str) -> Resolution: ...
+    def get_reso_from_freqstr(cls, freq: str) -> Resolution: ...
+    @property
+    def attr_abbrev(self) -> str: ...
+
+class NpyDatetimeUnit(Enum):
+    NPY_FR_Y: int
+    NPY_FR_M: int
+    NPY_FR_W: int
+    NPY_FR_D: int
+    NPY_FR_h: int
+    NPY_FR_m: int
+    NPY_FR_s: int
+    NPY_FR_ms: int
+    NPY_FR_us: int
+    NPY_FR_ns: int
+    NPY_FR_ps: int
+    NPY_FR_fs: int
+    NPY_FR_as: int
+    NPY_FR_GENERIC: int
diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index ea5454572ca7e..c09ac2a686d5c 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -1,7 +1,14 @@
 # period frequency constants corresponding to scikits timeseries
 # originals
+cimport cython
+
 from enum import Enum
 
+from pandas._libs.tslibs.np_datetime cimport (
+    NPY_DATETIMEUNIT,
+    get_conversion_factor,
+)
+
 
 cdef class PeriodDtypeBase:
     """
@@ -23,83 +30,94 @@ cdef class PeriodDtypeBase:
         return self._dtype_code == other._dtype_code
 
     @property
-    def freq_group_code(self) -> int:
+    def _freq_group_code(self) -> int:
         # See also: libperiod.get_freq_group
         return (self._dtype_code // 1000) * 1000
 
     @property
-    def resolution(self) -> "Resolution":
-        fgc = self.freq_group_code
-        return Resolution.from_freq_group(FreqGroup(fgc))
+    def _resolution_obj(self) -> "Resolution":
+        fgc = self._freq_group_code
+        freq_group = FreqGroup(fgc)
+        abbrev = _reverse_period_code_map[freq_group.value].split("-")[0]
+        if abbrev == "B":
+            return Resolution.RESO_DAY
+        attrname = _abbrev_to_attrnames[abbrev]
+        return Resolution.from_attrname(attrname)
 
     @property
-    def date_offset(self):
-        """
-        Corresponding DateOffset object.
+    def _freqstr(self) -> str:
+        # Will be passed to to_offset in Period._maybe_convert_freq
+        return _reverse_period_code_map.get(self._dtype_code)
 
-        This mapping is mainly for backward-compatibility.
+    cpdef int _get_to_timestamp_base(self):
         """
-        from .offsets import to_offset
+        Return frequency code group used for base of to_timestamp against
+        frequency code.
 
-        freqstr = _reverse_period_code_map.get(self._dtype_code)
+        Return day freq code against longer freq than day.
+        Return second freq code against hour between second.
 
-        return to_offset(freqstr)
-
-    @classmethod
-    def from_date_offset(cls, offset):
-        code = offset._period_dtype_code
-        return cls(code)
+        Returns
+        -------
+        int
+        """
+        base = <c_FreqGroup>self._dtype_code
+        if base < FR_BUS:
+            return FR_DAY
+        elif FR_HR <= base <= FR_SEC:
+            return FR_SEC
+        return base
 
 
 _period_code_map = {
     # Annual freqs with various fiscal year ends.
     # eg, 2005 for A-FEB runs Mar 1, 2004 to Feb 28, 2005
-    "A-DEC": 1000,  # Annual - December year end
-    "A-JAN": 1001,  # Annual - January year end
-    "A-FEB": 1002,  # Annual - February year end
-    "A-MAR": 1003,  # Annual - March year end
-    "A-APR": 1004,  # Annual - April year end
-    "A-MAY": 1005,  # Annual - May year end
-    "A-JUN": 1006,  # Annual - June year end
-    "A-JUL": 1007,  # Annual - July year end
-    "A-AUG": 1008,  # Annual - August year end
-    "A-SEP": 1009,  # Annual - September year end
-    "A-OCT": 1010,  # Annual - October year end
-    "A-NOV": 1011,  # Annual - November year end
+    "A-DEC": PeriodDtypeCode.A_DEC,  # Annual - December year end
+    "A-JAN": PeriodDtypeCode.A_JAN,  # Annual - January year end
+    "A-FEB": PeriodDtypeCode.A_FEB,  # Annual - February year end
+    "A-MAR": PeriodDtypeCode.A_MAR,  # Annual - March year end
+    "A-APR": PeriodDtypeCode.A_APR,  # Annual - April year end
+    "A-MAY": PeriodDtypeCode.A_MAY,  # Annual - May year end
+    "A-JUN": PeriodDtypeCode.A_JUN,  # Annual - June year end
+    "A-JUL": PeriodDtypeCode.A_JUL,  # Annual - July year end
+    "A-AUG": PeriodDtypeCode.A_AUG,  # Annual - August year end
+    "A-SEP": PeriodDtypeCode.A_SEP,  # Annual - September year end
+    "A-OCT": PeriodDtypeCode.A_OCT,  # Annual - October year end
+    "A-NOV": PeriodDtypeCode.A_NOV,  # Annual - November year end
 
     # Quarterly frequencies with various fiscal year ends.
     # eg, Q42005 for Q-OCT runs Aug 1, 2005 to Oct 31, 2005
-    "Q-DEC": 2000,    # Quarterly - December year end
-    "Q-JAN": 2001,    # Quarterly - January year end
-    "Q-FEB": 2002,    # Quarterly - February year end
-    "Q-MAR": 2003,    # Quarterly - March year end
-    "Q-APR": 2004,    # Quarterly - April year end
-    "Q-MAY": 2005,    # Quarterly - May year end
-    "Q-JUN": 2006,    # Quarterly - June year end
-    "Q-JUL": 2007,    # Quarterly - July year end
-    "Q-AUG": 2008,    # Quarterly - August year end
-    "Q-SEP": 2009,    # Quarterly - September year end
-    "Q-OCT": 2010,    # Quarterly - October year end
-    "Q-NOV": 2011,    # Quarterly - November year end
-
-    "M": 3000,        # Monthly
-
-    "W-SUN": 4000,    # Weekly - Sunday end of week
-    "W-MON": 4001,    # Weekly - Monday end of week
-    "W-TUE": 4002,    # Weekly - Tuesday end of week
-    "W-WED": 4003,    # Weekly - Wednesday end of week
-    "W-THU": 4004,    # Weekly - Thursday end of week
-    "W-FRI": 4005,    # Weekly - Friday end of week
-    "W-SAT": 4006,    # Weekly - Saturday end of week
-
-    "B": 5000,        # Business days
-    "D": 6000,        # Daily
-    "H": 7000,        # Hourly
-    "T": 8000,        # Minutely
-    "S": 9000,        # Secondly
-    "L": 10000,       # Millisecondly
-    "U": 11000,       # Microsecondly
-    "N": 12000,       # Nanosecondly
+    "Q-DEC": PeriodDtypeCode.Q_DEC,    # Quarterly - December year end
+    "Q-JAN": PeriodDtypeCode.Q_JAN,    # Quarterly - January year end
+    "Q-FEB": PeriodDtypeCode.Q_FEB,    # Quarterly - February year end
+    "Q-MAR": PeriodDtypeCode.Q_MAR,    # Quarterly - March year end
+    "Q-APR": PeriodDtypeCode.Q_APR,    # Quarterly - April year end
+    "Q-MAY": PeriodDtypeCode.Q_MAY,    # Quarterly - May year end
+    "Q-JUN": PeriodDtypeCode.Q_JUN,    # Quarterly - June year end
+    "Q-JUL": PeriodDtypeCode.Q_JUL,    # Quarterly - July year end
+    "Q-AUG": PeriodDtypeCode.Q_AUG,    # Quarterly - August year end
+    "Q-SEP": PeriodDtypeCode.Q_SEP,    # Quarterly - September year end
+    "Q-OCT": PeriodDtypeCode.Q_OCT,    # Quarterly - October year end
+    "Q-NOV": PeriodDtypeCode.Q_NOV,    # Quarterly - November year end
+
+    "M": PeriodDtypeCode.M,        # Monthly
+
+    "W-SUN": PeriodDtypeCode.W_SUN,    # Weekly - Sunday end of week
+    "W-MON": PeriodDtypeCode.W_MON,    # Weekly - Monday end of week
+    "W-TUE": PeriodDtypeCode.W_TUE,    # Weekly - Tuesday end of week
+    "W-WED": PeriodDtypeCode.W_WED,    # Weekly - Wednesday end of week
+    "W-THU": PeriodDtypeCode.W_THU,    # Weekly - Thursday end of week
+    "W-FRI": PeriodDtypeCode.W_FRI,    # Weekly - Friday end of week
+    "W-SAT": PeriodDtypeCode.W_SAT,    # Weekly - Saturday end of week
+
+    "B": PeriodDtypeCode.B,        # Business days
+    "D": PeriodDtypeCode.D,        # Daily
+    "H": PeriodDtypeCode.H,        # Hourly
+    "T": PeriodDtypeCode.T,        # Minutely
+    "S": PeriodDtypeCode.S,        # Secondly
+    "L": PeriodDtypeCode.L,       # Millisecondly
+    "U": PeriodDtypeCode.U,       # Microsecondly
+    "N": PeriodDtypeCode.N,       # Nanosecondly
 }
 
 _reverse_period_code_map = {
@@ -112,7 +130,7 @@ _period_code_map.update({"Y" + key[1:]: _period_code_map[key]
 
 _period_code_map.update({
     "Q": 2000,   # Quarterly - December year end (default quarterly)
-    "A": 1000,   # Annual
+    "A": PeriodDtypeCode.A,   # Annual
     "W": 4000,   # Weekly
     "C": 5000,   # Custom Business Day
 })
@@ -140,41 +158,38 @@ cdef dict _abbrev_to_attrnames = {v: k for k, v in attrname_to_abbrevs.items()}
 
 class FreqGroup(Enum):
     # Mirrors c_FreqGroup in the .pxd file
-    FR_ANN = 1000
-    FR_QTR = 2000
-    FR_MTH = 3000
-    FR_WK = 4000
-    FR_BUS = 5000
-    FR_DAY = 6000
-    FR_HR = 7000
-    FR_MIN = 8000
-    FR_SEC = 9000
-    FR_MS = 10000
-    FR_US = 11000
-    FR_NS = 12000
-    FR_UND = -10000  # undefined
+    FR_ANN = c_FreqGroup.FR_ANN
+    FR_QTR = c_FreqGroup.FR_QTR
+    FR_MTH = c_FreqGroup.FR_MTH
+    FR_WK = c_FreqGroup.FR_WK
+    FR_BUS = c_FreqGroup.FR_BUS
+    FR_DAY = c_FreqGroup.FR_DAY
+    FR_HR = c_FreqGroup.FR_HR
+    FR_MIN = c_FreqGroup.FR_MIN
+    FR_SEC = c_FreqGroup.FR_SEC
+    FR_MS = c_FreqGroup.FR_MS
+    FR_US = c_FreqGroup.FR_US
+    FR_NS = c_FreqGroup.FR_NS
+    FR_UND = c_FreqGroup.FR_UND  # undefined
 
     @staticmethod
-    def get_freq_group(code: int) -> "FreqGroup":
-        # See also: PeriodDtypeBase.freq_group_code
+    def from_period_dtype_code(code: int) -> "FreqGroup":
+        # See also: PeriodDtypeBase._freq_group_code
         code = (code // 1000) * 1000
         return FreqGroup(code)
 
 
 class Resolution(Enum):
-
-    # Note: cython won't allow us to reference the cdef versions at the
-    # module level
-    RESO_NS = 0
-    RESO_US = 1
-    RESO_MS = 2
-    RESO_SEC = 3
-    RESO_MIN = 4
-    RESO_HR = 5
-    RESO_DAY = 6
-    RESO_MTH = 7
-    RESO_QTR = 8
-    RESO_YR = 9
+    RESO_NS = c_Resolution.RESO_NS
+    RESO_US = c_Resolution.RESO_US
+    RESO_MS = c_Resolution.RESO_MS
+    RESO_SEC = c_Resolution.RESO_SEC
+    RESO_MIN = c_Resolution.RESO_MIN
+    RESO_HR = c_Resolution.RESO_HR
+    RESO_DAY = c_Resolution.RESO_DAY
+    RESO_MTH = c_Resolution.RESO_MTH
+    RESO_QTR = c_Resolution.RESO_QTR
+    RESO_YR = c_Resolution.RESO_YR
 
     def __lt__(self, other):
         return self.value < other.value
@@ -183,29 +198,9 @@ class Resolution(Enum):
         return self.value >= other.value
 
     @property
-    def freq_group(self) -> FreqGroup:
-        if self == Resolution.RESO_NS:
-            return FreqGroup.FR_NS
-        elif self == Resolution.RESO_US:
-            return FreqGroup.FR_US
-        elif self == Resolution.RESO_MS:
-            return FreqGroup.FR_MS
-        elif self == Resolution.RESO_SEC:
-            return FreqGroup.FR_SEC
-        elif self == Resolution.RESO_MIN:
-            return FreqGroup.FR_MIN
-        elif self == Resolution.RESO_HR:
-            return FreqGroup.FR_HR
-        elif self == Resolution.RESO_DAY:
-            return FreqGroup.FR_DAY
-        elif self == Resolution.RESO_MTH:
-            return FreqGroup.FR_MTH
-        elif self == Resolution.RESO_QTR:
-            return FreqGroup.FR_QTR
-        elif self == Resolution.RESO_YR:
-            return FreqGroup.FR_ANN
-        else:
-            raise ValueError(self)  # pragma: no cover
+    def attr_abbrev(self) -> str:
+        # string that we can pass to to_offset
+        return _attrname_to_abbrevs[self.attrname]
 
     @property
     def attrname(self) -> str:
@@ -235,7 +230,7 @@ class Resolution(Enum):
         return cls(_str_reso_map[attrname])
 
     @classmethod
-    def get_reso_from_freq(cls, freq: str) -> "Resolution":
+    def get_reso_from_freqstr(cls, freq: str) -> "Resolution":
         """
         Return resolution code against frequency str.
 
@@ -243,10 +238,10 @@ class Resolution(Enum):
 
         Examples
         --------
-        >>> Resolution.get_reso_from_freq('H')
+        >>> Resolution.get_reso_from_freqstr('H')
         <Resolution.RESO_HR: 5>
 
-        >>> Resolution.get_reso_from_freq('H') == Resolution.RESO_HR
+        >>> Resolution.get_reso_from_freqstr('H') == Resolution.RESO_HR
         True
         """
         try:
@@ -264,13 +259,141 @@ class Resolution(Enum):
 
         return cls.from_attrname(attr_name)
 
-    @classmethod
-    def from_freq_group(cls, freq_group: FreqGroup) -> "Resolution":
-        abbrev = _reverse_period_code_map[freq_group.value].split("-")[0]
-        if abbrev == "B":
-            return cls.RESO_DAY
-        attrname = _abbrev_to_attrnames[abbrev]
-        return cls.from_attrname(attrname)
+
+class NpyDatetimeUnit(Enum):
+    """
+    Python-space analogue to NPY_DATETIMEUNIT.
+    """
+    NPY_FR_Y = NPY_DATETIMEUNIT.NPY_FR_Y
+    NPY_FR_M = NPY_DATETIMEUNIT.NPY_FR_M
+    NPY_FR_W = NPY_DATETIMEUNIT.NPY_FR_W
+    NPY_FR_D = NPY_DATETIMEUNIT.NPY_FR_D
+    NPY_FR_h = NPY_DATETIMEUNIT.NPY_FR_h
+    NPY_FR_m = NPY_DATETIMEUNIT.NPY_FR_m
+    NPY_FR_s = NPY_DATETIMEUNIT.NPY_FR_s
+    NPY_FR_ms = NPY_DATETIMEUNIT.NPY_FR_ms
+    NPY_FR_us = NPY_DATETIMEUNIT.NPY_FR_us
+    NPY_FR_ns = NPY_DATETIMEUNIT.NPY_FR_ns
+    NPY_FR_ps = NPY_DATETIMEUNIT.NPY_FR_ps
+    NPY_FR_fs = NPY_DATETIMEUNIT.NPY_FR_fs
+    NPY_FR_as = NPY_DATETIMEUNIT.NPY_FR_as
+    NPY_FR_GENERIC = NPY_DATETIMEUNIT.NPY_FR_GENERIC
+
+
+def is_supported_unit(NPY_DATETIMEUNIT reso):
+    return (
+        reso == NPY_DATETIMEUNIT.NPY_FR_ns
+        or reso == NPY_DATETIMEUNIT.NPY_FR_us
+        or reso == NPY_DATETIMEUNIT.NPY_FR_ms
+        or reso == NPY_DATETIMEUNIT.NPY_FR_s
+    )
+
+
+cpdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit):
+    if unit == NPY_DATETIMEUNIT.NPY_FR_ns or unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
+        # generic -> default to nanoseconds
+        return "ns"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_us:
+        return "us"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_ms:
+        return "ms"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_s:
+        return "s"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_m:
+        return "m"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_h:
+        return "h"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_D:
+        return "D"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_W:
+        return "W"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_M:
+        return "M"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_Y:
+        return "Y"
+
+    # Checks for not-really-supported units go at the end, as we don't expect
+    #  to see these often
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_ps:
+        return "ps"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_fs:
+        return "fs"
+    elif unit == NPY_DATETIMEUNIT.NPY_FR_as:
+        return "as"
+
+    else:
+        raise NotImplementedError(unit)
+
+
+cdef NPY_DATETIMEUNIT abbrev_to_npy_unit(str abbrev):
+    if abbrev == "Y":
+        return NPY_DATETIMEUNIT.NPY_FR_Y
+    elif abbrev == "M":
+        return NPY_DATETIMEUNIT.NPY_FR_M
+    elif abbrev == "W":
+        return NPY_DATETIMEUNIT.NPY_FR_W
+    elif abbrev == "D" or abbrev == "d":
+        return NPY_DATETIMEUNIT.NPY_FR_D
+    elif abbrev == "h":
+        return NPY_DATETIMEUNIT.NPY_FR_h
+    elif abbrev == "m":
+        return NPY_DATETIMEUNIT.NPY_FR_m
+    elif abbrev == "s":
+        return NPY_DATETIMEUNIT.NPY_FR_s
+    elif abbrev == "ms":
+        return NPY_DATETIMEUNIT.NPY_FR_ms
+    elif abbrev == "us":
+        return NPY_DATETIMEUNIT.NPY_FR_us
+    elif abbrev == "ns":
+        return NPY_DATETIMEUNIT.NPY_FR_ns
+    elif abbrev == "ps":
+        return NPY_DATETIMEUNIT.NPY_FR_ps
+    elif abbrev == "fs":
+        return NPY_DATETIMEUNIT.NPY_FR_fs
+    elif abbrev == "as":
+        return NPY_DATETIMEUNIT.NPY_FR_as
+    elif abbrev is None:
+        return NPY_DATETIMEUNIT.NPY_FR_GENERIC
+    else:
+        raise ValueError(f"Unrecognized unit {abbrev}")
+
+
+cdef NPY_DATETIMEUNIT freq_group_code_to_npy_unit(int freq) nogil:
+    """
+    Convert the freq to the corresponding NPY_DATETIMEUNIT to pass
+    to npy_datetimestruct_to_datetime.
+    """
+    if freq == FR_MTH:
+        return NPY_DATETIMEUNIT.NPY_FR_M
+    elif freq == FR_DAY:
+        return NPY_DATETIMEUNIT.NPY_FR_D
+    elif freq == FR_HR:
+        return NPY_DATETIMEUNIT.NPY_FR_h
+    elif freq == FR_MIN:
+        return NPY_DATETIMEUNIT.NPY_FR_m
+    elif freq == FR_SEC:
+        return NPY_DATETIMEUNIT.NPY_FR_s
+    elif freq == FR_MS:
+        return NPY_DATETIMEUNIT.NPY_FR_ms
+    elif freq == FR_US:
+        return NPY_DATETIMEUNIT.NPY_FR_us
+    elif freq == FR_NS:
+        return NPY_DATETIMEUNIT.NPY_FR_ns
+    elif freq == FR_UND:
+        # Default to Day
+        return NPY_DATETIMEUNIT.NPY_FR_D
+
+
+# TODO: use in _matplotlib.converter?
+cpdef int64_t periods_per_day(NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns) except? -1:
+    """
+    How many of the given time units fit into a single day?
+    """
+    return get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_D, reso)
+
+
+cpdef int64_t periods_per_second(NPY_DATETIMEUNIT reso) except? -1:
+    return get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_s, reso)
 
 
 cdef dict _reso_str_map = {
diff --git a/pandas/_libs/tslibs/fields.pyi b/pandas/_libs/tslibs/fields.pyi
index 415b4329310c0..8b4bc1a31a1aa 100644
--- a/pandas/_libs/tslibs/fields.pyi
+++ b/pandas/_libs/tslibs/fields.pyi
@@ -4,34 +4,40 @@ from pandas._typing import npt
 
 def build_field_sarray(
     dtindex: npt.NDArray[np.int64],  # const int64_t[:]
+    reso: int,  # NPY_DATETIMEUNIT
 ) -> np.ndarray: ...
 def month_position_check(fields, weekdays) -> str | None: ...
 def get_date_name_field(
     dtindex: npt.NDArray[np.int64],  # const int64_t[:]
     field: str,
     locale: str | None = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.object_]: ...
 def get_start_end_field(
-    dtindex: npt.NDArray[np.int64],  # const int64_t[:]
+    dtindex: npt.NDArray[np.int64],
     field: str,
     freqstr: str | None = ...,
     month_kw: int = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.bool_]: ...
 def get_date_field(
     dtindex: npt.NDArray[np.int64],  # const int64_t[:]
     field: str,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.int32]: ...
 def get_timedelta_field(
-    tdindex: np.ndarray,  # const int64_t[:]
+    tdindex: npt.NDArray[np.int64],  # const int64_t[:]
     field: str,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.int32]: ...
 def isleapyear_arr(
     years: np.ndarray,
 ) -> npt.NDArray[np.bool_]: ...
 def build_isocalendar_sarray(
     dtindex: npt.NDArray[np.int64],  # const int64_t[:]
+    reso: int,  # NPY_DATETIMEUNIT
 ) -> np.ndarray: ...
-def get_locale_names(name_type: str, locale: str | None = ...): ...
+def _get_locale_names(name_type: str, locale: str | None = ...): ...
 
 class RoundTo:
     @property
diff --git a/pandas/_libs/tslibs/fields.pyx b/pandas/_libs/tslibs/fields.pyx
index c1915e719f515..71a0f2727445f 100644
--- a/pandas/_libs/tslibs/fields.pyx
+++ b/pandas/_libs/tslibs/fields.pyx
@@ -4,8 +4,11 @@ objects and arrays
 """
 from locale import LC_TIME
 
-import cython
-from cython import Py_ssize_t
+from _strptime import LocaleTime
+
+cimport cython
+from cython cimport Py_ssize_t
+
 import numpy as np
 
 cimport numpy as cnp
@@ -40,18 +43,19 @@ from pandas._libs.tslibs.ccalendar cimport (
 )
 from pandas._libs.tslibs.nattype cimport NPY_NAT
 from pandas._libs.tslibs.np_datetime cimport (
-    dt64_to_dtstruct,
+    NPY_DATETIMEUNIT,
+    NPY_FR_ns,
+    get_unit_from_dtype,
     npy_datetimestruct,
+    pandas_datetime_to_datetimestruct,
+    pandas_timedelta_to_timedeltastruct,
     pandas_timedeltastruct,
-    td64_to_tdstruct,
 )
 
-from pandas._libs.tslibs.strptime import LocaleTime
-
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def build_field_sarray(const int64_t[:] dtindex):
+def build_field_sarray(const int64_t[:] dtindex, NPY_DATETIMEUNIT reso):
     """
     Datetime as int64 representation to a structured array of fields
     """
@@ -81,7 +85,7 @@ def build_field_sarray(const int64_t[:] dtindex):
     mus = out['u']
 
     for i in range(count):
-        dt64_to_dtstruct(dtindex[i], &dts)
+        pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
         years[i] = dts.year
         months[i] = dts.month
         days[i] = dts.day
@@ -135,13 +139,18 @@ def month_position_check(fields, weekdays) -> str | None:
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def get_date_name_field(const int64_t[:] dtindex, str field, object locale=None):
+def get_date_name_field(
+    const int64_t[:] dtindex,
+    str field,
+    object locale=None,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+):
     """
     Given a int64-based datetime index, return array of strings of date
     name based on requested field (e.g. day_name)
     """
     cdef:
-        Py_ssize_t i, count = len(dtindex)
+        Py_ssize_t i, count = dtindex.shape[0]
         ndarray[object] out, names
         npy_datetimestruct dts
         int dow
@@ -152,14 +161,14 @@ def get_date_name_field(const int64_t[:] dtindex, str field, object locale=None)
         if locale is None:
             names = np.array(DAYS_FULL, dtype=np.object_)
         else:
-            names = np.array(get_locale_names('f_weekday', locale),
+            names = np.array(_get_locale_names('f_weekday', locale),
                              dtype=np.object_)
         for i in range(count):
             if dtindex[i] == NPY_NAT:
                 out[i] = np.nan
                 continue
 
-            dt64_to_dtstruct(dtindex[i], &dts)
+            pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
             dow = dayofweek(dts.year, dts.month, dts.day)
             out[i] = names[dow].capitalize()
 
@@ -167,14 +176,14 @@ def get_date_name_field(const int64_t[:] dtindex, str field, object locale=None)
         if locale is None:
             names = np.array(MONTHS_FULL, dtype=np.object_)
         else:
-            names = np.array(get_locale_names('f_month', locale),
+            names = np.array(_get_locale_names('f_month', locale),
                              dtype=np.object_)
         for i in range(count):
             if dtindex[i] == NPY_NAT:
                 out[i] = np.nan
                 continue
 
-            dt64_to_dtstruct(dtindex[i], &dts)
+            pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
             out[i] = names[dts.month].capitalize()
 
     else:
@@ -197,16 +206,33 @@ cdef inline bint _is_on_month(int month, int compare_month, int modby) nogil:
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def get_start_end_field(const int64_t[:] dtindex, str field,
-                        str freqstr=None, int month_kw=12):
+def get_start_end_field(
+    const int64_t[:] dtindex,
+    str field,
+    str freqstr=None,
+    int month_kw=12,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+):
     """
     Given an int64-based datetime index return array of indicators
     of whether timestamps are at the start/end of the month/quarter/year
     (defined by frequency).
+
+    Parameters
+    ----------
+    dtindex : ndarray[int64]
+    field : str
+    frestr : str or None, default None
+    month_kw : int, default 12
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
+
+    Returns
+    -------
+    ndarray[bool]
     """
     cdef:
         Py_ssize_t i
-        int count = len(dtindex)
+        int count = dtindex.shape[0]
         bint is_business = 0
         int end_month = 12
         int start_month = 1
@@ -252,7 +278,7 @@ def get_start_end_field(const int64_t[:] dtindex, str field,
                     out[i] = 0
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
 
                 if _is_on_month(dts.month, compare_month, modby) and (
                         dts.day == get_firstbday(dts.year, dts.month)):
@@ -264,7 +290,7 @@ def get_start_end_field(const int64_t[:] dtindex, str field,
                     out[i] = 0
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
 
                 if _is_on_month(dts.month, compare_month, modby) and dts.day == 1:
                     out[i] = 1
@@ -276,7 +302,7 @@ def get_start_end_field(const int64_t[:] dtindex, str field,
                     out[i] = 0
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
 
                 if _is_on_month(dts.month, compare_month, modby) and (
                         dts.day == get_lastbday(dts.year, dts.month)):
@@ -288,7 +314,7 @@ def get_start_end_field(const int64_t[:] dtindex, str field,
                     out[i] = 0
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
 
                 if _is_on_month(dts.month, compare_month, modby) and (
                         dts.day == get_days_in_month(dts.year, dts.month)):
@@ -302,7 +328,7 @@ def get_start_end_field(const int64_t[:] dtindex, str field,
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def get_date_field(const int64_t[:] dtindex, str field):
+def get_date_field(const int64_t[:] dtindex, str field, NPY_DATETIMEUNIT reso=NPY_FR_ns):
     """
     Given a int64-based datetime index, extract the year, month, etc.,
     field and return an array of these values.
@@ -321,7 +347,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.year
         return out
 
@@ -332,7 +358,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.month
         return out
 
@@ -343,7 +369,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.day
         return out
 
@@ -354,8 +380,9 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.hour
+                # TODO: can we de-dup with period.pyx <accessor>s?
         return out
 
     elif field == 'm':
@@ -365,7 +392,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.min
         return out
 
@@ -376,7 +403,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.sec
         return out
 
@@ -387,7 +414,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.us
         return out
 
@@ -398,7 +425,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.ps // 1000
         return out
     elif field == 'doy':
@@ -408,7 +435,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = get_day_of_year(dts.year, dts.month, dts.day)
         return out
 
@@ -419,7 +446,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dayofweek(dts.year, dts.month, dts.day)
         return out
 
@@ -430,7 +457,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = get_week_of_year(dts.year, dts.month, dts.day)
         return out
 
@@ -441,7 +468,7 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = dts.month
                 out[i] = ((out[i] - 1) // 3) + 1
         return out
@@ -453,18 +480,22 @@ def get_date_field(const int64_t[:] dtindex, str field):
                     out[i] = -1
                     continue
 
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 out[i] = get_days_in_month(dts.year, dts.month)
         return out
     elif field == 'is_leap_year':
-        return isleapyear_arr(get_date_field(dtindex, 'Y'))
+        return isleapyear_arr(get_date_field(dtindex, 'Y', reso=reso))
 
     raise ValueError(f"Field {field} not supported")
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def get_timedelta_field(const int64_t[:] tdindex, str field):
+def get_timedelta_field(
+    const int64_t[:] tdindex,
+    str field,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+):
     """
     Given a int64-based timedelta index, extract the days, hrs, sec.,
     field and return an array of these values.
@@ -483,7 +514,7 @@ def get_timedelta_field(const int64_t[:] tdindex, str field):
                     out[i] = -1
                     continue
 
-                td64_to_tdstruct(tdindex[i], &tds)
+                pandas_timedelta_to_timedeltastruct(tdindex[i], reso, &tds)
                 out[i] = tds.days
         return out
 
@@ -494,7 +525,7 @@ def get_timedelta_field(const int64_t[:] tdindex, str field):
                     out[i] = -1
                     continue
 
-                td64_to_tdstruct(tdindex[i], &tds)
+                pandas_timedelta_to_timedeltastruct(tdindex[i], reso, &tds)
                 out[i] = tds.seconds
         return out
 
@@ -505,7 +536,7 @@ def get_timedelta_field(const int64_t[:] tdindex, str field):
                     out[i] = -1
                     continue
 
-                td64_to_tdstruct(tdindex[i], &tds)
+                pandas_timedelta_to_timedeltastruct(tdindex[i], reso, &tds)
                 out[i] = tds.microseconds
         return out
 
@@ -516,7 +547,7 @@ def get_timedelta_field(const int64_t[:] tdindex, str field):
                     out[i] = -1
                     continue
 
-                td64_to_tdstruct(tdindex[i], &tds)
+                pandas_timedelta_to_timedeltastruct(tdindex[i], reso, &tds)
                 out[i] = tds.nanoseconds
         return out
 
@@ -537,7 +568,7 @@ cpdef isleapyear_arr(ndarray years):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def build_isocalendar_sarray(const int64_t[:] dtindex):
+def build_isocalendar_sarray(const int64_t[:] dtindex, NPY_DATETIMEUNIT reso):
     """
     Given a int64-based datetime array, return the ISO 8601 year, week, and day
     as a structured array.
@@ -565,7 +596,7 @@ def build_isocalendar_sarray(const int64_t[:] dtindex):
             if dtindex[i] == NPY_NAT:
                 ret_val = 0, 0, 0
             else:
-                dt64_to_dtstruct(dtindex[i], &dts)
+                pandas_datetime_to_datetimestruct(dtindex[i], reso, &dts)
                 ret_val = get_iso_calendar(dts.year, dts.month, dts.day)
 
             iso_years[i] = ret_val[0]
@@ -574,7 +605,7 @@ def build_isocalendar_sarray(const int64_t[:] dtindex):
     return out
 
 
-def get_locale_names(name_type: str, locale: object = None):
+def _get_locale_names(name_type: str, locale: object = None):
     """
     Returns an array of localized day or month names.
 
@@ -650,7 +681,7 @@ class RoundTo:
         return 4
 
 
-cdef inline ndarray[int64_t] _floor_int64(int64_t[:] values, int64_t unit):
+cdef inline ndarray[int64_t] _floor_int64(const int64_t[:] values, int64_t unit):
     cdef:
         Py_ssize_t i, n = len(values)
         ndarray[int64_t] result = np.empty(n, dtype="i8")
@@ -668,7 +699,7 @@ cdef inline ndarray[int64_t] _floor_int64(int64_t[:] values, int64_t unit):
     return result
 
 
-cdef inline ndarray[int64_t] _ceil_int64(int64_t[:] values, int64_t unit):
+cdef inline ndarray[int64_t] _ceil_int64(const int64_t[:] values, int64_t unit):
     cdef:
         Py_ssize_t i, n = len(values)
         ndarray[int64_t] result = np.empty(n, dtype="i8")
diff --git a/pandas/_libs/tslibs/nattype.pxd b/pandas/_libs/tslibs/nattype.pxd
index 5e5f4224f902f..e878fa7629f25 100644
--- a/pandas/_libs/tslibs/nattype.pxd
+++ b/pandas/_libs/tslibs/nattype.pxd
@@ -4,7 +4,6 @@ from numpy cimport int64_t
 
 cdef int64_t NPY_NAT
 
-cdef bint _nat_scalar_rules[6]
 cdef set c_nat_strings
 
 cdef class _NaT(datetime):
diff --git a/pandas/_libs/tslibs/nattype.pyi b/pandas/_libs/tslibs/nattype.pyi
index 8b409935b8fb8..e9ae46cee7aec 100644
--- a/pandas/_libs/tslibs/nattype.pyi
+++ b/pandas/_libs/tslibs/nattype.pyi
@@ -3,7 +3,6 @@ from datetime import (
     timedelta,
     tzinfo as _tzinfo,
 )
-from typing import Any
 
 import numpy as np
 
@@ -13,10 +12,14 @@ NaT: NaTType
 iNaT: int
 nat_strings: set[str]
 
-def is_null_datetimelike(val: object, inat_is_null: bool = ...) -> bool: ...
+_NaTComparisonTypes = datetime | timedelta | Period | np.datetime64 | np.timedelta64
 
-class NaTType(datetime):
+class _NatComparison:
+    def __call__(self, other: _NaTComparisonTypes) -> bool: ...
+
+class NaTType:
     value: np.int64
+    @property
     def asm8(self) -> np.datetime64: ...
     def to_datetime64(self) -> np.datetime64: ...
     def to_numpy(
@@ -54,26 +57,28 @@ class NaTType(datetime):
     def weekofyear(self) -> float: ...
     def day_name(self) -> float: ...
     def month_name(self) -> float: ...
-    # error: Return type "float" of "weekday" incompatible with return
-    # type "int" in supertype "date"
-    def weekday(self) -> float: ...  # type: ignore[override]
-    # error: Return type "float" of "isoweekday" incompatible with return
-    # type "int" in supertype "date"
-    def isoweekday(self) -> float: ...  # type: ignore[override]
+    def weekday(self) -> float: ...
+    def isoweekday(self) -> float: ...
     def total_seconds(self) -> float: ...
-    # error: Signature of "today" incompatible with supertype "datetime"
-    def today(self, *args, **kwargs) -> NaTType: ...  # type: ignore[override]
-    # error: Signature of "today" incompatible with supertype "datetime"
-    def now(self, *args, **kwargs) -> NaTType: ...  # type: ignore[override]
+    def today(self, *args, **kwargs) -> NaTType: ...
+    def now(self, *args, **kwargs) -> NaTType: ...
     def to_pydatetime(self) -> NaTType: ...
     def date(self) -> NaTType: ...
     def round(self) -> NaTType: ...
     def floor(self) -> NaTType: ...
     def ceil(self) -> NaTType: ...
-    def tz_convert(self) -> NaTType: ...
-    def tz_localize(self) -> NaTType: ...
-    # error: Signature of "replace" incompatible with supertype "datetime"
-    def replace(  # type: ignore[override]
+    @property
+    def tzinfo(self) -> None: ...
+    @property
+    def tz(self) -> None: ...
+    def tz_convert(self, tz: _tzinfo | str | None) -> NaTType: ...
+    def tz_localize(
+        self,
+        tz: _tzinfo | str | None,
+        ambiguous: str = ...,
+        nonexistent: str = ...,
+    ) -> NaTType: ...
+    def replace(
         self,
         year: int | None = ...,
         month: int | None = ...,
@@ -86,38 +91,24 @@ class NaTType(datetime):
         tzinfo: _tzinfo | None = ...,
         fold: int | None = ...,
     ) -> NaTType: ...
-    # error: Return type "float" of "year" incompatible with return
-    # type "int" in supertype "date"
     @property
-    def year(self) -> float: ...  # type: ignore[override]
+    def year(self) -> float: ...
     @property
     def quarter(self) -> float: ...
-    # error: Return type "float" of "month" incompatible with return
-    # type "int" in supertype "date"
     @property
-    def month(self) -> float: ...  # type: ignore[override]
-    # error: Return type "float" of "day" incompatible with return
-    # type "int" in supertype "date"
+    def month(self) -> float: ...
     @property
-    def day(self) -> float: ...  # type: ignore[override]
-    # error: Return type "float" of "hour" incompatible with return
-    # type "int" in supertype "date"
+    def day(self) -> float: ...
     @property
-    def hour(self) -> float: ...  # type: ignore[override]
-    # error: Return type "float" of "minute" incompatible with return
-    # type "int" in supertype "date"
+    def hour(self) -> float: ...
     @property
-    def minute(self) -> float: ...  # type: ignore[override]
-    # error: Return type "float" of "second" incompatible with return
-    # type "int" in supertype "date"
+    def minute(self) -> float: ...
     @property
-    def second(self) -> float: ...  # type: ignore[override]
+    def second(self) -> float: ...
     @property
     def millisecond(self) -> float: ...
-    # error: Return type "float" of "microsecond" incompatible with return
-    # type "int" in supertype "date"
     @property
-    def microsecond(self) -> float: ...  # type: ignore[override]
+    def microsecond(self) -> float: ...
     @property
     def nanosecond(self) -> float: ...
     # inject Timedelta properties
@@ -130,26 +121,9 @@ class NaTType(datetime):
     # inject Period properties
     @property
     def qyear(self) -> float: ...
-    def __eq__(self, other: Any) -> bool: ...
-    def __ne__(self, other: Any) -> bool: ...
-    # https://github.com/python/mypy/issues/9015
-    # error: Argument 1 of "__lt__" is incompatible with supertype "date";
-    # supertype defines the argument type as "date"
-    def __lt__(  # type: ignore[override]
-        self, other: datetime | timedelta | Period | np.datetime64 | np.timedelta64
-    ) -> bool: ...
-    # error: Argument 1 of "__le__" is incompatible with supertype "date";
-    # supertype defines the argument type as "date"
-    def __le__(  # type: ignore[override]
-        self, other: datetime | timedelta | Period | np.datetime64 | np.timedelta64
-    ) -> bool: ...
-    # error: Argument 1 of "__gt__" is incompatible with supertype "date";
-    # supertype defines the argument type as "date"
-    def __gt__(  # type: ignore[override]
-        self, other: datetime | timedelta | Period | np.datetime64 | np.timedelta64
-    ) -> bool: ...
-    # error: Argument 1 of "__ge__" is incompatible with supertype "date";
-    # supertype defines the argument type as "date"
-    def __ge__(  # type: ignore[override]
-        self, other: datetime | timedelta | Period | np.datetime64 | np.timedelta64
-    ) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    __lt__: _NatComparison
+    __le__: _NatComparison
+    __gt__: _NatComparison
+    __ge__: _NatComparison
diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index e6a70177463b8..0a5f86ba63569 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -1,13 +1,17 @@
 import warnings
 
+from pandas.util._exceptions import find_stack_level
+
 from cpython.datetime cimport (
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     PyDelta_Check,
     datetime,
+    import_datetime,
     timedelta,
 )
+
+import_datetime()
 from cpython.object cimport (
     Py_EQ,
     Py_GE,
@@ -18,10 +22,6 @@ from cpython.object cimport (
     PyObject_RichCompare,
 )
 
-PyDateTime_IMPORT
-
-from cpython.version cimport PY_MINOR_VERSION
-
 import numpy as np
 
 cimport numpy as cnp
@@ -43,14 +43,6 @@ cdef set c_nat_strings = nat_strings
 cdef int64_t NPY_NAT = util.get_nat()
 iNaT = NPY_NAT  # python-visible constant
 
-cdef bint _nat_scalar_rules[6]
-_nat_scalar_rules[Py_EQ] = False
-_nat_scalar_rules[Py_NE] = True
-_nat_scalar_rules[Py_LT] = False
-_nat_scalar_rules[Py_LE] = False
-_nat_scalar_rules[Py_GT] = False
-_nat_scalar_rules[Py_GE] = False
-
 # ----------------------------------------------------------------------
 
 
@@ -107,7 +99,6 @@ def __nat_unpickle(*args):
 cdef class _NaT(datetime):
     # cdef readonly:
     #    int64_t value
-    #    object freq
 
     # higher than np.ndarray and np.matrix
     __array_priority__ = 100
@@ -115,16 +106,16 @@ cdef class _NaT(datetime):
     def __richcmp__(_NaT self, object other, int op):
         if util.is_datetime64_object(other) or PyDateTime_Check(other):
             # We treat NaT as datetime-like for this comparison
-            return _nat_scalar_rules[op]
+            return op == Py_NE
 
         elif util.is_timedelta64_object(other) or PyDelta_Check(other):
             # We treat NaT as timedelta-like for this comparison
-            return _nat_scalar_rules[op]
+            return op == Py_NE
 
         elif util.is_array(other):
             if other.dtype.kind in "mM":
                 result = np.empty(other.shape, dtype=np.bool_)
-                result.fill(_nat_scalar_rules[op])
+                result.fill(op == Py_NE)
             elif other.dtype.kind == "O":
                 result = np.array([PyObject_RichCompare(self, x, op) for x in other])
             elif op == Py_EQ:
@@ -146,7 +137,7 @@ cdef class _NaT(datetime):
                 "order to match the standard library behavior. "
                 "In a future version these will be considered non-comparable.",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
             return False
 
@@ -154,6 +145,7 @@ cdef class _NaT(datetime):
 
     def __add__(self, other):
         if self is not c_NaT:
+            # TODO(cython3): remove this it moved to __radd__
             # cython __radd__ semantics
             self, other = other, self
 
@@ -180,6 +172,9 @@ cdef class _NaT(datetime):
         # Includes Period, DateOffset going through here
         return NotImplemented
 
+    def __radd__(self, other):
+        return self.__add__(other)
+
     def __sub__(self, other):
         # Duplicate some logic from _Timestamp.__sub__ to avoid needing
         # to subclass; allows us to @final(_Timestamp.__sub__)
@@ -188,6 +183,7 @@ cdef class _NaT(datetime):
 
         if self is not c_NaT:
             # cython __rsub__ semantics
+            # TODO(cython3): remove __rsub__ logic from here
             self, other = other, self
             is_rsub = True
 
@@ -211,6 +207,8 @@ cdef class _NaT(datetime):
                     result.fill("NaT")
                     return result
 
+                # __rsub__ logic here
+                # TODO(cython3): remove this, move above code out of ``if not is_rsub`` block
                 # timedelta64 - NaT we have to treat NaT as timedelta64
                 #  for this to be meaningful, and the result is timedelta64
                 result = np.empty(other.shape, dtype="timedelta64[ns]")
@@ -231,6 +229,24 @@ cdef class _NaT(datetime):
         # Includes Period, DateOffset going through here
         return NotImplemented
 
+    def __rsub__(self, other):
+        if util.is_array(other):
+            if other.dtype.kind == "m":
+                # timedelta64 - NaT we have to treat NaT as timedelta64
+                #  for this to be meaningful, and the result is timedelta64
+                result = np.empty(other.shape, dtype="timedelta64[ns]")
+                result.fill("NaT")
+                return result
+
+            elif other.dtype.kind == "M":
+                # We treat NaT as a datetime, so regardless of whether this is
+                #  NaT - other or other - NaT, the result is timedelta64
+                result = np.empty(other.shape, dtype="timedelta64[ns]")
+                result.fill("NaT")
+                return result
+        # other cases are same, swap operands is allowed even though we subtract because this is NaT
+        return self.__sub__(other)
+
     def __pos__(self):
         return NaT
 
@@ -365,7 +381,7 @@ class NaTType(_NaT):
         warnings.warn(
             "NaT.freq is deprecated and will be removed in a future version.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return None
 
@@ -432,6 +448,7 @@ class NaTType(_NaT):
         "weekday",
         """
         Return the day of the week represented by the date.
+
         Monday == 0 ... Sunday == 6.
         """,
     )
@@ -439,6 +456,7 @@ class NaTType(_NaT):
         "isoweekday",
         """
         Return the day of the week represented by the date.
+
         Monday == 1 ... Sunday == 7.
         """,
     )
@@ -510,8 +528,7 @@ class NaTType(_NaT):
     utcoffset = _make_error_func("utcoffset", datetime)
 
     # "fromisocalendar" was introduced in 3.8
-    if PY_MINOR_VERSION >= 8:
-        fromisocalendar = _make_error_func("fromisocalendar", datetime)
+    fromisocalendar = _make_error_func("fromisocalendar", datetime)
 
     # ----------------------------------------------------------------------
     # The remaining methods have docstrings copy/pasted from the analogous
@@ -520,10 +537,7 @@ class NaTType(_NaT):
     strftime = _make_error_func(
         "strftime",
         """
-        Timestamp.strftime(format)
-
-        Return a string representing the given POSIX timestamp
-        controlled by an explicit format string.
+        Return a formatted string of the Timestamp.
 
         Parameters
         ----------
@@ -667,10 +681,7 @@ class NaTType(_NaT):
     fromordinal = _make_error_func(
         "fromordinal",
         """
-        Timestamp.fromordinal(ordinal, freq=None, tz=None)
-
-        Passed an ordinal, translate and convert to a ts.
-        Note: by definition there cannot be any tz info on the ordinal itself.
+        Construct a timestamp from a a proleptic Gregorian ordinal.
 
         Parameters
         ----------
@@ -681,6 +692,10 @@ class NaTType(_NaT):
         tz : str, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for the Timestamp.
 
+        Notes
+        -----
+        By definition there cannot be any tz info on the ordinal itself.
+
         Examples
         --------
         >>> pd.Timestamp.fromordinal(737425)
@@ -712,10 +727,7 @@ class NaTType(_NaT):
     now = _make_nat_func(
         "now",
         """
-        Timestamp.now(tz=None)
-
-        Return new Timestamp object representing current time local to
-        tz.
+        Return new Timestamp object representing current time local to tz.
 
         Parameters
         ----------
@@ -736,10 +748,9 @@ class NaTType(_NaT):
     today = _make_nat_func(
         "today",
         """
-        Timestamp.today(cls, tz=None)
+        Return the current time in the local timezone.
 
-        Return the current time in the local timezone.  This differs
-        from datetime.today() in that it can be localized to a
+        This differs from datetime.today() in that it can be localized to a
         passed timezone.
 
         Parameters
@@ -1077,7 +1088,9 @@ timedelta}, default 'raise'
     tz_localize = _make_nat_func(
         "tz_localize",
         """
-        Convert naive Timestamp to local time zone, or remove
+        Localize the Timestamp to a timezone.
+
+        Convert naive Timestamp to local time zone or remove
         timezone from timezone-aware Timestamp.
 
         Parameters
@@ -1192,6 +1205,13 @@ default 'raise'
         NaT
         """,
     )
+    @property
+    def tz(self) -> None:
+        return None
+
+    @property
+    def tzinfo(self) -> None:
+        return None
 
 
 c_NaT = NaTType()  # C-visible
diff --git a/pandas/_libs/tslibs/np_datetime.pxd b/pandas/_libs/tslibs/np_datetime.pxd
index c2bbc4fe764fe..c1936e34cf8d0 100644
--- a/pandas/_libs/tslibs/np_datetime.pxd
+++ b/pandas/_libs/tslibs/np_datetime.pxd
@@ -1,3 +1,4 @@
+cimport numpy as cnp
 from cpython.datetime cimport (
     date,
     datetime,
@@ -8,6 +9,7 @@ from numpy cimport (
 )
 
 
+# TODO(cython3): most of these can be cimported directly from numpy
 cdef extern from "numpy/ndarrayobject.h":
     ctypedef int64_t npy_timedelta
     ctypedef int64_t npy_datetime
@@ -50,6 +52,8 @@ cdef extern from "numpy/ndarraytypes.h":
         NPY_FR_as
         NPY_FR_GENERIC
 
+    int64_t NPY_DATETIME_NAT  # elswhere we call this NPY_NAT
+
 cdef extern from "src/datetime/np_datetime.h":
     ctypedef struct pandas_timedeltastruct:
         int64_t days
@@ -59,16 +63,22 @@ cdef extern from "src/datetime/np_datetime.h":
                                            NPY_DATETIMEUNIT fr,
                                            npy_datetimestruct *result) nogil
 
+    npy_datetime npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT fr,
+                                                npy_datetimestruct *d) nogil
+
+    void pandas_timedelta_to_timedeltastruct(npy_timedelta val,
+                                             NPY_DATETIMEUNIT fr,
+                                             pandas_timedeltastruct *result
+                                             ) nogil
 
 cdef bint cmp_scalar(int64_t lhs, int64_t rhs, int op) except -1
 
-cdef check_dts_bounds(npy_datetimestruct *dts)
+cdef check_dts_bounds(npy_datetimestruct *dts, NPY_DATETIMEUNIT unit=?)
 
 cdef int64_t dtstruct_to_dt64(npy_datetimestruct* dts) nogil
-cdef void dt64_to_dtstruct(int64_t dt64, npy_datetimestruct* out) nogil
-cdef void td64_to_tdstruct(int64_t td64, pandas_timedeltastruct* out) nogil
 
 cdef int64_t pydatetime_to_dt64(datetime val, npy_datetimestruct *dts)
+cdef void pydatetime_to_dtstruct(datetime dt, npy_datetimestruct *dts)
 cdef int64_t pydate_to_dt64(date val, npy_datetimestruct *dts)
 cdef void pydate_to_dtstruct(date val, npy_datetimestruct *dts)
 
@@ -76,6 +86,33 @@ cdef npy_datetime get_datetime64_value(object obj) nogil
 cdef npy_timedelta get_timedelta64_value(object obj) nogil
 cdef NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil
 
-cdef int _string_to_dts(str val, npy_datetimestruct* dts,
-                        int* out_local, int* out_tzoffset,
-                        bint want_exc) except? -1
+cdef int string_to_dts(
+    str val,
+    npy_datetimestruct* dts,
+    NPY_DATETIMEUNIT* out_bestunit,
+    int* out_local,
+    int* out_tzoffset,
+    bint want_exc,
+) except? -1
+
+cdef NPY_DATETIMEUNIT get_unit_from_dtype(cnp.dtype dtype)
+
+cpdef cnp.ndarray astype_overflowsafe(
+    cnp.ndarray values,  # ndarray[datetime64[anyunit]]
+    cnp.dtype dtype,  # ndarray[datetime64[anyunit]]
+    bint copy=*,
+    bint round_ok=*,
+)
+cdef int64_t get_conversion_factor(NPY_DATETIMEUNIT from_unit, NPY_DATETIMEUNIT to_unit) except? -1
+
+cdef bint cmp_dtstructs(npy_datetimestruct* left, npy_datetimestruct* right, int op)
+cdef get_implementation_bounds(
+    NPY_DATETIMEUNIT reso, npy_datetimestruct *lower, npy_datetimestruct *upper
+)
+
+cdef int64_t convert_reso(
+    int64_t value,
+    NPY_DATETIMEUNIT from_reso,
+    NPY_DATETIMEUNIT to_reso,
+    bint round_ok,
+) except? -1
diff --git a/pandas/_libs/tslibs/np_datetime.pyi b/pandas/_libs/tslibs/np_datetime.pyi
index db0c277b73bd5..d80d26375412b 100644
--- a/pandas/_libs/tslibs/np_datetime.pyi
+++ b/pandas/_libs/tslibs/np_datetime.pyi
@@ -1 +1,20 @@
+import numpy as np
+
+from pandas._typing import npt
+
 class OutOfBoundsDatetime(ValueError): ...
+class OutOfBoundsTimedelta(ValueError): ...
+
+# only exposed for testing
+def py_get_unit_from_dtype(dtype: np.dtype): ...
+def py_td64_to_tdstruct(td64: int, unit: int) -> dict: ...
+def astype_overflowsafe(
+    arr: np.ndarray,
+    dtype: np.dtype,
+    copy: bool = ...,
+    round_ok: bool = ...,
+) -> np.ndarray: ...
+def is_unitless(dtype: np.dtype) -> bool: ...
+def compare_mismatched_resolutions(
+    left: np.ndarray, right: np.ndarray, op
+) -> npt.NDArray[np.bool_]: ...
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index bc03a3e7f885e..c58a8d4dc4ba6 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -1,4 +1,6 @@
+cimport cython
 from cpython.datetime cimport (
+    PyDateTime_CheckExact,
     PyDateTime_DATE_GET_HOUR,
     PyDateTime_DATE_GET_MICROSECOND,
     PyDateTime_DATE_GET_MINUTE,
@@ -6,7 +8,7 @@ from cpython.datetime cimport (
     PyDateTime_GET_DAY,
     PyDateTime_GET_MONTH,
     PyDateTime_GET_YEAR,
-    PyDateTime_IMPORT,
+    import_datetime,
 )
 from cpython.object cimport (
     Py_EQ,
@@ -17,9 +19,18 @@ from cpython.object cimport (
     Py_NE,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
-from numpy cimport int64_t
+import numpy as np
+
+cimport numpy as cnp
+
+cnp.import_array()
+from numpy cimport (
+    int64_t,
+    ndarray,
+    uint8_t,
+)
 
 from pandas._libs.tslibs.util cimport get_c_string_buf_and_size
 
@@ -28,23 +39,19 @@ cdef extern from "src/datetime/np_datetime.h":
     int cmp_npy_datetimestruct(npy_datetimestruct *a,
                                npy_datetimestruct *b)
 
-    npy_datetime npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT fr,
-                                                npy_datetimestruct *d) nogil
-
-    void pandas_datetime_to_datetimestruct(npy_datetime val,
-                                           NPY_DATETIMEUNIT fr,
-                                           npy_datetimestruct *result) nogil
-
-    void pandas_timedelta_to_timedeltastruct(npy_timedelta val,
-                                             NPY_DATETIMEUNIT fr,
-                                             pandas_timedeltastruct *result
-                                             ) nogil
-
+    # AS, FS, PS versions exist but are not imported because they are not used.
     npy_datetimestruct _NS_MIN_DTS, _NS_MAX_DTS
+    npy_datetimestruct _US_MIN_DTS, _US_MAX_DTS
+    npy_datetimestruct _MS_MIN_DTS, _MS_MAX_DTS
+    npy_datetimestruct _S_MIN_DTS, _S_MAX_DTS
+    npy_datetimestruct _M_MIN_DTS, _M_MAX_DTS
+
+    PyArray_DatetimeMetaData get_datetime_metadata_from_dtype(cnp.PyArray_Descr *dtype);
 
 cdef extern from "src/datetime/np_datetime_strings.h":
     int parse_iso_8601_datetime(const char *str, int len, int want_exc,
                                 npy_datetimestruct *out,
+                                NPY_DATETIMEUNIT *out_bestunit,
                                 int *out_local, int *out_tzoffset)
 
 
@@ -74,10 +81,60 @@ cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil:
     """
     return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base
 
+
+cdef NPY_DATETIMEUNIT get_unit_from_dtype(cnp.dtype dtype):
+    # NB: caller is responsible for ensuring this is *some* datetime64 or
+    #  timedelta64 dtype, otherwise we can segfault
+    cdef:
+        cnp.PyArray_Descr* descr = <cnp.PyArray_Descr*>dtype
+        PyArray_DatetimeMetaData meta
+    meta = get_datetime_metadata_from_dtype(descr)
+    return meta.base
+
+
+def py_get_unit_from_dtype(dtype):
+    # for testing get_unit_from_dtype; adds 896 bytes to the .so file.
+    return get_unit_from_dtype(dtype)
+
+
+def is_unitless(dtype: cnp.dtype) -> bool:
+    """
+    Check if a datetime64 or timedelta64 dtype has no attached unit.
+    """
+    if dtype.type_num not in [cnp.NPY_DATETIME, cnp.NPY_TIMEDELTA]:
+        raise ValueError("is_unitless dtype must be datetime64 or timedelta64")
+    cdef:
+        NPY_DATETIMEUNIT unit = get_unit_from_dtype(dtype)
+
+    return unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+
+
 # ----------------------------------------------------------------------
 # Comparison
 
 
+cdef bint cmp_dtstructs(
+    npy_datetimestruct* left, npy_datetimestruct* right, int op
+):
+    cdef:
+        int cmp_res
+
+    cmp_res = cmp_npy_datetimestruct(left, right)
+    if op == Py_EQ:
+        return cmp_res == 0
+    if op == Py_NE:
+        return cmp_res != 0
+    if op == Py_GT:
+        return cmp_res == 1
+    if op == Py_LT:
+        return cmp_res == -1
+    if op == Py_GE:
+        return cmp_res == 1 or cmp_res == 0
+    else:
+        # i.e. op == Py_LE
+        return cmp_res == -1 or cmp_res == 0
+
+
 cdef inline bint cmp_scalar(int64_t lhs, int64_t rhs, int op) except -1:
     """
     cmp_scalar is a more performant version of PyObject_RichCompare
@@ -98,25 +155,60 @@ cdef inline bint cmp_scalar(int64_t lhs, int64_t rhs, int op) except -1:
 
 
 class OutOfBoundsDatetime(ValueError):
+    """
+    Raised when the datetime is outside the range that can be represented.
+    """
+    pass
+
+
+class OutOfBoundsTimedelta(ValueError):
+    """
+    Raised when encountering a timedelta value that cannot be represented.
+
+    Representation should be within a timedelta64[ns].
+    """
+    # Timedelta analogue to OutOfBoundsDatetime
     pass
 
 
-cdef inline check_dts_bounds(npy_datetimestruct *dts):
+cdef get_implementation_bounds(NPY_DATETIMEUNIT reso, npy_datetimestruct *lower, npy_datetimestruct *upper):
+    if reso == NPY_FR_ns:
+        upper[0] = _NS_MAX_DTS
+        lower[0] = _NS_MIN_DTS
+    elif reso == NPY_FR_us:
+        upper[0] = _US_MAX_DTS
+        lower[0] = _US_MIN_DTS
+    elif reso == NPY_FR_ms:
+        upper[0] = _MS_MAX_DTS
+        lower[0] = _MS_MIN_DTS
+    elif reso == NPY_FR_s:
+        upper[0] = _S_MAX_DTS
+        lower[0] = _S_MIN_DTS
+    elif reso == NPY_FR_m:
+        upper[0] = _M_MAX_DTS
+        lower[0] = _M_MIN_DTS
+    else:
+        raise NotImplementedError(reso)
+
+
+cdef check_dts_bounds(npy_datetimestruct *dts, NPY_DATETIMEUNIT unit=NPY_FR_ns):
     """Raises OutOfBoundsDatetime if the given date is outside the range that
     can be represented by nanosecond-resolution 64-bit integers."""
     cdef:
         bint error = False
+        npy_datetimestruct cmp_upper, cmp_lower
 
-    if (dts.year <= 1677 and
-            cmp_npy_datetimestruct(dts, &_NS_MIN_DTS) == -1):
+    get_implementation_bounds(unit, &cmp_lower, &cmp_upper)
+
+    if cmp_npy_datetimestruct(dts, &cmp_lower) == -1:
         error = True
-    elif (dts.year >= 2262 and
-          cmp_npy_datetimestruct(dts, &_NS_MAX_DTS) == 1):
+    elif cmp_npy_datetimestruct(dts, &cmp_upper) == 1:
         error = True
 
     if error:
         fmt = (f'{dts.year}-{dts.month:02d}-{dts.day:02d} '
                f'{dts.hour:02d}:{dts.min:02d}:{dts.sec:02d}')
+        # TODO: "nanosecond" in the message assumes NPY_FR_ns
         raise OutOfBoundsDatetime(f'Out of bounds nanosecond timestamp: {fmt}')
 
 
@@ -129,20 +221,29 @@ cdef inline int64_t dtstruct_to_dt64(npy_datetimestruct* dts) nogil:
     return npy_datetimestruct_to_datetime(NPY_FR_ns, dts)
 
 
-cdef inline void dt64_to_dtstruct(int64_t dt64,
-                                  npy_datetimestruct* out) nogil:
-    """Convenience function to call pandas_datetime_to_datetimestruct
-    with the by-far-most-common frequency NPY_FR_ns"""
-    pandas_datetime_to_datetimestruct(dt64, NPY_FR_ns, out)
-    return
-
-
-cdef inline void td64_to_tdstruct(int64_t td64,
-                                  pandas_timedeltastruct* out) nogil:
-    """Convenience function to call pandas_timedelta_to_timedeltastruct
-    with the by-far-most-common frequency NPY_FR_ns"""
-    pandas_timedelta_to_timedeltastruct(td64, NPY_FR_ns, out)
-    return
+# just exposed for testing at the moment
+def py_td64_to_tdstruct(int64_t td64, NPY_DATETIMEUNIT unit):
+    cdef:
+        pandas_timedeltastruct tds
+    pandas_timedelta_to_timedeltastruct(td64, unit, &tds)
+    return tds  # <- returned as a dict to python
+
+
+cdef inline void pydatetime_to_dtstruct(datetime dt, npy_datetimestruct *dts):
+    if PyDateTime_CheckExact(dt):
+        dts.year = PyDateTime_GET_YEAR(dt)
+    else:
+        # We use dt.year instead of PyDateTime_GET_YEAR because with Timestamp
+        #  we override year such that PyDateTime_GET_YEAR is incorrect.
+        dts.year = dt.year
+
+    dts.month = PyDateTime_GET_MONTH(dt)
+    dts.day = PyDateTime_GET_DAY(dt)
+    dts.hour = PyDateTime_DATE_GET_HOUR(dt)
+    dts.min = PyDateTime_DATE_GET_MINUTE(dt)
+    dts.sec = PyDateTime_DATE_GET_SECOND(dt)
+    dts.us = PyDateTime_DATE_GET_MICROSECOND(dt)
+    dts.ps = dts.as = 0
 
 
 cdef inline int64_t pydatetime_to_dt64(datetime val,
@@ -150,14 +251,7 @@ cdef inline int64_t pydatetime_to_dt64(datetime val,
     """
     Note we are assuming that the datetime object is timezone-naive.
     """
-    dts.year = PyDateTime_GET_YEAR(val)
-    dts.month = PyDateTime_GET_MONTH(val)
-    dts.day = PyDateTime_GET_DAY(val)
-    dts.hour = PyDateTime_DATE_GET_HOUR(val)
-    dts.min = PyDateTime_DATE_GET_MINUTE(val)
-    dts.sec = PyDateTime_DATE_GET_SECOND(val)
-    dts.us = PyDateTime_DATE_GET_MICROSECOND(val)
-    dts.ps = dts.as = 0
+    pydatetime_to_dtstruct(val, dts)
     return dtstruct_to_dt64(dts)
 
 
@@ -174,13 +268,339 @@ cdef inline int64_t pydate_to_dt64(date val, npy_datetimestruct *dts):
     return dtstruct_to_dt64(dts)
 
 
-cdef inline int _string_to_dts(str val, npy_datetimestruct* dts,
-                               int* out_local, int* out_tzoffset,
-                               bint want_exc) except? -1:
+cdef inline int string_to_dts(
+    str val,
+    npy_datetimestruct* dts,
+    NPY_DATETIMEUNIT* out_bestunit,
+    int* out_local,
+    int* out_tzoffset,
+    bint want_exc,
+) except? -1:
     cdef:
         Py_ssize_t length
         const char* buf
 
     buf = get_c_string_buf_and_size(val, &length)
     return parse_iso_8601_datetime(buf, length, want_exc,
-                                   dts, out_local, out_tzoffset)
+                                   dts, out_bestunit, out_local, out_tzoffset)
+
+
+cpdef ndarray astype_overflowsafe(
+    ndarray values,
+    cnp.dtype dtype,
+    bint copy=True,
+    bint round_ok=True,
+):
+    """
+    Convert an ndarray with datetime64[X] to datetime64[Y]
+    or timedelta64[X] to timedelta64[Y],
+    raising on overflow.
+    """
+    if values.descr.type_num == dtype.type_num == cnp.NPY_DATETIME:
+        # i.e. dtype.kind == "M"
+        pass
+    elif values.descr.type_num == dtype.type_num == cnp.NPY_TIMEDELTA:
+        # i.e. dtype.kind == "m"
+        pass
+    else:
+        raise TypeError(
+            "astype_overflowsafe values.dtype and dtype must be either "
+            "both-datetime64 or both-timedelta64."
+        )
+
+    cdef:
+        NPY_DATETIMEUNIT from_unit = get_unit_from_dtype(values.dtype)
+        NPY_DATETIMEUNIT to_unit = get_unit_from_dtype(dtype)
+
+    if (
+        from_unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+        or to_unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+    ):
+        # without raising explicitly here, we end up with a SystemError
+        # built-in function [...] returned a result with an error
+        raise ValueError(
+            "datetime64/timedelta64 values and dtype must have a unit specified"
+        )
+
+    if from_unit == to_unit:
+        # Check this before allocating result for perf, might save some memory
+        if copy:
+            return values.copy()
+        return values
+
+    elif from_unit > to_unit:
+        if round_ok:
+            # e.g. ns -> us, so there is no risk of overflow, so we can use
+            #  numpy's astype safely. Note there _is_ risk of truncation.
+            return values.astype(dtype)
+        else:
+            iresult2 = astype_round_check(values.view("i8"), from_unit, to_unit)
+            return iresult2.view(dtype)
+
+    if (<object>values).dtype.byteorder == ">":
+        # GH#29684 we incorrectly get OutOfBoundsDatetime if we dont swap
+        values = values.astype(values.dtype.newbyteorder("<"))
+
+    cdef:
+        ndarray i8values = values.view("i8")
+
+        # equiv: result = np.empty((<object>values).shape, dtype="i8")
+        ndarray iresult = cnp.PyArray_EMPTY(
+            values.ndim, values.shape, cnp.NPY_INT64, 0
+        )
+
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(iresult, i8values)
+        Py_ssize_t i, N = values.size
+        int64_t value, new_value
+        npy_datetimestruct dts
+        bint is_td = dtype.type_num == cnp.NPY_TIMEDELTA
+
+    for i in range(N):
+        # Analogous to: item = values[i]
+        value = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        if value == NPY_DATETIME_NAT:
+            new_value = NPY_DATETIME_NAT
+        else:
+            pandas_datetime_to_datetimestruct(value, from_unit, &dts)
+
+            try:
+                check_dts_bounds(&dts, to_unit)
+            except OutOfBoundsDatetime as err:
+                if is_td:
+                    from_abbrev = np.datetime_data(values.dtype)[0]
+                    np_val = np.timedelta64(value, from_abbrev)
+                    msg = (
+                        "Cannot convert {np_val} to {dtype} without overflow"
+                        .format(np_val=str(np_val), dtype=str(dtype))
+                    )
+                    raise OutOfBoundsTimedelta(msg) from err
+                else:
+                    raise
+
+            new_value = npy_datetimestruct_to_datetime(to_unit, &dts)
+
+        # Analogous to: iresult[i] = new_value
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = new_value
+
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return iresult.view(dtype)
+
+
+# TODO: try to upstream this fix to numpy
+def compare_mismatched_resolutions(ndarray left, ndarray right, op):
+    """
+    Overflow-safe comparison of timedelta64/datetime64 with mismatched resolutions.
+
+    >>> left = np.array([500], dtype="M8[Y]")
+    >>> right = np.array([0], dtype="M8[ns]")
+    >>> left < right  # <- wrong!
+    array([ True])
+    """
+
+    if left.dtype.kind != right.dtype.kind or left.dtype.kind not in ["m", "M"]:
+        raise ValueError("left and right must both be timedelta64 or both datetime64")
+
+    cdef:
+        int op_code = op_to_op_code(op)
+        NPY_DATETIMEUNIT left_unit = get_unit_from_dtype(left.dtype)
+        NPY_DATETIMEUNIT right_unit = get_unit_from_dtype(right.dtype)
+
+        # equiv: result = np.empty((<object>left).shape, dtype="bool")
+        ndarray result = cnp.PyArray_EMPTY(
+            left.ndim, left.shape, cnp.NPY_BOOL, 0
+        )
+
+        ndarray lvalues = left.view("i8")
+        ndarray rvalues = right.view("i8")
+
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew3(result, lvalues, rvalues)
+        int64_t lval, rval
+        bint res_value
+
+        Py_ssize_t i, N = left.size
+        npy_datetimestruct ldts, rdts
+
+
+    for i in range(N):
+        # Analogous to: lval = lvalues[i]
+        lval = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        # Analogous to: rval = rvalues[i]
+        rval = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 2))[0]
+
+        if lval == NPY_DATETIME_NAT or rval == NPY_DATETIME_NAT:
+            res_value = op_code == Py_NE
+
+        else:
+            pandas_datetime_to_datetimestruct(lval, left_unit, &ldts)
+            pandas_datetime_to_datetimestruct(rval, right_unit, &rdts)
+
+            res_value = cmp_dtstructs(&ldts, &rdts, op_code)
+
+        # Analogous to: result[i] = res_value
+        (<uint8_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_value
+
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
+
+
+import operator
+
+
+cdef int op_to_op_code(op):
+    # TODO: should exist somewhere?
+    if op is operator.eq:
+        return Py_EQ
+    if op is operator.ne:
+        return Py_NE
+    if op is operator.le:
+        return Py_LE
+    if op is operator.lt:
+        return Py_LT
+    if op is operator.ge:
+        return Py_GE
+    if op is operator.gt:
+        return Py_GT
+
+
+cdef ndarray astype_round_check(
+    ndarray i8values,
+    NPY_DATETIMEUNIT from_unit,
+    NPY_DATETIMEUNIT to_unit
+):
+    # cases with from_unit > to_unit, e.g. ns->us, raise if the conversion
+    #  involves truncation, e.g. 1500ns->1us
+    cdef:
+        Py_ssize_t i, N = i8values.size
+
+        # equiv: iresult = np.empty((<object>i8values).shape, dtype="i8")
+        ndarray iresult = cnp.PyArray_EMPTY(
+            i8values.ndim, i8values.shape, cnp.NPY_INT64, 0
+        )
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(iresult, i8values)
+
+        # Note the arguments to_unit, from unit are swapped vs how they
+        #  are passed when going to a higher-frequency reso.
+        int64_t mult = get_conversion_factor(to_unit, from_unit)
+        int64_t value, mod
+
+    for i in range(N):
+        # Analogous to: item = i8values[i]
+        value = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        if value == NPY_DATETIME_NAT:
+            new_value = NPY_DATETIME_NAT
+        else:
+            new_value, mod = divmod(value, mult)
+            if mod != 0:
+                # TODO: avoid runtime import
+                from pandas._libs.tslibs.dtypes import npy_unit_to_abbrev
+                from_abbrev = npy_unit_to_abbrev(from_unit)
+                to_abbrev = npy_unit_to_abbrev(to_unit)
+                raise ValueError(
+                    f"Cannot losslessly cast '{value} {from_abbrev}' to {to_abbrev}"
+                )
+
+        # Analogous to: iresult[i] = new_value
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = new_value
+
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return iresult
+
+
+@cython.overflowcheck(True)
+cdef int64_t get_conversion_factor(NPY_DATETIMEUNIT from_unit, NPY_DATETIMEUNIT to_unit) except? -1:
+    """
+    Find the factor by which we need to multiply to convert from from_unit to to_unit.
+    """
+    if (
+        from_unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+        or to_unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+    ):
+        raise ValueError("unit-less resolutions are not supported")
+    if from_unit > to_unit:
+        raise ValueError
+
+    if from_unit == to_unit:
+        return 1
+
+    if from_unit == NPY_DATETIMEUNIT.NPY_FR_W:
+        return 7 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_D, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_D:
+        return 24 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_h, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_h:
+        return 60 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_m, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_m:
+        return 60 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_s, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_s:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_ms, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_ms:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_us, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_us:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_ns, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_ns:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_ps, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_ps:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_fs, to_unit)
+    elif from_unit == NPY_DATETIMEUNIT.NPY_FR_fs:
+        return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_as, to_unit)
+
+
+cdef int64_t convert_reso(
+    int64_t value,
+    NPY_DATETIMEUNIT from_reso,
+    NPY_DATETIMEUNIT to_reso,
+    bint round_ok,
+) except? -1:
+    cdef:
+        int64_t res_value, mult, div, mod
+
+    if from_reso == to_reso:
+        return value
+
+    elif to_reso < from_reso:
+        # e.g. ns -> us, no risk of overflow, but can be lossy rounding
+        mult = get_conversion_factor(to_reso, from_reso)
+        div, mod = divmod(value, mult)
+        if mod > 0 and not round_ok:
+            raise ValueError("Cannot losslessly convert units")
+
+        # Note that when mod > 0, we follow np.timedelta64 in always
+        #  rounding down.
+        res_value = div
+
+    elif (
+        from_reso == NPY_FR_Y
+        or from_reso == NPY_FR_M
+        or to_reso == NPY_FR_Y
+        or to_reso == NPY_FR_M
+    ):
+        # Converting by multiplying isn't _quite_ right bc the number of
+        #  seconds in a month/year isn't fixed.
+        res_value = _convert_reso_with_dtstruct(value, from_reso, to_reso)
+
+    else:
+        # e.g. ns -> us, risk of overflow, but no risk of lossy rounding
+        mult = get_conversion_factor(from_reso, to_reso)
+        with cython.overflowcheck(True):
+            # Note: caller is responsible for re-raising as OutOfBoundsTimedelta
+            res_value = value * mult
+
+    return res_value
+
+
+cdef int64_t _convert_reso_with_dtstruct(
+    int64_t value,
+    NPY_DATETIMEUNIT from_unit,
+    NPY_DATETIMEUNIT to_unit,
+) except? -1:
+    cdef:
+        npy_datetimestruct dts
+
+    pandas_datetime_to_datetimestruct(value, from_unit, &dts)
+    check_dts_bounds(&dts, to_unit)
+    return npy_datetimestruct_to_datetime(to_unit, &dts)
diff --git a/pandas/_libs/tslibs/offsets.pyi b/pandas/_libs/tslibs/offsets.pyi
new file mode 100644
index 0000000000000..c3d550c7a5ba9
--- /dev/null
+++ b/pandas/_libs/tslibs/offsets.pyi
@@ -0,0 +1,281 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Collection,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+
+from pandas._typing import npt
+
+from .timedeltas import Timedelta
+
+if TYPE_CHECKING:
+    from pandas.core.indexes.datetimes import DatetimeIndex
+_BaseOffsetT = TypeVar("_BaseOffsetT", bound=BaseOffset)
+_DatetimeT = TypeVar("_DatetimeT", bound=datetime)
+_TimedeltaT = TypeVar("_TimedeltaT", bound=timedelta)
+
+_relativedelta_kwds: set[str]
+prefix_mapping: dict[str, type]
+
+class ApplyTypeError(TypeError): ...
+
+class BaseOffset:
+    n: int
+    def __init__(self, n: int = ..., normalize: bool = ...) -> None: ...
+    def __eq__(self, other) -> bool: ...
+    def __ne__(self, other) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def kwds(self) -> dict: ...
+    @property
+    def base(self) -> BaseOffset: ...
+    @overload
+    def __add__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __add__(self: _BaseOffsetT, other: BaseOffset) -> _BaseOffsetT: ...
+    @overload
+    def __add__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __add__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    @overload
+    def __radd__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __radd__(self: _BaseOffsetT, other: BaseOffset) -> _BaseOffsetT: ...
+    @overload
+    def __radd__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __radd__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    def __sub__(self: _BaseOffsetT, other: BaseOffset) -> _BaseOffsetT: ...
+    @overload
+    def __rsub__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __rsub__(self: _BaseOffsetT, other: BaseOffset) -> _BaseOffsetT: ...
+    @overload
+    def __rsub__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __rsub__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    def __call__(self, other): ...
+    @overload
+    def __mul__(self, other: np.ndarray) -> np.ndarray: ...
+    @overload
+    def __mul__(self: _BaseOffsetT, other: int) -> _BaseOffsetT: ...
+    @overload
+    def __rmul__(self, other: np.ndarray) -> np.ndarray: ...
+    @overload
+    def __rmul__(self: _BaseOffsetT, other: int) -> _BaseOffsetT: ...
+    def __neg__(self: _BaseOffsetT) -> _BaseOffsetT: ...
+    def copy(self: _BaseOffsetT) -> _BaseOffsetT: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def rule_code(self) -> str: ...
+    @property
+    def freqstr(self) -> str: ...
+    def apply_index(self, dtindex: DatetimeIndex) -> DatetimeIndex: ...
+    def _apply_array(self, dtarr) -> None: ...
+    def rollback(self, dt: datetime) -> datetime: ...
+    def rollforward(self, dt: datetime) -> datetime: ...
+    def is_on_offset(self, dt: datetime) -> bool: ...
+    def __setstate__(self, state) -> None: ...
+    def __getstate__(self): ...
+    @property
+    def nanos(self) -> int: ...
+    def onOffset(self, dt: datetime) -> bool: ...
+    def isAnchored(self) -> bool: ...
+    def is_anchored(self) -> bool: ...
+
+def _get_offset(name: str) -> BaseOffset: ...
+
+class SingleConstructorOffset(BaseOffset):
+    @classmethod
+    def _from_name(cls, suffix: None = ...): ...
+    def __reduce__(self): ...
+
+@overload
+def to_offset(freq: None) -> None: ...
+@overload
+def to_offset(freq: _BaseOffsetT) -> _BaseOffsetT: ...
+@overload
+def to_offset(freq: timedelta | str) -> BaseOffset: ...
+
+class Tick(SingleConstructorOffset):
+    _reso: int
+    _prefix: str
+    _td64_unit: str
+    def __init__(self, n: int = ..., normalize: bool = ...) -> None: ...
+    @property
+    def delta(self) -> Timedelta: ...
+    @property
+    def nanos(self) -> int: ...
+
+def delta_to_tick(delta: timedelta) -> Tick: ...
+
+class Day(Tick): ...
+class Hour(Tick): ...
+class Minute(Tick): ...
+class Second(Tick): ...
+class Milli(Tick): ...
+class Micro(Tick): ...
+class Nano(Tick): ...
+
+class RelativeDeltaOffset(BaseOffset):
+    def __init__(self, n: int = ..., normalize: bool = ..., **kwds: Any) -> None: ...
+
+class BusinessMixin(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., offset: timedelta = ...
+    ) -> None: ...
+
+class BusinessDay(BusinessMixin): ...
+
+class BusinessHour(BusinessMixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        start: str | Collection[str] = ...,
+        end: str | Collection[str] = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class WeekOfMonthMixin(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., weekday: int = ...
+    ) -> None: ...
+
+class YearOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., month: int | None = ...
+    ) -> None: ...
+
+class BYearEnd(YearOffset): ...
+class BYearBegin(YearOffset): ...
+class YearEnd(YearOffset): ...
+class YearBegin(YearOffset): ...
+
+class QuarterOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., startingMonth: int | None = ...
+    ) -> None: ...
+
+class BQuarterEnd(QuarterOffset): ...
+class BQuarterBegin(QuarterOffset): ...
+class QuarterEnd(QuarterOffset): ...
+class QuarterBegin(QuarterOffset): ...
+class MonthOffset(SingleConstructorOffset): ...
+class MonthEnd(MonthOffset): ...
+class MonthBegin(MonthOffset): ...
+class BusinessMonthEnd(MonthOffset): ...
+class BusinessMonthBegin(MonthOffset): ...
+
+class SemiMonthOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., day_of_month: int | None = ...
+    ) -> None: ...
+
+class SemiMonthEnd(SemiMonthOffset): ...
+class SemiMonthBegin(SemiMonthOffset): ...
+
+class Week(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., weekday: int | None = ...
+    ) -> None: ...
+
+class WeekOfMonth(WeekOfMonthMixin):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., week: int = ..., weekday: int = ...
+    ) -> None: ...
+
+class LastWeekOfMonth(WeekOfMonthMixin): ...
+
+class FY5253Mixin(SingleConstructorOffset):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekday: int = ...,
+        startingMonth: int = ...,
+        variation: Literal["nearest", "last"] = ...,
+    ) -> None: ...
+
+class FY5253(FY5253Mixin): ...
+
+class FY5253Quarter(FY5253Mixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekday: int = ...,
+        startingMonth: int = ...,
+        qtr_with_extra_week: int = ...,
+        variation: Literal["nearest", "last"] = ...,
+    ) -> None: ...
+
+class Easter(SingleConstructorOffset): ...
+
+class _CustomBusinessMonth(BusinessMixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: np.busdaycalendar | None = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessDay(BusinessDay):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: np.busdaycalendar | None = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessHour(BusinessHour):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: np.busdaycalendar | None = ...,
+        start: str = ...,
+        end: str = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessMonthEnd(_CustomBusinessMonth): ...
+class CustomBusinessMonthBegin(_CustomBusinessMonth): ...
+class DateOffset(RelativeDeltaOffset): ...
+
+BDay = BusinessDay
+BMonthEnd = BusinessMonthEnd
+BMonthBegin = BusinessMonthBegin
+CBMonthEnd = CustomBusinessMonthEnd
+CBMonthBegin = CustomBusinessMonthBegin
+CDay = CustomBusinessDay
+
+def roll_qtrday(
+    other: datetime, n: int, month: int, day_opt: str, modby: int
+) -> int: ...
+
+INVALID_FREQ_ERR_MSG: Literal["Invalid frequency: {0}"]
+
+def shift_months(
+    dtindex: npt.NDArray[np.int64], months: int, day_opt: str | None = ...
+) -> npt.NDArray[np.int64]: ...
+
+_offset_map: dict[str, BaseOffset]
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 6df4abc160b0b..242eeffd1ee79 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -3,20 +3,21 @@ import re
 import time
 import warnings
 
-import cython
+from pandas.util._exceptions import find_stack_level
 
+cimport cython
 from cpython.datetime cimport (
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     PyDelta_Check,
     date,
     datetime,
+    import_datetime,
     time as dt_time,
     timedelta,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
 from dateutil.easter import easter
 from dateutil.relativedelta import relativedelta
@@ -49,30 +50,29 @@ from pandas._libs.tslibs.ccalendar import (
 )
 
 from pandas._libs.tslibs.ccalendar cimport (
-    DAY_NANOS,
     dayofweek,
     get_days_in_month,
     get_firstbday,
     get_lastbday,
 )
-from pandas._libs.tslibs.conversion cimport (
-    convert_datetime_to_tsobject,
-    localize_pydatetime,
-)
+from pandas._libs.tslibs.conversion cimport localize_pydatetime
+from pandas._libs.tslibs.dtypes cimport periods_per_day
 from pandas._libs.tslibs.nattype cimport (
     NPY_NAT,
     c_NaT as NaT,
 )
 from pandas._libs.tslibs.np_datetime cimport (
-    dt64_to_dtstruct,
-    dtstruct_to_dt64,
+    NPY_DATETIMEUNIT,
+    get_unit_from_dtype,
     npy_datetimestruct,
+    npy_datetimestruct_to_datetime,
+    pandas_datetime_to_datetimestruct,
     pydate_to_dtstruct,
 )
-from pandas._libs.tslibs.tzconversion cimport tz_convert_from_utc_single
 
 from .dtypes cimport PeriodDtypeCode
 from .timedeltas cimport (
+    _Timedelta,
     delta_to_nanoseconds,
     is_any_td_scalar,
 )
@@ -116,25 +116,12 @@ def apply_wrapper_core(func, self, other) -> ndarray:
     if self.normalize:
         # TODO: Avoid circular/runtime import
         from .vectorized import normalize_i8_timestamps
-        result = normalize_i8_timestamps(result.view("i8"), None)
+        reso = get_unit_from_dtype(other.dtype)
+        result = normalize_i8_timestamps(result.view("i8"), None, reso=reso)
 
     return result
 
 
-def apply_index_wraps(func):
-    # Note: normally we would use `@functools.wraps(func)`, but this does
-    # not play nicely with cython class methods
-    def wrapper(self, other):
-        # other is a DatetimeArray
-        result = apply_wrapper_core(func, self, other)
-        result = type(other)(result)
-        warnings.warn("'Offset.apply_index(other)' is deprecated. "
-                      "Use 'offset + other' instead.", FutureWarning)
-        return result
-
-    return wrapper
-
-
 def apply_array_wraps(func):
     # Note: normally we would use `@functools.wraps(func)`, but this does
     # not play nicely with cython class methods
@@ -271,10 +258,10 @@ cdef _to_dt64D(dt):
     if getattr(dt, 'tzinfo', None) is not None:
         # Get the nanosecond timestamp,
         #  equiv `Timestamp(dt).value` or `dt.timestamp() * 10**9`
-        nanos = getattr(dt, "nanosecond", 0)
-        i8 = convert_datetime_to_tsobject(dt, tz=None, nanos=nanos).value
-        dt = tz_convert_from_utc_single(i8, dt.tzinfo)
-        dt = np.int64(dt).astype('datetime64[ns]')
+        # The `naive` must be the `dt` naive wall time
+        #  instead of the naive absolute time (GH#49441)
+        naive = dt.replace(tzinfo=None)
+        dt = np.datetime64(naive, "D")
     else:
         dt = np.datetime64(dt)
     if dt.dtype.name != "datetime64[D]":
@@ -307,14 +294,15 @@ cdef _validate_business_time(t_input):
 
 _relativedelta_kwds = {"years", "months", "weeks", "days", "year", "month",
                        "day", "weekday", "hour", "minute", "second",
-                       "microsecond", "nanosecond", "nanoseconds", "hours",
-                       "minutes", "seconds", "microseconds"}
+                       "microsecond", "millisecond", "nanosecond",
+                       "nanoseconds", "hours", "minutes", "seconds",
+                       "milliseconds", "microseconds"}
 
 
 cdef _determine_offset(kwds):
     # timedelta is used for sub-daily plural offsets and all singular
-    # offsets relativedelta is used for plural offsets of daily length or
-    # more nanosecond(s) are handled by apply_wraps
+    # offsets, relativedelta is used for plural offsets of daily length or
+    # more, nanosecond(s) are handled by apply_wraps
     kwds_no_nanos = dict(
         (k, v) for k, v in kwds.items()
         if k not in ('nanosecond', 'nanoseconds')
@@ -323,18 +311,30 @@ cdef _determine_offset(kwds):
 
     _kwds_use_relativedelta = ('years', 'months', 'weeks', 'days',
                                'year', 'month', 'week', 'day', 'weekday',
-                               'hour', 'minute', 'second', 'microsecond')
+                               'hour', 'minute', 'second', 'microsecond',
+                               'millisecond')
 
     use_relativedelta = False
     if len(kwds_no_nanos) > 0:
         if any(k in _kwds_use_relativedelta for k in kwds_no_nanos):
+            if "millisecond" in kwds_no_nanos:
+                raise NotImplementedError(
+                    "Using DateOffset to replace `millisecond` component in "
+                    "datetime object is not supported. Use "
+                    "`microsecond=timestamp.microsecond % 1000 + ms * 1000` "
+                    "instead."
+                )
             offset = relativedelta(**kwds_no_nanos)
             use_relativedelta = True
         else:
             # sub-daily offset - use timedelta (tz-aware)
             offset = timedelta(**kwds_no_nanos)
+    elif any(nano in kwds for nano in ('nanosecond', 'nanoseconds')):
+        offset = timedelta(days=0)
     else:
-        offset = timedelta(0)
+        # GH 45643/45890: (historically) defaults to 1 day for non-nano
+        # since datetime.timedelta doesn't handle nanoseconds
+        offset = timedelta(days=1)
     return offset, use_relativedelta
 
 
@@ -371,7 +371,23 @@ cdef class BaseOffset:
     def __init__(self, n=1, normalize=False):
         n = self._validate_n(n)
         self.n = n
+        """
+        Number of multiples of the frequency.
+
+        Examples
+        --------
+        >>> pd.offsets.Hour(5).n
+        5
+        """
         self.normalize = normalize
+        """
+        Return boolean whether the frequency can align with midnight.
+
+        Examples
+        --------
+        >>> pd.offsets.Hour(5).normalize
+        False
+        """
         self._cache = {}
 
     def __eq__(self, other) -> bool:
@@ -421,6 +437,20 @@ cdef class BaseOffset:
 
     @property
     def kwds(self) -> dict:
+        """
+        Return a dict of extra parameters for the offset.
+
+        Examples
+        --------
+        >>> pd.DateOffset(5).kwds
+        {}
+
+        >>> pd.offsets.FY5253Quarter().kwds
+        {'weekday': 0,
+         'startingMonth': 1,
+         'qtr_with_extra_week': 1,
+         'variation': 'nearest'}
+        """
         # for backwards-compatibility
         kwds = {name: getattr(self, name, None) for name in self._attributes
                 if name not in ["n", "normalize"]}
@@ -437,6 +467,7 @@ cdef class BaseOffset:
     def __add__(self, other):
         if not isinstance(self, BaseOffset):
             # cython semantics; this is __radd__
+            # TODO(cython3): remove this, this moved to __radd__
             return other.__add__(self)
 
         elif util.is_array(other) and other.dtype == object:
@@ -447,6 +478,9 @@ cdef class BaseOffset:
         except ApplyTypeError:
             return NotImplemented
 
+    def __radd__(self, other):
+        return self.__add__(other)
+
     def __sub__(self, other):
         if PyDateTime_Check(other):
             raise TypeError('Cannot subtract datetime from offset.')
@@ -454,18 +488,22 @@ cdef class BaseOffset:
             return type(self)(self.n - other.n, normalize=self.normalize,
                               **self.kwds)
         elif not isinstance(self, BaseOffset):
+            # TODO(cython3): remove, this moved to __rsub__
             # cython semantics, this is __rsub__
             return (-other).__add__(self)
         else:
             # e.g. PeriodIndex
             return NotImplemented
 
+    def __rsub__(self, other):
+        return (-self).__add__(other)
+
     def __call__(self, other):
         warnings.warn(
             "DateOffset.__call__ is deprecated and will be removed in a future "
             "version.  Use `offset + other` instead.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return self._apply(other)
 
@@ -475,7 +513,7 @@ cdef class BaseOffset:
             f"{type(self).__name__}.apply is deprecated and will be removed "
             "in a future version. Use `offset + other` instead",
             FutureWarning,
-            stacklevel=2,
+            stacklevel=find_stack_level(),
         )
         return self._apply(other)
 
@@ -486,10 +524,14 @@ cdef class BaseOffset:
             return type(self)(n=other * self.n, normalize=self.normalize,
                               **self.kwds)
         elif not isinstance(self, BaseOffset):
+            # TODO(cython3): remove this, this moved to __rmul__
             # cython semantics, this is __rmul__
             return other.__mul__(self)
         return NotImplemented
 
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
     def __neg__(self):
         # Note: we are deferring directly to __mul__ instead of __rmul__, as
         # that allows us to use methods that can go in a `cdef class`
@@ -498,6 +540,16 @@ cdef class BaseOffset:
     def copy(self):
         # Note: we are deferring directly to __mul__ instead of __rmul__, as
         # that allows us to use methods that can go in a `cdef class`
+        """
+        Return a copy of the frequency.
+
+        Examples
+        --------
+        >>> freq = pd.DateOffset(1)
+        >>> freq_copy = freq.copy()
+        >>> freq is freq_copy
+        False
+        """
         return self * 1
 
     # ------------------------------------------------------------------
@@ -539,6 +591,17 @@ cdef class BaseOffset:
 
     @property
     def name(self) -> str:
+        """
+        Return a string representing the base frequency.
+
+        Examples
+        --------
+        >>> pd.offsets.Hour().name
+        'H'
+
+        >>> pd.offsets.Hour(5).name
+        'H'
+        """
         return self.rule_code
 
     @property
@@ -551,6 +614,23 @@ cdef class BaseOffset:
 
     @cache_readonly
     def freqstr(self) -> str:
+        """
+        Return a string representing the frequency.
+
+        Examples
+        --------
+        >>> pd.DateOffset(5).freqstr
+        '<5 * DateOffsets>'
+
+        >>> pd.offsets.BusinessHour(2).freqstr
+        '2BH'
+
+        >>> pd.offsets.Nano().freqstr
+        'N'
+
+        >>> pd.offsets.Nano(-3).freqstr
+        '-3N'
+        """
         try:
             code = self.rule_code
         except NotImplementedError:
@@ -575,12 +655,9 @@ cdef class BaseOffset:
 
     # ------------------------------------------------------------------
 
-    @apply_index_wraps
     def apply_index(self, dtindex):
         """
-        Vectorized apply of DateOffset to DatetimeIndex,
-        raises NotImplementedError for offsets without a
-        vectorized implementation.
+        Vectorized apply of DateOffset to DatetimeIndex.
 
         .. deprecated:: 1.1.0
 
@@ -600,10 +677,11 @@ cdef class BaseOffset:
             When the specific offset subclass does not have a vectorized
             implementation.
         """
-        raise NotImplementedError(  # pragma: no cover
-            f"DateOffset subclass {type(self).__name__} "
-            "does not have a vectorized implementation"
-        )
+        warnings.warn("'Offset.apply_index(other)' is deprecated. "
+                      "Use 'offset + other' instead.", FutureWarning)
+
+        res = self._apply_array(dtindex)
+        return type(dtindex)(res)
 
     @apply_array_wraps
     def _apply_array(self, dtarr):
@@ -649,6 +727,28 @@ cdef class BaseOffset:
         return get_day_of_month(&dts, self._day_opt)
 
     def is_on_offset(self, dt: datetime) -> bool:
+        """
+        Return boolean whether a timestamp intersects with this frequency.
+
+        Parameters
+        ----------
+        dt : datetime.datetime
+            Timestamp to check intersections with frequency.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Day(1)
+        >>> freq.is_on_offset(ts)
+        True
+
+        >>> ts = pd.Timestamp(2022, 8, 6)
+        >>> ts.day_name()
+        'Saturday'
+        >>> freq = pd.offsets.BusinessDay(1)
+        >>> freq.is_on_offset(ts)
+        False
+        """
         if self.normalize and not _is_normalized(dt):
             return False
 
@@ -724,7 +824,7 @@ cdef class BaseOffset:
         warnings.warn(
             "onOffset is a deprecated, use is_on_offset instead.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return self.is_on_offset(dt)
 
@@ -732,33 +832,103 @@ cdef class BaseOffset:
         warnings.warn(
             "isAnchored is a deprecated, use is_anchored instead.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return self.is_anchored()
 
     def is_anchored(self) -> bool:
         # TODO: Does this make sense for the general case?  It would help
         # if there were a canonical docstring for what is_anchored means.
+        """
+        Return boolean whether the frequency is a unit frequency (n=1).
+
+        Examples
+        --------
+        >>> pd.DateOffset().is_anchored()
+        True
+        >>> pd.DateOffset(2).is_anchored()
+        False
+        """
         return self.n == 1
 
     # ------------------------------------------------------------------
 
     def is_month_start(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the month start.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_month_start(ts)
+        True
+        """
         return ts._get_start_end_field("is_month_start", self)
 
     def is_month_end(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the month end.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_month_end(ts)
+        False
+        """
         return ts._get_start_end_field("is_month_end", self)
 
     def is_quarter_start(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the quarter start.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_quarter_start(ts)
+        True
+        """
         return ts._get_start_end_field("is_quarter_start", self)
 
     def is_quarter_end(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the quarter end.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_quarter_end(ts)
+        False
+        """
         return ts._get_start_end_field("is_quarter_end", self)
 
     def is_year_start(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the year start.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_year_start(ts)
+        True
+        """
         return ts._get_start_end_field("is_year_start", self)
 
     def is_year_end(self, _Timestamp ts):
+        """
+        Return boolean whether a timestamp occurs on the year end.
+
+        Examples
+        --------
+        >>> ts = pd.Timestamp(2022, 1, 1)
+        >>> freq = pd.offsets.Hour(5)
+        >>> freq.is_year_end(ts)
+        False
+        """
         return ts._get_start_end_field("is_year_end", self)
 
 
@@ -788,6 +958,7 @@ cdef class SingleConstructorOffset(BaseOffset):
 cdef class Tick(SingleConstructorOffset):
     _adjust_dst = False
     _prefix = "undefined"
+    _td64_unit = "undefined"
     _attributes = tuple(["n", "normalize"])
 
     def __init__(self, n=1, normalize=False):
@@ -830,6 +1001,19 @@ cdef class Tick(SingleConstructorOffset):
 
     @property
     def nanos(self) -> int64_t:
+        """
+        Return an integer of the total number of nanoseconds.
+
+        Raises
+        ------
+        ValueError
+            If the frequency is non-fixed.
+
+        Examples
+        --------
+        >>> pd.offsets.Hour(5).nanos
+        18000000000000
+        """
         return self.n * self._nanos_inc
 
     def is_on_offset(self, dt: datetime) -> bool:
@@ -874,6 +1058,7 @@ cdef class Tick(SingleConstructorOffset):
 
     def __mul__(self, other):
         if not isinstance(self, Tick):
+            # TODO(cython3), remove this, this moved to __rmul__
             # cython semantics, this is __rmul__
             return other.__mul__(self)
         if is_float_object(other):
@@ -887,6 +1072,9 @@ cdef class Tick(SingleConstructorOffset):
             return new_self * other
         return BaseOffset.__mul__(self, other)
 
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
     def __truediv__(self, other):
         if not isinstance(self, Tick):
             # cython semantics mean the args are sometimes swapped
@@ -895,9 +1083,14 @@ cdef class Tick(SingleConstructorOffset):
             result = self.delta.__truediv__(other)
         return _wrap_timedelta_result(result)
 
+    def __rtruediv__(self, other):
+        result = self.delta.__rtruediv__(other)
+        return _wrap_timedelta_result(result)
+
     def __add__(self, other):
         if not isinstance(self, Tick):
             # cython semantics; this is __radd__
+            # TODO(cython3): remove this, this moved to __radd__
             return other.__add__(self)
 
         if isinstance(other, Tick):
@@ -915,6 +1108,9 @@ cdef class Tick(SingleConstructorOffset):
                 f"the add operation between {self} and {other} will overflow"
             ) from err
 
+    def __radd__(self, other):
+        return self.__add__(other)
+
     def _apply(self, other):
         # Timestamp can handle tz and nano sec, thus no need to use apply_wraps
         if isinstance(other, _Timestamp):
@@ -948,43 +1144,57 @@ cdef class Tick(SingleConstructorOffset):
 cdef class Day(Tick):
     _nanos_inc = 24 * 3600 * 1_000_000_000
     _prefix = "D"
+    _td64_unit = "D"
     _period_dtype_code = PeriodDtypeCode.D
+    _reso = NPY_DATETIMEUNIT.NPY_FR_D
 
 
 cdef class Hour(Tick):
     _nanos_inc = 3600 * 1_000_000_000
     _prefix = "H"
+    _td64_unit = "h"
     _period_dtype_code = PeriodDtypeCode.H
+    _reso = NPY_DATETIMEUNIT.NPY_FR_h
 
 
 cdef class Minute(Tick):
     _nanos_inc = 60 * 1_000_000_000
     _prefix = "T"
+    _td64_unit = "m"
     _period_dtype_code = PeriodDtypeCode.T
+    _reso = NPY_DATETIMEUNIT.NPY_FR_m
 
 
 cdef class Second(Tick):
     _nanos_inc = 1_000_000_000
     _prefix = "S"
+    _td64_unit = "s"
     _period_dtype_code = PeriodDtypeCode.S
+    _reso = NPY_DATETIMEUNIT.NPY_FR_s
 
 
 cdef class Milli(Tick):
     _nanos_inc = 1_000_000
     _prefix = "L"
+    _td64_unit = "ms"
     _period_dtype_code = PeriodDtypeCode.L
+    _reso = NPY_DATETIMEUNIT.NPY_FR_ms
 
 
 cdef class Micro(Tick):
     _nanos_inc = 1000
     _prefix = "U"
+    _td64_unit = "us"
     _period_dtype_code = PeriodDtypeCode.U
+    _reso = NPY_DATETIMEUNIT.NPY_FR_us
 
 
 cdef class Nano(Tick):
     _nanos_inc = 1
     _prefix = "N"
+    _td64_unit = "ns"
     _period_dtype_code = PeriodDtypeCode.N
+    _reso = NPY_DATETIMEUNIT.NPY_FR_ns
 
 
 def delta_to_tick(delta: timedelta) -> Tick:
@@ -1089,25 +1299,9 @@ cdef class RelativeDeltaOffset(BaseOffset):
         else:
             return other + timedelta(self.n)
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        """
-        Vectorized apply of DateOffset to DatetimeIndex,
-        raises NotImplementedError for offsets without a
-        vectorized implementation.
-
-        Parameters
-        ----------
-        index : DatetimeIndex
-
-        Returns
-        -------
-        ndarray[datetime64[ns]]
-        """
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
+        reso = get_unit_from_dtype(dtarr.dtype)
         dt64other = np.asarray(dtarr)
         kwds = self.kwds
         relativedelta_fast = {
@@ -1125,12 +1319,14 @@ cdef class RelativeDeltaOffset(BaseOffset):
 
             months = (kwds.get("years", 0) * 12 + kwds.get("months", 0)) * self.n
             if months:
-                shifted = shift_months(dt64other.view("i8"), months)
-                dt64other = shifted.view("datetime64[ns]")
+                shifted = shift_months(dt64other.view("i8"), months, reso=reso)
+                dt64other = shifted.view(dtarr.dtype)
 
             weeks = kwds.get("weeks", 0) * self.n
             if weeks:
-                dt64other = dt64other + Timedelta(days=7 * weeks)
+                delta = Timedelta(days=7 * weeks)
+                td = (<_Timedelta>delta)._as_reso(reso)
+                dt64other = dt64other + td
 
             timedelta_kwds = {
                 k: v
@@ -1139,11 +1335,19 @@ cdef class RelativeDeltaOffset(BaseOffset):
             }
             if timedelta_kwds:
                 delta = Timedelta(**timedelta_kwds)
-                dt64other = dt64other + (self.n * delta)
+                td = (<_Timedelta>delta)._as_reso(reso)
+                dt64other = dt64other + (self.n * td)
             return dt64other
         elif not self._use_relativedelta and hasattr(self, "_offset"):
             # timedelta
-            return dt64other + Timedelta(self._offset * self.n)
+            num_nano = getattr(self, "nanoseconds", 0)
+            if num_nano != 0:
+                rem_nano = Timedelta(nanoseconds=num_nano)
+                delta = Timedelta((self._offset + rem_nano) * self.n)
+            else:
+                delta = Timedelta(self._offset * self.n)
+            td = (<_Timedelta>delta)._as_reso(reso)
+            return dt64other + td
         else:
             # relativedelta with other keywords
             kwd = set(kwds) - relativedelta_fast
@@ -1219,10 +1423,14 @@ class DateOffset(RelativeDeltaOffset, metaclass=OffsetMeta):
 
     Since 0 is a bit weird, we suggest avoiding its use.
 
+    Besides, adding a DateOffsets specified by the singular form of the date
+    component can be used to replace certain component of the timestamp.
+
     Parameters
     ----------
     n : int, default 1
         The number of time periods the offset represents.
+        If specified without a temporal pattern, defaults to n days.
     normalize : bool, default False
         Whether to round the result of a DateOffset addition down to the
         previous midnight.
@@ -1238,6 +1446,7 @@ class DateOffset(RelativeDeltaOffset, metaclass=OffsetMeta):
         - hours
         - minutes
         - seconds
+        - milliseconds
         - microseconds
         - nanoseconds
 
@@ -1269,6 +1478,11 @@ class DateOffset(RelativeDeltaOffset, metaclass=OffsetMeta):
     >>> ts = pd.Timestamp('2017-01-01 09:10:11')
     >>> ts + DateOffset(months=2)
     Timestamp('2017-03-01 09:10:11')
+    >>> ts + DateOffset(day=31)
+    Timestamp('2017-01-31 09:10:11')
+
+    >>> ts + pd.DateOffset(hour=8)
+    Timestamp('2017-01-01 08:10:11')
     """
     def __setattr__(self, name, value):
         raise AttributeError("DateOffset objects are immutable.")
@@ -1347,6 +1561,12 @@ cdef class BusinessMixin(SingleConstructorOffset):
 cdef class BusinessDay(BusinessMixin):
     """
     DateOffset subclass representing possibly n business days.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 8, 5)
+    >>> ts + pd.offsets.BusinessDay()
+    Timestamp('2022-08-08 00:00:00')
     """
     _period_dtype_code = PeriodDtypeCode.B
     _prefix = "B"
@@ -1435,16 +1655,13 @@ cdef class BusinessDay(BusinessMixin):
                 "Only know how to combine business day with datetime or timedelta."
             )
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
         i8other = dtarr.view("i8")
-        res = _shift_bdays(i8other, self.n)
+        reso = get_unit_from_dtype(dtarr.dtype)
+        res = _shift_bdays(i8other, self.n, reso=reso)
         if self.offset:
-            res = res.view("M8[ns]") + Timedelta(self.offset)
+            res = res.view(dtarr.dtype) + Timedelta(self.offset)
             res = res.view("i8")
         return res
 
@@ -1470,6 +1687,12 @@ cdef class BusinessHour(BusinessMixin):
         Start time of your custom business hour in 24h format.
     end : str, default: "17:00"
         End time of your custom business hour in 24h format.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 8, 5, 16)
+    >>> ts + pd.offsets.BusinessHour()
+    Timestamp('2022-08-08 09:00:00')
     """
 
     _prefix = "BH"
@@ -1543,8 +1766,9 @@ cdef class BusinessHour(BusinessMixin):
 
     def _repr_attrs(self) -> str:
         out = super()._repr_attrs()
+        # Use python string formatting to be faster than strftime
         hours = ",".join(
-            f'{st.strftime("%H:%M")}-{en.strftime("%H:%M")}'
+            f'{st.hour:02d}:{st.minute:02d}-{en.hour:02d}:{en.minute:02d}'
             for st, en in zip(self.start, self.end)
         )
         attrs = [f"{self._prefix}={hours}"]
@@ -1863,7 +2087,7 @@ cdef class WeekOfMonthMixin(SingleConstructorOffset):
 
         shifted = shift_month(other, months, "start")
         to_day = self._get_offset_day(shifted)
-        return shift_day(shifted, to_day - shifted.day)
+        return _shift_day(shifted, to_day - shifted.day)
 
     def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
@@ -1940,14 +2164,11 @@ cdef class YearOffset(SingleConstructorOffset):
         months = years * 12 + (self.month - other.month)
         return shift_month(other, months, self._day_opt)
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
+        reso = get_unit_from_dtype(dtarr.dtype)
         shifted = shift_quarters(
-            dtarr.view("i8"), self.n, self.month, self._day_opt, modby=12
+            dtarr.view("i8"), self.n, self.month, self._day_opt, modby=12, reso=reso
         )
         return shifted
 
@@ -2005,6 +2226,12 @@ cdef class BYearBegin(YearOffset):
 cdef class YearEnd(YearOffset):
     """
     DateOffset increments between calendar year ends.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.YearEnd()
+    Timestamp('2022-12-31 00:00:00')
     """
 
     _default_month = 12
@@ -2024,6 +2251,12 @@ cdef class YearEnd(YearOffset):
 cdef class YearBegin(YearOffset):
     """
     DateOffset increments between calendar year begin dates.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.YearBegin()
+    Timestamp('2023-01-01 00:00:00')
     """
 
     _default_month = 1
@@ -2097,14 +2330,11 @@ cdef class QuarterOffset(SingleConstructorOffset):
         months = qtrs * 3 - months_since
         return shift_month(other, months, self._day_opt)
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
+        reso = get_unit_from_dtype(dtarr.dtype)
         shifted = shift_quarters(
-            dtarr.view("i8"), self.n, self.startingMonth, self._day_opt
+            dtarr.view("i8"), self.n, self.startingMonth, self._day_opt, modby=3, reso=reso
         )
         return shifted
 
@@ -2172,6 +2402,12 @@ cdef class QuarterEnd(QuarterOffset):
     startingMonth = 1 corresponds to dates like 1/31/2007, 4/30/2007, ...
     startingMonth = 2 corresponds to dates like 2/28/2007, 5/31/2007, ...
     startingMonth = 3 corresponds to dates like 3/31/2007, 6/30/2007, ...
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.QuarterEnd()
+    Timestamp('2022-03-31 00:00:00')
     """
     _default_starting_month = 3
     _prefix = "Q"
@@ -2194,6 +2430,12 @@ cdef class QuarterBegin(QuarterOffset):
     startingMonth = 1 corresponds to dates like 1/01/2007, 4/01/2007, ...
     startingMonth = 2 corresponds to dates like 2/01/2007, 5/01/2007, ...
     startingMonth = 3 corresponds to dates like 3/01/2007, 6/01/2007, ...
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.QuarterBegin()
+    Timestamp('2022-03-01 00:00:00')
     """
     _default_starting_month = 3
     _from_name_starting_month = 1
@@ -2216,13 +2458,10 @@ cdef class MonthOffset(SingleConstructorOffset):
         n = roll_convention(other.day, self.n, compare_day)
         return shift_month(other, n, self._day_opt)
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
-        shifted = shift_months(dtarr.view("i8"), self.n, self._day_opt)
+        reso = get_unit_from_dtype(dtarr.dtype)
+        shifted = shift_months(dtarr.view("i8"), self.n, self._day_opt, reso=reso)
         return shifted
 
     cpdef __setstate__(self, state):
@@ -2237,6 +2476,12 @@ cdef class MonthOffset(SingleConstructorOffset):
 cdef class MonthEnd(MonthOffset):
     """
     DateOffset of one month end.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.MonthEnd()
+    Timestamp('2022-01-31 00:00:00')
     """
     _period_dtype_code = PeriodDtypeCode.M
     _prefix = "M"
@@ -2246,6 +2491,12 @@ cdef class MonthEnd(MonthOffset):
 cdef class MonthBegin(MonthOffset):
     """
     DateOffset of one month at beginning.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.MonthBegin()
+    Timestamp('2022-02-01 00:00:00')
     """
     _prefix = "MS"
     _day_opt = "start"
@@ -2355,81 +2606,89 @@ cdef class SemiMonthOffset(SingleConstructorOffset):
 
         return shift_month(other, months, to_day)
 
-    @apply_index_wraps
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     @cython.wraparound(False)
     @cython.boundscheck(False)
     def _apply_array(self, dtarr):
         cdef:
-            int64_t[:] i8other = dtarr.view("i8")
-            Py_ssize_t i, count = len(i8other)
-            int64_t val
-            int64_t[:] out = np.empty(count, dtype="i8")
+            ndarray i8other = dtarr.view("i8")
+            Py_ssize_t i, count = dtarr.size
+            int64_t val, res_val
+            ndarray out = cnp.PyArray_EMPTY(i8other.ndim, i8other.shape, cnp.NPY_INT64, 0)
             npy_datetimestruct dts
             int months, to_day, nadj, n = self.n
             int days_in_month, day, anchor_dom = self.day_of_month
             bint is_start = isinstance(self, SemiMonthBegin)
+            NPY_DATETIMEUNIT reso = get_unit_from_dtype(dtarr.dtype)
+            cnp.broadcast mi = cnp.PyArray_MultiIterNew2(out, i8other)
 
         with nogil:
             for i in range(count):
-                val = i8other[i]
+                # Analogous to: val = i8other[i]
+                val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
                 if val == NPY_NAT:
-                    out[i] = NPY_NAT
-                    continue
-
-                dt64_to_dtstruct(val, &dts)
-                day = dts.day
-
-                # Adjust so that we are always looking at self.day_of_month,
-                #  incrementing/decrementing n if necessary.
-                nadj = roll_convention(day, n, anchor_dom)
-
-                days_in_month = get_days_in_month(dts.year, dts.month)
-                # For SemiMonthBegin on other.day == 1 and
-                #  SemiMonthEnd on other.day == days_in_month,
-                #  shifting `other` to `self.day_of_month` _always_ requires
-                #  incrementing/decrementing `n`, regardless of whether it is
-                #  initially positive.
-                if is_start and (n <= 0 and day == 1):
-                    nadj -= 1
-                elif (not is_start) and (n > 0 and day == days_in_month):
-                    nadj += 1
-
-                if is_start:
-                    # See also: SemiMonthBegin._apply
-                    months = nadj // 2 + nadj % 2
-                    to_day = 1 if nadj % 2 else anchor_dom
+                    res_val = NPY_NAT
 
                 else:
-                    # See also: SemiMonthEnd._apply
-                    months = nadj // 2
-                    to_day = 31 if nadj % 2 else anchor_dom
-
-                dts.year = year_add_months(dts, months)
-                dts.month = month_add_months(dts, months)
-                days_in_month = get_days_in_month(dts.year, dts.month)
-                dts.day = min(to_day, days_in_month)
+                    pandas_datetime_to_datetimestruct(val, reso, &dts)
+                    day = dts.day
+
+                    # Adjust so that we are always looking at self.day_of_month,
+                    #  incrementing/decrementing n if necessary.
+                    nadj = roll_convention(day, n, anchor_dom)
+
+                    days_in_month = get_days_in_month(dts.year, dts.month)
+                    # For SemiMonthBegin on other.day == 1 and
+                    #  SemiMonthEnd on other.day == days_in_month,
+                    #  shifting `other` to `self.day_of_month` _always_ requires
+                    #  incrementing/decrementing `n`, regardless of whether it is
+                    #  initially positive.
+                    if is_start and (n <= 0 and day == 1):
+                        nadj -= 1
+                    elif (not is_start) and (n > 0 and day == days_in_month):
+                        nadj += 1
+
+                    if is_start:
+                        # See also: SemiMonthBegin._apply
+                        months = nadj // 2 + nadj % 2
+                        to_day = 1 if nadj % 2 else anchor_dom
+
+                    else:
+                        # See also: SemiMonthEnd._apply
+                        months = nadj // 2
+                        to_day = 31 if nadj % 2 else anchor_dom
+
+                    dts.year = year_add_months(dts, months)
+                    dts.month = month_add_months(dts, months)
+                    days_in_month = get_days_in_month(dts.year, dts.month)
+                    dts.day = min(to_day, days_in_month)
+
+                    res_val = npy_datetimestruct_to_datetime(reso, &dts)
+
+                # Analogous to: out[i] = res_val
+                (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
+
+                cnp.PyArray_MultiIter_NEXT(mi)
 
-                out[i] = dtstruct_to_dt64(&dts)
-
-        return out.base
+        return out
 
 
 cdef class SemiMonthEnd(SemiMonthOffset):
     """
-    Two DateOffset's per month repeating on the last
-    day of the month and day_of_month.
+    Two DateOffset's per month repeating on the last day of the month & day_of_month.
 
     Parameters
     ----------
     n : int
     normalize : bool, default False
     day_of_month : int, {1, 3,...,27}, default 15
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.SemiMonthEnd()
+    Timestamp('2022-01-15 00:00:00')
     """
 
     _prefix = "SM"
@@ -2444,14 +2703,19 @@ cdef class SemiMonthEnd(SemiMonthOffset):
 
 cdef class SemiMonthBegin(SemiMonthOffset):
     """
-    Two DateOffset's per month repeating on the first
-    day of the month and day_of_month.
+    Two DateOffset's per month repeating on the first day of the month & day_of_month.
 
     Parameters
     ----------
     n : int
     normalize : bool, default False
     day_of_month : int, {2, 3,...,27}, default 15
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.SemiMonthBegin()
+    Timestamp('2022-01-15 00:00:00')
     """
 
     _prefix = "SMS"
@@ -2474,6 +2738,12 @@ cdef class Week(SingleConstructorOffset):
     ----------
     weekday : int or None, default None
         Always generate specific day of week. 0 for Monday.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.Week()
+    Timestamp('2022-01-08 00:00:00')
     """
 
     _inc = timedelta(weeks=1)
@@ -2522,10 +2792,6 @@ cdef class Week(SingleConstructorOffset):
 
         return other + timedelta(weeks=k)
 
-    @apply_index_wraps
-    def apply_index(self, dtindex):
-        return self._apply_array(dtindex)
-
     @apply_array_wraps
     def _apply_array(self, dtarr):
         if self.weekday is None:
@@ -2533,12 +2799,13 @@ cdef class Week(SingleConstructorOffset):
             td64 = np.timedelta64(td, "ns")
             return dtarr + td64
         else:
+            reso = get_unit_from_dtype(dtarr.dtype)
             i8other = dtarr.view("i8")
-            return self._end_apply_index(i8other)
+            return self._end_apply_index(i8other, reso=reso)
 
     @cython.wraparound(False)
     @cython.boundscheck(False)
-    cdef _end_apply_index(self, const int64_t[:] i8other):
+    cdef ndarray _end_apply_index(self, ndarray i8other, NPY_DATETIMEUNIT reso):
         """
         Add self to the given DatetimeIndex, specialized for case where
         self.weekday is non-null.
@@ -2546,39 +2813,48 @@ cdef class Week(SingleConstructorOffset):
         Parameters
         ----------
         i8other : const int64_t[:]
+        reso : NPY_DATETIMEUNIT
 
         Returns
         -------
         ndarray[int64_t]
         """
         cdef:
-            Py_ssize_t i, count = len(i8other)
-            int64_t val
-            int64_t[:] out = np.empty(count, dtype="i8")
+            Py_ssize_t i, count = i8other.size
+            int64_t val, res_val
+            ndarray out = cnp.PyArray_EMPTY(i8other.ndim, i8other.shape, cnp.NPY_INT64, 0)
             npy_datetimestruct dts
             int wday, days, weeks, n = self.n
             int anchor_weekday = self.weekday
+            int64_t DAY_PERIODS = periods_per_day(reso)
+            cnp.broadcast mi = cnp.PyArray_MultiIterNew2(out, i8other)
 
         with nogil:
             for i in range(count):
-                val = i8other[i]
+                # Analogous to: val = i8other[i]
+                val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
                 if val == NPY_NAT:
-                    out[i] = NPY_NAT
-                    continue
+                    res_val = NPY_NAT
+                else:
+                    pandas_datetime_to_datetimestruct(val, reso, &dts)
+                    wday = dayofweek(dts.year, dts.month, dts.day)
+
+                    days = 0
+                    weeks = n
+                    if wday != anchor_weekday:
+                        days = (anchor_weekday - wday) % 7
+                        if weeks > 0:
+                            weeks -= 1
 
-                dt64_to_dtstruct(val, &dts)
-                wday = dayofweek(dts.year, dts.month, dts.day)
+                    res_val = val + (7 * weeks + days) * DAY_PERIODS
 
-                days = 0
-                weeks = n
-                if wday != anchor_weekday:
-                    days = (anchor_weekday - wday) % 7
-                    if weeks > 0:
-                        weeks -= 1
+                # Analogous to: out[i] = res_val
+                (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
 
-                out[i] = val + (7 * weeks + days) * DAY_NANOS
+                cnp.PyArray_MultiIter_NEXT(mi)
 
-        return out.base
+        return out
 
     def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
@@ -2624,6 +2900,12 @@ cdef class WeekOfMonth(WeekOfMonthMixin):
         - 4 is Friday
         - 5 is Saturday
         - 6 is Sunday.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.WeekOfMonth()
+    Timestamp('2022-01-03 00:00:00')
     """
 
     _prefix = "WOM"
@@ -2672,8 +2954,9 @@ cdef class WeekOfMonth(WeekOfMonthMixin):
 
 cdef class LastWeekOfMonth(WeekOfMonthMixin):
     """
-    Describes monthly dates in last week of month like "the last Tuesday of
-    each month".
+    Describes monthly dates in last week of month.
+
+    For example "the last Tuesday of each month".
 
     Parameters
     ----------
@@ -2688,6 +2971,12 @@ cdef class LastWeekOfMonth(WeekOfMonthMixin):
         - 4 is Friday
         - 5 is Saturday
         - 6 is Sunday.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.LastWeekOfMonth()
+    Timestamp('2022-01-31 00:00:00')
     """
 
     _prefix = "LWOM"
@@ -2835,6 +3124,12 @@ cdef class FY5253(FY5253Mixin):
 
         - "nearest" means year end is **weekday** closest to last day of month in year.
         - "last" means year end is final **weekday** of the final month in fiscal year.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.FY5253()
+    Timestamp('2022-01-31 00:00:00')
     """
 
     _prefix = "RE"
@@ -2959,8 +3254,9 @@ cdef class FY5253(FY5253Mixin):
 
 cdef class FY5253Quarter(FY5253Mixin):
     """
-    DateOffset increments between business quarter dates
-    for 52-53 week fiscal year (also known as a 4-4-5 calendar).
+    DateOffset increments between business quarter dates for 52-53 week fiscal year.
+
+    Also known as a 4-4-5 calendar.
 
     It is used by companies that desire that their
     fiscal year always end on the same day of the week.
@@ -3011,6 +3307,12 @@ cdef class FY5253Quarter(FY5253Mixin):
 
         - "nearest" means year end is **weekday** closest to last day of month in year.
         - "last" means year end is final **weekday** of the final month in fiscal year.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.FY5253Quarter()
+    Timestamp('2022-01-31 00:00:00')
     """
 
     _prefix = "REQ"
@@ -3085,14 +3387,14 @@ cdef class FY5253Quarter(FY5253Mixin):
             qtr_lens = self.get_weeks(norm)
 
             # check that qtr_lens is consistent with self._offset addition
-            end = shift_day(start, days=7 * sum(qtr_lens))
+            end = _shift_day(start, days=7 * sum(qtr_lens))
             assert self._offset.is_on_offset(end), (start, end, qtr_lens)
 
             tdelta = norm - start
             for qlen in qtr_lens:
                 if qlen * 7 <= tdelta.days:
                     num_qtrs += 1
-                    tdelta -= Timedelta(days=qlen * 7)
+                    tdelta -= (<_Timedelta>Timedelta(days=qlen * 7))._as_reso(norm._reso)
                 else:
                     break
         else:
@@ -3126,7 +3428,7 @@ cdef class FY5253Quarter(FY5253Mixin):
         # Note: we always have 0 <= n < 4
         weeks = sum(qtr_lens[:n])
         if weeks:
-            res = shift_day(res, days=weeks * 7)
+            res = _shift_day(res, days=weeks * 7)
 
         return res
 
@@ -3163,7 +3465,7 @@ cdef class FY5253Quarter(FY5253Mixin):
 
         current = next_year_end
         for qtr_len in qtr_lens:
-            current = shift_day(current, days=qtr_len * 7)
+            current = _shift_day(current, days=qtr_len * 7)
             if dt == current:
                 return True
         return False
@@ -3186,6 +3488,12 @@ cdef class Easter(SingleConstructorOffset):
     DateOffset for the Easter holiday using logic defined in dateutil.
 
     Right now uses the revised method which is valid in years 1583-4099.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 1, 1)
+    >>> ts + pd.offsets.Easter()
+    Timestamp('2022-04-17 00:00:00')
     """
 
     cpdef __setstate__(self, state):
@@ -3245,8 +3553,14 @@ cdef class CustomBusinessDay(BusinessDay):
     holidays : list
         List/array of dates to exclude from the set of valid business days,
         passed to ``numpy.busdaycalendar``.
-    calendar : pd.HolidayCalendar or np.busdaycalendar
+    calendar : np.busdaycalendar
     offset : timedelta, default timedelta(0)
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 8, 5)
+    >>> ts + pd.offsets.CustomBusinessDay(1)
+    Timestamp('2022-08-08 00:00:00')
     """
 
     _prefix = "C"
@@ -3254,6 +3568,8 @@ cdef class CustomBusinessDay(BusinessDay):
         ["n", "normalize", "weekmask", "holidays", "calendar", "offset"]
     )
 
+    _apply_array = BaseOffset._apply_array
+
     def __init__(
         self,
         n=1,
@@ -3302,12 +3618,6 @@ cdef class CustomBusinessDay(BusinessDay):
                 "datetime, datetime64 or timedelta."
             )
 
-    def apply_index(self, dtindex):
-        raise NotImplementedError
-
-    def _apply_array(self, dtarr):
-        raise NotImplementedError
-
     def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
@@ -3331,6 +3641,12 @@ cdef class CustomBusinessHour(BusinessHour):
         Start time of your custom business hour in 24h format.
     end : str, default: "17:00"
         End time of your custom business hour in 24h format.
+
+    Examples
+    --------
+    >>> ts = pd.Timestamp(2022, 8, 5, 16)
+    >>> ts + pd.offsets.CustomBusinessHour()
+    Timestamp('2022-08-08 09:00:00')
     """
 
     _prefix = "CBH"
@@ -3371,7 +3687,7 @@ cdef class _CustomBusinessMonth(BusinessMixin):
     holidays : list
         List/array of dates to exclude from the set of valid business days,
         passed to ``numpy.busdaycalendar``.
-    calendar : pd.HolidayCalendar or np.busdaycalendar
+    calendar : np.busdaycalendar
         Calendar to integrate.
     offset : timedelta, default timedelta(0)
         Time offset to apply.
@@ -3574,8 +3890,7 @@ def _get_offset(name: str) -> BaseOffset:
 
 cpdef to_offset(freq):
     """
-    Return DateOffset object from string or tuple representation
-    or datetime.timedelta object.
+    Return DateOffset object from string or datetime.timedelta object.
 
     Parameters
     ----------
@@ -3682,7 +3997,7 @@ cpdef to_offset(freq):
 # ----------------------------------------------------------------------
 # RelativeDelta Arithmetic
 
-def shift_day(other: datetime, days: int) -> datetime:
+cdef datetime _shift_day(datetime other, int days):
     """
     Increment the datetime `other` by the given number of days, retaining
     the time-portion of the datetime.  For tz-naive datetimes this is
@@ -3726,12 +4041,13 @@ cdef inline int month_add_months(npy_datetimestruct dts, int months) nogil:
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cdef shift_quarters(
-    const int64_t[:] dtindex,
+cdef ndarray shift_quarters(
+    ndarray dtindex,
     int quarters,
     int q1start_month,
-    object day_opt,
+    str day_opt,
     int modby=3,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
 ):
     """
     Given an int64 array representing nanosecond timestamps, shift all elements
@@ -3744,26 +4060,61 @@ cdef shift_quarters(
     q1start_month : int month in which Q1 begins by convention
     day_opt : {'start', 'end', 'business_start', 'business_end'}
     modby : int (3 for quarters, 12 for years)
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
     out : ndarray[int64_t]
     """
-    cdef:
-        Py_ssize_t count = len(dtindex)
-        int64_t[:] out = np.empty(count, dtype="int64")
-
     if day_opt not in ["start", "end", "business_start", "business_end"]:
         raise ValueError("day must be None, 'start', 'end', "
                          "'business_start', or 'business_end'")
 
-    _shift_quarters(dtindex, out, count, quarters, q1start_month, day_opt, modby)
-    return np.asarray(out)
+    cdef:
+        Py_ssize_t count = dtindex.size
+        ndarray out = cnp.PyArray_EMPTY(dtindex.ndim, dtindex.shape, cnp.NPY_INT64, 0)
+        Py_ssize_t i
+        int64_t val, res_val
+        int months_since, n
+        npy_datetimestruct dts
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(out, dtindex)
+
+    with nogil:
+        for i in range(count):
+            # Analogous to: val = dtindex[i]
+            val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+            if val == NPY_NAT:
+                res_val = NPY_NAT
+            else:
+                pandas_datetime_to_datetimestruct(val, reso, &dts)
+                n = quarters
+
+                months_since = (dts.month - q1start_month) % modby
+                n = _roll_qtrday(&dts, n, months_since, day_opt)
+
+                dts.year = year_add_months(dts, modby * n - months_since)
+                dts.month = month_add_months(dts, modby * n - months_since)
+                dts.day = get_day_of_month(&dts, day_opt)
+
+                res_val = npy_datetimestruct_to_datetime(reso, &dts)
+
+            # Analogous to: out[i] = res_val
+            (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
+
+            cnp.PyArray_MultiIter_NEXT(mi)
+
+    return out
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def shift_months(const int64_t[:] dtindex, int months, object day_opt=None):
+def shift_months(
+    ndarray dtindex,  # int64_t, arbitrary ndim
+    int months,
+    str day_opt=None,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
+):
     """
     Given an int64-based datetime index, shift all elements
     specified number of months using DateOffset semantics
@@ -3776,99 +4127,77 @@ def shift_months(const int64_t[:] dtindex, int months, object day_opt=None):
     cdef:
         Py_ssize_t i
         npy_datetimestruct dts
-        int count = len(dtindex)
-        int64_t[:] out = np.empty(count, dtype="int64")
+        int count = dtindex.size
+        ndarray out = cnp.PyArray_EMPTY(dtindex.ndim, dtindex.shape, cnp.NPY_INT64, 0)
+        int months_to_roll
+        int64_t val, res_val
 
-    if day_opt is None:
-        with nogil:
-            for i in range(count):
-                if dtindex[i] == NPY_NAT:
-                    out[i] = NPY_NAT
-                    continue
-
-                dt64_to_dtstruct(dtindex[i], &dts)
-                dts.year = year_add_months(dts, months)
-                dts.month = month_add_months(dts, months)
-
-                dts.day = min(dts.day, get_days_in_month(dts.year, dts.month))
-                out[i] = dtstruct_to_dt64(&dts)
-    elif day_opt in ["start", "end", "business_start", "business_end"]:
-        _shift_months(dtindex, out, count, months, day_opt)
-    else:
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(out, dtindex)
+
+    if day_opt is not None and day_opt not in {
+            "start", "end", "business_start", "business_end"
+    }:
         raise ValueError("day must be None, 'start', 'end', "
                          "'business_start', or 'business_end'")
 
-    return np.asarray(out)
-
+    if day_opt is None:
+        # TODO: can we combine this with the non-None case?
+        with nogil:
+            for i in range(count):
+                # Analogous to: val = i8other[i]
+                val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
 
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline void _shift_months(const int64_t[:] dtindex,
-                               int64_t[:] out,
-                               Py_ssize_t count,
-                               int months,
-                               str day_opt) nogil:
-    """
-    See shift_months.__doc__
-    """
-    cdef:
-        Py_ssize_t i
-        int months_to_roll
-        npy_datetimestruct dts
+                if val == NPY_NAT:
+                    res_val = NPY_NAT
+                else:
+                    pandas_datetime_to_datetimestruct(val, reso, &dts)
+                    dts.year = year_add_months(dts, months)
+                    dts.month = month_add_months(dts, months)
 
-    for i in range(count):
-        if dtindex[i] == NPY_NAT:
-            out[i] = NPY_NAT
-            continue
+                    dts.day = min(dts.day, get_days_in_month(dts.year, dts.month))
+                    res_val = npy_datetimestruct_to_datetime(reso, &dts)
 
-        dt64_to_dtstruct(dtindex[i], &dts)
-        months_to_roll = months
+                # Analogous to: out[i] = res_val
+                (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
 
-        months_to_roll = _roll_qtrday(&dts, months_to_roll, 0, day_opt)
+                cnp.PyArray_MultiIter_NEXT(mi)
 
-        dts.year = year_add_months(dts, months_to_roll)
-        dts.month = month_add_months(dts, months_to_roll)
-        dts.day = get_day_of_month(&dts, day_opt)
+    else:
+        with nogil:
+            for i in range(count):
 
-        out[i] = dtstruct_to_dt64(&dts)
+                # Analogous to: val = i8other[i]
+                val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
 
+                if val == NPY_NAT:
+                    res_val = NPY_NAT
+                else:
+                    pandas_datetime_to_datetimestruct(val, reso, &dts)
+                    months_to_roll = months
 
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline void _shift_quarters(const int64_t[:] dtindex,
-                                 int64_t[:] out,
-                                 Py_ssize_t count,
-                                 int quarters,
-                                 int q1start_month,
-                                 str day_opt,
-                                 int modby) nogil:
-    """
-    See shift_quarters.__doc__
-    """
-    cdef:
-        Py_ssize_t i
-        int months_since, n
-        npy_datetimestruct dts
+                    months_to_roll = _roll_qtrday(&dts, months_to_roll, 0, day_opt)
 
-    for i in range(count):
-        if dtindex[i] == NPY_NAT:
-            out[i] = NPY_NAT
-            continue
+                    dts.year = year_add_months(dts, months_to_roll)
+                    dts.month = month_add_months(dts, months_to_roll)
+                    dts.day = get_day_of_month(&dts, day_opt)
 
-        dt64_to_dtstruct(dtindex[i], &dts)
-        n = quarters
+                    res_val = npy_datetimestruct_to_datetime(reso, &dts)
 
-        months_since = (dts.month - q1start_month) % modby
-        n = _roll_qtrday(&dts, n, months_since, day_opt)
+                # Analogous to: out[i] = res_val
+                (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
 
-        dts.year = year_add_months(dts, modby * n - months_since)
-        dts.month = month_add_months(dts, modby * n - months_since)
-        dts.day = get_day_of_month(&dts, day_opt)
+                cnp.PyArray_MultiIter_NEXT(mi)
 
-        out[i] = dtstruct_to_dt64(&dts)
+    return out
 
 
-cdef ndarray[int64_t] _shift_bdays(const int64_t[:] i8other, int periods):
+@cython.wraparound(False)
+@cython.boundscheck(False)
+cdef ndarray _shift_bdays(
+    ndarray i8other,
+    int periods,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
+):
     """
     Implementation of BusinessDay.apply_offset.
 
@@ -3876,27 +4205,32 @@ cdef ndarray[int64_t] _shift_bdays(const int64_t[:] i8other, int periods):
     ----------
     i8other : const int64_t[:]
     periods : int
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
     ndarray[int64_t]
     """
     cdef:
-        Py_ssize_t i, n = len(i8other)
-        int64_t[:] result = np.empty(n, dtype="i8")
-        int64_t val, res
+        Py_ssize_t i, n = i8other.size
+        ndarray result = cnp.PyArray_EMPTY(i8other.ndim, i8other.shape, cnp.NPY_INT64, 0)
+        int64_t val, res_val
         int wday, nadj, days
         npy_datetimestruct dts
+        int64_t DAY_PERIODS = periods_per_day(reso)
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(result, i8other)
 
     for i in range(n):
-        val = i8other[i]
+        # Analogous to: val = i8other[i]
+        val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
         if val == NPY_NAT:
-            result[i] = NPY_NAT
+            res_val = NPY_NAT
         else:
             # The rest of this is effectively a copy of BusinessDay.apply
             nadj = periods
             weeks = nadj // 5
-            dt64_to_dtstruct(val, &dts)
+            pandas_datetime_to_datetimestruct(val, reso, &dts)
             wday = dayofweek(dts.year, dts.month, dts.day)
 
             if nadj <= 0 and wday > 4:
@@ -3919,10 +4253,14 @@ cdef ndarray[int64_t] _shift_bdays(const int64_t[:] i8other, int periods):
                 # shift by nadj days plus 2 to get past the weekend
                 days = nadj + 2
 
-            res = val + (7 * weeks + days) * DAY_NANOS
-            result[i] = res
+            res_val = val + (7 * weeks + days) * DAY_PERIODS
 
-    return result.base
+        # Analogous to: out[i] = res_val
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
+
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
 
 
 def shift_month(stamp: datetime, months: int, day_opt: object = None) -> datetime:
@@ -3931,7 +4269,7 @@ def shift_month(stamp: datetime, months: int, day_opt: object = None) -> datetim
     option `day_opt`, return a new datetimelike that many months later,
     with day determined by `day_opt` using relativedelta semantics.
 
-    Scalar analogue of shift_months
+    Scalar analogue of shift_months.
 
     Parameters
     ----------
diff --git a/pandas/_libs/tslibs/parsing.pyi b/pandas/_libs/tslibs/parsing.pyi
index 6a96b05d53c37..ce49136e6b379 100644
--- a/pandas/_libs/tslibs/parsing.pyi
+++ b/pandas/_libs/tslibs/parsing.pyi
@@ -51,9 +51,7 @@ def try_parse_datetime_components(
 def format_is_iso(f: str) -> bool: ...
 def guess_datetime_format(
     dt_str,
-    dayfirst: bool = ...,
-    dt_str_parse=...,
-    dt_str_split=...,
+    dayfirst: bool | None = ...,
 ) -> str | None: ...
 def concat_date_cols(
     date_cols: tuple,
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index f2b480642e083..35f97f1978b69 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -5,19 +5,17 @@ import re
 import time
 import warnings
 
-from libc.string cimport strchr
-
-import cython
-from cython import Py_ssize_t
+from pandas.util._exceptions import find_stack_level
 
+cimport cython
 from cpython.datetime cimport (
     datetime,
     datetime_new,
     import_datetime,
-    tzinfo,
 )
 from cpython.object cimport PyObject_Str
-from cpython.version cimport PY_VERSION_HEX
+from cython cimport Py_ssize_t
+from libc.string cimport strchr
 
 import_datetime()
 
@@ -45,7 +43,6 @@ from dateutil.relativedelta import relativedelta
 from dateutil.tz import (
     tzlocal as _dateutil_tzlocal,
     tzoffset,
-    tzstr as _dateutil_tzstr,
     tzutc as _dateutil_tzutc,
 )
 
@@ -56,6 +53,11 @@ from pandas._libs.tslibs.nattype cimport (
     c_NaT as NaT,
     c_nat_strings as nat_strings,
 )
+from pandas._libs.tslibs.np_datetime cimport (
+    NPY_DATETIMEUNIT,
+    npy_datetimestruct,
+    string_to_dts,
+)
 from pandas._libs.tslibs.offsets cimport is_offset_object
 from pandas._libs.tslibs.util cimport (
     get_c_string_buf_and_size,
@@ -83,8 +85,9 @@ _DEFAULT_DATETIME = datetime(1, 1, 1).replace(hour=0, minute=0,
                                               second=0, microsecond=0)
 
 PARSING_WARNING_MSG = (
-    "Parsing '{date_string}' in {format} format. Provide format "
-    "or specify infer_datetime_format=True for consistent parsing."
+    "Parsing dates in {format} format when dayfirst={dayfirst} was specified. "
+    "This may lead to inconsistently parsed dates! Specify a format "
+    "to ensure consistent parsing."
 )
 
 cdef:
@@ -96,8 +99,14 @@ cdef:
     int MAX_DAYS_IN_MONTH = 31, MAX_MONTH = 12
 
 
-cdef inline bint _is_not_delimiter(const char ch):
-    return strchr(delimiters, ch) == NULL
+cdef inline bint _is_delimiter(const char ch):
+    return strchr(delimiters, ch) != NULL
+
+
+cdef inline int _parse_1digit(const char* s):
+    cdef int result = 0
+    result += getdigit_ascii(s[0], -10) * 1
+    return result
 
 
 cdef inline int _parse_2digit(const char* s):
@@ -148,18 +157,37 @@ cdef inline object _parse_delimited_date(str date_string, bint dayfirst):
         bint can_swap = 0
 
     buf = get_c_string_buf_and_size(date_string, &length)
-    if length == 10:
+    if length == 10 and _is_delimiter(buf[2]) and _is_delimiter(buf[5]):
         # parsing MM?DD?YYYY and DD?MM?YYYY dates
-        if _is_not_delimiter(buf[2]) or _is_not_delimiter(buf[5]):
-            return None, None
         month = _parse_2digit(buf)
         day = _parse_2digit(buf + 3)
         year = _parse_4digit(buf + 6)
         reso = 'day'
         can_swap = 1
-    elif length == 7:
+    elif length == 9 and _is_delimiter(buf[1]) and _is_delimiter(buf[4]):
+        # parsing M?DD?YYYY and D?MM?YYYY dates
+        month = _parse_1digit(buf)
+        day = _parse_2digit(buf + 2)
+        year = _parse_4digit(buf + 5)
+        reso = 'day'
+        can_swap = 1
+    elif length == 9 and _is_delimiter(buf[2]) and _is_delimiter(buf[4]):
+        # parsing MM?D?YYYY and DD?M?YYYY dates
+        month = _parse_2digit(buf)
+        day = _parse_1digit(buf + 3)
+        year = _parse_4digit(buf + 5)
+        reso = 'day'
+        can_swap = 1
+    elif length == 8 and _is_delimiter(buf[1]) and _is_delimiter(buf[3]):
+        # parsing M?D?YYYY and D?M?YYYY dates
+        month = _parse_1digit(buf)
+        day = _parse_1digit(buf + 2)
+        year = _parse_4digit(buf + 4)
+        reso = 'day'
+        can_swap = 1
+    elif length == 7 and _is_delimiter(buf[2]):
         # parsing MM?YYYY dates
-        if buf[2] == b'.' or _is_not_delimiter(buf[2]):
+        if buf[2] == b'.':
             # we cannot reliably tell whether e.g. 10.2010 is a float
             # or a date, thus we refuse to parse it here
             return None, None
@@ -183,24 +211,22 @@ cdef inline object _parse_delimited_date(str date_string, bint dayfirst):
         if dayfirst and not swapped_day_and_month:
             warnings.warn(
                 PARSING_WARNING_MSG.format(
-                    date_string=date_string,
-                    format='MM/DD/YYYY'
+                    format='MM/DD/YYYY',
+                    dayfirst='True',
                 ),
-                stacklevel=4,
+                stacklevel=find_stack_level(),
             )
         elif not dayfirst and swapped_day_and_month:
             warnings.warn(
                 PARSING_WARNING_MSG.format(
-                    date_string=date_string,
-                    format='DD/MM/YYYY'
+                    format='DD/MM/YYYY',
+                    dayfirst='False (the default)',
                 ),
-                stacklevel=4,
+                stacklevel=find_stack_level(),
             )
-        if PY_VERSION_HEX >= 0x03060100:
-            # In Python <= 3.6.0 there is no range checking for invalid dates
-            # in C api, thus we call faster C version for 3.6.1 or newer
-            return datetime_new(year, month, day, 0, 0, 0, 0, None), reso
-        return datetime(year, month, day, 0, 0, 0, 0, None), reso
+        # In Python <= 3.6.0 there is no range checking for invalid dates
+        # in C api, thus we call faster C version for 3.6.1 or newer
+        return datetime_new(year, month, day, 0, 0, 0, 0, None), reso
 
     raise DateParseError(f"Invalid date specified ({month}/{day})")
 
@@ -239,6 +265,9 @@ cdef inline bint does_string_look_like_time(str parse_string):
 
 
 def parse_datetime_string(
+    # NB: This will break with np.str_ (GH#32264) even though
+    #  isinstance(npstrobj, str) evaluates to True, so caller must ensure
+    #  the argument is *exactly* 'str'
     str date_string,
     bint dayfirst=False,
     bint yearfirst=False,
@@ -254,10 +283,10 @@ def parse_datetime_string(
     """
 
     cdef:
-        object dt
+        datetime dt
 
     if not _does_string_look_like_datetime(date_string):
-        raise ValueError('Given date string not likely a datetime.')
+        raise ValueError(f'Given date string {date_string} not likely a datetime')
 
     if does_string_look_like_time(date_string):
         # use current datetime as default, not pass _DEFAULT_DATETIME
@@ -269,6 +298,14 @@ def parse_datetime_string(
     if dt is not None:
         return dt
 
+    # Handling special case strings today & now
+    if date_string == "now":
+        dt = datetime.now()
+        return dt
+    elif date_string == "today":
+        dt = datetime.today()
+        return dt
+
     try:
         dt, _ = _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq=None)
         return dt
@@ -283,12 +320,12 @@ def parse_datetime_string(
     except TypeError:
         # following may be raised from dateutil
         # TypeError: 'NoneType' object is not iterable
-        raise ValueError('Given date string not likely a datetime.')
+        raise ValueError(f'Given date string {date_string} not likely a datetime')
 
     return dt
 
 
-def parse_time_string(arg: str, freq=None, dayfirst=None, yearfirst=None):
+def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
     """
     Try hard to parse datetime string, leveraging dateutil plus some extra
     goodies like quarter recognition.
@@ -309,14 +346,23 @@ def parse_time_string(arg: str, freq=None, dayfirst=None, yearfirst=None):
     str
         Describing resolution of parsed string.
     """
+    if type(arg) is not str:
+        # GH#45580 np.str_ satisfies isinstance(obj, str) but if we annotate
+        #  arg as "str" this raises here
+        if not isinstance(arg, np.str_):
+            raise TypeError(
+                "Argument 'arg' has incorrect type "
+                f"(expected str, got {type(arg).__name__})"
+            )
+        arg = str(arg)
+
     if is_offset_object(freq):
         freq = freq.rule_code
 
-    if dayfirst is None or yearfirst is None:
-        if dayfirst is None:
-            dayfirst = get_option("display.date_dayfirst")
-        if yearfirst is None:
-            yearfirst = get_option("display.date_yearfirst")
+    if dayfirst is None:
+        dayfirst = get_option("display.date_dayfirst")
+    if yearfirst is None:
+        yearfirst = get_option("display.date_yearfirst")
 
     res = parse_datetime_string_with_reso(arg, freq=freq,
                                           dayfirst=dayfirst,
@@ -343,14 +389,46 @@ cdef parse_datetime_string_with_reso(
     """
     cdef:
         object parsed, reso
+        bint string_to_dts_failed
+        npy_datetimestruct dts
+        NPY_DATETIMEUNIT out_bestunit
+        int out_local
+        int out_tzoffset
 
     if not _does_string_look_like_datetime(date_string):
-        raise ValueError('Given date string not likely a datetime.')
+        raise ValueError(f'Given date string {date_string} not likely a datetime')
 
     parsed, reso = _parse_delimited_date(date_string, dayfirst)
     if parsed is not None:
         return parsed, reso
 
+    # Try iso8601 first, as it handles nanoseconds
+    # TODO: does this render some/all of parse_delimited_date redundant?
+    string_to_dts_failed = string_to_dts(
+        date_string, &dts, &out_bestunit, &out_local,
+        &out_tzoffset, False
+    )
+    if not string_to_dts_failed:
+        if dts.ps != 0 or out_local:
+            # TODO: the not-out_local case we could do without Timestamp;
+            #  avoid circular import
+            from pandas import Timestamp
+            parsed = Timestamp(date_string)
+        else:
+            parsed = datetime(dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.us)
+        reso = {
+            NPY_DATETIMEUNIT.NPY_FR_Y: "year",
+            NPY_DATETIMEUNIT.NPY_FR_M: "month",
+            NPY_DATETIMEUNIT.NPY_FR_D: "day",
+            NPY_DATETIMEUNIT.NPY_FR_h: "hour",
+            NPY_DATETIMEUNIT.NPY_FR_m: "minute",
+            NPY_DATETIMEUNIT.NPY_FR_s: "second",
+            NPY_DATETIMEUNIT.NPY_FR_ms: "millisecond",
+            NPY_DATETIMEUNIT.NPY_FR_us: "microsecond",
+            NPY_DATETIMEUNIT.NPY_FR_ns: "nanosecond",
+            }[out_bestunit]
+        return parsed, reso
+
     try:
         return _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
     except DateParseError:
@@ -361,7 +439,7 @@ cdef parse_datetime_string_with_reso(
     try:
         parsed, reso = dateutil_parse(date_string, _DEFAULT_DATETIME,
                                       dayfirst=dayfirst, yearfirst=yearfirst,
-                                      ignoretz=False, tzinfos=None)
+                                      ignoretz=False)
     except (ValueError, OverflowError) as err:
         # TODO: allow raise of errors within instead
         raise DateParseError(err)
@@ -553,14 +631,15 @@ cdef dateutil_parse(
     str timestr,
     object default,
     bint ignoretz=False,
-    object tzinfos=None,
     bint dayfirst=False,
     bint yearfirst=False,
 ):
     """ lifted from dateutil to get resolution"""
 
     cdef:
-        object res, attr, ret, tzdata
+        str attr
+        datetime ret
+        object res
         object reso = None
         dict repl = {}
 
@@ -589,24 +668,7 @@ cdef dateutil_parse(
     if res.weekday is not None and not res.day:
         ret = ret + relativedelta.relativedelta(weekday=res.weekday)
     if not ignoretz:
-        if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
-            # Note: as of 1.0 this is not reached because
-            #  we never pass tzinfos, see GH#22234
-            if callable(tzinfos):
-                tzdata = tzinfos(res.tzname, res.tzoffset)
-            else:
-                tzdata = tzinfos.get(res.tzname)
-            if isinstance(tzdata, tzinfo):
-                new_tzinfo = tzdata
-            elif isinstance(tzdata, str):
-                new_tzinfo = _dateutil_tzstr(tzdata)
-            elif isinstance(tzdata, int):
-                new_tzinfo = tzoffset(res.tzname, tzdata)
-            else:
-                raise ValueError("offset must be tzinfo subclass, "
-                                 "tz string, or int offset")
-            ret = ret.replace(tzinfo=new_tzinfo)
-        elif res.tzname and res.tzname in time.tzname:
+        if res.tzname and res.tzname in time.tzname:
             ret = ret.replace(tzinfo=_dateutil_tzlocal())
         elif res.tzoffset == 0:
             ret = ret.replace(tzinfo=_dateutil_tzutc())
@@ -624,7 +686,7 @@ def try_parse_dates(
 ) -> np.ndarray:
     cdef:
         Py_ssize_t i, n
-        object[:] result
+        object[::1] result
 
     n = len(values)
     result = np.empty(n, dtype='O')
@@ -668,7 +730,7 @@ def try_parse_date_and_time(
 ) -> np.ndarray:
     cdef:
         Py_ssize_t i, n
-        object[:] result
+        object[::1] result
 
     n = len(dates)
     # TODO(cython3): Use len instead of `shape[0]`
@@ -706,7 +768,7 @@ def try_parse_year_month_day(
 ) -> np.ndarray:
     cdef:
         Py_ssize_t i, n
-        object[:] result
+        object[::1] result
 
     n = len(years)
     # TODO(cython3): Use len instead of `shape[0]`
@@ -729,7 +791,7 @@ def try_parse_datetime_components(object[:] years,
 
     cdef:
         Py_ssize_t i, n
-        object[:] result
+        object[::1] result
         int secs
         double float_secs
         double micros
@@ -860,12 +922,7 @@ def format_is_iso(f: str) -> bint:
     return False
 
 
-def guess_datetime_format(
-    dt_str,
-    bint dayfirst=False,
-    dt_str_parse=du_parse,
-    dt_str_split=_DATEUTIL_LEXER_SPLIT,
-):
+def guess_datetime_format(dt_str, bint dayfirst=False):
     """
     Guess the datetime format of a given datetime string.
 
@@ -877,20 +934,11 @@ def guess_datetime_format(
         If True parses dates with the day first, eg 20/01/2005
         Warning: dayfirst=True is not strict, but will prefer to parse
         with day first (this is a known bug).
-    dt_str_parse : function, defaults to `dateutil.parser.parse`
-        This function should take in a datetime string and return
-        a `datetime.datetime` guess that the datetime string represents
-    dt_str_split : function, defaults to `_DATEUTIL_LEXER_SPLIT` (dateutil)
-        This function should take in a datetime string and return
-        a list of strings, the guess of the various specific parts
-        e.g. '2011/12/30' -> ['2011', '/', '12', '/', '30']
 
     Returns
     -------
     ret : datetime format string (for `strftime` or `strptime`)
     """
-    if dt_str_parse is None or dt_str_split is None:
-        return None
 
     if not isinstance(dt_str, str):
         return None
@@ -922,7 +970,7 @@ def guess_datetime_format(
         datetime_attrs_to_format.insert(0, day_attribute_and_format)
 
     try:
-        parsed_datetime = dt_str_parse(dt_str, dayfirst=dayfirst)
+        parsed_datetime = du_parse(dt_str, dayfirst=dayfirst)
     except (ValueError, OverflowError):
         # In case the datetime can't be parsed, its format cannot be guessed
         return None
@@ -930,9 +978,8 @@ def guess_datetime_format(
     if parsed_datetime is None:
         return None
 
-    # the default dt_str_split from dateutil will never raise here; we assume
-    #  that any user-provided function will not either.
-    tokens = dt_str_split(dt_str)
+    # _DATEUTIL_LEXER_SPLIT from dateutil will never raise here
+    tokens = _DATEUTIL_LEXER_SPLIT(dt_str)
 
     # Normalize offset part of tokens.
     # There are multiple formats for the timezone offset.
@@ -1082,7 +1129,7 @@ def concat_date_cols(tuple date_cols, bint keep_trivial_numbers=True) -> np.ndar
         object[::1] iters_view
         flatiter it
         cnp.ndarray[object] result
-        object[:] result_view
+        object[::1] result_view
 
     if col_count == 0:
         return np.zeros(0, dtype=object)
diff --git a/pandas/_libs/tslibs/period.pyi b/pandas/_libs/tslibs/period.pyi
index 2f60df0ad888e..5ad919649262c 100644
--- a/pandas/_libs/tslibs/period.pyi
+++ b/pandas/_libs/tslibs/period.pyi
@@ -1,3 +1,4 @@
+from datetime import timedelta
 from typing import Literal
 
 import numpy as np
@@ -33,7 +34,7 @@ def get_period_field_arr(
 ) -> npt.NDArray[np.int64]: ...
 def from_ordinals(
     values: npt.NDArray[np.int64],  # const int64_t[:]
-    freq: Frequency,
+    freq: timedelta | BaseOffset | str,
 ) -> npt.NDArray[np.int64]: ...
 def extract_ordinals(
     values: npt.NDArray[np.object_],
@@ -51,7 +52,14 @@ def period_ordinal(
 def freq_to_dtype_code(freq: BaseOffset) -> int: ...
 def validate_end_alias(how: str) -> Literal["E", "S"]: ...
 
-class Period:
+class PeriodMixin:
+    @property
+    def end_time(self) -> Timestamp: ...
+    @property
+    def start_time(self) -> Timestamp: ...
+    def _require_matching_freq(self, other, base: bool = ...) -> None: ...
+
+class Period(PeriodMixin):
     ordinal: int  # int64_t
     freq: BaseOffset
 
@@ -59,7 +67,7 @@ class Period:
     def __new__(  # type: ignore[misc]
         cls,
         value=...,
-        freq: int | str | None = ...,
+        freq: int | str | BaseOffset | None = ...,
         ordinal: int | None = ...,
         year: int | None = ...,
         month: int | None = ...,
@@ -82,7 +90,7 @@ class Period:
         how: str = ...,
         tz: Timezone | None = ...,
     ) -> Timestamp: ...
-    def asfreq(self, freq: str, how: str = ...) -> Period: ...
+    def asfreq(self, freq: str | BaseOffset, how: str = ...) -> Period: ...
     @property
     def freqstr(self) -> str: ...
     @property
@@ -117,9 +125,5 @@ class Period:
     def month(self) -> int: ...
     @property
     def year(self) -> int: ...
-    @property
-    def end_time(self) -> Timestamp: ...
-    @property
-    def start_time(self) -> Timestamp: ...
     def __sub__(self, other) -> Period | BaseOffset: ...
     def __add__(self, other) -> Period: ...
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index b2ea2e746b44c..a9d607ca9fd30 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1,13 +1,17 @@
 import warnings
 
+from pandas.util._exceptions import find_stack_level
+
 cimport numpy as cnp
 from cpython.object cimport (
     Py_EQ,
     Py_NE,
+    PyObject,
     PyObject_RichCompare,
     PyObject_RichCompareBool,
 )
 from numpy cimport (
+    int32_t,
     int64_t,
     ndarray,
 )
@@ -16,6 +20,14 @@ import numpy as np
 
 cnp.import_array()
 
+cimport cython
+from cpython.datetime cimport (
+    PyDate_Check,
+    PyDateTime_Check,
+    PyDelta_Check,
+    datetime,
+    import_datetime,
+)
 from libc.stdlib cimport (
     free,
     malloc,
@@ -29,42 +41,26 @@ from libc.time cimport (
     tm,
 )
 
-import cython
-
-from cpython.datetime cimport (
-    PyDate_Check,
-    PyDateTime_Check,
-    PyDateTime_IMPORT,
-    PyDelta_Check,
-    datetime,
-)
-
 # import datetime C API
-PyDateTime_IMPORT
+import_datetime()
 
+cimport pandas._libs.tslibs.util as util
+from pandas._libs.missing cimport C_NA
 from pandas._libs.tslibs.np_datetime cimport (
     NPY_DATETIMEUNIT,
     NPY_FR_D,
     NPY_FR_us,
+    astype_overflowsafe,
     check_dts_bounds,
-    dt64_to_dtstruct,
-    dtstruct_to_dt64,
+    get_timedelta64_value,
     npy_datetimestruct,
+    npy_datetimestruct_to_datetime,
     pandas_datetime_to_datetimestruct,
 )
 
-
-cdef extern from "src/datetime/np_datetime.h":
-    int64_t npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT fr,
-                                           npy_datetimestruct *d) nogil
-
-cimport pandas._libs.tslibs.util as util
-
-from pandas._libs.tslibs.timedeltas import Timedelta
 from pandas._libs.tslibs.timestamps import Timestamp
 
 from pandas._libs.tslibs.ccalendar cimport (
-    c_MONTH_NUMBERS,
     dayofweek,
     get_day_of_year,
     get_days_in_month,
@@ -76,7 +72,7 @@ from pandas._libs.tslibs.timedeltas cimport (
     is_any_td_scalar,
 )
 
-from pandas._libs.tslibs.conversion import ensure_datetime64ns
+from pandas._libs.tslibs.conversion import DT64NS_DTYPE
 
 from pandas._libs.tslibs.dtypes cimport (
     FR_ANN,
@@ -94,6 +90,7 @@ from pandas._libs.tslibs.dtypes cimport (
     FR_WK,
     PeriodDtypeBase,
     attrname_to_abbrevs,
+    freq_group_code_to_npy_unit,
 )
 from pandas._libs.tslibs.parsing cimport quarter_to_myear
 
@@ -101,7 +98,6 @@ from pandas._libs.tslibs.parsing import parse_time_string
 
 from pandas._libs.tslibs.nattype cimport (
     NPY_NAT,
-    _nat_scalar_rules,
     c_NaT as NaT,
     c_nat_strings as nat_strings,
     checknull_with_nat,
@@ -688,8 +684,7 @@ cdef char* c_strftime(npy_datetimestruct *dts, char *fmt):
 # Conversion between date_info and npy_datetimestruct
 
 cdef inline int get_freq_group(int freq) nogil:
-    # Note: this is equivalent to libfrequencies.get_freq_group, specialized
-    #  to integer argument.
+    # See also FreqGroup.get_freq_group
     return (freq // 1000) * 1000
 
 
@@ -805,36 +800,10 @@ cdef int64_t get_period_ordinal(npy_datetimestruct *dts, int freq) nogil:
         unix_date = npy_datetimestruct_to_datetime(NPY_FR_D, dts)
         return DtoB(dts, 0, unix_date)
 
-    unit = get_unit(freq)
+    unit = freq_group_code_to_npy_unit(freq)
     return npy_datetimestruct_to_datetime(unit, dts)
 
 
-cdef NPY_DATETIMEUNIT get_unit(int freq) nogil:
-    """
-    Convert the freq to the corresponding NPY_DATETIMEUNIT to pass
-    to npy_datetimestruct_to_datetime.
-    """
-    if freq == FR_MTH:
-        return NPY_DATETIMEUNIT.NPY_FR_M
-    elif freq == FR_DAY:
-        return NPY_DATETIMEUNIT.NPY_FR_D
-    elif freq == FR_HR:
-        return NPY_DATETIMEUNIT.NPY_FR_h
-    elif freq == FR_MIN:
-        return NPY_DATETIMEUNIT.NPY_FR_m
-    elif freq == FR_SEC:
-        return NPY_DATETIMEUNIT.NPY_FR_s
-    elif freq == FR_MS:
-        return NPY_DATETIMEUNIT.NPY_FR_ms
-    elif freq == FR_US:
-        return NPY_DATETIMEUNIT.NPY_FR_us
-    elif freq == FR_NS:
-        return NPY_DATETIMEUNIT.NPY_FR_ns
-    elif freq == FR_UND:
-        # Default to Day
-        return NPY_DATETIMEUNIT.NPY_FR_D
-
-
 cdef void get_date_info(int64_t ordinal, int freq, npy_datetimestruct *dts) nogil:
     cdef:
         int64_t unix_date, nanos
@@ -845,7 +814,7 @@ cdef void get_date_info(int64_t ordinal, int freq, npy_datetimestruct *dts) nogi
 
     pandas_datetime_to_datetimestruct(unix_date, NPY_FR_D, dts)
 
-    dt64_to_dtstruct(nanos, &dts2)
+    pandas_datetime_to_datetimestruct(nanos, NPY_DATETIMEUNIT.NPY_FR_ns, &dts2)
     dts.hour = dts2.hour
     dts.min = dts2.min
     dts.sec = dts2.sec
@@ -982,7 +951,7 @@ def periodarr_to_dt64arr(const int64_t[:] periodarr, int freq):
     periods per period convention.
     """
     cdef:
-        int64_t[:] out
+        int64_t[::1] out
         Py_ssize_t i, N
 
     if freq < 6000:  # i.e. FR_DAY, hard-code to avoid need to cast
@@ -998,6 +967,7 @@ def periodarr_to_dt64arr(const int64_t[:] periodarr, int freq):
     else:
         # Short-circuit for performance
         if freq == FR_NS:
+            # TODO: copy?
             return periodarr.base
 
         if freq == FR_US:
@@ -1012,7 +982,7 @@ def periodarr_to_dt64arr(const int64_t[:] periodarr, int freq):
             dta = periodarr.base.view("M8[h]")
         elif freq == FR_DAY:
             dta = periodarr.base.view("M8[D]")
-        return ensure_datetime64ns(dta)
+        return astype_overflowsafe(dta, dtype=DT64NS_DTYPE)
 
 
 cdef void get_asfreq_info(int from_freq, int to_freq,
@@ -1089,7 +1059,7 @@ def period_asfreq_arr(ndarray[int64_t] arr, int freq1, int freq2, bint end):
     cdef:
         Py_ssize_t n = len(arr)
         Py_ssize_t increment = arr.strides[0] // 8
-        ndarray[int64_t] result = np.empty(n, dtype=np.int64)
+        ndarray[int64_t] result = cnp.PyArray_EMPTY(arr.ndim, arr.shape, cnp.NPY_INT64, 0)
 
     _period_asfreq(
         <int64_t*>cnp.PyArray_DATA(arr),
@@ -1180,7 +1150,7 @@ cdef int64_t period_ordinal_to_dt64(int64_t ordinal, int freq) except? -1:
     get_date_info(ordinal, freq, &dts)
 
     check_dts_bounds(&dts)
-    return dtstruct_to_dt64(&dts)
+    return npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT.NPY_FR_ns, &dts)
 
 
 cdef str period_format(int64_t value, int freq, object fmt=None):
@@ -1242,10 +1212,14 @@ cdef str _period_strftime(int64_t value, int freq, bytes fmt):
         char *formatted
         bytes pat, brepl
         list found_pat = [False] * len(extra_fmts)
-        int year, quarter
+        int quarter
+        int32_t us, ps
         str result, repl
 
     get_date_info(value, freq, &dts)
+
+    # Find our additional directives in the pattern and replace them with
+    # placeholders that are not processed by c_strftime
     for i in range(len(extra_fmts)):
         pat = extra_fmts[i][0]
         brepl = extra_fmts[i][1]
@@ -1253,28 +1227,41 @@ cdef str _period_strftime(int64_t value, int freq, bytes fmt):
             fmt = fmt.replace(pat, brepl)
             found_pat[i] = True
 
+    # Execute c_strftime to process the usual datetime directives
     formatted = c_strftime(&dts, <char*>fmt)
 
     result = util.char_to_string(formatted)
     free(formatted)
 
+    # Now we will fill the placeholders corresponding to our additional directives
+
+    # First prepare the contents
+    # Save these to local vars as dts can be modified by get_yq below
+    us = dts.us
+    ps = dts.ps
+    if any(found_pat[0:3]):
+        # Note: this modifies `dts` in-place so that year becomes fiscal year
+        # However it looses the us and ps
+        quarter = get_yq(value, freq, &dts)
+    else:
+        quarter = 0
+
+    # Now do the filling per se
     for i in range(len(extra_fmts)):
         if found_pat[i]:
 
-            quarter = get_yq(value, freq, &dts)
-
-            if i == 0:
-                repl = str(quarter)
-            elif i == 1:  # %f, 2-digit year
+            if i == 0:  # %q, 1-digit quarter.
+                repl = f"{quarter}"
+            elif i == 1:  # %f, 2-digit 'Fiscal' year
                 repl = f"{(dts.year % 100):02d}"
-            elif i == 2:
+            elif i == 2:  # %F, 'Fiscal' year with a century
                 repl = str(dts.year)
-            elif i == 3:
-                repl = f"{(value % 1_000):03d}"
-            elif i == 4:
-                repl = f"{(value % 1_000_000):06d}"
-            elif i == 5:
-                repl = f"{(value % 1_000_000_000):09d}"
+            elif i == 3:  # %l, milliseconds
+                repl = f"{(us // 1_000):03d}"
+            elif i == 4:  # %u, microseconds
+                repl = f"{(us):06d}"
+            elif i == 5:  # %n, nanoseconds
+                repl = f"{((us * 1000) + (ps // 1000)):09d}"
 
             result = result.replace(str_extra_fmts[i], repl)
 
@@ -1378,7 +1365,7 @@ cdef int pdays_in_month(int64_t ordinal, int freq):
 def get_period_field_arr(str field, const int64_t[:] arr, int freq):
     cdef:
         Py_ssize_t i, sz
-        int64_t[:] out
+        int64_t[::1] out
         accessor f
 
     func = _get_accessor_func(field)
@@ -1430,7 +1417,7 @@ cdef accessor _get_accessor_func(str field):
 def from_ordinals(const int64_t[:] values, freq):
     cdef:
         Py_ssize_t i, n = len(values)
-        int64_t[:] result = np.empty(len(values), dtype="i8")
+        int64_t[::1] result = np.empty(len(values), dtype="i8")
         int64_t val
 
     freq = to_offset(freq)
@@ -1449,45 +1436,69 @@ def from_ordinals(const int64_t[:] values, freq):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def extract_ordinals(ndarray[object] values, freq) -> np.ndarray:
-    # TODO: Change type to const object[:] when Cython supports that.
+def extract_ordinals(ndarray values, freq) -> np.ndarray:
+    # values is object-dtype, may be 2D
 
     cdef:
-        Py_ssize_t i, n = len(values)
-        int64_t[:] ordinals = np.empty(n, dtype=np.int64)
+        Py_ssize_t i, n = values.size
+        int64_t ordinal
+        ndarray ordinals = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_INT64, 0)
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(ordinals, values)
         object p
 
+    if values.descr.type_num != cnp.NPY_OBJECT:
+        # if we don't raise here, we'll segfault later!
+        raise TypeError("extract_ordinals values must be object-dtype")
+
     freqstr = Period._maybe_convert_freq(freq).freqstr
 
     for i in range(n):
-        p = values[i]
+        # Analogous to: p = values[i]
+        p = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
 
-        if checknull_with_nat(p):
-            ordinals[i] = NPY_NAT
-        elif util.is_integer_object(p):
-            if p == NPY_NAT:
-                ordinals[i] = NPY_NAT
-            else:
-                raise TypeError(p)
-        else:
-            try:
-                ordinals[i] = p.ordinal
+        ordinal = _extract_ordinal(p, freqstr, freq)
 
-                if p.freqstr != freqstr:
-                    msg = DIFFERENT_FREQ.format(cls="PeriodIndex",
-                                                own_freq=freqstr,
-                                                other_freq=p.freqstr)
-                    raise IncompatibleFrequency(msg)
+        # Analogous to: ordinals[i] = ordinal
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ordinal
 
-            except AttributeError:
-                p = Period(p, freq=freq)
-                if p is NaT:
-                    # input may contain NaT-like string
-                    ordinals[i] = NPY_NAT
-                else:
-                    ordinals[i] = p.ordinal
+        cnp.PyArray_MultiIter_NEXT(mi)
 
-    return ordinals.base  # .base to access underlying np.ndarray
+    return ordinals
+
+
+cdef inline int64_t _extract_ordinal(object item, str freqstr, freq) except? -1:
+    """
+    See extract_ordinals.
+    """
+    cdef:
+        int64_t ordinal
+
+    if checknull_with_nat(item) or item is C_NA:
+        ordinal = NPY_NAT
+    elif util.is_integer_object(item):
+        if item == NPY_NAT:
+            ordinal = NPY_NAT
+        else:
+            raise TypeError(item)
+    else:
+        try:
+            ordinal = item.ordinal
+
+            if item.freqstr != freqstr:
+                msg = DIFFERENT_FREQ.format(cls="PeriodIndex",
+                                            own_freq=freqstr,
+                                            other_freq=item.freqstr)
+                raise IncompatibleFrequency(msg)
+
+        except AttributeError:
+            item = Period(item, freq=freq)
+            if item is NaT:
+                # input may contain NaT-like string
+                ordinal = NPY_NAT
+            else:
+                ordinal = item.ordinal
+
+    return ordinal
 
 
 def extract_freq(ndarray[object] values) -> BaseOffset:
@@ -1520,25 +1531,6 @@ class IncompatibleFrequency(ValueError):
 cdef class PeriodMixin:
     # Methods shared between Period and PeriodArray
 
-    cpdef int _get_to_timestamp_base(self):
-        """
-        Return frequency code group used for base of to_timestamp against
-        frequency code.
-
-        Return day freq code against longer freq than day.
-        Return second freq code against hour between second.
-
-        Returns
-        -------
-        int
-        """
-        base = self._dtype._dtype_code
-        if base < FR_BUS:
-            return FR_DAY
-        elif FR_HR <= base <= FR_SEC:
-            return FR_SEC
-        return base
-
     @property
     def start_time(self) -> Timestamp:
         """
@@ -1643,7 +1635,7 @@ cdef class _Period(PeriodMixin):
         if isinstance(freq, int):
             # We already have a dtype code
             dtype = PeriodDtypeBase(freq)
-            freq = dtype.date_offset
+            freq = dtype._freqstr
 
         freq = to_offset(freq)
 
@@ -1654,7 +1646,7 @@ cdef class _Period(PeriodMixin):
         return freq
 
     @classmethod
-    def _from_ordinal(cls, ordinal: int, freq) -> "Period":
+    def _from_ordinal(cls, ordinal: int64_t, freq) -> "Period":
         """
         Fast creation from an ordinal and freq that are already validated!
         """
@@ -1675,7 +1667,7 @@ cdef class _Period(PeriodMixin):
                 self._require_matching_freq(other)
             return PyObject_RichCompareBool(self.ordinal, other.ordinal, op)
         elif other is NaT:
-            return _nat_scalar_rules[op]
+            return op == Py_NE
         elif util.is_array(other):
             # GH#44285
             if cnp.PyArray_IsZeroDim(other):
@@ -1690,16 +1682,24 @@ cdef class _Period(PeriodMixin):
 
     def _add_timedeltalike_scalar(self, other) -> "Period":
         cdef:
-            int64_t nanos, base_nanos
+            int64_t inc
+
+        if not is_tick_object(self.freq):
+            raise IncompatibleFrequency("Input cannot be converted to "
+                                        f"Period(freq={self.freqstr})")
+
+        if util.is_timedelta64_object(other) and get_timedelta64_value(other) == NPY_NAT:
+            # i.e. np.timedelta64("nat")
+            return NaT
 
-        if is_tick_object(self.freq):
-            nanos = delta_to_nanoseconds(other)
-            base_nanos = self.freq.base.nanos
-            if nanos % base_nanos == 0:
-                ordinal = self.ordinal + (nanos // base_nanos)
-                return Period(ordinal=ordinal, freq=self.freq)
-        raise IncompatibleFrequency("Input cannot be converted to "
-                                    f"Period(freq={self.freqstr})")
+        try:
+            inc = delta_to_nanoseconds(other, reso=self.freq._reso, round_ok=False)
+        except ValueError as err:
+            raise IncompatibleFrequency("Input cannot be converted to "
+                                        f"Period(freq={self.freqstr})") from err
+        # TODO: overflow-check here
+        ordinal = self.ordinal + inc
+        return Period(ordinal=ordinal, freq=self.freq)
 
     def _add_offset(self, other) -> "Period":
         # Non-Tick DateOffset other
@@ -1714,6 +1714,7 @@ cdef class _Period(PeriodMixin):
     def __add__(self, other):
         if not is_period_object(self):
             # cython semantics; this is analogous to a call to __radd__
+            # TODO(cython3): remove this
             if self is NaT:
                 return NaT
             return other.__add__(self)
@@ -1727,10 +1728,12 @@ cdef class _Period(PeriodMixin):
         elif util.is_integer_object(other):
             ordinal = self.ordinal + other * self.freq.n
             return Period(ordinal=ordinal, freq=self.freq)
-        elif (PyDateTime_Check(other) or
-              is_period_object(other) or util.is_datetime64_object(other)):
+
+        elif is_period_object(other):
             # can't add datetime-like
-            # GH#17983
+            # GH#17983; can't just return NotImplemented bc we get a RecursionError
+            #  when called via np.add.reduce see TestNumpyReductions.test_add
+            #  in npdev build
             sname = type(self).__name__
             oname = type(other).__name__
             raise TypeError(f"unsupported operand type(s) for +: '{sname}' "
@@ -1738,23 +1741,23 @@ cdef class _Period(PeriodMixin):
 
         return NotImplemented
 
+    def __radd__(self, other):
+        return self.__add__(other)
+
     def __sub__(self, other):
         if not is_period_object(self):
             # cython semantics; this is like a call to __rsub__
+            # TODO(cython3): remove this
             if self is NaT:
                 return NaT
             return NotImplemented
 
-        elif is_any_td_scalar(other):
-            neg_other = -other
-            return self + neg_other
-        elif is_offset_object(other):
-            # Non-Tick DateOffset
-            neg_other = -other
-            return self + neg_other
-        elif util.is_integer_object(other):
-            ordinal = self.ordinal - other * self.freq.n
-            return Period(ordinal=ordinal, freq=self.freq)
+        elif (
+            is_any_td_scalar(other)
+            or is_offset_object(other)
+            or util.is_integer_object(other)
+        ):
+            return self + (-other)
         elif is_period_object(other):
             self._require_matching_freq(other)
             # GH 23915 - mul by base freq since __add__ is agnostic of n
@@ -1764,13 +1767,18 @@ cdef class _Period(PeriodMixin):
 
         return NotImplemented
 
+    def __rsub__(self, other):
+        if other is NaT:
+            return NaT
+        return NotImplemented
+
     def asfreq(self, freq, how='E') -> "Period":
         """
         Convert Period to desired frequency, at the start or end of the interval.
 
         Parameters
         ----------
-        freq : str
+        freq : str, BaseOffset
             The desired frequency.
         how : {'E', 'S', 'end', 'start'}, default 'end'
             Start or end of the timespan.
@@ -1821,7 +1829,7 @@ cdef class _Period(PeriodMixin):
                 "be removed in a future version.  Use "
                 "`per.to_timestamp(...).tz_localize(tz)` instead.",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
 
         how = validate_end_alias(how)
@@ -1830,13 +1838,13 @@ cdef class _Period(PeriodMixin):
         if end:
             if freq == "B" or self.freq == "B":
                 # roll forward to ensure we land on B date
-                adjust = Timedelta(1, "D") - Timedelta(1, "ns")
+                adjust = np.timedelta64(1, "D") - np.timedelta64(1, "ns")
                 return self.to_timestamp(how="start") + adjust
             endpoint = (self + self.freq).to_timestamp(how='start')
-            return endpoint - Timedelta(1, 'ns')
+            return endpoint - np.timedelta64(1, "ns")
 
         if freq is None:
-            freq = self._get_to_timestamp_base()
+            freq = self._dtype._get_to_timestamp_base()
             base = freq
         else:
             freq = self._maybe_convert_freq(freq)
@@ -2202,7 +2210,7 @@ cdef class _Period(PeriodMixin):
         2018
 
         If the fiscal year starts in April (`Q-MAR`), the first quarter of
-        2018 will start in April 2017. `year` will then be 2018, but `qyear`
+        2018 will start in April 2017. `year` will then be 2017, but `qyear`
         will be the fiscal year, 2018.
 
         >>> per = pd.Period('2018Q1', freq='Q-MAR')
@@ -2253,7 +2261,7 @@ cdef class _Period(PeriodMixin):
     @property
     def daysinmonth(self) -> int:
         """
-        Get the total number of days of the month that the Period falls in.
+        Get the total number of days of the month that this period falls on.
 
         Returns
         -------
@@ -2317,12 +2325,13 @@ cdef class _Period(PeriodMixin):
 
     def strftime(self, fmt: str) -> str:
         r"""
-        Returns the string representation of the :class:`Period`, depending
-        on the selected ``fmt``. ``fmt`` must be a string
-        containing one or several directives.  The method recognizes the same
-        directives as the :func:`time.strftime` function of the standard Python
-        distribution, as well as the specific additional directives ``%f``,
-        ``%F``, ``%q``. (formatting & docs originally from scikits.timeries).
+        Returns a formatted string representation of the :class:`Period`.
+
+        ``fmt`` must be a string containing one or several directives.
+        The method recognizes the same directives as the :func:`time.strftime`
+        function of the standard Python distribution, as well as the specific
+        additional directives ``%f``, ``%F``, ``%q``, ``%l``, ``%u``, ``%n``.
+        (formatting & docs originally from scikits.timeries).
 
         +-----------+--------------------------------+-------+
         | Directive | Meaning                        | Notes |
@@ -2369,11 +2378,20 @@ cdef class _Period(PeriodMixin):
         |           | AM or PM.                      |       |
         +-----------+--------------------------------+-------+
         | ``%q``    | Quarter as a decimal number    |       |
-        |           | [01,04]                        |       |
+        |           | [1,4]                          |       |
         +-----------+--------------------------------+-------+
         | ``%S``    | Second as a decimal number     | \(4)  |
         |           | [00,61].                       |       |
         +-----------+--------------------------------+-------+
+        | ``%l``    | Millisecond as a decimal number|       |
+        |           | [000,999].                     |       |
+        +-----------+--------------------------------+-------+
+        | ``%u``    | Microsecond as a decimal number|       |
+        |           | [000000,999999].               |       |
+        +-----------+--------------------------------+-------+
+        | ``%n``    | Nanosecond as a decimal number |       |
+        |           | [000000000,999999999].         |       |
+        +-----------+--------------------------------+-------+
         | ``%U``    | Week number of the year        | \(5)  |
         |           | (Sunday as the first day of    |       |
         |           | the week) as a decimal number  |       |
@@ -2465,9 +2483,11 @@ class Period(_Period):
     Parameters
     ----------
     value : Period or str, default None
-        The time period represented (e.g., '4Q2005').
+        The time period represented (e.g., '4Q2005'). This represents neither
+        the start or the end of the period, but rather the entire period itself.
     freq : str, default None
-        One of pandas period strings or corresponding objects.
+        One of pandas period strings or corresponding objects. Accepted
+        strings are listed in the :ref:`offset alias section <timeseries.offset_aliases>` in the user docs.
     ordinal : int, default None
         The period offset from the proleptic Gregorian epoch.
     year : int, default None
@@ -2484,6 +2504,12 @@ class Period(_Period):
         Minute value of the period.
     second : int, default 0
         Second value of the period.
+
+    Examples
+    --------
+    >>> period = pd.Period('2012-1-1', freq='D')
+    >>> period
+    Period('2012-01-01', 'D')
     """
 
     def __new__(cls, value=None, freq=None, ordinal=None,
@@ -2574,10 +2600,13 @@ class Period(_Period):
             dt = value
             if freq is None:
                 raise ValueError('Must supply freq for datetime value')
+            if isinstance(dt, Timestamp):
+                nanosecond = dt.nanosecond
         elif util.is_datetime64_object(value):
             dt = Timestamp(value)
             if freq is None:
                 raise ValueError('Must supply freq for datetime value')
+            nanosecond = dt.nanosecond
         elif PyDate_Check(value):
             dt = datetime(year=value.year, month=value.month, day=value.day)
             if freq is None:
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.c b/pandas/_libs/tslibs/src/datetime/np_datetime.c
index 9ad2ead5f919f..2bac6c720c3b6 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.c
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.c
@@ -27,14 +27,40 @@ This file is derived from NumPy 1.7. See NUMPY_LICENSE.txt
 #include <numpy/ndarraytypes.h>
 #include "np_datetime.h"
 
-#if PY_MAJOR_VERSION >= 3
-#define PyInt_AsLong PyLong_AsLong
-#endif  // PyInt_AsLong
 
+const npy_datetimestruct _AS_MIN_DTS = {
+    1969, 12, 31, 23, 59, 50, 776627, 963145, 224193};
+const npy_datetimestruct _FS_MIN_DTS = {
+    1969, 12, 31, 21, 26, 16, 627963, 145224, 193000};
+const npy_datetimestruct _PS_MIN_DTS = {
+    1969, 9, 16, 5, 57, 7, 963145, 224193, 0};
 const npy_datetimestruct _NS_MIN_DTS = {
     1677, 9, 21, 0, 12, 43, 145224, 193000, 0};
+const npy_datetimestruct _US_MIN_DTS = {
+    -290308, 12, 21, 19, 59, 05, 224193, 0, 0};
+const npy_datetimestruct _MS_MIN_DTS = {
+    -292275055, 5, 16, 16, 47, 4, 193000, 0, 0};
+const npy_datetimestruct _S_MIN_DTS = {
+    -292277022657, 1, 27, 8, 29, 53, 0, 0, 0};
+const npy_datetimestruct _M_MIN_DTS = {
+    -17536621475646, 5, 4, 5, 53, 0, 0, 0, 0};
+
+const npy_datetimestruct _AS_MAX_DTS = {
+    1970, 1, 1, 0, 0, 9, 223372, 36854, 775807};
+const npy_datetimestruct _FS_MAX_DTS = {
+    1970, 1, 1, 2, 33, 43, 372036, 854775, 807000};
+const npy_datetimestruct _PS_MAX_DTS = {
+    1970, 4, 17, 18, 2, 52, 36854, 775807, 0};
 const npy_datetimestruct _NS_MAX_DTS = {
     2262, 4, 11, 23, 47, 16, 854775, 807000, 0};
+const npy_datetimestruct _US_MAX_DTS = {
+    294247, 1, 10, 4, 0, 54, 775807, 0, 0};
+const npy_datetimestruct _MS_MAX_DTS = {
+    292278994, 8, 17, 7, 12, 55, 807000, 0, 0};
+const npy_datetimestruct _S_MAX_DTS = {
+    292277026596, 12, 4, 15, 30, 7, 0, 0, 0};
+const npy_datetimestruct _M_MAX_DTS = {
+    17536621479585, 8, 30, 18, 7, 0, 0, 0, 0};
 
 
 const int days_per_month_table[2][12] = {
@@ -305,6 +331,31 @@ int cmp_npy_datetimestruct(const npy_datetimestruct *a,
 
     return 0;
 }
+/*
+* Returns the offset from utc of the timezone as a timedelta.
+* The caller is responsible for ensuring that the tzinfo
+* attribute exists on the datetime object.
+*
+* If the passed object is timezone naive, Py_None is returned.
+* If extraction of the offset fails, NULL is returned.
+*
+* NOTE: This function is not vendored from numpy.
+*/
+PyObject *extract_utc_offset(PyObject *obj) {
+    PyObject *tmp = PyObject_GetAttrString(obj, "tzinfo");
+    if (tmp == NULL) {
+        return NULL;
+    }
+    if (tmp != Py_None) {
+        PyObject *offset = PyObject_CallMethod(tmp, "utcoffset", "O", obj);
+        if (offset == NULL) {
+            Py_DECREF(tmp);
+            return NULL;
+        }
+        return offset;
+    }
+    return tmp;
+}
 
 /*
  *
@@ -330,9 +381,9 @@ int convert_pydatetime_to_datetimestruct(PyObject *dtobj,
     out->month = 1;
     out->day = 1;
 
-    out->year = PyInt_AsLong(PyObject_GetAttrString(obj, "year"));
-    out->month = PyInt_AsLong(PyObject_GetAttrString(obj, "month"));
-    out->day = PyInt_AsLong(PyObject_GetAttrString(obj, "day"));
+    out->year = PyLong_AsLong(PyObject_GetAttrString(obj, "year"));
+    out->month = PyLong_AsLong(PyObject_GetAttrString(obj, "month"));
+    out->day = PyLong_AsLong(PyObject_GetAttrString(obj, "day"));
 
     // TODO(anyone): If we can get PyDateTime_IMPORT to work, we could use
     // PyDateTime_Check here, and less verbose attribute lookups.
@@ -345,44 +396,42 @@ int convert_pydatetime_to_datetimestruct(PyObject *dtobj,
         return 0;
     }
 
-    out->hour = PyInt_AsLong(PyObject_GetAttrString(obj, "hour"));
-    out->min = PyInt_AsLong(PyObject_GetAttrString(obj, "minute"));
-    out->sec = PyInt_AsLong(PyObject_GetAttrString(obj, "second"));
-    out->us = PyInt_AsLong(PyObject_GetAttrString(obj, "microsecond"));
-
-    /* Apply the time zone offset if datetime obj is tz-aware */
-    if (PyObject_HasAttrString((PyObject*)obj, "tzinfo")) {
-        tmp = PyObject_GetAttrString(obj, "tzinfo");
-        if (tmp == NULL) {
-            return -1;
-        }
-        if (tmp == Py_None) {
-            Py_DECREF(tmp);
-        } else {
-            PyObject *offset;
-            int seconds_offset, minutes_offset;
-
-            /* The utcoffset function should return a timedelta */
-            offset = PyObject_CallMethod(tmp, "utcoffset", "O", obj);
-            if (offset == NULL) {
-                Py_DECREF(tmp);
-                return -1;
+    out->hour = PyLong_AsLong(PyObject_GetAttrString(obj, "hour"));
+    out->min = PyLong_AsLong(PyObject_GetAttrString(obj, "minute"));
+    out->sec = PyLong_AsLong(PyObject_GetAttrString(obj, "second"));
+    out->us = PyLong_AsLong(PyObject_GetAttrString(obj, "microsecond"));
+
+    if (PyObject_HasAttrString(obj, "tzinfo")) {
+        PyObject *offset = extract_utc_offset(obj);
+        /* Apply the time zone offset if datetime obj is tz-aware */
+        if (offset != NULL) {
+            if (offset == Py_None) {
+                Py_DECREF(offset);
+                return 0;
             }
-            Py_DECREF(tmp);
-
+            PyObject *tmp_int;
+            int seconds_offset, minutes_offset;
             /*
              * The timedelta should have a function "total_seconds"
              * which contains the value we want.
              */
             tmp = PyObject_CallMethod(offset, "total_seconds", "");
+            Py_DECREF(offset);
             if (tmp == NULL) {
                 return -1;
             }
-            seconds_offset = PyInt_AsLong(tmp);
+            tmp_int = PyNumber_Long(tmp);
+            if (tmp_int == NULL) {
+                Py_DECREF(tmp);
+                return -1;
+            }
+            seconds_offset = PyLong_AsLong(tmp_int);
             if (seconds_offset == -1 && PyErr_Occurred()) {
+                Py_DECREF(tmp_int);
                 Py_DECREF(tmp);
                 return -1;
             }
+            Py_DECREF(tmp_int);
             Py_DECREF(tmp);
 
             /* Convert to a minutes offset and apply it */
@@ -678,7 +727,8 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
     npy_int64 sfrac;
     npy_int64 ifrac;
     int sign;
-    npy_int64 DAY_NS = 86400000000000LL;
+    npy_int64 per_day;
+    npy_int64 per_sec;
 
     /* Initialize the output to all zeros */
     memset(out, 0, sizeof(pandas_timedeltastruct));
@@ -686,11 +736,14 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
     switch (base) {
         case NPY_FR_ns:
 
+        per_day = 86400000000000LL;
+        per_sec = 1000LL * 1000LL * 1000LL;
+
         // put frac in seconds
-        if (td < 0 && td % (1000LL * 1000LL * 1000LL) != 0)
-            frac = td / (1000LL * 1000LL * 1000LL) - 1;
+        if (td < 0 && td % per_sec != 0)
+            frac = td / per_sec - 1;
         else
-            frac = td / (1000LL * 1000LL * 1000LL);
+            frac = td / per_sec;
 
         if (frac < 0) {
             sign = -1;
@@ -734,12 +787,12 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
         }
 
         sfrac = (out->hrs * 3600LL + out->min * 60LL
-                 + out->sec) * (1000LL * 1000LL * 1000LL);
+                 + out->sec) * per_sec;
 
         if (sign < 0)
             out->days = -out->days;
 
-        ifrac = td - (out->days * DAY_NS + sfrac);
+        ifrac = td - (out->days * per_day + sfrac);
 
         if (ifrac != 0) {
             out->ms = ifrac / (1000LL * 1000LL);
@@ -752,10 +805,268 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
             out->us = 0;
             out->ns = 0;
         }
+        break;
+
+        case NPY_FR_us:
+
+        per_day = 86400000000LL;
+        per_sec = 1000LL * 1000LL;
+
+        // put frac in seconds
+        if (td < 0 && td % per_sec != 0)
+            frac = td / per_sec - 1;
+        else
+            frac = td / per_sec;
+
+        if (frac < 0) {
+            sign = -1;
+
+            // even fraction
+            if ((-frac % 86400LL) != 0) {
+              out->days = -frac / 86400LL + 1;
+              frac += 86400LL * out->days;
+            } else {
+              frac = -frac;
+            }
+        } else {
+            sign = 1;
+            out->days = 0;
+        }
+
+        if (frac >= 86400) {
+            out->days += frac / 86400LL;
+            frac -= out->days * 86400LL;
+        }
+
+        if (frac >= 3600) {
+            out->hrs = frac / 3600LL;
+            frac -= out->hrs * 3600LL;
+        } else {
+            out->hrs = 0;
+        }
+
+        if (frac >= 60) {
+            out->min = frac / 60LL;
+            frac -= out->min * 60LL;
+        } else {
+            out->min = 0;
+        }
 
-        out->seconds = out->hrs * 3600 + out->min * 60 + out->sec;
-        out->microseconds = out->ms * 1000 + out->us;
-        out->nanoseconds = out->ns;
+        if (frac >= 0) {
+            out->sec = frac;
+            frac -= out->sec;
+        } else {
+            out->sec = 0;
+        }
+
+        sfrac = (out->hrs * 3600LL + out->min * 60LL
+                 + out->sec) * per_sec;
+
+        if (sign < 0)
+            out->days = -out->days;
+
+        ifrac = td - (out->days * per_day + sfrac);
+
+        if (ifrac != 0) {
+            out->ms = ifrac / 1000LL;
+            ifrac -= out->ms * 1000LL;
+            out->us = ifrac / 1L;
+            ifrac -= out->us * 1L;
+            out->ns = ifrac;
+        } else {
+            out->ms = 0;
+            out->us = 0;
+            out->ns = 0;
+        }
+        break;
+
+        case NPY_FR_ms:
+
+        per_day = 86400000LL;
+        per_sec = 1000LL;
+
+        // put frac in seconds
+        if (td < 0 && td % per_sec != 0)
+            frac = td / per_sec - 1;
+        else
+            frac = td / per_sec;
+
+        if (frac < 0) {
+            sign = -1;
+
+            // even fraction
+            if ((-frac % 86400LL) != 0) {
+              out->days = -frac / 86400LL + 1;
+              frac += 86400LL * out->days;
+            } else {
+              frac = -frac;
+            }
+        } else {
+            sign = 1;
+            out->days = 0;
+        }
+
+        if (frac >= 86400) {
+            out->days += frac / 86400LL;
+            frac -= out->days * 86400LL;
+        }
+
+        if (frac >= 3600) {
+            out->hrs = frac / 3600LL;
+            frac -= out->hrs * 3600LL;
+        } else {
+            out->hrs = 0;
+        }
+
+        if (frac >= 60) {
+            out->min = frac / 60LL;
+            frac -= out->min * 60LL;
+        } else {
+            out->min = 0;
+        }
+
+        if (frac >= 0) {
+            out->sec = frac;
+            frac -= out->sec;
+        } else {
+            out->sec = 0;
+        }
+
+        sfrac = (out->hrs * 3600LL + out->min * 60LL
+                 + out->sec) * per_sec;
+
+        if (sign < 0)
+            out->days = -out->days;
+
+        ifrac = td - (out->days * per_day + sfrac);
+
+        if (ifrac != 0) {
+            out->ms = ifrac;
+            out->us = 0;
+            out->ns = 0;
+        } else {
+            out->ms = 0;
+            out->us = 0;
+            out->ns = 0;
+        }
+        break;
+
+        case NPY_FR_s:
+        // special case where we can simplify many expressions bc per_sec=1
+
+        per_day = 86400LL;
+        per_sec = 1L;
+
+        // put frac in seconds
+        if (td < 0 && td % per_sec != 0)
+            frac = td / per_sec - 1;
+        else
+            frac = td / per_sec;
+
+        if (frac < 0) {
+            sign = -1;
+
+            // even fraction
+            if ((-frac % 86400LL) != 0) {
+              out->days = -frac / 86400LL + 1;
+              frac += 86400LL * out->days;
+            } else {
+              frac = -frac;
+            }
+        } else {
+            sign = 1;
+            out->days = 0;
+        }
+
+        if (frac >= 86400) {
+            out->days += frac / 86400LL;
+            frac -= out->days * 86400LL;
+        }
+
+        if (frac >= 3600) {
+            out->hrs = frac / 3600LL;
+            frac -= out->hrs * 3600LL;
+        } else {
+            out->hrs = 0;
+        }
+
+        if (frac >= 60) {
+            out->min = frac / 60LL;
+            frac -= out->min * 60LL;
+        } else {
+            out->min = 0;
+        }
+
+        if (frac >= 0) {
+            out->sec = frac;
+            frac -= out->sec;
+        } else {
+            out->sec = 0;
+        }
+
+        sfrac = (out->hrs * 3600LL + out->min * 60LL
+                 + out->sec) * per_sec;
+
+        if (sign < 0)
+            out->days = -out->days;
+
+        ifrac = td - (out->days * per_day + sfrac);
+
+        if (ifrac != 0) {
+            out->ms = 0;
+            out->us = 0;
+            out->ns = 0;
+        } else {
+            out->ms = 0;
+            out->us = 0;
+            out->ns = 0;
+        }
+        break;
+
+        case NPY_FR_m:
+
+        out->days = td / 1440LL;
+        td -= out->days * 1440LL;
+        out->hrs = td / 60LL;
+        td -= out->hrs * 60LL;
+        out->min = td;
+
+        out->sec = 0;
+        out->ms = 0;
+        out->us = 0;
+        out->ns = 0;
+        break;
+
+        case NPY_FR_h:
+        out->days = td / 24LL;
+        td -= out->days * 24LL;
+        out->hrs = td;
+
+        out->min = 0;
+        out->sec = 0;
+        out->ms = 0;
+        out->us = 0;
+        out->ns = 0;
+        break;
+
+        case NPY_FR_D:
+        out->days = td;
+        out->hrs = 0;
+        out->min = 0;
+        out->sec = 0;
+        out->ms = 0;
+        out->us = 0;
+        out->ns = 0;
+        break;
+
+        case NPY_FR_W:
+        out->days = 7 * td;
+        out->hrs = 0;
+        out->min = 0;
+        out->sec = 0;
+        out->ms = 0;
+        out->us = 0;
+        out->ns = 0;
         break;
 
         default:
@@ -763,4 +1074,20 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
                             "NumPy timedelta metadata is corrupted with "
                             "invalid base unit");
     }
+
+    out->seconds = out->hrs * 3600 + out->min * 60 + out->sec;
+    out->microseconds = out->ms * 1000 + out->us;
+    out->nanoseconds = out->ns;
+}
+
+
+/*
+ * This function returns a pointer to the DateTimeMetaData
+ * contained within the provided datetime dtype.
+ *
+ * Copied near-verbatim from numpy/core/src/multiarray/datetime.c
+ */
+PyArray_DatetimeMetaData
+get_datetime_metadata_from_dtype(PyArray_Descr *dtype) {
+    return (((PyArray_DatetimeDTypeMetaData *)dtype->c_metadata)->meta);
 }
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.h b/pandas/_libs/tslibs/src/datetime/np_datetime.h
index 0bbc24ed822c5..6ab915e517cfb 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.h
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.h
@@ -28,12 +28,28 @@ typedef struct {
         npy_int32 hrs, min, sec, ms, us, ns, seconds, microseconds, nanoseconds;
 } pandas_timedeltastruct;
 
+extern const npy_datetimestruct _AS_MIN_DTS;
+extern const npy_datetimestruct _AS_MAX_DTS;
+extern const npy_datetimestruct _FS_MIN_DTS;
+extern const npy_datetimestruct _FS_MAX_DTS;
+extern const npy_datetimestruct _PS_MIN_DTS;
+extern const npy_datetimestruct _PS_MAX_DTS;
 extern const npy_datetimestruct _NS_MIN_DTS;
 extern const npy_datetimestruct _NS_MAX_DTS;
+extern const npy_datetimestruct _US_MIN_DTS;
+extern const npy_datetimestruct _US_MAX_DTS;
+extern const npy_datetimestruct _MS_MIN_DTS;
+extern const npy_datetimestruct _MS_MAX_DTS;
+extern const npy_datetimestruct _S_MIN_DTS;
+extern const npy_datetimestruct _S_MAX_DTS;
+extern const npy_datetimestruct _M_MIN_DTS;
+extern const npy_datetimestruct _M_MAX_DTS;
 
 // stuff pandas needs
 // ----------------------------------------------------------------------------
 
+PyObject *extract_utc_offset(PyObject *obj);
+
 int convert_pydatetime_to_datetimestruct(PyObject *dtobj,
                                          npy_datetimestruct *out);
 
@@ -75,5 +91,12 @@ int cmp_npy_datetimestruct(const npy_datetimestruct *a,
 void
 add_minutes_to_datetimestruct(npy_datetimestruct *dts, int minutes);
 
+/*
+ * This function returns the DateTimeMetaData
+ * contained within the provided datetime dtype.
+ */
+PyArray_DatetimeMetaData get_datetime_metadata_from_dtype(
+        PyArray_Descr *dtype);
+
 
 #endif  // PANDAS__LIBS_TSLIBS_SRC_DATETIME_NP_DATETIME_H_
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
index 847e84b21c06c..cfbaed01b57c9 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
@@ -68,11 +68,13 @@ This file implements string parsing and creation for NumPy datetime.
  */
 int parse_iso_8601_datetime(const char *str, int len, int want_exc,
                             npy_datetimestruct *out,
+                            NPY_DATETIMEUNIT *out_bestunit,
                             int *out_local, int *out_tzoffset) {
     int year_leap = 0;
     int i, numdigits;
     const char *substr;
     int sublen;
+    NPY_DATETIMEUNIT bestunit = NPY_FR_GENERIC;
 
     /* If year-month-day are separated by a valid separator,
      * months/days without leading zeroes will be parsed
@@ -137,6 +139,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
         if (out_local != NULL) {
             *out_local = 0;
         }
+        bestunit = NPY_FR_Y;
         goto finish;
     }
 
@@ -182,6 +185,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
 
     /* Next character must be the separator, start of day, or end of string */
     if (sublen == 0) {
+        bestunit = NPY_FR_M;
         /* Forbid YYYYMM. Parsed instead as YYMMDD by someone else. */
         if (!has_ymd_sep) {
             goto parse_error;
@@ -231,6 +235,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
         if (out_local != NULL) {
             *out_local = 0;
         }
+        bestunit = NPY_FR_D;
         goto finish;
     }
 
@@ -269,6 +274,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
         if (!hour_was_2_digits) {
             goto parse_error;
         }
+        bestunit = NPY_FR_h;
         goto finish;
     }
 
@@ -310,6 +316,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
     }
 
     if (sublen == 0) {
+        bestunit = NPY_FR_m;
         goto finish;
     }
 
@@ -354,6 +361,7 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
         ++substr;
         --sublen;
     } else {
+        bestunit = NPY_FR_s;
         goto parse_timezone;
     }
 
@@ -370,6 +378,11 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
     }
 
     if (sublen == 0 || !isdigit(*substr)) {
+        if (numdigits > 3) {
+            bestunit = NPY_FR_us;
+        } else {
+            bestunit = NPY_FR_ms;
+        }
         goto parse_timezone;
     }
 
@@ -386,6 +399,11 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
     }
 
     if (sublen == 0 || !isdigit(*substr)) {
+        if (numdigits > 3) {
+            bestunit = NPY_FR_ps;
+        } else {
+            bestunit = NPY_FR_ns;
+        }
         goto parse_timezone;
     }
 
@@ -401,8 +419,14 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
         }
     }
 
+    if (numdigits > 3) {
+        bestunit = NPY_FR_as;
+    } else {
+        bestunit = NPY_FR_fs;
+    }
+
 parse_timezone:
-    /* trim any whitespace between time/timeezone */
+    /* trim any whitespace between time/timezone */
     while (sublen > 0 && isspace(*substr)) {
         ++substr;
         --sublen;
@@ -521,6 +545,9 @@ int parse_iso_8601_datetime(const char *str, int len, int want_exc,
     }
 
 finish:
+    if (out_bestunit != NULL) {
+        *out_bestunit = bestunit;
+    }
     return 0;
 
 parse_error:
@@ -605,7 +632,7 @@ int get_datetime_iso_8601_strlen(int local, NPY_DATETIMEUNIT base) {
  *  string was too short).
  */
 int make_iso_8601_datetime(npy_datetimestruct *dts, char *outstr, int outlen,
-                           NPY_DATETIMEUNIT base) {
+                           int utc, NPY_DATETIMEUNIT base) {
     char *substr = outstr;
     int sublen = outlen;
     int tmplen;
@@ -884,13 +911,14 @@ int make_iso_8601_datetime(npy_datetimestruct *dts, char *outstr, int outlen,
 
 add_time_zone:
     /* UTC "Zulu" time */
-    if (sublen < 1) {
-        goto string_too_short;
+    if (utc) {
+        if (sublen < 1) {
+            goto string_too_short;
+        }
+        substr[0] = 'Z';
+        substr += 1;
+        sublen -= 1;
     }
-    substr[0] = 'Z';
-    substr += 1;
-    sublen -= 1;
-
     /* Add a NULL terminator, and return */
     if (sublen > 0) {
         substr[0] = '\0';
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
index 200a71ff0c2b7..511d9a401fed2 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
@@ -56,6 +56,7 @@ This file implements string parsing and creation for NumPy datetime.
 int
 parse_iso_8601_datetime(const char *str, int len, int want_exc,
                         npy_datetimestruct *out,
+                        NPY_DATETIMEUNIT *out_bestunit,
                         int *out_local,
                         int *out_tzoffset);
 
@@ -78,7 +79,7 @@ get_datetime_iso_8601_strlen(int local, NPY_DATETIMEUNIT base);
  */
 int
 make_iso_8601_datetime(npy_datetimestruct *dts, char *outstr, int outlen,
-                       NPY_DATETIMEUNIT base);
+                       int utc, NPY_DATETIMEUNIT base);
 
 /*
  * Converts an pandas_timedeltastruct to an ISO 8601 string.
diff --git a/pandas/_libs/tslibs/strptime.pyx b/pandas/_libs/tslibs/strptime.pyx
index d214694fb659d..7aaeefc366fbe 100644
--- a/pandas/_libs/tslibs/strptime.pyx
+++ b/pandas/_libs/tslibs/strptime.pyx
@@ -57,7 +57,7 @@ cdef dict _parse_code_table = {'y': 0,
                                'u': 22}
 
 
-def array_strptime(ndarray[object] values, object fmt, bint exact=True, errors='raise'):
+def array_strptime(ndarray[object] values, str fmt, bint exact=True, errors='raise'):
     """
     Calculates the datetime structs represented by the passed array of strings
 
@@ -72,8 +72,8 @@ def array_strptime(ndarray[object] values, object fmt, bint exact=True, errors='
     cdef:
         Py_ssize_t i, n = len(values)
         npy_datetimestruct dts
-        int64_t[:] iresult
-        object[:] result_timezone
+        int64_t[::1] iresult
+        object[::1] result_timezone
         int year, month, day, minute, hour, second, weekday, julian
         int week_of_year, week_of_year_start, parse_code, ordinal
         int iso_week, iso_year
@@ -349,9 +349,9 @@ def array_strptime(ndarray[object] values, object fmt, bint exact=True, errors='
 
 
 """
-_getlang, LocaleTime, TimeRE, _calc_julian_from_U_or_W are vendored
+TimeRE, _calc_julian_from_U_or_W are vendored
 from the standard library, see
-https://github.com/python/cpython/blob/master/Lib/_strptime.py
+https://github.com/python/cpython/blob/main/Lib/_strptime.py
 The original module-level docstring follows.
 
 Strptime-related classes and functions.
@@ -364,161 +364,14 @@ FUNCTIONS:
     strptime -- Calculates the time struct represented by the passed-in string
 """
 
-
-def _getlang():
-    """Figure out what language is being used for the locale"""
-    return locale.getlocale(locale.LC_TIME)
-
-
-class LocaleTime:
-    """
-    Stores and handles locale-specific information related to time.
-
-    ATTRIBUTES:
-        f_weekday -- full weekday names (7-item list)
-        a_weekday -- abbreviated weekday names (7-item list)
-        f_month -- full month names (13-item list; dummy value in [0], which
-                    is added by code)
-        a_month -- abbreviated month names (13-item list, dummy value in
-                    [0], which is added by code)
-        am_pm -- AM/PM representation (2-item list)
-        LC_date_time -- format string for date/time representation (string)
-        LC_date -- format string for date representation (string)
-        LC_time -- format string for time representation (string)
-        timezone -- daylight- and non-daylight-savings timezone representation
-                    (2-item list of sets)
-        lang -- Language used by instance (2-item tuple)
-    """
-
-    def __init__(self):
-        """
-        Set all attributes.
-
-        Order of methods called matters for dependency reasons.
-
-        The locale language is set at the offset and then checked again before
-        exiting.  This is to make sure that the attributes were not set with a
-        mix of information from more than one locale.  This would most likely
-        happen when using threads where one thread calls a locale-dependent
-        function while another thread changes the locale while the function in
-        the other thread is still running.  Proper coding would call for
-        locks to prevent changing the locale while locale-dependent code is
-        running.  The check here is done in case someone does not think about
-        doing this.
-
-        Only other possible issue is if someone changed the timezone and did
-        not call tz.tzset .  That is an issue for the programmer, though,
-        since changing the timezone is worthless without that call.
-        """
-        self.lang = _getlang()
-        self.__calc_weekday()
-        self.__calc_month()
-        self.__calc_am_pm()
-        self.__calc_timezone()
-        self.__calc_date_time()
-        if _getlang() != self.lang:
-            raise ValueError("locale changed during initialization")
-
-    def __pad(self, seq, front):
-        # Add '' to seq to either the front (is True), else the back.
-        seq = list(seq)
-        if front:
-            seq.insert(0, '')
-        else:
-            seq.append('')
-        return seq
-
-    def __calc_weekday(self):
-        # Set self.a_weekday and self.f_weekday using the calendar
-        # module.
-        a_weekday = [calendar.day_abbr[i].lower() for i in range(7)]
-        f_weekday = [calendar.day_name[i].lower() for i in range(7)]
-        self.a_weekday = a_weekday
-        self.f_weekday = f_weekday
-
-    def __calc_month(self):
-        # Set self.f_month and self.a_month using the calendar module.
-        a_month = [calendar.month_abbr[i].lower() for i in range(13)]
-        f_month = [calendar.month_name[i].lower() for i in range(13)]
-        self.a_month = a_month
-        self.f_month = f_month
-
-    def __calc_am_pm(self):
-        # Set self.am_pm by using time.strftime().
-
-        # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that
-        # magical; just happened to have used it everywhere else where a
-        # static date was needed.
-        am_pm = []
-        for hour in (01, 22):
-            time_tuple = time.struct_time(
-                (1999, 3, 17, hour, 44, 55, 2, 76, 0))
-            am_pm.append(time.strftime("%p", time_tuple).lower())
-        self.am_pm = am_pm
-
-    def __calc_date_time(self):
-        # Set self.date_time, self.date, & self.time by using
-        # time.strftime().
-
-        # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of
-        # overloaded numbers is minimized.  The order in which searches for
-        # values within the format string is very important; it eliminates
-        # possible ambiguity for what something represents.
-        time_tuple = time.struct_time((1999, 3, 17, 22, 44, 55, 2, 76, 0))
-        date_time = [None, None, None]
-        date_time[0] = time.strftime("%c", time_tuple).lower()
-        date_time[1] = time.strftime("%x", time_tuple).lower()
-        date_time[2] = time.strftime("%X", time_tuple).lower()
-        replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'),
-                             (self.f_month[3], '%B'),
-                             (self.a_weekday[2], '%a'),
-                             (self.a_month[3], '%b'), (self.am_pm[1], '%p'),
-                             ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
-                             ('44', '%M'), ('55', '%S'), ('76', '%j'),
-                             ('17', '%d'), ('03', '%m'), ('3', '%m'),
-                             # '3' needed for when no leading zero.
-                             ('2', '%w'), ('10', '%I')]
-        replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone
-                                  for tz in tz_values])
-        for offset, directive in ((0, '%c'), (1, '%x'), (2, '%X')):
-            current_format = date_time[offset]
-            for old, new in replacement_pairs:
-                # Must deal with possible lack of locale info
-                # manifesting itself as the empty string (e.g., Swedish's
-                # lack of AM/PM info) or a platform returning a tuple of empty
-                # strings (e.g., MacOS 9 having timezone as ('','')).
-                if old:
-                    current_format = current_format.replace(old, new)
-            # If %W is used, then Sunday, 2005-01-03 will fall on week 0 since
-            # 2005-01-03 occurs before the first Monday of the year.  Otherwise
-            # %U is used.
-            time_tuple = time.struct_time((1999, 1, 3, 1, 1, 1, 6, 3, 0))
-            if '00' in time.strftime(directive, time_tuple):
-                U_W = '%W'
-            else:
-                U_W = '%U'
-            date_time[offset] = current_format.replace('11', U_W)
-        self.LC_date_time = date_time[0]
-        self.LC_date = date_time[1]
-        self.LC_time = date_time[2]
-
-    def __calc_timezone(self):
-        # Set self.timezone by using time.tzname.
-        # Do not worry about possibility of time.tzname[0] == timetzname[1]
-        # and time.daylight; handle that in strptime .
-        try:
-            time.tzset()
-        except AttributeError:
-            pass
-        no_saving = frozenset(["utc", "gmt", time.tzname[0].lower()])
-        if time.daylight:
-            has_saving = frozenset([time.tzname[1].lower()])
-        else:
-            has_saving = frozenset()
-        self.timezone = (no_saving, has_saving)
+from _strptime import (
+    LocaleTime,
+    TimeRE as _TimeRE,
+    _getlang,
+)
 
 
-class TimeRE(dict):
+class TimeRE(_TimeRE):
     """
     Handle conversion from format directives to regexes.
 
@@ -532,100 +385,23 @@ class TimeRE(dict):
 
         Order of execution is important for dependency reasons.
         """
-        if locale_time:
-            self.locale_time = locale_time
-        else:
-            self.locale_time = LocaleTime()
         self._Z = None
-        base = super()
-        base.__init__({
-            # The " \d" part of the regex is to make %c from ANSI C work
-            'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
-            'f': r"(?P<f>[0-9]{1,9})",
-            'G': r"(?P<G>\d\d\d\d)",
-            'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
-            'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])",
-            'j': (r"(?P<j>36[0-6]|3[0-5]\d|[1-2]\d\d|0[1-9]\d|00[1-9]|"
-                  r"[1-9]\d|0[1-9]|[1-9])"),
-            'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])",
-            'M': r"(?P<M>[0-5]\d|\d)",
-            'S': r"(?P<S>6[0-1]|[0-5]\d|\d)",
-            'u': r"(?P<u>[1-7])",
-            'U': r"(?P<U>5[0-3]|[0-4]\d|\d)",
-            'V': r"(?P<V>5[0-3]|0[1-9]|[1-4]\d|\d)",
-            'w': r"(?P<w>[0-6])",
-            # W is set below by using 'U'
-            'y': r"(?P<y>\d\d)",
-            # TODO: Does 'Y' need to worry about having less or more than
-            #     4 digits?
-            'Y': r"(?P<Y>\d\d\d\d)",
-            'z': r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|Z)",
-            'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
-            'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
-            'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'),
-            'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'),
-            'p': self.__seqToRE(self.locale_time.am_pm, 'p'),
-            # 'Z' key is generated lazily via __getitem__
-            '%': '%'})
-        base.__setitem__('W', base.__getitem__('U').replace('U', 'W'))
-        base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
-        base.__setitem__('x', self.pattern(self.locale_time.LC_date))
-        base.__setitem__('X', self.pattern(self.locale_time.LC_time))
+        super().__init__(locale_time=locale_time)
+        # GH 48767: Overrides for cpython's TimeRE
+        #  1) Parse up to nanos instead of micros
+        self.update({"f": r"(?P<f>[0-9]{1,9})"}),
 
     def __getitem__(self, key):
         if key == "Z":
             # lazy computation
             if self._Z is None:
                 self._Z = self.__seqToRE(pytz.all_timezones, 'Z')
+            # Note: handling Z is the key difference vs using the stdlib
+            # _strptime.TimeRE. test_to_datetime_parse_tzname_or_tzoffset with
+            # fmt='%Y-%m-%d %H:%M:%S %Z' fails with the stdlib version.
             return self._Z
         return super().__getitem__(key)
 
-    def __seqToRE(self, to_convert, directive):
-        """
-        Convert a list to a regex string for matching a directive.
-
-        Want possible matching values to be from longest to shortest.  This
-        prevents the possibility of a match occurring for a value that also
-        a substring of a larger value that should have matched (e.g., 'abc'
-        matching when 'abcdef' should have been the match).
-        """
-        to_convert = sorted(to_convert, key=len, reverse=True)
-        for value in to_convert:
-            if value != '':
-                break
-        else:
-            return ''
-        regex = '|'.join(re.escape(stuff) for stuff in to_convert)
-        regex = f"(?P<{directive}>{regex})"
-        return regex
-
-    def pattern(self, format):
-        """
-        Return regex pattern for the format string.
-
-        Need to make sure that any characters that might be interpreted as
-        regex syntax are escaped.
-        """
-        processed_format = ''
-        # The sub() call escapes all characters that might be misconstrued
-        # as regex syntax.  Cannot use re.escape since we have to deal with
-        # format directives (%m, etc.).
-        regex_chars = re.compile(r"([\\.^$*+?\(\){}\[\]|])")
-        format = regex_chars.sub(r"\\\1", format)
-        whitespace_replacement = re.compile(r'\s+')
-        format = whitespace_replacement.sub(r'\\s+', format)
-        while '%' in format:
-            directive_index = format.index('%') +1
-            processed_format = (f"{processed_format}"
-                                f"{format[:directive_index -1]}"
-                                f"{self[format[directive_index]]}")
-            format = format[directive_index +1:]
-        return f"{processed_format}{format}"
-
-    def compile(self, format):
-        """Return a compiled re object for the format string."""
-        return re.compile(self.pattern(format), re.IGNORECASE)
-
 
 _cache_lock = _thread_allocate_lock()
 # DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock
diff --git a/pandas/_libs/tslibs/timedeltas.pxd b/pandas/_libs/tslibs/timedeltas.pxd
index fed1f2d326819..3251e10a88b73 100644
--- a/pandas/_libs/tslibs/timedeltas.pxd
+++ b/pandas/_libs/tslibs/timedeltas.pxd
@@ -1,19 +1,27 @@
 from cpython.datetime cimport timedelta
 from numpy cimport int64_t
 
+from .np_datetime cimport NPY_DATETIMEUNIT
+
 
 # Exposed for tslib, not intended for outside use.
-cpdef int64_t delta_to_nanoseconds(delta) except? -1
+cpdef int64_t delta_to_nanoseconds(
+    delta, NPY_DATETIMEUNIT reso=*, bint round_ok=*
+) except? -1
 cdef convert_to_timedelta64(object ts, str unit)
 cdef bint is_any_td_scalar(object obj)
+cdef object ensure_td64ns(object ts)
 
 
 cdef class _Timedelta(timedelta):
     cdef readonly:
         int64_t value      # nanoseconds
-        object freq        # frequency reference
-        bint is_populated  # are my components populated
+        bint _is_populated  # are my components populated
         int64_t _d, _h, _m, _s, _ms, _us, _ns
+        NPY_DATETIMEUNIT _reso
 
     cpdef timedelta to_pytimedelta(_Timedelta self)
-    cpdef bint _has_ns(self)
+    cdef bint _has_ns(self)
+    cdef _ensure_components(_Timedelta self)
+    cdef inline bint _compare_mismatched_resos(self, _Timedelta other, op)
+    cdef _Timedelta _as_reso(self, NPY_DATETIMEUNIT reso, bint round_ok=*)
diff --git a/pandas/_libs/tslibs/timedeltas.pyi b/pandas/_libs/tslibs/timedeltas.pyi
index d8369f0cc90f9..1fb2bf1b45888 100644
--- a/pandas/_libs/tslibs/timedeltas.pyi
+++ b/pandas/_libs/tslibs/timedeltas.pyi
@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import (
     ClassVar,
-    Type,
+    Literal,
     TypeVar,
     overload,
 )
@@ -14,10 +14,55 @@ from pandas._libs.tslibs import (
 )
 from pandas._typing import npt
 
+# This should be kept consistent with the keys in the dict timedelta_abbrevs
+# in pandas/_libs/tslibs/timedeltas.pyx
+UnitChoices = Literal[
+    "Y",
+    "y",
+    "M",
+    "W",
+    "w",
+    "D",
+    "d",
+    "days",
+    "day",
+    "hours",
+    "hour",
+    "hr",
+    "h",
+    "m",
+    "minute",
+    "min",
+    "minutes",
+    "t",
+    "s",
+    "seconds",
+    "sec",
+    "second",
+    "ms",
+    "milliseconds",
+    "millisecond",
+    "milli",
+    "millis",
+    "l",
+    "us",
+    "microseconds",
+    "microsecond",
+    "µs",
+    "micro",
+    "micros",
+    "u",
+    "ns",
+    "nanoseconds",
+    "nano",
+    "nanos",
+    "nanosecond",
+    "n",
+]
 _S = TypeVar("_S", bound=timedelta)
 
 def ints_to_pytimedelta(
-    arr: npt.NDArray[np.int64],  # const int64_t[:]
+    arr: npt.NDArray[np.timedelta64],
     box: bool = ...,
 ) -> npt.NDArray[np.object_]: ...
 def array_to_timedelta64(
@@ -25,22 +70,27 @@ def array_to_timedelta64(
     unit: str | None = ...,
     errors: str = ...,
 ) -> np.ndarray: ...  # np.ndarray[m8ns]
-def parse_timedelta_unit(unit: str | None) -> str: ...
-def delta_to_nanoseconds(delta: Tick | np.timedelta64 | timedelta | int) -> int: ...
+def parse_timedelta_unit(unit: str | None) -> UnitChoices: ...
+def delta_to_nanoseconds(
+    delta: np.timedelta64 | timedelta | Tick,
+    reso: int = ...,  # NPY_DATETIMEUNIT
+    round_ok: bool = ...,
+) -> int: ...
 
 class Timedelta(timedelta):
     min: ClassVar[Timedelta]
     max: ClassVar[Timedelta]
     resolution: ClassVar[Timedelta]
     value: int  # np.int64
-
-    # error: "__new__" must return a class instance (got "Union[Timedelta, NaTType]")
+    # error: "__new__" must return a class instance (got "Union[Timestamp, NaTType]")
     def __new__(  # type: ignore[misc]
-        cls: Type[_S],
+        cls: type[_S],
         value=...,
-        unit: str = ...,
-        **kwargs: int | float | np.integer | np.floating,
+        unit: str | None = ...,
+        **kwargs: float | np.integer | np.floating,
     ) -> _S | NaTType: ...
+    @classmethod
+    def _from_value_and_reso(cls, value: np.int64, reso: int) -> Timedelta: ...
     @property
     def days(self) -> int: ...
     @property
@@ -58,27 +108,49 @@ class Timedelta(timedelta):
     def ceil(self: _S, freq: str) -> _S: ...
     @property
     def resolution_string(self) -> str: ...
-    def __add__(self, other: timedelta) -> timedelta: ...
-    def __radd__(self, other: timedelta) -> timedelta: ...
-    def __sub__(self, other: timedelta) -> timedelta: ...
-    def __rsub__(self, other: timedelta) -> timedelta: ...
-    def __neg__(self) -> timedelta: ...
-    def __pos__(self) -> timedelta: ...
-    def __abs__(self) -> timedelta: ...
-    def __mul__(self, other: float) -> timedelta: ...
-    def __rmul__(self, other: float) -> timedelta: ...
-    @overload
+    def __add__(self, other: timedelta) -> Timedelta: ...
+    def __radd__(self, other: timedelta) -> Timedelta: ...
+    def __sub__(self, other: timedelta) -> Timedelta: ...
+    def __rsub__(self, other: timedelta) -> Timedelta: ...
+    def __neg__(self) -> Timedelta: ...
+    def __pos__(self) -> Timedelta: ...
+    def __abs__(self) -> Timedelta: ...
+    def __mul__(self, other: float) -> Timedelta: ...
+    def __rmul__(self, other: float) -> Timedelta: ...
+    # error: Signature of "__floordiv__" incompatible with supertype "timedelta"
+    @overload  # type: ignore[override]
     def __floordiv__(self, other: timedelta) -> int: ...
     @overload
-    def __floordiv__(self, other: int) -> timedelta: ...
+    def __floordiv__(self, other: float) -> Timedelta: ...
+    @overload
+    def __floordiv__(
+        self, other: npt.NDArray[np.timedelta64]
+    ) -> npt.NDArray[np.intp]: ...
+    @overload
+    def __floordiv__(
+        self, other: npt.NDArray[np.number]
+    ) -> npt.NDArray[np.timedelta64] | Timedelta: ...
+    @overload
+    def __rfloordiv__(self, other: timedelta | str) -> int: ...
+    @overload
+    def __rfloordiv__(self, other: None | NaTType) -> NaTType: ...
+    @overload
+    def __rfloordiv__(self, other: np.ndarray) -> npt.NDArray[np.timedelta64]: ...
     @overload
     def __truediv__(self, other: timedelta) -> float: ...
     @overload
-    def __truediv__(self, other: float) -> timedelta: ...
-    def __mod__(self, other: timedelta) -> timedelta: ...
-    def __divmod__(self, other: timedelta) -> tuple[int, timedelta]: ...
+    def __truediv__(self, other: float) -> Timedelta: ...
+    def __mod__(self, other: timedelta) -> Timedelta: ...
+    def __divmod__(self, other: timedelta) -> tuple[int, Timedelta]: ...
     def __le__(self, other: timedelta) -> bool: ...
     def __lt__(self, other: timedelta) -> bool: ...
     def __ge__(self, other: timedelta) -> bool: ...
     def __gt__(self, other: timedelta) -> bool: ...
     def __hash__(self) -> int: ...
+    def isoformat(self) -> str: ...
+    def to_numpy(self) -> np.timedelta64: ...
+    @property
+    def freq(self) -> None: ...
+    @property
+    def is_populated(self) -> bool: ...
+    def _as_unit(self, unit: str, round_ok: bool = ...) -> Timedelta: ...
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 02017c5900ca0..0b33af1159fe5 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1,11 +1,13 @@
 import collections
 import warnings
 
-import cython
+from pandas.util._exceptions import find_stack_level
 
+cimport cython
 from cpython.object cimport (
     Py_EQ,
     Py_NE,
+    PyObject,
     PyObject_RichCompare,
 )
 
@@ -21,12 +23,12 @@ cnp.import_array()
 
 from cpython.datetime cimport (
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     PyDelta_Check,
+    import_datetime,
     timedelta,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
 
 cimport pandas._libs.tslibs.util as util
@@ -35,6 +37,7 @@ from pandas._libs.tslibs.conversion cimport (
     cast_from_unit,
     precision_from_unit,
 )
+from pandas._libs.tslibs.dtypes cimport npy_unit_to_abbrev
 from pandas._libs.tslibs.nattype cimport (
     NPY_NAT,
     c_NaT as NaT,
@@ -43,12 +46,25 @@ from pandas._libs.tslibs.nattype cimport (
 )
 from pandas._libs.tslibs.np_datetime cimport (
     NPY_DATETIMEUNIT,
+    NPY_FR_ns,
+    cmp_dtstructs,
     cmp_scalar,
+    convert_reso,
+    get_conversion_factor,
     get_datetime64_unit,
     get_timedelta64_value,
+    get_unit_from_dtype,
+    npy_datetimestruct,
+    pandas_datetime_to_datetimestruct,
+    pandas_timedelta_to_timedeltastruct,
     pandas_timedeltastruct,
-    td64_to_tdstruct,
 )
+
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+)
+
 from pandas._libs.tslibs.offsets cimport is_tick_object
 from pandas._libs.tslibs.util cimport (
     is_array,
@@ -80,6 +96,7 @@ Components = collections.namedtuple(
     ],
 )
 
+# This should be kept consistent with UnitChoices in pandas/_libs/tslibs/timedeltas.pyi
 cdef dict timedelta_abbrevs = {
     "Y": "Y",
     "y": "Y",
@@ -132,14 +149,14 @@ _no_input = object()
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def ints_to_pytimedelta(const int64_t[:] arr, box=False):
+def ints_to_pytimedelta(ndarray m8values, box=False):
     """
     convert an i8 repr to an ndarray of timedelta or Timedelta (if box ==
     True)
 
     Parameters
     ----------
-    arr : ndarray[int64_t]
+    arr : ndarray[timedelta64]
     box : bool, default False
 
     Returns
@@ -148,73 +165,117 @@ def ints_to_pytimedelta(const int64_t[:] arr, box=False):
         array of Timedelta or timedeltas objects
     """
     cdef:
-        Py_ssize_t i, n = len(arr)
+        NPY_DATETIMEUNIT reso = get_unit_from_dtype(m8values.dtype)
+        Py_ssize_t i, n = m8values.size
         int64_t value
-        object[:] result = np.empty(n, dtype=object)
+        object res_val
+
+        # Note that `result` (and thus `result_flat`) is C-order and
+        #  `it` iterates C-order as well, so the iteration matches
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        ndarray result = cnp.PyArray_EMPTY(m8values.ndim, m8values.shape, cnp.NPY_OBJECT, 0)
+        object[::1] res_flat = result.ravel()     # should NOT be a copy
+
+        ndarray arr = m8values.view("i8")
+        cnp.flatiter it = cnp.PyArray_IterNew(arr)
 
     for i in range(n):
+        # Analogous to: value = arr[i]
+        value = (<int64_t*>cnp.PyArray_ITER_DATA(it))[0]
 
-        value = arr[i]
         if value == NPY_NAT:
-            result[i] = <object>NaT
+            res_val = <object>NaT
         else:
             if box:
-                result[i] = Timedelta(value)
+                res_val = _timedelta_from_value_and_reso(Timedelta, value, reso=reso)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_ns:
+                res_val = timedelta(microseconds=int(value) / 1000)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_us:
+                res_val = timedelta(microseconds=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_ms:
+                res_val = timedelta(milliseconds=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_s:
+                res_val = timedelta(seconds=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_m:
+                res_val = timedelta(minutes=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_h:
+                res_val = timedelta(hours=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_D:
+                res_val = timedelta(days=value)
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_W:
+                res_val = timedelta(weeks=value)
             else:
-                result[i] = timedelta(microseconds=int(value) / 1000)
+                # Month, Year, NPY_FR_GENERIC, pico, femto, atto
+                raise NotImplementedError(reso)
 
-    return result.base  # .base to access underlying np.ndarray
+        # Note: we can index result directly instead of using PyArray_MultiIter_DATA
+        #  like we do for the other functions because result is known C-contiguous
+        #  and is the first argument to PyArray_MultiIterNew2.  The usual pattern
+        #  does not seem to work with object dtype.
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        res_flat[i] = res_val
+
+        cnp.PyArray_ITER_NEXT(it)
+
+    return result
 
 
 # ----------------------------------------------------------------------
 
-cpdef int64_t delta_to_nanoseconds(delta) except? -1:
+
+cpdef int64_t delta_to_nanoseconds(
+    delta,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+    bint round_ok=True,
+) except? -1:
+    # Note: this will raise on timedelta64 with Y or M unit
+
+    cdef:
+        NPY_DATETIMEUNIT in_reso
+        int64_t n
+
     if is_tick_object(delta):
-        return delta.nanos
-    if isinstance(delta, _Timedelta):
-        delta = delta.value
-    if is_timedelta64_object(delta):
-        return get_timedelta64_value(ensure_td64ns(delta))
-    if is_integer_object(delta):
-        return delta
-    if PyDelta_Check(delta):
+        n = delta.n
+        in_reso = delta._reso
+
+    elif isinstance(delta, _Timedelta):
+        n = delta.value
+        in_reso = delta._reso
+
+    elif is_timedelta64_object(delta):
+        in_reso = get_datetime64_unit(delta)
+        if in_reso == NPY_DATETIMEUNIT.NPY_FR_Y or in_reso == NPY_DATETIMEUNIT.NPY_FR_M:
+            raise ValueError(
+                "delta_to_nanoseconds does not support Y or M units, "
+                "as their duration in nanoseconds is ambiguous."
+            )
+        n = get_timedelta64_value(delta)
+
+    elif PyDelta_Check(delta):
+        in_reso = NPY_DATETIMEUNIT.NPY_FR_us
         try:
-            return (
+            n = (
                 delta.days * 24 * 3600 * 1_000_000
                 + delta.seconds * 1_000_000
                 + delta.microseconds
-            ) * 1000
+                )
         except OverflowError as err:
-            from pandas._libs.tslibs.conversion import OutOfBoundsTimedelta
             raise OutOfBoundsTimedelta(*err.args) from err
 
-    raise TypeError(type(delta))
-
-
-cdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit):
-    if unit == NPY_DATETIMEUNIT.NPY_FR_ns or unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
-        # generic -> default to nanoseconds
-        return "ns"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_us:
-        return "us"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_ms:
-        return "ms"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_s:
-        return "s"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_m:
-        return "m"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_h:
-        return "h"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_D:
-        return "D"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_W:
-        return "W"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_M:
-        return "M"
-    elif unit == NPY_DATETIMEUNIT.NPY_FR_Y:
-        return "Y"
     else:
-        raise NotImplementedError(unit)
+        raise TypeError(type(delta))
+
+    try:
+        return convert_reso(n, in_reso, reso, round_ok=round_ok)
+    except (OutOfBoundsDatetime, OverflowError) as err:
+        # Catch OutOfBoundsDatetime bc convert_reso can call check_dts_bounds
+        #  for Y/M-resolution cases
+        unit_str = npy_unit_to_abbrev(reso)
+        raise OutOfBoundsTimedelta(
+            f"Cannot cast {str(delta)} to unit={unit_str} without overflow."
+        ) from err
 
 
 @cython.overflowcheck(True)
@@ -249,7 +310,6 @@ cdef object ensure_td64ns(object ts):
             # NB: cython#1381 this cannot be *=
             td64_value = td64_value * mult
         except OverflowError as err:
-            from pandas._libs.tslibs.conversion import OutOfBoundsTimedelta
             raise OutOfBoundsTimedelta(ts) from err
 
         return np.timedelta64(td64_value, "ns")
@@ -271,10 +331,14 @@ cdef convert_to_timedelta64(object ts, str unit):
 
     Return an ns based int64
     """
+    # Caller is responsible for checking unit not in ["Y", "y", "M"]
+
     if checknull_with_nat(ts):
         return np.timedelta64(NPY_NAT, "ns")
     elif isinstance(ts, _Timedelta):
         # already in the proper format
+        if ts._reso != NPY_FR_ns:
+            raise NotImplementedError
         ts = np.timedelta64(ts.value, "ns")
     elif is_timedelta64_object(ts):
         ts = ensure_td64ns(ts)
@@ -282,17 +346,9 @@ cdef convert_to_timedelta64(object ts, str unit):
         if ts == NPY_NAT:
             return np.timedelta64(NPY_NAT, "ns")
         else:
-            if unit in ["Y", "M", "W"]:
-                ts = np.timedelta64(ts, unit)
-            else:
-                ts = cast_from_unit(ts, unit)
-                ts = np.timedelta64(ts, "ns")
+            ts = _maybe_cast_from_unit(ts, unit)
     elif is_float_object(ts):
-        if unit in ["Y", "M", "W"]:
-            ts = np.timedelta64(int(ts), unit)
-        else:
-            ts = cast_from_unit(ts, unit)
-            ts = np.timedelta64(ts, "ns")
+        ts = _maybe_cast_from_unit(ts, unit)
     elif isinstance(ts, str):
         if (len(ts) > 0 and ts[0] == "P") or (len(ts) > 1 and ts[:2] == "-P"):
             ts = parse_iso_format_string(ts)
@@ -309,11 +365,26 @@ cdef convert_to_timedelta64(object ts, str unit):
     return ts.astype("timedelta64[ns]")
 
 
+cdef _maybe_cast_from_unit(ts, str unit):
+    # caller is responsible for checking
+    #  assert unit not in ["Y", "y", "M"]
+    try:
+        ts = cast_from_unit(ts, unit)
+    except OverflowError as err:
+        raise OutOfBoundsTimedelta(
+            f"Cannot cast {ts} from {unit} to 'ns' without overflow."
+        ) from err
+
+    ts = np.timedelta64(ts, "ns")
+    return ts
+
+
 @cython.boundscheck(False)
 @cython.wraparound(False)
 def array_to_timedelta64(
-    ndarray[object] values, str unit=None, str errors="raise"
+    ndarray values, str unit=None, str errors="raise"
 ) -> ndarray:
+    # values is object-dtype, may be 2D
     """
     Convert an ndarray to an array of timedeltas. If errors == 'coerce',
     coerce non-convertible objects to NaT. Otherwise, raise.
@@ -322,52 +393,93 @@ def array_to_timedelta64(
     -------
     np.ndarray[timedelta64ns]
     """
+    # Caller is responsible for checking
+    assert unit not in ["Y", "y", "M"]
 
     cdef:
-        Py_ssize_t i, n
-        int64_t[:] iresult
+        Py_ssize_t i, n = values.size
+        ndarray result = np.empty((<object>values).shape, dtype="m8[ns]")
+        object item
+        int64_t ival
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(result, values)
+        cnp.flatiter it
+
+    if values.descr.type_num != cnp.NPY_OBJECT:
+        # raise here otherwise we segfault below
+        raise TypeError("array_to_timedelta64 'values' must have object dtype")
 
     if errors not in {'ignore', 'raise', 'coerce'}:
         raise ValueError("errors must be one of {'ignore', 'raise', or 'coerce'}")
 
-    n = values.shape[0]
-    result = np.empty(n, dtype='m8[ns]')
-    iresult = result.view('i8')
-
-    if unit is not None:
+    if unit is not None and errors != "coerce":
+        it = cnp.PyArray_IterNew(values)
         for i in range(n):
-            if isinstance(values[i], str) and errors != "coerce":
+            # Analogous to: item = values[i]
+            item = cnp.PyArray_GETITEM(values, cnp.PyArray_ITER_DATA(it))
+            if isinstance(item, str):
                 raise ValueError(
                     "unit must not be specified if the input contains a str"
                 )
+            cnp.PyArray_ITER_NEXT(it)
 
     # Usually, we have all strings. If so, we hit the fast path.
     # If this path fails, we try conversion a different way, and
     # this is where all of the error handling will take place.
     try:
         for i in range(n):
-            if values[i] is NaT:
-                # we allow this check in the fast-path because NaT is a C-object
-                #  so this is an inexpensive check
-                iresult[i] = NPY_NAT
-            else:
-                result[i] = parse_timedelta_string(values[i])
+            # Analogous to: item = values[i]
+            item = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+            ival = _item_to_timedelta64_fastpath(item)
+
+            # Analogous to: iresult[i] = ival
+            (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ival
+
+            cnp.PyArray_MultiIter_NEXT(mi)
+
     except (TypeError, ValueError):
+        cnp.PyArray_MultiIter_RESET(mi)
+
         parsed_unit = parse_timedelta_unit(unit or 'ns')
         for i in range(n):
-            try:
-                result[i] = convert_to_timedelta64(values[i], parsed_unit)
-            except ValueError as err:
-                if errors == 'coerce':
-                    result[i] = NPY_NAT
-                elif "unit abbreviation w/o a number" in str(err):
-                    # re-raise with more pertinent message
-                    msg = f"Could not convert '{values[i]}' to NumPy timedelta"
-                    raise ValueError(msg) from err
-                else:
-                    raise
+            item = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+            ival = _item_to_timedelta64(item, parsed_unit, errors)
+
+            (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ival
+
+            cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
+
+
+cdef inline int64_t _item_to_timedelta64_fastpath(object item) except? -1:
+    """
+    See array_to_timedelta64.
+    """
+    if item is NaT:
+        # we allow this check in the fast-path because NaT is a C-object
+        #  so this is an inexpensive check
+        return NPY_NAT
+    else:
+        return parse_timedelta_string(item)
+
 
-    return iresult.base  # .base to access underlying np.ndarray
+cdef inline int64_t _item_to_timedelta64(object item, str parsed_unit, str errors) except? -1:
+    """
+    See array_to_timedelta64.
+    """
+    try:
+        return get_timedelta64_value(convert_to_timedelta64(item, parsed_unit))
+    except ValueError as err:
+        if errors == "coerce":
+            return NPY_NAT
+        elif "unit abbreviation w/o a number" in str(err):
+            # re-raise with more pertinent message
+            msg = f"Could not convert '{item}' to NumPy timedelta"
+            raise ValueError(msg) from err
+        else:
+            raise
 
 
 cdef inline int64_t parse_timedelta_string(str ts) except? -1:
@@ -565,24 +677,20 @@ cdef inline timedelta_from_spec(object number, object frac, object unit):
     cdef:
         str n
 
-    try:
-        unit = ''.join(unit)
-
-        if unit in ["M", "Y", "y"]:
-            warnings.warn(
-                "Units 'M', 'Y' and 'y' do not represent unambiguous "
-                "timedelta values and will be removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-
-        if unit == 'M':
-            # To parse ISO 8601 string, 'M' should be treated as minute,
-            # not month
-            unit = 'm'
-        unit = parse_timedelta_unit(unit)
-    except KeyError:
-        raise ValueError(f"invalid abbreviation: {unit}")
+    unit = ''.join(unit)
+    if unit in ["M", "Y", "y"]:
+        warnings.warn(
+            "Units 'M', 'Y' and 'y' do not represent unambiguous "
+            "timedelta values and will be removed in a future version.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    if unit == 'M':
+        # To parse ISO 8601 string, 'M' should be treated as minute,
+        # not month
+        unit = 'm'
+    unit = parse_timedelta_unit(unit)
 
     n = ''.join(number) + '.' + ''.join(frac)
     return cast_from_unit(float(n), unit)
@@ -609,7 +717,7 @@ cpdef inline str parse_timedelta_unit(str unit):
         return unit
     try:
         return timedelta_abbrevs[unit.lower()]
-    except (KeyError, AttributeError):
+    except KeyError:
         raise ValueError(f"invalid unit abbreviation: {unit}")
 
 # ----------------------------------------------------------------------
@@ -628,7 +736,8 @@ cdef bint _validate_ops_compat(other):
 
 def _op_unary_method(func, name):
     def f(self):
-        return Timedelta(func(self.value), unit='ns')
+        new_value = func(self.value)
+        return _timedelta_from_value_and_reso(Timedelta, new_value, self._reso)
     f.__name__ = name
     return f
 
@@ -652,8 +761,12 @@ def _binary_op_method_timedeltalike(op, name):
             # defined by Timestamp methods.
 
         elif is_array(other):
-            # nd-array like
-            if other.dtype.kind in ['m', 'M']:
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return f(self, item)
+
+            elif other.dtype.kind in ['m', 'M']:
                 return op(self.to_timedelta64(), other)
             elif other.dtype.kind == 'O':
                 return np.array([op(self, x) for x in other])
@@ -673,7 +786,28 @@ def _binary_op_method_timedeltalike(op, name):
         if other is NaT:
             # e.g. if original other was timedelta64('NaT')
             return NaT
-        return Timedelta(op(self.value, other.value), unit='ns')
+
+        # We allow silent casting to the lower resolution if and only
+        #  if it is lossless.
+        try:
+            if self._reso < other._reso:
+                other = (<_Timedelta>other)._as_reso(self._reso, round_ok=False)
+            elif self._reso > other._reso:
+                self = (<_Timedelta>self)._as_reso(other._reso, round_ok=False)
+        except ValueError as err:
+            raise ValueError(
+                "Timedelta addition/subtraction with mismatched resolutions is not "
+                "allowed when casting to the lower resolution would require "
+                "lossy rounding."
+            ) from err
+
+        res = op(self.value, other.value)
+        if res == NPY_NAT:
+            # e.g. test_implementation_limits
+            # TODO: more generally could do an overflowcheck in op?
+            return NaT
+
+        return _timedelta_from_value_and_reso(Timedelta, res, reso=self._reso)
 
     f.__name__ = name
     return f
@@ -803,6 +937,74 @@ cdef _to_py_int_float(v):
     raise TypeError(f"Invalid type {type(v)}. Must be int or float.")
 
 
+def _timedelta_unpickle(value, reso):
+    return _timedelta_from_value_and_reso(Timedelta, value, reso)
+
+
+cdef _timedelta_from_value_and_reso(cls, int64_t value, NPY_DATETIMEUNIT reso):
+    # Could make this a classmethod if/when cython supports cdef classmethods
+    cdef:
+        _Timedelta td_base
+
+    # For millisecond and second resos, we cannot actually pass int(value) because
+    #  many cases would fall outside of the pytimedelta implementation bounds.
+    #  We pass 0 instead, and override seconds, microseconds, days.
+    #  In principle we could pass 0 for ns and us too.
+    if reso == NPY_FR_ns:
+        td_base = _Timedelta.__new__(cls, microseconds=int(value) // 1000)
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_us:
+        td_base = _Timedelta.__new__(cls, microseconds=int(value))
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_ms:
+        td_base = _Timedelta.__new__(cls, milliseconds=0)
+    elif reso == NPY_DATETIMEUNIT.NPY_FR_s:
+        td_base = _Timedelta.__new__(cls, seconds=0)
+    # Other resolutions are disabled but could potentially be implemented here:
+    # elif reso == NPY_DATETIMEUNIT.NPY_FR_m:
+    #    td_base = _Timedelta.__new__(Timedelta, minutes=int(value))
+    # elif reso == NPY_DATETIMEUNIT.NPY_FR_h:
+    #    td_base = _Timedelta.__new__(Timedelta, hours=int(value))
+    # elif reso == NPY_DATETIMEUNIT.NPY_FR_D:
+    #    td_base = _Timedelta.__new__(Timedelta, days=int(value))
+    else:
+        raise NotImplementedError(
+            "Only resolutions 's', 'ms', 'us', 'ns' are supported."
+        )
+
+
+    td_base.value = value
+    td_base._is_populated = 0
+    td_base._reso = reso
+    return td_base
+
+
+class MinMaxReso:
+    """
+    We need to define min/max/resolution on both the Timedelta _instance_
+    and Timedelta class.  On an instance, these depend on the object's _reso.
+    On the class, we default to the values we would get with nanosecond _reso.
+    """
+    def __init__(self, name):
+        self._name = name
+
+    def __get__(self, obj, type=None):
+        if self._name == "min":
+            val = np.iinfo(np.int64).min + 1
+        elif self._name == "max":
+            val = np.iinfo(np.int64).max
+        else:
+            assert self._name == "resolution"
+            val = 1
+
+        if obj is None:
+            # i.e. this is on the class, default to nanos
+            return Timedelta(val)
+        else:
+            return Timedelta._from_value_and_reso(val, obj._reso)
+
+    def __set__(self, obj, value):
+        raise AttributeError(f"{self._name} is not settable.")
+
+
 # Similar to Timestamp/datetime, this is a construction requirement for
 # timedeltas that we need to do object instantiation in python. This will
 # serve as a C extension type that shadows the Python class, where we do any
@@ -810,15 +1012,82 @@ cdef _to_py_int_float(v):
 cdef class _Timedelta(timedelta):
     # cdef readonly:
     #    int64_t value      # nanoseconds
-    #    object freq        # frequency reference
-    #    bint is_populated  # are my components populated
+    #    bint _is_populated  # are my components populated
     #    int64_t _d, _h, _m, _s, _ms, _us, _ns
+    #    NPY_DATETIMEUNIT _reso
 
     # higher than np.ndarray and np.matrix
     __array_priority__ = 100
+    min = MinMaxReso("min")
+    max = MinMaxReso("max")
+    resolution = MinMaxReso("resolution")
+
+    @property
+    def days(self) -> int:  # TODO(cython3): make cdef property
+        # NB: using the python C-API PyDateTime_DELTA_GET_DAYS will fail
+        #  (or be incorrect)
+        self._ensure_components()
+        return self._d
+
+    @property
+    def seconds(self) -> int:  # TODO(cython3): make cdef property
+        # NB: using the python C-API PyDateTime_DELTA_GET_SECONDS will fail
+        #  (or be incorrect)
+        self._ensure_components()
+        return self._h * 3600 + self._m * 60 + self._s
+
+    @property
+    def microseconds(self) -> int:  # TODO(cython3): make cdef property
+        # NB: using the python C-API PyDateTime_DELTA_GET_MICROSECONDS will fail
+        #  (or be incorrect)
+        self._ensure_components()
+        return self._ms * 1000 + self._us
+
+    def total_seconds(self) -> float:
+        """Total seconds in the duration."""
+        # We need to override bc we overrided days/seconds/microseconds
+        # TODO: add nanos/1e9?
+        return self.days * 24 * 3600 + self.seconds + self.microseconds / 1_000_000
+
+    @property
+    def freq(self) -> None:
+        """
+        Freq property.
+
+        .. deprecated:: 1.5.0
+            This argument is deprecated.
+        """
+        # GH#46430
+        warnings.warn(
+            "Timedelta.freq is deprecated and will be removed in a future version",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        return None
+
+    @property
+    def is_populated(self) -> bool:
+        """
+        Is_populated property.
+
+        .. deprecated:: 1.5.0
+            This argument is deprecated.
+        """
+        # GH#46430
+        warnings.warn(
+            "Timedelta.is_populated is deprecated and will be removed in a future version",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        return self._is_populated
 
     def __hash__(_Timedelta self):
         if self._has_ns():
+            # Note: this does *not* satisfy the invariance
+            #  td1 == td2 \\Rightarrow hash(td1) == hash(td2)
+            #  if td1 and td2 have different _resos. timedelta64 also has this
+            #  non-invariant behavior.
+            #  see GH#44504
             return hash(self.value)
         else:
             return timedelta.__hash__(self)
@@ -826,7 +1095,6 @@ cdef class _Timedelta(timedelta):
     def __richcmp__(_Timedelta self, object other, int op):
         cdef:
             _Timedelta ots
-            int ndim
 
         if isinstance(other, _Timedelta):
             ots = other
@@ -838,7 +1106,6 @@ cdef class _Timedelta(timedelta):
             return op == Py_NE
 
         elif util.is_array(other):
-            # TODO: watch out for zero-dim
             if other.dtype.kind == "m":
                 return PyObject_RichCompare(self.asm8, other, op)
             elif other.dtype.kind == "O":
@@ -856,22 +1123,42 @@ cdef class _Timedelta(timedelta):
         else:
             return NotImplemented
 
-        return cmp_scalar(self.value, ots.value, op)
+        if self._reso == ots._reso:
+            return cmp_scalar(self.value, ots.value, op)
+        return self._compare_mismatched_resos(ots, op)
 
-    cpdef bint _has_ns(self):
-        return self.value % 1000 != 0
+    # TODO: re-use/share with Timestamp
+    cdef inline bint _compare_mismatched_resos(self, _Timedelta other, op):
+        # Can't just dispatch to numpy as they silently overflow and get it wrong
+        cdef:
+            npy_datetimestruct dts_self
+            npy_datetimestruct dts_other
+
+        # dispatch to the datetimestruct utils instead of writing new ones!
+        pandas_datetime_to_datetimestruct(self.value, self._reso, &dts_self)
+        pandas_datetime_to_datetimestruct(other.value, other._reso, &dts_other)
+        return cmp_dtstructs(&dts_self,  &dts_other, op)
+
+    cdef bint _has_ns(self):
+        if self._reso == NPY_FR_ns:
+            return self.value % 1000 != 0
+        elif self._reso < NPY_FR_ns:
+            # i.e. seconds, millisecond, microsecond
+            return False
+        else:
+            raise NotImplementedError(self._reso)
 
-    def _ensure_components(_Timedelta self):
+    cdef _ensure_components(_Timedelta self):
         """
         compute the components
         """
-        if self.is_populated:
+        if self._is_populated:
             return
 
         cdef:
             pandas_timedeltastruct tds
 
-        td64_to_tdstruct(self.value, &tds)
+        pandas_timedelta_to_timedeltastruct(self.value, self._reso, &tds)
         self._d = tds.days
         self._h = tds.hrs
         self._m = tds.min
@@ -882,7 +1169,7 @@ cdef class _Timedelta(timedelta):
         self._seconds = tds.seconds
         self._microseconds = tds.microseconds
 
-        self.is_populated = 1
+        self._is_populated = 1
 
     cpdef timedelta to_pytimedelta(_Timedelta self):
         """
@@ -903,13 +1190,24 @@ cdef class _Timedelta(timedelta):
         -----
         Any nanosecond resolution will be lost.
         """
-        return timedelta(microseconds=int(self.value) / 1000)
+        if self._reso == NPY_FR_ns:
+            return timedelta(microseconds=int(self.value) / 1000)
+
+        # TODO(@WillAyd): is this the right way to use components?
+        self._ensure_components()
+        return timedelta(
+            days=self._d, seconds=self._seconds, microseconds=self._microseconds
+        )
 
     def to_timedelta64(self) -> np.timedelta64:
         """
         Return a numpy.timedelta64 object with 'ns' precision.
         """
-        return np.timedelta64(self.value, 'ns')
+        cdef:
+            str abbrev = npy_unit_to_abbrev(self._reso)
+        # TODO: way to create a np.timedelta64 obj with the reso directly
+        #  instead of having to get the abbrev?
+        return np.timedelta64(self.value, abbrev)
 
     def to_numpy(self, dtype=None, copy=False) -> np.timedelta64:
         """
@@ -956,6 +1254,9 @@ cdef class _Timedelta(timedelta):
         """
         Return the timedelta in nanoseconds (ns), for internal compatibility.
 
+        .. deprecated:: 1.5.0
+            This argument is deprecated.
+
         Returns
         -------
         int
@@ -979,6 +1280,12 @@ cdef class _Timedelta(timedelta):
         >>> td.delta
         42
         """
+        # Deprecated GH#46476
+        warnings.warn(
+            "Timedelta.delta is deprecated and will be removed in a future version.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
         return self.value
 
     @property
@@ -1014,7 +1321,7 @@ cdef class _Timedelta(timedelta):
         >>> td.asm8
         numpy.timedelta64(42,'ns')
         """
-        return np.int64(self.value).view('m8[ns]')
+        return self.to_timedelta64()
 
     @property
     def resolution_string(self) -> str:
@@ -1120,7 +1427,10 @@ cdef class _Timedelta(timedelta):
         converted : string of a Timedelta
 
         """
-        cdef object sign, seconds_pretty, subs, fmt, comp_dict
+        cdef:
+            str sign, fmt
+            dict comp_dict
+            object subs
 
         self._ensure_components()
 
@@ -1169,7 +1479,8 @@ cdef class _Timedelta(timedelta):
 
     def isoformat(self) -> str:
         """
-        Format Timedelta as ISO 8601 Duration like
+        Format the Timedelta as ISO 8601 Duration.
+
         ``P[n]Y[n]M[n]DT[n]H[n]M[n]S``, where the ``[n]`` s are replaced by the
         values. See https://en.wikipedia.org/wiki/ISO_8601#Durations.
 
@@ -1215,6 +1526,35 @@ cdef class _Timedelta(timedelta):
                f'H{components.minutes}M{seconds}S')
         return tpl
 
+    # ----------------------------------------------------------------
+    # Constructors
+
+    @classmethod
+    def _from_value_and_reso(cls, int64_t value, NPY_DATETIMEUNIT reso):
+        # exposing as classmethod for testing
+        return _timedelta_from_value_and_reso(cls, value, reso)
+
+    def _as_unit(self, str unit, bint round_ok=True):
+        dtype = np.dtype(f"m8[{unit}]")
+        reso = get_unit_from_dtype(dtype)
+        try:
+            return self._as_reso(reso, round_ok=round_ok)
+        except OverflowError as err:
+            raise OutOfBoundsTimedelta(
+                f"Cannot cast {self} to unit='{unit}' without overflow."
+            ) from err
+
+    @cython.cdivision(False)
+    cdef _Timedelta _as_reso(self, NPY_DATETIMEUNIT reso, bint round_ok=True):
+        cdef:
+            int64_t value, mult, div, mod
+
+        if reso == self._reso:
+            return self
+
+        value = convert_reso(self.value, self._reso, reso, round_ok=round_ok)
+        return type(self)._from_value_and_reso(value, reso=reso)
+
 
 # Python front end to C extension type _Timedelta
 # This serves as the box for timedelta64
@@ -1251,10 +1591,29 @@ class Timedelta(_Timedelta):
 
     Notes
     -----
+    The constructor may take in either both values of value and unit or
+    kwargs as above. Either one of them must be used during initialization
+
     The ``.value`` attribute is always in ns.
 
     If the precision is higher than nanoseconds, the precision of the duration is
     truncated to nanoseconds.
+
+    Examples
+    --------
+    Here we initialize Timedelta object with both value and unit
+
+    >>> td = pd.Timedelta(1, "d")
+    >>> td
+    Timedelta('1 days 00:00:00')
+
+    Here we initialize the Timedelta object with kwargs
+
+    >>> td2 = pd.Timedelta(days=1)
+    >>> td2
+    Timedelta('1 days 00:00:00')
+
+    We see that either way we get the same result
     """
 
     _req_any_kwargs_new = {"weeks", "days", "hours", "minutes", "seconds",
@@ -1270,7 +1629,10 @@ class Timedelta(_Timedelta):
                                  "(days,seconds....)")
 
             kwargs = {key: _to_py_int_float(kwargs[key]) for key in kwargs}
-            if not cls._req_any_kwargs_new.intersection(kwargs):
+
+            unsupported_kwargs = set(kwargs)
+            unsupported_kwargs.difference_update(cls._req_any_kwargs_new)
+            if unsupported_kwargs or not cls._req_any_kwargs_new.intersection(kwargs):
                 raise ValueError(
                     "cannot construct a Timedelta from the passed arguments, "
                     "allowed keywords are "
@@ -1324,8 +1686,6 @@ class Timedelta(_Timedelta):
         elif PyDelta_Check(value):
             value = convert_to_timedelta64(value, 'ns')
         elif is_timedelta64_object(value):
-            if unit is not None:
-                value = value.astype(f'timedelta64[{unit}]')
             value = ensure_td64ns(value)
         elif is_tick_object(value):
             value = np.timedelta64(value.nanos, 'ns')
@@ -1348,19 +1708,21 @@ class Timedelta(_Timedelta):
         if value == NPY_NAT:
             return NaT
 
-        # make timedelta happy
-        td_base = _Timedelta.__new__(cls, microseconds=int(value) // 1000)
-        td_base.value = value
-        td_base.is_populated = 0
-        return td_base
+        return _timedelta_from_value_and_reso(cls, value, NPY_FR_ns)
 
     def __setstate__(self, state):
-        (value) = state
+        if len(state) == 1:
+            # older pickle, only supported nanosecond
+            value = state[0]
+            reso = NPY_FR_ns
+        else:
+            value, reso = state
         self.value = value
+        self._reso = reso
 
     def __reduce__(self):
-        object_state = self.value,
-        return (Timedelta, object_state)
+        object_state = self.value, self._reso
+        return (_timedelta_unpickle, object_state)
 
     @cython.cdivision(True)
     def _round(self, freq, mode):
@@ -1369,11 +1731,13 @@ class Timedelta(_Timedelta):
             ndarray[int64_t] arr
 
         from pandas._libs.tslibs.offsets import to_offset
-        unit = to_offset(freq).nanos
+
+        to_offset(freq).nanos  # raises on non-fixed freq
+        unit = delta_to_nanoseconds(to_offset(freq), self._reso)
 
         arr = np.array([self.value], dtype="i8")
         result = round_nsint64(arr, mode, unit)[0]
-        return Timedelta(result, unit="ns")
+        return Timedelta._from_value_and_reso(result, self._reso)
 
     def round(self, freq):
         """
@@ -1431,10 +1795,21 @@ class Timedelta(_Timedelta):
 
     def __mul__(self, other):
         if is_integer_object(other) or is_float_object(other):
-            return Timedelta(other * self.value, unit='ns')
+            if util.is_nan(other):
+                # np.nan * timedelta -> np.timedelta64("NaT"), in this case NaT
+                return NaT
+
+            return _timedelta_from_value_and_reso(
+                Timedelta,
+                <int64_t>(other * self.value),
+                reso=self._reso,
+            )
 
         elif is_array(other):
-            # ndarray-like
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return self.__mul__(item)
             return other * self.to_timedelta64()
 
         return NotImplemented
@@ -1442,18 +1817,35 @@ class Timedelta(_Timedelta):
     __rmul__ = __mul__
 
     def __truediv__(self, other):
+        cdef:
+            int64_t new_value
+
         if _should_cast_to_timedelta(other):
             # We interpret NaT as timedelta64("NaT")
             other = Timedelta(other)
             if other is NaT:
                 return np.nan
+            if other._reso != self._reso:
+                raise ValueError(
+                    "division between Timedeltas with mismatched resolutions "
+                    "are not supported. Explicitly cast to matching resolutions "
+                    "before dividing."
+                )
             return self.value / float(other.value)
 
         elif is_integer_object(other) or is_float_object(other):
             # integers or floats
-            return Timedelta(self.value / other, unit='ns')
+            if util.is_nan(other):
+                return NaT
+            return Timedelta._from_value_and_reso(
+                <int64_t>(self.value / other), self._reso
+            )
 
         elif is_array(other):
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return self.__truediv__(item)
             return self.to_timedelta64() / other
 
         return NotImplemented
@@ -1464,12 +1856,26 @@ class Timedelta(_Timedelta):
             other = Timedelta(other)
             if other is NaT:
                 return np.nan
+            if self._reso != other._reso:
+                raise ValueError(
+                    "division between Timedeltas with mismatched resolutions "
+                    "are not supported. Explicitly cast to matching resolutions "
+                    "before dividing."
+                )
             return float(other.value) / self.value
 
         elif is_array(other):
-            if other.dtype.kind == "O":
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return self.__rtruediv__(item)
+            elif other.dtype.kind == "O":
                 # GH#31869
                 return np.array([x / self for x in other])
+
+            # TODO: if other.dtype.kind == "m" and other.dtype != self.asm8.dtype
+            #  then should disallow for consistency with scalar behavior; requires
+            #  deprecation cycle. (or changing scalar behavior)
             return other / self.to_timedelta64()
 
         return NotImplemented
@@ -1482,18 +1888,33 @@ class Timedelta(_Timedelta):
             other = Timedelta(other)
             if other is NaT:
                 return np.nan
+            if self._reso != other._reso:
+                raise ValueError(
+                    "floordivision between Timedeltas with mismatched resolutions "
+                    "are not supported. Explicitly cast to matching resolutions "
+                    "before dividing."
+                )
             return self.value // other.value
 
         elif is_integer_object(other) or is_float_object(other):
-            return Timedelta(self.value // other, unit='ns')
+            if util.is_nan(other):
+                return NaT
+            return type(self)._from_value_and_reso(self.value // other, self._reso)
 
         elif is_array(other):
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return self.__floordiv__(item)
+
             if other.dtype.kind == 'm':
                 # also timedelta-like
+                if self._reso != NPY_FR_ns:
+                    raise NotImplementedError
                 return _broadcast_floordiv_td64(self.value, other, _floordiv)
             elif other.dtype.kind in ['i', 'u', 'f']:
                 if other.ndim == 0:
-                    return Timedelta(self.value // other)
+                    return self // other.item()
                 else:
                     return self.to_timedelta64() // other
 
@@ -1509,11 +1930,24 @@ class Timedelta(_Timedelta):
             other = Timedelta(other)
             if other is NaT:
                 return np.nan
+            if self._reso != other._reso:
+                raise ValueError(
+                    "floordivision between Timedeltas with mismatched resolutions "
+                    "are not supported. Explicitly cast to matching resolutions "
+                    "before dividing."
+                )
             return other.value // self.value
 
         elif is_array(other):
+            if other.ndim == 0:
+                # see also: item_from_zerodim
+                item = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other), other)
+                return self.__rfloordiv__(item)
+
             if other.dtype.kind == 'm':
                 # also timedelta-like
+                if self._reso != NPY_FR_ns:
+                    raise NotImplementedError
                 return _broadcast_floordiv_td64(self.value, other, _rfloordiv)
 
             # Includes integer array // Timedelta, disallowed in GH#19761
@@ -1595,26 +2029,14 @@ cdef _broadcast_floordiv_td64(
     result : varies based on `other`
     """
     # assumes other.dtype.kind == 'm', i.e. other is timedelta-like
+    # assumes other.ndim != 0
 
     # We need to watch out for np.timedelta64('NaT').
     mask = other.view('i8') == NPY_NAT
 
-    if other.ndim == 0:
-        if mask:
-            return np.nan
-
-        return operation(value, other.astype('m8[ns]').astype('i8'))
-
-    else:
-        res = operation(value, other.astype('m8[ns]').astype('i8'))
-
-        if mask.any():
-            res = res.astype('f8')
-            res[mask] = np.nan
-        return res
-
+    res = operation(value, other.astype('m8[ns]', copy=False).astype('i8'))
 
-# resolution in ns
-Timedelta.min = Timedelta(np.iinfo(np.int64).min + 1)
-Timedelta.max = Timedelta(np.iinfo(np.int64).max)
-Timedelta.resolution = Timedelta(nanoseconds=1)
+    if mask.any():
+        res = res.astype('f8')
+        res[mask] = np.nan
+    return res
diff --git a/pandas/_libs/tslibs/timestamps.pxd b/pandas/_libs/tslibs/timestamps.pxd
index 8833a611b0722..0ecb26822cf50 100644
--- a/pandas/_libs/tslibs/timestamps.pxd
+++ b/pandas/_libs/tslibs/timestamps.pxd
@@ -5,18 +5,26 @@ from cpython.datetime cimport (
 from numpy cimport int64_t
 
 from pandas._libs.tslibs.base cimport ABCTimestamp
-from pandas._libs.tslibs.np_datetime cimport npy_datetimestruct
+from pandas._libs.tslibs.np_datetime cimport (
+    NPY_DATETIMEUNIT,
+    npy_datetimestruct,
+)
+from pandas._libs.tslibs.offsets cimport BaseOffset
 
 
-cdef object create_timestamp_from_ts(int64_t value,
-                                     npy_datetimestruct dts,
-                                     tzinfo tz, object freq, bint fold)
+cdef _Timestamp create_timestamp_from_ts(int64_t value,
+                                         npy_datetimestruct dts,
+                                         tzinfo tz,
+                                         BaseOffset freq,
+                                         bint fold,
+                                         NPY_DATETIMEUNIT reso=*)
 
 
 cdef class _Timestamp(ABCTimestamp):
     cdef readonly:
-        int64_t value, nanosecond
-        object _freq
+        int64_t value, nanosecond, year
+        BaseOffset _freq
+        NPY_DATETIMEUNIT _reso
 
     cdef bint _get_start_end_field(self, str field, freq)
     cdef _get_date_name_field(self, str field, object locale)
@@ -28,3 +36,5 @@ cdef class _Timestamp(ABCTimestamp):
                                          int op) except -1
     cpdef void _set_freq(self, freq)
     cdef _warn_on_field_deprecation(_Timestamp self, freq, str field)
+    cdef bint _compare_mismatched_resos(_Timestamp self, _Timestamp other, int op)
+    cdef _Timestamp _as_reso(_Timestamp self, NPY_DATETIMEUNIT reso, bint round_ok=*)
diff --git a/pandas/_libs/tslibs/timestamps.pyi b/pandas/_libs/tslibs/timestamps.pyi
index ecddd83322bbf..e4be7fda43005 100644
--- a/pandas/_libs/tslibs/timestamps.pyi
+++ b/pandas/_libs/tslibs/timestamps.pyi
@@ -18,6 +18,7 @@ from pandas._libs.tslibs import (
     BaseOffset,
     NaTType,
     Period,
+    Tick,
     Timedelta,
 )
 
@@ -31,17 +32,10 @@ class Timestamp(datetime):
 
     resolution: ClassVar[Timedelta]
     value: int  # np.int64
-
     # error: "__new__" must return a class instance (got "Union[Timestamp, NaTType]")
     def __new__(  # type: ignore[misc]
         cls: type[_DatetimeT],
-        ts_input: int
-        | np.integer
-        | float
-        | str
-        | _date
-        | datetime
-        | np.datetime64 = ...,
+        ts_input: np.integer | float | str | _date | datetime | np.datetime64 = ...,
         freq: int | None | str | BaseOffset = ...,
         tz: str | _tzinfo | None | int = ...,
         unit: str | int | None = ...,
@@ -58,6 +52,10 @@ class Timestamp(datetime):
         fold: int | None = ...,
     ) -> _DatetimeT | NaTType: ...
     def _set_freq(self, freq: BaseOffset | None) -> None: ...
+    @classmethod
+    def _from_value_and_reso(
+        cls, value: int, reso: int, tz: _tzinfo | None
+    ) -> Timestamp: ...
     @property
     def year(self) -> int: ...
     @property
@@ -80,10 +78,10 @@ class Timestamp(datetime):
     def fold(self) -> int: ...
     @classmethod
     def fromtimestamp(
-        cls: type[_DatetimeT], t: float, tz: _tzinfo | None = ...
+        cls: type[_DatetimeT], ts: float, tz: _tzinfo | None = ...
     ) -> _DatetimeT: ...
     @classmethod
-    def utcfromtimestamp(cls: type[_DatetimeT], t: float) -> _DatetimeT: ...
+    def utcfromtimestamp(cls: type[_DatetimeT], ts: float) -> _DatetimeT: ...
     @classmethod
     def today(cls: type[_DatetimeT], tz: _tzinfo | str | None = ...) -> _DatetimeT: ...
     @classmethod
@@ -99,7 +97,9 @@ class Timestamp(datetime):
     def utcnow(cls: type[_DatetimeT]) -> _DatetimeT: ...
     # error: Signature of "combine" incompatible with supertype "datetime"
     @classmethod
-    def combine(cls, date: _date, time: _time) -> datetime: ...  # type: ignore[override]
+    def combine(  # type: ignore[override]
+        cls, date: _date, time: _time
+    ) -> datetime: ...
     @classmethod
     def fromisoformat(cls: type[_DatetimeT], date_string: str) -> _DatetimeT: ...
     def strftime(self, format: str) -> str: ...
@@ -111,19 +111,25 @@ class Timestamp(datetime):
     def date(self) -> _date: ...
     def time(self) -> _time: ...
     def timetz(self) -> _time: ...
-    def replace(
-        self,
-        year: int = ...,
-        month: int = ...,
-        day: int = ...,
-        hour: int = ...,
-        minute: int = ...,
-        second: int = ...,
-        microsecond: int = ...,
-        tzinfo: _tzinfo | None = ...,
-        fold: int = ...,
-    ) -> datetime: ...
-    def astimezone(self: _DatetimeT, tz: _tzinfo | None = ...) -> _DatetimeT: ...
+    # LSP violation: nanosecond is not present in datetime.datetime.replace
+    # and has positional args following it
+    def replace(  # type: ignore[override]
+        self: _DatetimeT,
+        year: int | None = ...,
+        month: int | None = ...,
+        day: int | None = ...,
+        hour: int | None = ...,
+        minute: int | None = ...,
+        second: int | None = ...,
+        microsecond: int | None = ...,
+        nanosecond: int | None = ...,
+        tzinfo: _tzinfo | type[object] | None = ...,
+        fold: int | None = ...,
+    ) -> _DatetimeT: ...
+    # LSP violation: datetime.datetime.astimezone has a default value for tz
+    def astimezone(  # type: ignore[override]
+        self: _DatetimeT, tz: _tzinfo | None
+    ) -> _DatetimeT: ...
     def ctime(self) -> str: ...
     def isoformat(self, sep: str = ..., timespec: str = ...) -> str: ...
     @classmethod
@@ -131,22 +137,24 @@ class Timestamp(datetime):
     def utcoffset(self) -> timedelta | None: ...
     def tzname(self) -> str | None: ...
     def dst(self) -> timedelta | None: ...
-    def __le__(self, other: datetime) -> bool: ...  # type: ignore
-    def __lt__(self, other: datetime) -> bool: ...  # type: ignore
-    def __ge__(self, other: datetime) -> bool: ...  # type: ignore
-    def __gt__(self, other: datetime) -> bool: ...  # type: ignore
+    def __le__(self, other: datetime) -> bool: ...  # type: ignore[override]
+    def __lt__(self, other: datetime) -> bool: ...  # type: ignore[override]
+    def __ge__(self, other: datetime) -> bool: ...  # type: ignore[override]
+    def __gt__(self, other: datetime) -> bool: ...  # type: ignore[override]
     # error: Signature of "__add__" incompatible with supertype "date"/"datetime"
     @overload  # type: ignore[override]
     def __add__(self, other: np.ndarray) -> np.ndarray: ...
     @overload
-    # TODO: other can also be Tick (but it cannot be resolved)
-    def __add__(self: _DatetimeT, other: timedelta | np.timedelta64) -> _DatetimeT: ...
+    def __add__(
+        self: _DatetimeT, other: timedelta | np.timedelta64 | Tick
+    ) -> _DatetimeT: ...
     def __radd__(self: _DatetimeT, other: timedelta) -> _DatetimeT: ...
-    @overload  # type: ignore
-    def __sub__(self, other: datetime) -> timedelta: ...
+    @overload  # type: ignore[override]
+    def __sub__(self, other: datetime) -> Timedelta: ...
     @overload
-    # TODO: other can also be Tick (but it cannot be resolved)
-    def __sub__(self, other: timedelta | np.timedelta64) -> datetime: ...
+    def __sub__(
+        self: _DatetimeT, other: timedelta | np.timedelta64 | Tick
+    ) -> _DatetimeT: ...
     def __hash__(self) -> int: ...
     def weekday(self) -> int: ...
     def isoweekday(self) -> int: ...
@@ -195,13 +203,22 @@ class Timestamp(datetime):
     @property
     def day_of_week(self) -> int: ...
     @property
-    def day_of_month(self) -> int: ...
+    def dayofweek(self) -> int: ...
     @property
     def day_of_year(self) -> int: ...
     @property
+    def dayofyear(self) -> int: ...
+    @property
     def quarter(self) -> int: ...
     @property
     def week(self) -> int: ...
     def to_numpy(
         self, dtype: np.dtype | None = ..., copy: bool = ...
     ) -> np.datetime64: ...
+    @property
+    def _date_repr(self) -> str: ...
+    @property
+    def days_in_month(self) -> int: ...
+    @property
+    def daysinmonth(self) -> int: ...
+    def _as_unit(self, unit: str, round_ok: bool = ...) -> Timestamp: ...
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index b13b77506ecc7..a574b648278fb 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -25,10 +25,10 @@ cnp.import_array()
 from cpython.datetime cimport (  # alias bc `tzinfo` is a kwarg below
     PyDate_Check,
     PyDateTime_Check,
-    PyDateTime_IMPORT,
     PyDelta_Check,
     PyTZInfo_Check,
     datetime,
+    import_datetime,
     time,
     tzinfo as tzinfo_type,
 )
@@ -43,15 +43,23 @@ from cpython.object cimport (
     PyObject_RichCompareBool,
 )
 
-PyDateTime_IMPORT
+import_datetime()
 
 from pandas._libs.tslibs cimport ccalendar
 from pandas._libs.tslibs.base cimport ABCTimestamp
+
+from pandas.util._exceptions import find_stack_level
+
 from pandas._libs.tslibs.conversion cimport (
     _TSObject,
     convert_datetime_to_tsobject,
     convert_to_tsobject,
-    normalize_i8_stamp,
+    maybe_localize_tso,
+)
+from pandas._libs.tslibs.dtypes cimport (
+    npy_unit_to_abbrev,
+    periods_per_day,
+    periods_per_second,
 )
 from pandas._libs.tslibs.util cimport (
     is_array,
@@ -73,21 +81,35 @@ from pandas._libs.tslibs.nattype cimport (
     c_NaT as NaT,
 )
 from pandas._libs.tslibs.np_datetime cimport (
-    check_dts_bounds,
+    NPY_DATETIMEUNIT,
+    NPY_FR_ns,
+    cmp_dtstructs,
     cmp_scalar,
-    dt64_to_dtstruct,
+    convert_reso,
+    get_conversion_factor,
+    get_datetime64_unit,
+    get_datetime64_value,
+    get_unit_from_dtype,
     npy_datetimestruct,
-    pydatetime_to_dt64,
+    npy_datetimestruct_to_datetime,
+    pandas_datetime_to_datetimestruct,
+    pydatetime_to_dtstruct,
 )
 
-from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+)
 
 from pandas._libs.tslibs.offsets cimport (
+    BaseOffset,
     is_offset_object,
     to_offset,
 )
 from pandas._libs.tslibs.timedeltas cimport (
+    _Timedelta,
     delta_to_nanoseconds,
+    ensure_td64ns,
     is_any_td_scalar,
 )
 
@@ -114,24 +136,47 @@ _no_input = object()
 # ----------------------------------------------------------------------
 
 
-cdef inline object create_timestamp_from_ts(int64_t value,
-                                            npy_datetimestruct dts,
-                                            tzinfo tz, object freq, bint fold):
+cdef inline _Timestamp create_timestamp_from_ts(
+    int64_t value,
+    npy_datetimestruct dts,
+    tzinfo tz,
+    BaseOffset freq,
+    bint fold,
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+):
     """ convenience routine to construct a Timestamp from its parts """
-    cdef _Timestamp ts_base
-    ts_base = _Timestamp.__new__(Timestamp, dts.year, dts.month,
+    cdef:
+        _Timestamp ts_base
+        int64_t pass_year = dts.year
+
+    # We pass year=1970/1972 here and set year below because with non-nanosecond
+    #  resolution we may have datetimes outside of the stdlib pydatetime
+    #  implementation bounds, which would raise.
+    # NB: this means the C-API macro PyDateTime_GET_YEAR is unreliable.
+    if 1 <= pass_year <= 9999:
+        # we are in-bounds for pydatetime
+        pass
+    elif ccalendar.is_leapyear(dts.year):
+        pass_year = 1972
+    else:
+        pass_year = 1970
+
+    ts_base = _Timestamp.__new__(Timestamp, pass_year, dts.month,
                                  dts.day, dts.hour, dts.min,
                                  dts.sec, dts.us, tz, fold=fold)
+
     ts_base.value = value
     ts_base._freq = freq
+    ts_base.year = dts.year
     ts_base.nanosecond = dts.ps // 1000
+    ts_base._reso = reso
 
     return ts_base
 
 
-def _unpickle_timestamp(value, freq, tz):
+def _unpickle_timestamp(value, freq, tz, reso=NPY_FR_ns):
     # GH#41949 dont warn on unpickle if we have a freq
-    ts = Timestamp(value, tz=tz)
+    ts = Timestamp._from_value_and_reso(value, reso, tz)
     ts._set_freq(freq)
     return ts
 
@@ -153,6 +198,40 @@ def integer_op_not_supported(obj):
     return TypeError(int_addsub_msg)
 
 
+class MinMaxReso:
+    """
+    We need to define min/max/resolution on both the Timestamp _instance_
+    and Timestamp class.  On an instance, these depend on the object's _reso.
+    On the class, we default to the values we would get with nanosecond _reso.
+
+    See also: timedeltas.MinMaxReso
+    """
+    def __init__(self, name):
+        self._name = name
+
+    def __get__(self, obj, type=None):
+        cls = Timestamp
+        if self._name == "min":
+            val = np.iinfo(np.int64).min + 1
+        elif self._name == "max":
+            val = np.iinfo(np.int64).max
+        else:
+            assert self._name == "resolution"
+            val = 1
+            cls = Timedelta
+
+        if obj is None:
+            # i.e. this is on the class, default to nanos
+            return cls(val)
+        elif self._name == "resolution":
+            return Timedelta._from_value_and_reso(val, obj._reso)
+        else:
+            return Timestamp._from_value_and_reso(val, obj._reso, tz=None)
+
+    def __set__(self, obj, value):
+        raise AttributeError(f"{self._name} is not settable.")
+
+
 # ----------------------------------------------------------------------
 
 cdef class _Timestamp(ABCTimestamp):
@@ -162,6 +241,10 @@ cdef class _Timestamp(ABCTimestamp):
     dayofweek = _Timestamp.day_of_week
     dayofyear = _Timestamp.day_of_year
 
+    min = MinMaxReso("min")
+    max = MinMaxReso("max")
+    resolution = MinMaxReso("resolution")  # GH#21336, GH#21365
+
     cpdef void _set_freq(self, freq):
         # set the ._freq attribute without going through the constructor,
         #  which would issue a warning
@@ -173,13 +256,58 @@ cdef class _Timestamp(ABCTimestamp):
         warnings.warn(
             "Timestamp.freq is deprecated and will be removed in a future version.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return self._freq
 
+    # -----------------------------------------------------------------
+    # Constructors
+
+    @classmethod
+    def _from_value_and_reso(cls, int64_t value, NPY_DATETIMEUNIT reso, tzinfo tz):
+        cdef:
+            npy_datetimestruct dts
+            _TSObject obj = _TSObject()
+
+        if value == NPY_NAT:
+            return NaT
+
+        if reso < NPY_DATETIMEUNIT.NPY_FR_s or reso > NPY_DATETIMEUNIT.NPY_FR_ns:
+            raise NotImplementedError(
+                "Only resolutions 's', 'ms', 'us', 'ns' are supported."
+            )
+
+        obj.value = value
+        pandas_datetime_to_datetimestruct(value, reso, &obj.dts)
+        maybe_localize_tso(obj, tz, reso)
+
+        return create_timestamp_from_ts(
+            value, obj.dts, tz=obj.tzinfo, freq=None, fold=obj.fold, reso=reso
+        )
+
+    @classmethod
+    def _from_dt64(cls, dt64: np.datetime64):
+        # construct a Timestamp from a np.datetime64 object, keeping the
+        #  resolution of the input.
+        # This is herely mainly so we can incrementally implement non-nano
+        #  (e.g. only tznaive at first)
+        cdef:
+            npy_datetimestruct dts
+            int64_t value
+            NPY_DATETIMEUNIT reso
+
+        reso = get_datetime64_unit(dt64)
+        value = get_datetime64_value(dt64)
+        return cls._from_value_and_reso(value, reso, None)
+
+    # -----------------------------------------------------------------
+
     def __hash__(_Timestamp self):
         if self.nanosecond:
             return hash(self.value)
+        if not (1 <= self.year <= 9999):
+            # out of bounds for pydatetime
+            return hash(self.value)
         if self.fold:
             return datetime.__hash__(self.replace(fold=0))
         return datetime.__hash__(self)
@@ -193,17 +321,16 @@ cdef class _Timestamp(ABCTimestamp):
             ots = other
         elif other is NaT:
             return op == Py_NE
-        elif PyDateTime_Check(other) or is_datetime64_object(other):
-            if self.nanosecond == 0 and PyDateTime_Check(other):
+        elif is_datetime64_object(other):
+            ots = _Timestamp._from_dt64(other)
+        elif PyDateTime_Check(other):
+            if self.nanosecond == 0:
                 val = self.to_pydatetime()
                 return PyObject_RichCompareBool(val, other, op)
 
             try:
                 ots = type(self)(other)
             except ValueError:
-                if is_datetime64_object(other):
-                    # cast non-nano dt64 to pydatetime
-                    other = other.astype(object)
                 return self._compare_outside_nanorange(other, op)
 
         elif is_array(other):
@@ -241,7 +368,7 @@ cdef class _Timestamp(ABCTimestamp):
                 "In a future version these will be considered non-comparable. "
                 "Use 'ts == pd.Timestamp(date)' or 'ts.date() == date' instead.",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
             return NotImplemented
         else:
@@ -253,7 +380,21 @@ cdef class _Timestamp(ABCTimestamp):
             raise TypeError(
                 "Cannot compare tz-naive and tz-aware timestamps"
             )
-        return cmp_scalar(self.value, ots.value, op)
+        if self._reso == ots._reso:
+            return cmp_scalar(self.value, ots.value, op)
+        return self._compare_mismatched_resos(ots, op)
+
+    # TODO: copied from Timedelta; try to de-duplicate
+    cdef inline bint _compare_mismatched_resos(self, _Timestamp other, int op):
+        # Can't just dispatch to numpy as they silently overflow and get it wrong
+        cdef:
+            npy_datetimestruct dts_self
+            npy_datetimestruct dts_other
+
+        # dispatch to the datetimestruct utils instead of writing new ones!
+        pandas_datetime_to_datetimestruct(self.value, self._reso, &dts_self)
+        pandas_datetime_to_datetimestruct(other.value, other._reso, &dts_other)
+        return cmp_dtstructs(&dts_self,  &dts_other, op)
 
     cdef bint _compare_outside_nanorange(_Timestamp self, datetime other,
                                          int op) except -1:
@@ -281,13 +422,75 @@ cdef class _Timestamp(ABCTimestamp):
             return other.tzinfo is not None
         return other.tzinfo is None
 
+    @cython.overflowcheck(True)
     def __add__(self, other):
         cdef:
             int64_t nanos = 0
 
         if is_any_td_scalar(other):
-            nanos = delta_to_nanoseconds(other)
-            result = type(self)(self.value + nanos, tz=self.tzinfo)
+            if is_timedelta64_object(other):
+                other_reso = get_datetime64_unit(other)
+                if (
+                    other_reso == NPY_DATETIMEUNIT.NPY_FR_GENERIC
+                ):
+                    # TODO: deprecate allowing this?  We only get here
+                    #  with test_timedelta_add_timestamp_interval
+                    other = np.timedelta64(other.view("i8"), "ns")
+                elif (
+                    other_reso == NPY_DATETIMEUNIT.NPY_FR_Y or other_reso == NPY_DATETIMEUNIT.NPY_FR_M
+                ):
+                    # TODO: deprecate allowing these?  or handle more like the
+                    #  corresponding DateOffsets?
+                    # TODO: no tests get here
+                    other = ensure_td64ns(other)
+
+            if isinstance(other, _Timedelta):
+                # TODO: share this with __sub__, Timedelta.__add__
+                # We allow silent casting to the lower resolution if and only
+                #  if it is lossless.  See also Timestamp.__sub__
+                #  and Timedelta.__add__
+                try:
+                    if self._reso < other._reso:
+                        other = (<_Timedelta>other)._as_reso(self._reso, round_ok=False)
+                    elif self._reso > other._reso:
+                        self = (<_Timestamp>self)._as_reso(other._reso, round_ok=False)
+                except ValueError as err:
+                    raise ValueError(
+                        "Timestamp addition with mismatched resolutions is not "
+                        "allowed when casting to the lower resolution would require "
+                        "lossy rounding."
+                    ) from err
+
+            try:
+                nanos = delta_to_nanoseconds(
+                    other, reso=self._reso, round_ok=False
+                )
+            except OutOfBoundsTimedelta:
+                raise
+            except ValueError as err:
+                raise ValueError(
+                    "Addition between Timestamp and Timedelta with mismatched "
+                    "resolutions is not allowed when casting to the lower "
+                    "resolution would require lossy rounding."
+                ) from err
+
+            try:
+                new_value = self.value + nanos
+            except OverflowError:
+                # Use Python ints
+                # Hit in test_tdi_add_overflow
+                new_value = int(self.value) + int(nanos)
+
+            try:
+                result = type(self)._from_value_and_reso(
+                    new_value, reso=self._reso, tz=self.tzinfo
+                )
+            except OverflowError as err:
+                # TODO: don't hard-code nanosecond here
+                raise OutOfBoundsDatetime(
+                    f"Out of bounds nanosecond timestamp: {new_value}"
+                ) from err
+
             if result is not NaT:
                 result._set_freq(self._freq)  # avoid warning in constructor
             return result
@@ -308,12 +511,21 @@ cdef class _Timestamp(ABCTimestamp):
 
         elif not isinstance(self, _Timestamp):
             # cython semantics, args have been switched and this is __radd__
+            # TODO(cython3): remove this it moved to __radd__
             return other.__add__(self)
         return NotImplemented
 
+    def __radd__(self, other):
+        # Have to duplicate checks to avoid infinite recursion due to NotImplemented
+        if is_any_td_scalar(other) or is_integer_object(other) or is_array(other):
+            return self.__add__(other)
+        return NotImplemented
+
     def __sub__(self, other):
+        if other is NaT:
+            return NaT
 
-        if is_any_td_scalar(other) or is_integer_object(other):
+        elif is_any_td_scalar(other) or is_integer_object(other):
             neg_other = -other
             return self + neg_other
 
@@ -329,14 +541,12 @@ cdef class _Timestamp(ABCTimestamp):
                 )
             return NotImplemented
 
-        if other is NaT:
-            return NaT
-
         # coerce if necessary if we are a Timestamp-like
         if (PyDateTime_Check(self)
                 and (PyDateTime_Check(other) or is_datetime64_object(other))):
             # both_timestamps is to determine whether Timedelta(self - other)
             # should raise the OOB error, or fall back returning a timedelta.
+            # TODO(cython3): clean out the bits that moved to __rsub__
             both_timestamps = (isinstance(other, _Timestamp) and
                                isinstance(self, _Timestamp))
             if isinstance(self, _Timestamp):
@@ -349,11 +559,26 @@ cdef class _Timestamp(ABCTimestamp):
                     "Cannot subtract tz-naive and tz-aware datetime-like objects."
                 )
 
+            # We allow silent casting to the lower resolution if and only
+            #  if it is lossless.
+            try:
+                if self._reso < other._reso:
+                    other = (<_Timestamp>other)._as_reso(self._reso, round_ok=False)
+                elif self._reso > other._reso:
+                    self = (<_Timestamp>self)._as_reso(other._reso, round_ok=False)
+            except ValueError as err:
+                raise ValueError(
+                    "Timestamp subtraction with mismatched resolutions is not "
+                    "allowed when casting to the lower resolution would require "
+                    "lossy rounding."
+                ) from err
+
             # scalar Timestamp/datetime - Timestamp/datetime -> yields a
             # Timedelta
             try:
-                return Timedelta(self.value - other.value)
-            except (OverflowError, OutOfBoundsDatetime) as err:
+                res_value = self.value - other.value
+                return Timedelta._from_value_and_reso(res_value, self._reso)
+            except (OverflowError, OutOfBoundsDatetime, OutOfBoundsTimedelta) as err:
                 if isinstance(other, _Timestamp):
                     if both_timestamps:
                         raise OutOfBoundsDatetime(
@@ -367,10 +592,23 @@ cdef class _Timestamp(ABCTimestamp):
         elif is_datetime64_object(self):
             # GH#28286 cython semantics for __rsub__, `other` is actually
             #  the Timestamp
+            # TODO(cython3): remove this, this moved to __rsub__
             return type(other)(self) - other
 
         return NotImplemented
 
+    def __rsub__(self, other):
+        if PyDateTime_Check(other):
+            try:
+                return type(self)(other) - self
+            except (OverflowError, OutOfBoundsDatetime) as err:
+                # We get here in stata tests, fall back to stdlib datetime
+                #  method and return stdlib timedelta object
+                pass
+        elif is_datetime64_object(other):
+            return type(self)(other) - self
+        return NotImplemented
+
     # -----------------------------------------------------------------
 
     cdef int64_t _maybe_convert_value_to_local(self):
@@ -381,11 +619,13 @@ cdef class _Timestamp(ABCTimestamp):
             npy_datetimestruct dts
 
         if own_tz is not None and not is_utc(own_tz):
-            val = pydatetime_to_dt64(self, &dts) + self.nanosecond
+            pydatetime_to_dtstruct(self, &dts)
+            val = npy_datetimestruct_to_datetime(self._reso, &dts) + self.nanosecond
         else:
             val = self.value
         return val
 
+    @cython.boundscheck(False)
     cdef bint _get_start_end_field(self, str field, freq):
         cdef:
             int64_t val
@@ -402,8 +642,9 @@ cdef class _Timestamp(ABCTimestamp):
             freqstr = None
 
         val = self._maybe_convert_value_to_local()
+
         out = get_start_end_field(np.array([val], dtype=np.int64),
-                                  field, freqstr, month_kw)
+                                  field, freqstr, month_kw, self._reso)
         return out[0]
 
     cdef _warn_on_field_deprecation(self, freq, str field):
@@ -428,7 +669,7 @@ cdef class _Timestamp(ABCTimestamp):
                     "version. When you have a freq, use "
                     f"freq.{field}(timestamp) instead.",
                     FutureWarning,
-                    stacklevel=1,
+                    stacklevel=find_stack_level(),
                 )
 
     @property
@@ -557,14 +798,16 @@ cdef class _Timestamp(ABCTimestamp):
         self._warn_on_field_deprecation(self._freq, "is_year_end")
         return self._get_start_end_field("is_year_end", self._freq)
 
+    @cython.boundscheck(False)
     cdef _get_date_name_field(self, str field, object locale):
         cdef:
             int64_t val
-            object[:] out
+            object[::1] out
 
         val = self._maybe_convert_value_to_local()
+
         out = get_date_name_field(np.array([val], dtype=np.int64),
-                                  field, locale=locale)
+                                  field, locale=locale, reso=self._reso)
         return out[0]
 
     def day_name(self, locale=None) -> str:
@@ -713,9 +956,12 @@ cdef class _Timestamp(ABCTimestamp):
         cdef:
             local_val = self._maybe_convert_value_to_local()
             int64_t normalized
+            int64_t ppd = periods_per_day(self._reso)
+            _Timestamp ts
 
-        normalized = normalize_i8_stamp(local_val)
-        return Timestamp(normalized).tz_localize(self.tzinfo)
+        normalized = normalize_i8_stamp(local_val, ppd)
+        ts = type(self)._from_value_and_reso(normalized, reso=self._reso, tz=None)
+        return ts.tz_localize(self.tzinfo)
 
     # -----------------------------------------------------------------
     # Pickle Methods
@@ -731,8 +977,16 @@ cdef class _Timestamp(ABCTimestamp):
         self._freq = state[1]
         self.tzinfo = state[2]
 
+        if len(state) == 3:
+            # pre-non-nano pickle
+            # TODO: no tests get here 2022-05-10
+            reso = NPY_FR_ns
+        else:
+            reso = state[4]
+        self._reso = reso
+
     def __reduce__(self):
-        object_state = self.value, self._freq, self.tzinfo
+        object_state = self.value, self._freq, self.tzinfo, self._reso
         return (_unpickle_timestamp, object_state)
 
     # -----------------------------------------------------------------
@@ -773,6 +1027,9 @@ cdef class _Timestamp(ABCTimestamp):
         """
         base_ts = "microseconds" if timespec == "nanoseconds" else timespec
         base = super(_Timestamp, self).isoformat(sep=sep, timespec=base_ts)
+        # We need to replace the fake year 1970 with our real year
+        base = f"{self.year}-" + base.split("-", 1)[1]
+
         if self.nanosecond == 0 and timespec != "nanoseconds":
             return base
 
@@ -819,7 +1076,7 @@ cdef class _Timestamp(ABCTimestamp):
     @property
     def _date_repr(self) -> str:
         # Ideal here would be self.strftime("%Y-%m-%d"), but
-        # the datetime strftime() methods require year >= 1900
+        # the datetime strftime() methods require year >= 1900 and is slower
         return f'{self.year}-{self.month:02d}-{self.day:02d}'
 
     @property
@@ -848,6 +1105,27 @@ cdef class _Timestamp(ABCTimestamp):
     # -----------------------------------------------------------------
     # Conversion Methods
 
+    @cython.cdivision(False)
+    cdef _Timestamp _as_reso(self, NPY_DATETIMEUNIT reso, bint round_ok=True):
+        cdef:
+            int64_t value, mult, div, mod
+
+        if reso == self._reso:
+            return self
+
+        value = convert_reso(self.value, self._reso, reso, round_ok=round_ok)
+        return type(self)._from_value_and_reso(value, reso=reso, tz=self.tzinfo)
+
+    def _as_unit(self, str unit, bint round_ok=True):
+        dtype = np.dtype(f"M8[{unit}]")
+        reso = get_unit_from_dtype(dtype)
+        try:
+            return self._as_reso(reso, round_ok=round_ok)
+        except OverflowError as err:
+            raise OutOfBoundsDatetime(
+                f"Cannot cast {self} to unit='{unit}' without overflow."
+            ) from err
+
     @property
     def asm8(self) -> np.datetime64:
         """
@@ -859,7 +1137,7 @@ cdef class _Timestamp(ABCTimestamp):
         >>> ts.asm8
         numpy.datetime64('2020-03-14T15:00:00.000000000')
         """
-        return np.datetime64(self.value, 'ns')
+        return self.to_datetime64()
 
     def timestamp(self):
         """
@@ -873,7 +1151,10 @@ cdef class _Timestamp(ABCTimestamp):
         """
         # GH 17329
         # Note: Naive timestamps will not match datetime.stdlib
-        return round(self.value / 1e9, 6)
+
+        denom = periods_per_second(self._reso)
+
+        return round(self.value / denom, 6)
 
     cpdef datetime to_pydatetime(_Timestamp self, bint warn=True):
         """
@@ -894,17 +1175,19 @@ cdef class _Timestamp(ABCTimestamp):
         """
         if self.nanosecond != 0 and warn:
             warnings.warn("Discarding nonzero nanoseconds in conversion.",
-                          UserWarning, stacklevel=2)
+                          UserWarning, stacklevel=find_stack_level())
 
         return datetime(self.year, self.month, self.day,
                         self.hour, self.minute, self.second,
-                        self.microsecond, self.tzinfo)
+                        self.microsecond, self.tzinfo, fold=self.fold)
 
     cpdef to_datetime64(self):
         """
         Return a numpy.datetime64 object with 'ns' precision.
         """
-        return np.datetime64(self.value, "ns")
+        # TODO: find a way to construct dt64 directly from _reso
+        abbrev = npy_unit_to_abbrev(self._reso)
+        return np.datetime64(self.value, abbrev)
 
     def to_numpy(self, dtype=None, copy=False) -> np.datetime64:
         """
@@ -971,6 +1254,7 @@ cdef class _Timestamp(ABCTimestamp):
             warnings.warn(
                 "Converting to Period representation will drop timezone information.",
                 UserWarning,
+                stacklevel=find_stack_level(),
             )
 
         if freq is None:
@@ -979,7 +1263,7 @@ cdef class _Timestamp(ABCTimestamp):
                 "In a future version, calling 'Timestamp.to_period()' without "
                 "passing a 'freq' will raise an exception.",
                 FutureWarning,
-                stacklevel=2,
+                stacklevel=find_stack_level(),
             )
 
         return Period(self, freq=freq)
@@ -1065,10 +1349,7 @@ class Timestamp(_Timestamp):
     @classmethod
     def fromordinal(cls, ordinal, freq=None, tz=None):
         """
-        Timestamp.fromordinal(ordinal, freq=None, tz=None)
-
-        Passed an ordinal, translate and convert to a ts.
-        Note: by definition there cannot be any tz info on the ordinal itself.
+        Construct a timestamp from a a proleptic Gregorian ordinal.
 
         Parameters
         ----------
@@ -1079,6 +1360,10 @@ class Timestamp(_Timestamp):
         tz : str, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for the Timestamp.
 
+        Notes
+        -----
+        By definition there cannot be any tz info on the ordinal itself.
+
         Examples
         --------
         >>> pd.Timestamp.fromordinal(737425)
@@ -1090,10 +1375,7 @@ class Timestamp(_Timestamp):
     @classmethod
     def now(cls, tz=None):
         """
-        Timestamp.now(tz=None)
-
-        Return new Timestamp object representing current time local to
-        tz.
+        Return new Timestamp object representing current time local to tz.
 
         Parameters
         ----------
@@ -1117,10 +1399,9 @@ class Timestamp(_Timestamp):
     @classmethod
     def today(cls, tz=None):
         """
-        Timestamp.today(cls, tz=None)
+        Return the current time in the local timezone.
 
-        Return the current time in the local timezone.  This differs
-        from datetime.today() in that it can be localized to a
+        This differs from datetime.today() in that it can be localized to a
         passed timezone.
 
         Parameters
@@ -1174,7 +1455,7 @@ class Timestamp(_Timestamp):
             "Timestamp.utcfromtimestamp(ts).tz_localize(None). "
             "To get the future behavior, use Timestamp.fromtimestamp(ts, 'UTC')",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return cls(datetime.utcfromtimestamp(ts))
 
@@ -1197,10 +1478,7 @@ class Timestamp(_Timestamp):
 
     def strftime(self, format):
         """
-        Timestamp.strftime(format)
-
-        Return a string representing the given POSIX timestamp
-        controlled by an explicit format string.
+        Return a formatted string of the Timestamp.
 
         Parameters
         ----------
@@ -1295,6 +1573,27 @@ class Timestamp(_Timestamp):
             # GH#17690 tzinfo must be a datetime.tzinfo object, ensured
             #  by the cython annotation.
             if tz is not None:
+                if (is_integer_object(tz)
+                    and is_integer_object(ts_input)
+                    and is_integer_object(freq)
+                ):
+                    # GH#31929 e.g. Timestamp(2019, 3, 4, 5, 6, tzinfo=foo)
+                    # TODO(GH#45307): this will still be fragile to
+                    #  mixed-and-matched positional/keyword arguments
+                    ts_input = datetime(
+                        ts_input,
+                        freq,
+                        tz,
+                        unit or 0,
+                        year or 0,
+                        month or 0,
+                        day or 0,
+                        fold=fold or 0,
+                    )
+                    nanosecond = hour
+                    tz = tzinfo
+                    return cls(ts_input, nanosecond=nanosecond, tz=tz)
+
                 raise ValueError('Can provide at most one of tz, tzinfo')
 
             # User passed tzinfo instead of tz; avoid silently ignoring
@@ -1392,7 +1691,7 @@ class Timestamp(_Timestamp):
                 "as a wall time, not a UTC time.  To interpret as a UTC time, "
                 "use `Timestamp(dt64).tz_localize('UTC').tz_convert(tz)`",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
             # Once this deprecation is enforced, we can do
             #  return Timestamp(ts_input).tz_localize(tzobj)
@@ -1409,7 +1708,7 @@ class Timestamp(_Timestamp):
                 "The 'freq' argument in Timestamp is deprecated and will be "
                 "removed in a future version.",
                 FutureWarning,
-                stacklevel=1,
+                stacklevel=find_stack_level(),
             )
             if not is_offset_object(freq):
                 freq = to_offset(freq)
@@ -1418,7 +1717,10 @@ class Timestamp(_Timestamp):
 
     def _round(self, freq, mode, ambiguous='raise', nonexistent='raise'):
         cdef:
-            int64_t nanos = to_offset(freq).nanos
+            int64_t nanos
+
+        to_offset(freq).nanos  # raises on non-fixed freq
+        nanos = delta_to_nanoseconds(to_offset(freq), self._reso)
 
         if self.tz is not None:
             value = self.tz_localize(None).value
@@ -1429,7 +1731,7 @@ class Timestamp(_Timestamp):
 
         # Will only ever contain 1 element for timestamp
         r = round_nsint64(value, mode, nanos)[0]
-        result = Timestamp(r, unit='ns')
+        result = Timestamp._from_value_and_reso(r, self._reso, None)
         if self.tz is not None:
             result = result.tz_localize(
                 self.tz, ambiguous=ambiguous, nonexistent=nonexistent
@@ -1742,13 +2044,15 @@ timedelta}, default 'raise'
         warnings.warn(
             "Timestamp.freqstr is deprecated and will be removed in a future version.",
             FutureWarning,
-            stacklevel=1,
+            stacklevel=find_stack_level(),
         )
         return self._freqstr
 
     def tz_localize(self, tz, ambiguous='raise', nonexistent='raise'):
         """
-        Convert naive Timestamp to local time zone, or remove
+        Localize the Timestamp to a timezone.
+
+        Convert naive Timestamp to local time zone or remove
         timezone from timezone-aware Timestamp.
 
         Parameters
@@ -1832,23 +2136,21 @@ default 'raise'
                 ambiguous = [ambiguous]
             value = tz_localize_to_utc_single(self.value, tz,
                                               ambiguous=ambiguous,
-                                              nonexistent=nonexistent)
-            out = Timestamp(value, tz=tz)
-            if out is not NaT:
-                out._set_freq(self._freq)  # avoid warning in constructor
-            return out
+                                              nonexistent=nonexistent,
+                                              reso=self._reso)
+        elif tz is None:
+            # reset tz
+            value = tz_convert_from_utc_single(self.value, self.tz, reso=self._reso)
+
         else:
-            if tz is None:
-                # reset tz
-                value = tz_convert_from_utc_single(self.value, self.tz)
-                out = Timestamp(value, tz=tz)
-                if out is not NaT:
-                    out._set_freq(self._freq)  # avoid warning in constructor
-                return out
-            else:
-                raise TypeError(
-                    "Cannot localize tz-aware Timestamp, use tz_convert for conversions"
-                )
+            raise TypeError(
+                "Cannot localize tz-aware Timestamp, use tz_convert for conversions"
+            )
+
+        out = type(self)._from_value_and_reso(value, self._reso, tz=tz)
+        if out is not NaT:
+            out._set_freq(self._freq)  # avoid warning in constructor
+        return out
 
     def tz_convert(self, tz):
         """
@@ -1899,7 +2201,8 @@ default 'raise'
             )
         else:
             # Same UTC timestamp, different time zone
-            out = Timestamp(self.value, tz=tz)
+            tz = maybe_get_tz(tz)
+            out = type(self)._from_value_and_reso(self.value, reso=self._reso, tz=tz)
             if out is not NaT:
                 out._set_freq(self._freq)  # avoid warning in constructor
             return out
@@ -1980,10 +2283,10 @@ default 'raise'
             fold = self.fold
 
         if tzobj is not None:
-            value = tz_convert_from_utc_single(value, tzobj)
+            value = tz_convert_from_utc_single(value, tzobj, reso=self._reso)
 
         # setup components
-        dt64_to_dtstruct(value, &dts)
+        pandas_datetime_to_datetimestruct(value, self._reso, &dts)
         dts.ps = self.nanosecond * 1000
 
         # replace
@@ -2030,16 +2333,17 @@ default 'raise'
                       'fold': fold}
             ts_input = datetime(**kwargs)
 
-        ts = convert_datetime_to_tsobject(ts_input, tzobj)
-        value = ts.value + (dts.ps // 1000)
-        if value != NPY_NAT:
-            check_dts_bounds(&dts)
-
-        return create_timestamp_from_ts(value, dts, tzobj, self._freq, fold)
+        ts = convert_datetime_to_tsobject(
+            ts_input, tzobj, nanos=dts.ps // 1000, reso=self._reso
+        )
+        return create_timestamp_from_ts(
+            ts.value, dts, tzobj, self._freq, fold, reso=self._reso
+        )
 
     def to_julian_date(self) -> np.float64:
         """
         Convert TimeStamp to a Julian Date.
+
         0 Julian date is noon January 1, 4713 BC.
 
         Examples
@@ -2071,27 +2375,46 @@ default 'raise'
     def isoweekday(self):
         """
         Return the day of the week represented by the date.
+
         Monday == 1 ... Sunday == 7.
         """
-        return super().isoweekday()
+        # same as super().isoweekday(), but that breaks because of how
+        #  we have overriden year, see note in create_timestamp_from_ts
+        return self.weekday() + 1
 
     def weekday(self):
         """
         Return the day of the week represented by the date.
+
         Monday == 0 ... Sunday == 6.
         """
-        return super().weekday()
+        # same as super().weekday(), but that breaks because of how
+        #  we have overriden year, see note in create_timestamp_from_ts
+        return ccalendar.dayofweek(self.year, self.month, self.day)
 
 
 # Aliases
 Timestamp.weekofyear = Timestamp.week
 Timestamp.daysinmonth = Timestamp.days_in_month
 
-# Add the min and max fields at the class level
-cdef int64_t _NS_UPPER_BOUND = np.iinfo(np.int64).max
-cdef int64_t _NS_LOWER_BOUND = NPY_NAT + 1
 
-# Resolution is in nanoseconds
-Timestamp.min = Timestamp(_NS_LOWER_BOUND)
-Timestamp.max = Timestamp(_NS_UPPER_BOUND)
-Timestamp.resolution = Timedelta(nanoseconds=1)  # GH#21336, GH#21365
+# ----------------------------------------------------------------------
+# Scalar analogues to functions in vectorized.pyx
+
+
+@cython.cdivision(False)
+cdef inline int64_t normalize_i8_stamp(int64_t local_val, int64_t ppd) nogil:
+    """
+    Round the localized nanosecond timestamp down to the previous midnight.
+
+    Parameters
+    ----------
+    local_val : int64_t
+    ppd : int64_t
+        Periods per day in the Timestamp's resolution.
+
+    Returns
+    -------
+    int64_t
+    """
+    return local_val - (local_val % ppd)
diff --git a/pandas/_libs/tslibs/timezones.pxd b/pandas/_libs/tslibs/timezones.pxd
index 13f196a567952..c1a4e2bd5e1ac 100644
--- a/pandas/_libs/tslibs/timezones.pxd
+++ b/pandas/_libs/tslibs/timezones.pxd
@@ -9,6 +9,7 @@ cdef tzinfo utc_pytz
 
 cpdef bint is_utc(tzinfo tz)
 cdef bint is_tzlocal(tzinfo tz)
+cdef bint is_zoneinfo(tzinfo tz)
 
 cdef bint treat_tz_as_pytz(tzinfo tz)
 
@@ -17,6 +18,6 @@ cpdef object get_timezone(tzinfo tz)
 cpdef tzinfo maybe_get_tz(object tz)
 
 cdef timedelta get_utcoffset(tzinfo tz, datetime obj)
-cdef bint is_fixed_offset(tzinfo tz)
+cpdef bint is_fixed_offset(tzinfo tz)
 
 cdef object get_dst_info(tzinfo tz)
diff --git a/pandas/_libs/tslibs/timezones.pyi b/pandas/_libs/tslibs/timezones.pyi
index 20c403e93b149..4e9f0c6ae6c33 100644
--- a/pandas/_libs/tslibs/timezones.pyi
+++ b/pandas/_libs/tslibs/timezones.pyi
@@ -6,8 +6,6 @@ from typing import Callable
 
 import numpy as np
 
-from pandas._typing import npt
-
 # imported from dateutil.tz
 dateutil_gettz: Callable[[str], tzinfo]
 
@@ -17,9 +15,7 @@ def infer_tzinfo(
     start: datetime | None,
     end: datetime | None,
 ) -> tzinfo | None: ...
-def get_dst_info(
-    tz: tzinfo,
-) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64], str]: ...
 def maybe_get_tz(tz: str | int | np.int64 | tzinfo | None) -> tzinfo | None: ...
 def get_timezone(tz: tzinfo) -> tzinfo | str: ...
 def is_utc(tz: tzinfo | None) -> bool: ...
+def is_fixed_offset(tz: tzinfo) -> bool: ...
diff --git a/pandas/_libs/tslibs/timezones.pyx b/pandas/_libs/tslibs/timezones.pyx
index 224c5be1f3b7d..abf8bbc5ca5b9 100644
--- a/pandas/_libs/tslibs/timezones.pyx
+++ b/pandas/_libs/tslibs/timezones.pyx
@@ -3,6 +3,16 @@ from datetime import (
     timezone,
 )
 
+from pandas.compat._optional import import_optional_dependency
+
+try:
+    # py39+
+    import zoneinfo
+    from zoneinfo import ZoneInfo
+except ImportError:
+    zoneinfo = None
+    ZoneInfo = None
+
 from cpython.datetime cimport (
     datetime,
     timedelta,
@@ -42,18 +52,46 @@ cdef tzinfo utc_stdlib = timezone.utc
 cdef tzinfo utc_pytz = UTC
 cdef tzinfo utc_dateutil_str = dateutil_gettz("UTC")  # NB: *not* the same as tzutc()
 
+cdef tzinfo utc_zoneinfo = None
+
 
 # ----------------------------------------------------------------------
 
+cdef inline bint is_utc_zoneinfo(tzinfo tz):
+    # Workaround for cases with missing tzdata
+    #  https://github.com/pandas-dev/pandas/pull/46425#discussion_r830633025
+    if tz is None or zoneinfo is None:
+        return False
+
+    global utc_zoneinfo
+    if utc_zoneinfo is None:
+        try:
+            utc_zoneinfo = ZoneInfo("UTC")
+        except zoneinfo.ZoneInfoNotFoundError:
+            return False
+        # Warn if tzdata is too old, even if there is a system tzdata to alert
+        # users about the mismatch between local/system tzdata
+        import_optional_dependency("tzdata", errors="warn", min_version="2022.1")
+
+    return tz is utc_zoneinfo
+
+
 cpdef inline bint is_utc(tzinfo tz):
     return (
         tz is utc_pytz
         or tz is utc_stdlib
         or isinstance(tz, _dateutil_tzutc)
         or tz is utc_dateutil_str
+        or is_utc_zoneinfo(tz)
     )
 
 
+cdef inline bint is_zoneinfo(tzinfo tz):
+    if ZoneInfo is None:
+        return False
+    return isinstance(tz, ZoneInfo)
+
+
 cdef inline bint is_tzlocal(tzinfo tz):
     return isinstance(tz, _dateutil_tzlocal)
 
@@ -198,7 +236,7 @@ cdef timedelta get_utcoffset(tzinfo tz, datetime obj):
         return tz.utcoffset(obj)
 
 
-cdef inline bint is_fixed_offset(tzinfo tz):
+cpdef inline bint is_fixed_offset(tzinfo tz):
     if treat_tz_as_dateutil(tz):
         if len(tz._trans_idx) == 0 and len(tz._trans_list) == 0:
             return 1
@@ -210,6 +248,8 @@ cdef inline bint is_fixed_offset(tzinfo tz):
             return 1
         else:
             return 0
+    elif is_zoneinfo(tz):
+        return 0
     # This also implicitly accepts datetime.timezone objects which are
     # considered fixed
     return 1
@@ -230,10 +270,10 @@ cdef object _get_utc_trans_times_from_dateutil_tz(tzinfo tz):
     return new_trans
 
 
-cdef int64_t[:] unbox_utcoffsets(object transinfo):
+cdef int64_t[::1] unbox_utcoffsets(object transinfo):
     cdef:
         Py_ssize_t i, sz
-        int64_t[:] arr
+        int64_t[::1] arr
 
     sz = len(transinfo)
     arr = np.empty(sz, dtype='i8')
@@ -264,6 +304,8 @@ cdef object get_dst_info(tzinfo tz):
         # e.g. pytz.FixedOffset, matplotlib.dates._UTC,
         # psycopg2.tz.FixedOffsetTimezone
         num = int(get_utcoffset(tz, None).total_seconds()) * 1_000_000_000
+        # If we have e.g. ZoneInfo here, the get_utcoffset call will return None,
+        #  so the total_seconds() call will raise AttributeError.
         return (np.array([NPY_NAT + 1], dtype=np.int64),
                 np.array([num], dtype=np.int64),
                 "unknown")
@@ -291,13 +333,13 @@ cdef object get_dst_info(tzinfo tz):
                 # deltas
                 deltas = np.array([v.offset for v in (
                     tz._ttinfo_before,) + tz._trans_idx], dtype='i8')
-                deltas *= 1000000000
+                deltas *= 1_000_000_000
                 typ = 'dateutil'
 
             elif is_fixed_offset(tz):
                 trans = np.array([NPY_NAT + 1], dtype=np.int64)
                 deltas = np.array([tz._ttinfo_std.offset],
-                                  dtype='i8') * 1000000000
+                                  dtype='i8') * 1_000_000_000
                 typ = 'fixed'
             else:
                 # 2018-07-12 this is not reached in the tests, and this case
diff --git a/pandas/_libs/tslibs/tzconversion.pxd b/pandas/_libs/tslibs/tzconversion.pxd
index 3666d00707ac8..13735fb5945a4 100644
--- a/pandas/_libs/tslibs/tzconversion.pxd
+++ b/pandas/_libs/tslibs/tzconversion.pxd
@@ -1,11 +1,39 @@
 from cpython.datetime cimport tzinfo
-from numpy cimport int64_t
+from numpy cimport (
+    int64_t,
+    intp_t,
+    ndarray,
+)
 
+from pandas._libs.tslibs.np_datetime cimport NPY_DATETIMEUNIT
 
-cdef int64_t tz_convert_utc_to_tzlocal(
-    int64_t utc_val, tzinfo tz, bint* fold=*
+
+cpdef int64_t tz_convert_from_utc_single(
+    int64_t utc_val, tzinfo tz, NPY_DATETIMEUNIT reso=*
 ) except? -1
-cpdef int64_t tz_convert_from_utc_single(int64_t val, tzinfo tz)
 cdef int64_t tz_localize_to_utc_single(
-    int64_t val, tzinfo tz, object ambiguous=*, object nonexistent=*
+    int64_t val,
+    tzinfo tz,
+    object ambiguous=*,
+    object nonexistent=*,
+    NPY_DATETIMEUNIT reso=*,
 ) except? -1
+
+
+cdef class Localizer:
+    cdef:
+        tzinfo tz
+        NPY_DATETIMEUNIT _reso
+        bint use_utc, use_fixed, use_tzlocal, use_dst, use_pytz
+        ndarray trans
+        Py_ssize_t ntrans
+        const int64_t[::1] deltas
+        int64_t delta
+        int64_t* tdata
+
+    cdef inline int64_t utc_val_to_local_val(
+        self,
+        int64_t utc_val,
+        Py_ssize_t* pos,
+        bint* fold=?,
+    ) except? -1
diff --git a/pandas/_libs/tslibs/tzconversion.pyi b/pandas/_libs/tslibs/tzconversion.pyi
index e1a0263cf59ef..fab73f96b0dfb 100644
--- a/pandas/_libs/tslibs/tzconversion.pyi
+++ b/pandas/_libs/tslibs/tzconversion.pyi
@@ -8,14 +8,14 @@ import numpy as np
 
 from pandas._typing import npt
 
-def tz_convert_from_utc(
-    vals: npt.NDArray[np.int64],  # const int64_t[:]
-    tz: tzinfo,
-) -> npt.NDArray[np.int64]: ...
-def tz_convert_from_utc_single(val: np.int64, tz: tzinfo) -> np.int64: ...
+# tz_convert_from_utc_single exposed for testing
+def tz_convert_from_utc_single(
+    val: np.int64, tz: tzinfo, reso: int = ...
+) -> np.int64: ...
 def tz_localize_to_utc(
     vals: npt.NDArray[np.int64],
     tz: tzinfo | None,
     ambiguous: str | bool | Iterable[bool] | None = ...,
     nonexistent: str | timedelta | np.timedelta64 | None = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.int64]: ...
diff --git a/pandas/_libs/tslibs/tzconversion.pyx b/pandas/_libs/tslibs/tzconversion.pyx
index d28b851d0fbc1..4487136aa7fb8 100644
--- a/pandas/_libs/tslibs/tzconversion.pyx
+++ b/pandas/_libs/tslibs/tzconversion.pyx
@@ -1,20 +1,19 @@
 """
 timezone conversion
 """
-import cython
-from cython import Py_ssize_t
-
+cimport cython
 from cpython.datetime cimport (
-    PyDateTime_IMPORT,
     PyDelta_Check,
     datetime,
+    datetime_new,
+    import_datetime,
     timedelta,
     tzinfo,
 )
+from cython cimport Py_ssize_t
 
-PyDateTime_IMPORT
+import_datetime()
 
-from dateutil.tz import tzutc
 import numpy as np
 import pytz
 
@@ -28,46 +27,149 @@ from numpy cimport (
 
 cnp.import_array()
 
-from pandas._libs.tslibs.ccalendar cimport (
-    DAY_NANOS,
-    HOUR_NANOS,
+from pandas._libs.tslibs.dtypes cimport (
+    periods_per_day,
+    periods_per_second,
 )
 from pandas._libs.tslibs.nattype cimport NPY_NAT
 from pandas._libs.tslibs.np_datetime cimport (
-    dt64_to_dtstruct,
+    NPY_DATETIMEUNIT,
     npy_datetimestruct,
+    pandas_datetime_to_datetimestruct,
 )
 from pandas._libs.tslibs.timezones cimport (
     get_dst_info,
-    get_utcoffset,
     is_fixed_offset,
     is_tzlocal,
     is_utc,
+    is_zoneinfo,
+    utc_pytz,
 )
 
 
+cdef const int64_t[::1] _deltas_placeholder = np.array([], dtype=np.int64)
+
+
+@cython.freelist(16)
+@cython.final
+cdef class Localizer:
+    # cdef:
+    #    tzinfo tz
+    #    NPY_DATETIMEUNIT _reso
+    #    bint use_utc, use_fixed, use_tzlocal, use_dst, use_pytz
+    #    ndarray trans
+    #    Py_ssize_t ntrans
+    #    const int64_t[::1] deltas
+    #    int64_t delta
+    #    int64_t* tdata
+
+    @cython.initializedcheck(False)
+    @cython.boundscheck(False)
+    def __cinit__(self, tzinfo tz, NPY_DATETIMEUNIT reso):
+        self.tz = tz
+        self._reso = reso
+        self.use_utc = self.use_tzlocal = self.use_fixed = False
+        self.use_dst = self.use_pytz = False
+        self.ntrans = -1  # placeholder
+        self.delta = -1  # placeholder
+        self.deltas = _deltas_placeholder
+        self.tdata = NULL
+
+        if is_utc(tz) or tz is None:
+            self.use_utc = True
+
+        elif is_tzlocal(tz) or is_zoneinfo(tz):
+            self.use_tzlocal = True
+
+        else:
+            trans, deltas, typ = get_dst_info(tz)
+            if reso != NPY_DATETIMEUNIT.NPY_FR_ns:
+                # NB: using floordiv here is implicitly assuming we will
+                #  never see trans or deltas that are not an integer number
+                #  of seconds.
+                # TODO: avoid these np.array calls
+                if reso == NPY_DATETIMEUNIT.NPY_FR_us:
+                    trans = np.array(trans) // 1_000
+                    deltas = np.array(deltas) // 1_000
+                elif reso == NPY_DATETIMEUNIT.NPY_FR_ms:
+                    trans = np.array(trans) // 1_000_000
+                    deltas = np.array(deltas) // 1_000_000
+                elif reso == NPY_DATETIMEUNIT.NPY_FR_s:
+                    trans = np.array(trans) // 1_000_000_000
+                    deltas = np.array(deltas) // 1_000_000_000
+                else:
+                    raise NotImplementedError(reso)
+
+            self.trans = trans
+            self.ntrans = self.trans.shape[0]
+            self.deltas = deltas
+
+            if typ != "pytz" and typ != "dateutil":
+                # static/fixed; in this case we know that len(delta) == 1
+                self.use_fixed = True
+                self.delta = deltas[0]
+            else:
+                self.use_dst = True
+                if typ == "pytz":
+                    self.use_pytz = True
+                self.tdata = <int64_t*>cnp.PyArray_DATA(trans)
+
+    @cython.boundscheck(False)
+    cdef inline int64_t utc_val_to_local_val(
+        self, int64_t utc_val, Py_ssize_t* pos, bint* fold=NULL
+    ) except? -1:
+        if self.use_utc:
+            return utc_val
+        elif self.use_tzlocal:
+            return utc_val + _tz_localize_using_tzinfo_api(
+                utc_val, self.tz, to_utc=False, reso=self._reso, fold=fold
+            )
+        elif self.use_fixed:
+            return utc_val + self.delta
+        else:
+            pos[0] = bisect_right_i8(self.tdata, utc_val, self.ntrans) - 1
+            if fold is not NULL:
+                fold[0] = _infer_dateutil_fold(
+                    utc_val, self.trans, self.deltas, pos[0]
+                )
+
+            return utc_val + self.deltas[pos[0]]
+
+
 cdef int64_t tz_localize_to_utc_single(
-    int64_t val, tzinfo tz, object ambiguous=None, object nonexistent=None,
+    int64_t val,
+    tzinfo tz,
+    object ambiguous=None,
+    object nonexistent=None,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
 ) except? -1:
     """See tz_localize_to_utc.__doc__"""
     cdef:
         int64_t delta
-        int64_t[:] deltas
+        int64_t[::1] deltas
 
     if val == NPY_NAT:
         return val
 
     elif is_utc(tz) or tz is None:
+        # TODO: test with non-nano
         return val
 
-    elif is_tzlocal(tz):
-        return _tz_convert_tzlocal_utc(val, tz, to_utc=True)
+    elif is_tzlocal(tz) or is_zoneinfo(tz):
+        return val - _tz_localize_using_tzinfo_api(val, tz, to_utc=True, reso=reso)
 
     elif is_fixed_offset(tz):
-        # TODO: in this case we should be able to use get_utcoffset,
-        #  that returns None for e.g. 'dateutil//usr/share/zoneinfo/Etc/GMT-9'
         _, deltas, _ = get_dst_info(tz)
         delta = deltas[0]
+        # TODO: de-duplicate with Localizer.__init__
+        if reso != NPY_DATETIMEUNIT.NPY_FR_ns:
+            if reso == NPY_DATETIMEUNIT.NPY_FR_us:
+                delta = delta // 1000
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_ms:
+                delta = delta // 1_000_000
+            elif reso == NPY_DATETIMEUNIT.NPY_FR_s:
+                delta = delta // 1_000_000_000
+
         return val - delta
 
     else:
@@ -76,13 +178,19 @@ cdef int64_t tz_localize_to_utc_single(
             tz,
             ambiguous=ambiguous,
             nonexistent=nonexistent,
+            reso=reso,
         )[0]
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def tz_localize_to_utc(ndarray[int64_t] vals, tzinfo tz, object ambiguous=None,
-                       object nonexistent=None):
+def tz_localize_to_utc(
+    ndarray[int64_t] vals,
+    tzinfo tz,
+    object ambiguous=None,
+    object nonexistent=None,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
+):
     """
     Localize tzinfo-naive i8 to given time zone (using pytz). If
     there are ambiguities in the values, raise AmbiguousTimeError.
@@ -109,43 +217,55 @@ def tz_localize_to_utc(ndarray[int64_t] vals, tzinfo tz, object ambiguous=None,
     nonexistent : {None, "NaT", "shift_forward", "shift_backward", "raise", \
 timedelta-like}
         How to handle non-existent times when converting wall times to UTC
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
     localized : ndarray[int64_t]
     """
     cdef:
-        int64_t[:] deltas, idx_shifted, idx_shifted_left, idx_shifted_right
-        ndarray[uint8_t, cast=True] ambiguous_array, both_nat, both_eq
-        Py_ssize_t i, idx, pos, ntrans, n = len(vals)
+        ndarray[uint8_t, cast=True] ambiguous_array
+        Py_ssize_t i, idx, pos, n = vals.shape[0]
         Py_ssize_t delta_idx_offset, delta_idx, pos_left, pos_right
-        int64_t *tdata
-        int64_t v, left, right, val, v_left, v_right, new_local, remaining_mins
-        int64_t first_delta
+        int64_t v, left, right, val, new_local, remaining_mins
+        int64_t first_delta, delta
         int64_t shift_delta = 0
-        ndarray[int64_t] trans, result, result_a, result_b, dst_hours, delta
-        ndarray trans_idx, grp, a_idx, b_idx, one_diff
+        ndarray[int64_t] result_a, result_b, dst_hours
+        int64_t[::1] result
         npy_datetimestruct dts
         bint infer_dst = False, is_dst = False, fill = False
         bint shift_forward = False, shift_backward = False
         bint fill_nonexist = False
-        list trans_grp
         str stamp
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t pph = periods_per_day(reso) // 24
 
     # Vectorized version of DstTzInfo.localize
-    if is_utc(tz) or tz is None:
-        return vals
+    if info.use_utc:
+        return vals.copy()
 
-    result = np.empty(n, dtype=np.int64)
+    result = cnp.PyArray_EMPTY(vals.ndim, vals.shape, cnp.NPY_INT64, 0)
+
+    if info.use_tzlocal:
+        for i in range(n):
+            v = vals[i]
+            if v == NPY_NAT:
+                result[i] = NPY_NAT
+            else:
+                result[i] = v - _tz_localize_using_tzinfo_api(
+                    v, tz, to_utc=True, reso=reso
+                )
+        return result.base  # to return underlying ndarray
 
-    if is_tzlocal(tz):
+    elif info.use_fixed:
+        delta = info.delta
         for i in range(n):
             v = vals[i]
             if v == NPY_NAT:
                 result[i] = NPY_NAT
             else:
-                result[i] = _tz_convert_tzlocal_utc(v, tz, to_utc=True)
-        return result
+                result[i] = v - delta
+        return result.base  # to return underlying ndarray
 
     # silence false-positive compiler warning
     ambiguous_array = np.empty(0, dtype=bool)
@@ -175,102 +295,50 @@ timedelta-like}
         shift_backward = True
     elif PyDelta_Check(nonexistent):
         from .timedeltas import delta_to_nanoseconds
-        shift_delta = delta_to_nanoseconds(nonexistent)
+        shift_delta = delta_to_nanoseconds(nonexistent, reso=reso)
     elif nonexistent not in ('raise', None):
         msg = ("nonexistent must be one of {'NaT', 'raise', 'shift_forward', "
                "shift_backwards} or a timedelta object")
         raise ValueError(msg)
 
-    trans, deltas, _ = get_dst_info(tz)
-
-    tdata = <int64_t*>cnp.PyArray_DATA(trans)
-    ntrans = len(trans)
-
     # Determine whether each date lies left of the DST transition (store in
     # result_a) or right of the DST transition (store in result_b)
-    result_a = np.empty(n, dtype=np.int64)
-    result_b = np.empty(n, dtype=np.int64)
-    result_a[:] = NPY_NAT
-    result_b[:] = NPY_NAT
-
-    idx_shifted_left = (np.maximum(0, trans.searchsorted(
-        vals - DAY_NANOS, side='right') - 1)).astype(np.int64)
-
-    idx_shifted_right = (np.maximum(0, trans.searchsorted(
-        vals + DAY_NANOS, side='right') - 1)).astype(np.int64)
-
-    for i in range(n):
-        val = vals[i]
-        v_left = val - deltas[idx_shifted_left[i]]
-        pos_left = bisect_right_i8(tdata, v_left, ntrans) - 1
-        # timestamp falls to the left side of the DST transition
-        if v_left + deltas[pos_left] == val:
-            result_a[i] = v_left
-
-        v_right = val - deltas[idx_shifted_right[i]]
-        pos_right = bisect_right_i8(tdata, v_right, ntrans) - 1
-        # timestamp falls to the right side of the DST transition
-        if v_right + deltas[pos_right] == val:
-            result_b[i] = v_right
+    result_a, result_b =_get_utc_bounds(
+        vals, info.tdata, info.ntrans, info.deltas, reso=reso
+    )
 
     # silence false-positive compiler warning
     dst_hours = np.empty(0, dtype=np.int64)
     if infer_dst:
-        dst_hours = np.empty(n, dtype=np.int64)
-        dst_hours[:] = NPY_NAT
-
-        # Get the ambiguous hours (given the above, these are the hours
-        # where result_a != result_b and neither of them are NAT)
-        both_nat = np.logical_and(result_a != NPY_NAT, result_b != NPY_NAT)
-        both_eq = result_a == result_b
-        trans_idx = np.squeeze(np.nonzero(np.logical_and(both_nat, ~both_eq)))
-        if trans_idx.size == 1:
-            stamp = _render_tstamp(vals[trans_idx])
-            raise pytz.AmbiguousTimeError(
-                f"Cannot infer dst time from {stamp} as there "
-                f"are no repeated times")
-        # Split the array into contiguous chunks (where the difference between
-        # indices is 1).  These are effectively dst transitions in different
-        # years which is useful for checking that there is not an ambiguous
-        # transition in an individual year.
-        if trans_idx.size > 0:
-            one_diff = np.where(np.diff(trans_idx) != 1)[0] + 1
-            trans_grp = np.array_split(trans_idx, one_diff)
-
-            # Iterate through each day, if there are no hours where the
-            # delta is negative (indicates a repeat of hour) the switch
-            # cannot be inferred
-            for grp in trans_grp:
-
-                delta = np.diff(result_a[grp])
-                if grp.size == 1 or np.all(delta > 0):
-                    stamp = _render_tstamp(vals[grp[0]])
-                    raise pytz.AmbiguousTimeError(stamp)
-
-                # Find the index for the switch and pull from a for dst and b
-                # for standard
-                switch_idx = (delta <= 0).nonzero()[0]
-                if switch_idx.size > 1:
-                    raise pytz.AmbiguousTimeError(
-                        f"There are {switch_idx.size} dst switches when "
-                        f"there should only be 1.")
-                switch_idx = switch_idx[0] + 1
-                # Pull the only index and adjust
-                a_idx = grp[:switch_idx]
-                b_idx = grp[switch_idx:]
-                dst_hours[grp] = np.hstack((result_a[a_idx], result_b[b_idx]))
+        dst_hours = _get_dst_hours(vals, result_a, result_b, reso=reso)
+
+    # Pre-compute delta_idx_offset that will be used if we go down non-existent
+    #  paths.
+    # Shift the delta_idx by if the UTC offset of
+    # the target tz is greater than 0 and we're moving forward
+    # or vice versa
+    first_delta = info.deltas[0]
+    if (shift_forward or shift_delta > 0) and first_delta > 0:
+        delta_idx_offset = 1
+    elif (shift_backward or shift_delta < 0) and first_delta < 0:
+        delta_idx_offset = 1
+    else:
+        delta_idx_offset = 0
 
     for i in range(n):
         val = vals[i]
         left = result_a[i]
         right = result_b[i]
         if val == NPY_NAT:
+            # TODO: test with non-nano
             result[i] = val
         elif left != NPY_NAT and right != NPY_NAT:
             if left == right:
+                # TODO: test with non-nano
                 result[i] = left
             else:
                 if infer_dst and dst_hours[i] != NPY_NAT:
+                    # TODO: test with non-nano
                     result[i] = dst_hours[i]
                 elif is_dst:
                     if ambiguous_array[i]:
@@ -278,71 +346,71 @@ timedelta-like}
                     else:
                         result[i] = right
                 elif fill:
+                    # TODO: test with non-nano; parametrize test_dt_round_tz_ambiguous
                     result[i] = NPY_NAT
                 else:
-                    stamp = _render_tstamp(val)
+                    stamp = _render_tstamp(val, reso=reso)
                     raise pytz.AmbiguousTimeError(
                         f"Cannot infer dst time from {stamp}, try using the "
-                        f"'ambiguous' argument")
+                        "'ambiguous' argument"
+                    )
         elif left != NPY_NAT:
             result[i] = left
         elif right != NPY_NAT:
+            # TODO: test with non-nano
             result[i] = right
         else:
             # Handle nonexistent times
             if shift_forward or shift_backward or shift_delta != 0:
                 # Shift the nonexistent time to the closest existing time
-                remaining_mins = val % HOUR_NANOS
+                remaining_mins = val % pph
                 if shift_delta != 0:
                     # Validate that we don't relocalize on another nonexistent
                     # time
-                    if -1 < shift_delta + remaining_mins < HOUR_NANOS:
+                    if -1 < shift_delta + remaining_mins < pph:
                         raise ValueError(
-                            f"The provided timedelta will relocalize on a "
+                            "The provided timedelta will relocalize on a "
                             f"nonexistent time: {nonexistent}"
                         )
                     new_local = val + shift_delta
                 elif shift_forward:
-                    new_local = val + (HOUR_NANOS - remaining_mins)
+                    new_local = val + (pph - remaining_mins)
                 else:
                     # Subtract 1 since the beginning hour is _inclusive_ of
                     # nonexistent times
                     new_local = val - remaining_mins - 1
-                delta_idx = trans.searchsorted(new_local, side='right')
-                # Shift the delta_idx by if the UTC offset of
-                # the target tz is greater than 0 and we're moving forward
-                # or vice versa
-                first_delta = deltas[0]
-                if (shift_forward or shift_delta > 0) and first_delta > 0:
-                    delta_idx_offset = 1
-                elif (shift_backward or shift_delta < 0) and first_delta < 0:
-                    delta_idx_offset = 1
-                else:
-                    delta_idx_offset = 0
+
+                delta_idx = bisect_right_i8(info.tdata, new_local, info.ntrans)
+
                 delta_idx = delta_idx - delta_idx_offset
-                result[i] = new_local - deltas[delta_idx]
+                result[i] = new_local - info.deltas[delta_idx]
             elif fill_nonexist:
                 result[i] = NPY_NAT
             else:
-                stamp = _render_tstamp(val)
+                stamp = _render_tstamp(val, reso=reso)
                 raise pytz.NonExistentTimeError(stamp)
 
-    return result
+    return result.base  # .base to get underlying ndarray
 
 
 cdef inline Py_ssize_t bisect_right_i8(int64_t *data,
                                        int64_t val, Py_ssize_t n):
+    # Caller is responsible for checking n > 0
+    # This looks very similar to local_search_right in the ndarray.searchsorted
+    #  implementation.
     cdef:
         Py_ssize_t pivot, left = 0, right = n
 
-    assert n >= 1
-
     # edge cases
     if val > data[n - 1]:
         return n
 
-    if val < data[0]:
-        return 0
+    # Caller is responsible for ensuring 'val >= data[0]'. This is
+    #  ensured by the fact that 'data' comes from get_dst_info where data[0]
+    #  is *always* NPY_NAT+1. If that ever changes, we will need to restore
+    #  the following disabled check.
+    # if val < data[0]:
+    #    return 0
 
     while left < right:
         pivot = left + (right - left) // 2
@@ -355,184 +423,207 @@ cdef inline Py_ssize_t bisect_right_i8(int64_t *data,
     return left
 
 
-cdef inline str _render_tstamp(int64_t val):
+cdef inline str _render_tstamp(int64_t val, NPY_DATETIMEUNIT reso):
     """ Helper function to render exception messages"""
     from pandas._libs.tslibs.timestamps import Timestamp
-    return str(Timestamp(val))
+    ts = Timestamp._from_value_and_reso(val, reso, None)
+    return str(ts)
 
 
-# ----------------------------------------------------------------------
-# Timezone Conversion
+cdef _get_utc_bounds(
+    ndarray vals,
+    int64_t* tdata,
+    Py_ssize_t ntrans,
+    const int64_t[::1] deltas,
+    NPY_DATETIMEUNIT reso,
+):
+    # Determine whether each date lies left of the DST transition (store in
+    # result_a) or right of the DST transition (store in result_b)
 
-cdef int64_t tz_convert_utc_to_tzlocal(
-    int64_t utc_val, tzinfo tz, bint* fold=NULL
-) except? -1:
-    """
-    Parameters
-    ----------
-    utc_val : int64_t
-    tz : tzinfo
-    fold : bint*
-        pointer to fold: whether datetime ends up in a fold or not
-        after adjustment
+    cdef:
+        ndarray result_a, result_b
+        Py_ssize_t i, n = vals.size
+        int64_t val, v_left, v_right
+        Py_ssize_t isl, isr, pos_left, pos_right
+        int64_t ppd = periods_per_day(reso)
 
-    Returns
-    -------
-    local_val : int64_t
-    """
-    return _tz_convert_tzlocal_utc(utc_val, tz, to_utc=False, fold=fold)
+    result_a = cnp.PyArray_EMPTY(vals.ndim, vals.shape, cnp.NPY_INT64, 0)
+    result_b = cnp.PyArray_EMPTY(vals.ndim, vals.shape, cnp.NPY_INT64, 0)
 
+    for i in range(n):
+        # This loops resembles the "Find the two best possibilities" block
+        #  in pytz's DstTZInfo.localize method.
+        result_a[i] = NPY_NAT
+        result_b[i] = NPY_NAT
 
-cpdef int64_t tz_convert_from_utc_single(int64_t val, tzinfo tz):
-    """
-    Convert the val (in i8) from UTC to tz
+        val = vals[i]
+        if val == NPY_NAT:
+            continue
 
-    This is a single value version of tz_convert_from_utc.
+        # TODO: be careful of overflow in val-ppd
+        isl = bisect_right_i8(tdata, val - ppd, ntrans) - 1
+        if isl < 0:
+            isl = 0
 
-    Parameters
-    ----------
-    val : int64
-    tz : tzinfo
+        v_left = val - deltas[isl]
+        pos_left = bisect_right_i8(tdata, v_left, ntrans) - 1
+        # timestamp falls to the left side of the DST transition
+        if v_left + deltas[pos_left] == val:
+            result_a[i] = v_left
 
-    Returns
-    -------
-    converted: int64
-    """
-    cdef:
-        int64_t delta
-        int64_t[:] deltas
-        ndarray[int64_t, ndim=1] trans
-        intp_t pos
+        # TODO: be careful of overflow in val+ppd
+        isr = bisect_right_i8(tdata, val + ppd, ntrans) - 1
+        if isr < 0:
+            isr = 0
 
-    if val == NPY_NAT:
-        return val
+        v_right = val - deltas[isr]
+        pos_right = bisect_right_i8(tdata, v_right, ntrans) - 1
+        # timestamp falls to the right side of the DST transition
+        if v_right + deltas[pos_right] == val:
+            result_b[i] = v_right
 
-    if is_utc(tz):
-        return val
-    elif is_tzlocal(tz):
-        return _tz_convert_tzlocal_utc(val, tz, to_utc=False)
-    elif is_fixed_offset(tz):
-        _, deltas, _ = get_dst_info(tz)
-        delta = deltas[0]
-        return val + delta
-    else:
-        trans, deltas, _ = get_dst_info(tz)
-        pos = trans.searchsorted(val, side="right") - 1
-        return val + deltas[pos]
+    return result_a, result_b
 
 
-def tz_convert_from_utc(const int64_t[:] vals, tzinfo tz):
-    """
-    Convert the values (in i8) from UTC to tz
+@cython.boundscheck(False)
+cdef ndarray[int64_t] _get_dst_hours(
+    # vals, reso only needed here to potential render an exception message
+    const int64_t[:] vals,
+    ndarray[int64_t] result_a,
+    ndarray[int64_t] result_b,
+    NPY_DATETIMEUNIT reso,
+):
+    cdef:
+        Py_ssize_t i, n = vals.shape[0]
+        ndarray[uint8_t, cast=True] mismatch
+        ndarray[int64_t] delta, dst_hours
+        ndarray[intp_t] switch_idxs, trans_idx, grp, a_idx, b_idx, one_diff
+        list trans_grp
+        intp_t switch_idx
+        int64_t left, right
 
-    Parameters
-    ----------
-    vals : int64 ndarray
-    tz : tzinfo
+    dst_hours = cnp.PyArray_EMPTY(result_a.ndim, result_a.shape, cnp.NPY_INT64, 0)
+    dst_hours[:] = NPY_NAT
 
-    Returns
-    -------
-    int64 ndarray of converted
-    """
-    cdef:
-        const int64_t[:] converted
+    mismatch = cnp.PyArray_ZEROS(result_a.ndim, result_a.shape, cnp.NPY_BOOL, 0)
 
-    if len(vals) == 0:
-        return np.array([], dtype=np.int64)
+    for i in range(n):
+        left = result_a[i]
+        right = result_b[i]
 
-    converted = _tz_convert_from_utc(vals, tz)
-    return np.array(converted, dtype=np.int64)
+        # Get the ambiguous hours (given the above, these are the hours
+        # where result_a != result_b and neither of them are NAT)
+        if left != right and left != NPY_NAT and right != NPY_NAT:
+            mismatch[i] = 1
+
+    trans_idx = mismatch.nonzero()[0]
+
+    if trans_idx.size == 1:
+        # see test_tz_localize_to_utc_ambiguous_infer
+        stamp = _render_tstamp(vals[trans_idx[0]], reso=reso)
+        raise pytz.AmbiguousTimeError(
+            f"Cannot infer dst time from {stamp} as there "
+            "are no repeated times"
+        )
+
+    # Split the array into contiguous chunks (where the difference between
+    # indices is 1).  These are effectively dst transitions in different
+    # years which is useful for checking that there is not an ambiguous
+    # transition in an individual year.
+    if trans_idx.size > 0:
+        one_diff = np.where(np.diff(trans_idx) != 1)[0] + 1
+        trans_grp = np.array_split(trans_idx, one_diff)
+
+        # Iterate through each day, if there are no hours where the
+        # delta is negative (indicates a repeat of hour) the switch
+        # cannot be inferred
+        for grp in trans_grp:
+
+            delta = np.diff(result_a[grp])
+            if grp.size == 1 or np.all(delta > 0):
+                # see test_tz_localize_to_utc_ambiguous_infer
+                stamp = _render_tstamp(vals[grp[0]], reso=reso)
+                raise pytz.AmbiguousTimeError(stamp)
+
+            # Find the index for the switch and pull from a for dst and b
+            # for standard
+            switch_idxs = (delta <= 0).nonzero()[0]
+            if switch_idxs.size > 1:
+                # see test_tz_localize_to_utc_ambiguous_infer
+                raise pytz.AmbiguousTimeError(
+                    f"There are {switch_idxs.size} dst switches when "
+                    "there should only be 1."
+                )
+
+            switch_idx = switch_idxs[0] + 1
+            # Pull the only index and adjust
+            a_idx = grp[:switch_idx]
+            b_idx = grp[switch_idx:]
+            dst_hours[grp] = np.hstack((result_a[a_idx], result_b[b_idx]))
+
+    return dst_hours
 
 
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef const int64_t[:] _tz_convert_from_utc(const int64_t[:] vals, tzinfo tz):
+# ----------------------------------------------------------------------
+# Timezone Conversion
+
+cpdef int64_t tz_convert_from_utc_single(
+    int64_t utc_val, tzinfo tz, NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns
+) except? -1:
     """
-    Convert the given values (in i8) either to UTC or from UTC.
+    Convert the val (in i8) from UTC to tz
+
+    This is a single value version of tz_convert_from_utc.
 
     Parameters
     ----------
-    vals : int64 ndarray
+    utc_val : int64
     tz : tzinfo
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
 
     Returns
     -------
-    converted : ndarray[int64_t]
+    converted: int64
     """
     cdef:
-        int64_t[:] converted, deltas
-        Py_ssize_t i, n = len(vals)
-        int64_t val, delta
-        intp_t[:] pos
-        ndarray[int64_t] trans
-        str typ
-
-    if is_utc(tz):
-        return vals
-    elif is_tzlocal(tz):
-        converted = np.empty(n, dtype=np.int64)
-        for i in range(n):
-            val = vals[i]
-            if val == NPY_NAT:
-                converted[i] = NPY_NAT
-            else:
-                converted[i] = _tz_convert_tzlocal_utc(val, tz, to_utc=False)
-    else:
-        converted = np.empty(n, dtype=np.int64)
+        Localizer info = Localizer(tz, reso=reso)
+        Py_ssize_t pos
 
-        trans, deltas, typ = get_dst_info(tz)
-
-        if typ not in ["pytz", "dateutil"]:
-            # FixedOffset, we know len(deltas) == 1
-            delta = deltas[0]
-
-            for i in range(n):
-                val = vals[i]
-                if val == NPY_NAT:
-                    converted[i] = val
-                else:
-                    converted[i] = val + delta
-
-        else:
-            pos = trans.searchsorted(vals, side="right") - 1
-
-            for i in range(n):
-                val = vals[i]
-                if val == NPY_NAT:
-                    converted[i] = val
-                else:
-                    if pos[i] < 0:
-                        # TODO: How is this reached?  Should we be checking for
-                        #  it elsewhere?
-                        raise ValueError("First time before start of DST info")
-
-                    converted[i] = val + deltas[pos[i]]
-
-    return converted
+    # Note: caller is responsible for ensuring utc_val != NPY_NAT
+    return info.utc_val_to_local_val(utc_val, &pos)
 
 
 # OSError may be thrown by tzlocal on windows at or close to 1970-01-01
 #  see https://github.com/pandas-dev/pandas/pull/37591#issuecomment-720628241
-cdef inline int64_t _tzlocal_get_offset_components(int64_t val, tzinfo tz,
-                                                   bint to_utc,
-                                                   bint *fold=NULL) except? -1:
+cdef int64_t _tz_localize_using_tzinfo_api(
+    int64_t val,
+    tzinfo tz,
+    bint to_utc=True,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_ns,
+    bint* fold=NULL,
+) except? -1:
     """
-    Calculate offset in nanoseconds needed to convert the i8 representation of
-    a datetime from a tzlocal timezone to UTC, or vice-versa.
+    Convert the i8 representation of a datetime from a general-case timezone to
+    UTC, or vice-versa using the datetime/tzinfo API.
+
+    Private, not intended for use outside of tslibs.tzconversion.
 
     Parameters
     ----------
     val : int64_t
     tz : tzinfo
     to_utc : bint
-        True if converting tzlocal _to_ UTC, False if going the other direction
+        True if converting _to_ UTC, False if going the other direction.
+    reso : NPY_DATETIMEUNIT
     fold : bint*, default NULL
         pointer to fold: whether datetime ends up in a fold or not
-        after adjustment
+        after adjustment.
+        Only passed with to_utc=False.
 
     Returns
     -------
     delta : int64_t
+        Value to add when converting from utc, subtract when converting to utc.
 
     Notes
     -----
@@ -543,57 +634,92 @@ cdef inline int64_t _tzlocal_get_offset_components(int64_t val, tzinfo tz,
         datetime dt
         int64_t delta
         timedelta td
+        int64_t pps = periods_per_second(reso)
 
-    dt64_to_dtstruct(val, &dts)
-    dt = datetime(dts.year, dts.month, dts.day, dts.hour,
-                  dts.min, dts.sec, dts.us)
-    # tz.utcoffset only makes sense if datetime
-    # is _wall time_, so if val is a UTC timestamp convert to wall time
+    pandas_datetime_to_datetimestruct(val, reso, &dts)
+
+    # datetime_new is cython-optimized constructor
     if not to_utc:
-        dt = dt.replace(tzinfo=tzutc())
-        dt = dt.astimezone(tz)
+        # tz.utcoffset only makes sense if datetime
+        # is _wall time_, so if val is a UTC timestamp convert to wall time
+        dt = _astimezone(dts, tz)
 
-    if fold is not NULL:
-        fold[0] = dt.fold
+        if fold is not NULL:
+            # NB: fold is only passed with to_utc=False
+            fold[0] = dt.fold
+    else:
+        dt = datetime_new(dts.year, dts.month, dts.day, dts.hour,
+                          dts.min, dts.sec, dts.us, None)
 
     td = tz.utcoffset(dt)
-    return int(td.total_seconds() * 1_000_000_000)
+    delta = int(td.total_seconds() * pps)
+    return delta
 
 
-# OSError may be thrown by tzlocal on windows at or close to 1970-01-01
-#  see https://github.com/pandas-dev/pandas/pull/37591#issuecomment-720628241
-cdef int64_t _tz_convert_tzlocal_utc(int64_t val, tzinfo tz, bint to_utc=True,
-                                     bint* fold=NULL) except? -1:
+cdef datetime _astimezone(npy_datetimestruct dts, tzinfo tz):
+    """
+    Optimized equivalent to:
+
+    dt = datetime(dts.year, dts.month, dts.day, dts.hour,
+                  dts.min, dts.sec, dts.us, utc_pytz)
+    dt = dt.astimezone(tz)
+
+    Derived from the datetime.astimezone implementation at
+    https://github.com/python/cpython/blob/main/Modules/_datetimemodule.c#L6187
+
+    NB: we are assuming tz is not None.
     """
-    Convert the i8 representation of a datetime from a tzlocal timezone to
-    UTC, or vice-versa.
+    cdef:
+        datetime result
+
+    result = datetime_new(dts.year, dts.month, dts.day, dts.hour,
+                          dts.min, dts.sec, dts.us, tz)
+    return tz.fromutc(result)
+
 
-    Private, not intended for use outside of tslibs.conversion
+# NB: relies on dateutil internals, subject to change.
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef bint _infer_dateutil_fold(
+    int64_t value,
+    const int64_t[::1] trans,
+    const int64_t[::1] deltas,
+    Py_ssize_t pos,
+):
+    """
+    Infer _TSObject fold property from value by assuming 0 and then setting
+    to 1 if necessary.
 
     Parameters
     ----------
-    val : int64_t
-    tz : tzinfo
-    to_utc : bint
-        True if converting tzlocal _to_ UTC, False if going the other direction
-    fold : bint*
-        pointer to fold: whether datetime ends up in a fold or not
-        after adjustment
+    value : int64_t
+    trans : ndarray[int64_t]
+        ndarray of offset transition points in nanoseconds since epoch.
+    deltas : int64_t[:]
+        array of offsets corresponding to transition points in trans.
+    pos : Py_ssize_t
+        Position of the last transition point before taking fold into account.
 
     Returns
     -------
-    result : int64_t
+    bint
+        Due to daylight saving time, one wall clock time can occur twice
+        when shifting from summer to winter time; fold describes whether the
+        datetime-like corresponds  to the first (0) or the second time (1)
+        the wall clock hits the ambiguous time
 
-    Notes
-    -----
-    Sets fold by pointer
+    References
+    ----------
+    .. [1] "PEP 495 - Local Time Disambiguation"
+           https://www.python.org/dev/peps/pep-0495/#the-fold-attribute
     """
     cdef:
-        int64_t delta
+        bint fold = 0
+        int64_t fold_delta
 
-    delta = _tzlocal_get_offset_components(val, tz, to_utc, fold)
+    if pos > 0:
+        fold_delta = deltas[pos - 1] - deltas[pos]
+        if value - fold_delta < trans[pos]:
+            fold = 1
 
-    if to_utc:
-        return val - delta
-    else:
-        return val + delta
+    return fold
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index 150516aadffc6..492b7d519551f 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -14,7 +14,6 @@ cdef extern from *:
 cdef extern from "Python.h":
     # Note: importing extern-style allows us to declare these as nogil
     # functions, whereas `from cpython cimport` does not.
-    bint PyUnicode_Check(object obj) nogil
     bint PyBool_Check(object obj) nogil
     bint PyFloat_Check(object obj) nogil
     bint PyComplex_Check(object obj) nogil
diff --git a/pandas/_libs/tslibs/vectorized.pyi b/pandas/_libs/tslibs/vectorized.pyi
index e9a39a6a75a39..d24541aede8d8 100644
--- a/pandas/_libs/tslibs/vectorized.pyi
+++ b/pandas/_libs/tslibs/vectorized.pyi
@@ -11,26 +11,36 @@ from pandas._libs.tslibs.offsets import BaseOffset
 from pandas._typing import npt
 
 def dt64arr_to_periodarr(
-    stamps: npt.NDArray[np.int64],  # const int64_t[:]
+    stamps: npt.NDArray[np.int64],
     freq: int,
     tz: tzinfo | None,
-) -> npt.NDArray[np.int64]: ...  # np.ndarray[np.int64, ndim=1]
+    reso: int = ...,  # NPY_DATETIMEUNIT
+) -> npt.NDArray[np.int64]: ...
 def is_date_array_normalized(
-    stamps: npt.NDArray[np.int64],  # const int64_t[:]
-    tz: tzinfo | None = ...,
+    stamps: npt.NDArray[np.int64],
+    tz: tzinfo | None,
+    reso: int,  # NPY_DATETIMEUNIT
 ) -> bool: ...
 def normalize_i8_timestamps(
-    stamps: npt.NDArray[np.int64],  # const int64_t[:]
+    stamps: npt.NDArray[np.int64],
     tz: tzinfo | None,
+    reso: int,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.int64]: ...
 def get_resolution(
-    stamps: npt.NDArray[np.int64],  # const int64_t[:]
+    stamps: npt.NDArray[np.int64],
     tz: tzinfo | None = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> Resolution: ...
 def ints_to_pydatetime(
-    arr: npt.NDArray[np.int64],  # const int64_t[:}]
+    arr: npt.NDArray[np.int64],
     tz: tzinfo | None = ...,
-    freq: str | BaseOffset | None = ...,
+    freq: BaseOffset | None = ...,
     fold: bool = ...,
     box: str = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
 ) -> npt.NDArray[np.object_]: ...
+def tz_convert_from_utc(
+    stamps: npt.NDArray[np.int64],
+    tz: tzinfo | None,
+    reso: int = ...,  # NPY_DATETIMEUNIT
+) -> npt.NDArray[np.int64]: ...
diff --git a/pandas/_libs/tslibs/vectorized.pyx b/pandas/_libs/tslibs/vectorized.pyx
index 02bdae3a8dbac..b63b4cf1df66b 100644
--- a/pandas/_libs/tslibs/vectorized.pyx
+++ b/pandas/_libs/tslibs/vectorized.pyx
@@ -1,5 +1,4 @@
-import cython
-
+cimport cython
 from cpython.datetime cimport (
     date,
     datetime,
@@ -9,97 +8,109 @@ from cpython.datetime cimport (
 
 import numpy as np
 
+cimport numpy as cnp
 from numpy cimport (
     int64_t,
     intp_t,
     ndarray,
 )
 
-from .conversion cimport normalize_i8_stamp
+cnp.import_array()
 
 from .dtypes import Resolution
 
+from .dtypes cimport (
+    c_Resolution,
+    periods_per_day,
+)
 from .nattype cimport (
     NPY_NAT,
     c_NaT as NaT,
 )
 from .np_datetime cimport (
-    dt64_to_dtstruct,
+    NPY_DATETIMEUNIT,
+    NPY_FR_ns,
     npy_datetimestruct,
+    pandas_datetime_to_datetimestruct,
 )
-from .offsets cimport to_offset
+from .offsets cimport BaseOffset
 from .period cimport get_period_ordinal
 from .timestamps cimport create_timestamp_from_ts
-from .timezones cimport (
-    get_dst_info,
-    is_tzlocal,
-    is_utc,
-)
-from .tzconversion cimport tz_convert_utc_to_tzlocal
+from .timezones cimport is_utc
+from .tzconversion cimport Localizer
 
-# -------------------------------------------------------------------------
 
-cdef inline object create_datetime_from_ts(
-    int64_t value,
-    npy_datetimestruct dts,
-    tzinfo tz,
-    object freq,
-    bint fold,
-):
-    """
-    Convenience routine to construct a datetime.datetime from its parts.
-    """
-    return datetime(
-        dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.us,
-        tz, fold=fold,
-    )
-
-
-cdef inline object create_date_from_ts(
-    int64_t value,
-    npy_datetimestruct dts,
-    tzinfo tz,
-    object freq,
-    bint fold
-):
-    """
-    Convenience routine to construct a datetime.date from its parts.
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def tz_convert_from_utc(ndarray stamps, tzinfo tz, NPY_DATETIMEUNIT reso=NPY_FR_ns):
+    # stamps is int64_t, arbitrary ndim
     """
-    # GH#25057 add fold argument to match other func_create signatures
-    return date(dts.year, dts.month, dts.day)
+    Convert the values (in i8) from UTC to tz
 
+    Parameters
+    ----------
+    stamps : ndarray[int64]
+    tz : tzinfo
 
-cdef inline object create_time_from_ts(
-    int64_t value,
-    npy_datetimestruct dts,
-    tzinfo tz,
-    object freq,
-    bint fold
-):
-    """
-    Convenience routine to construct a datetime.time from its parts.
+    Returns
+    -------
+    ndarray[int64]
     """
-    return time(dts.hour, dts.min, dts.sec, dts.us, tz, fold=fold)
+    cdef:
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t utc_val, local_val
+        Py_ssize_t pos, i, n = stamps.size
+
+        ndarray result
+        cnp.broadcast mi
+
+    if tz is None or is_utc(tz) or stamps.size == 0:
+        # Much faster than going through the "standard" pattern below
+        return stamps.copy()
+
+    result = cnp.PyArray_EMPTY(stamps.ndim, stamps.shape, cnp.NPY_INT64, 0)
+    mi = cnp.PyArray_MultiIterNew2(result, stamps)
+
+    for i in range(n):
+        # Analogous to: utc_val = stamps[i]
+        utc_val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        if utc_val == NPY_NAT:
+            local_val = NPY_NAT
+        else:
+            local_val = info.utc_val_to_local_val(utc_val, &pos)
+
+        # Analogous to: result[i] = local_val
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = local_val
+
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
+
+
+# -------------------------------------------------------------------------
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def ints_to_pydatetime(
-    const int64_t[:] arr,
+    ndarray stamps,
     tzinfo tz=None,
-    object freq=None,
+    BaseOffset freq=None,
     bint fold=False,
-    str box="datetime"
+    str box="datetime",
+    NPY_DATETIMEUNIT reso=NPY_FR_ns,
 ) -> np.ndarray:
+    # stamps is int64, arbitrary ndim
     """
     Convert an i8 repr to an ndarray of datetimes, date, time or Timestamp.
 
     Parameters
     ----------
-    arr : array of i8
+    stamps : array of i8
     tz : str, optional
          convert to this timezone
-    freq : str/Offset, optional
+    freq : BaseOffset, optional
          freq to convert
     fold : bint, default is 0
         Due to daylight saving time, one wall clock time can occur twice
@@ -114,165 +125,152 @@ def ints_to_pydatetime(
         * If time, convert to datetime.time
         * If Timestamp, convert to pandas.Timestamp
 
+    reso : NPY_DATETIMEUNIT, default NPY_FR_ns
+
     Returns
     -------
     ndarray[object] of type specified by box
     """
     cdef:
-        Py_ssize_t i, n = len(arr)
-        ndarray[int64_t] trans
-        int64_t[:] deltas
-        intp_t[:] pos
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t utc_val, local_val
+        Py_ssize_t i, n = stamps.size
+        Py_ssize_t pos = -1  # unused, avoid not-initialized warning
+
         npy_datetimestruct dts
-        object dt, new_tz
-        str typ
-        int64_t value, local_value, delta = NPY_NAT  # dummy for delta
-        ndarray[object] result = np.empty(n, dtype=object)
-        object (*func_create)(int64_t, npy_datetimestruct, tzinfo, object, bint)
-        bint use_utc = False, use_tzlocal = False, use_fixed = False
-        bint use_pytz = False
+        tzinfo new_tz
+        bint use_date = False, use_time = False, use_ts = False, use_pydt = False
+        object res_val
+
+        # Note that `result` (and thus `result_flat`) is C-order and
+        #  `it` iterates C-order as well, so the iteration matches
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        ndarray result = cnp.PyArray_EMPTY(stamps.ndim, stamps.shape, cnp.NPY_OBJECT, 0)
+        object[::1] res_flat = result.ravel()     # should NOT be a copy
+        cnp.flatiter it = cnp.PyArray_IterNew(stamps)
 
     if box == "date":
         assert (tz is None), "tz should be None when converting to date"
-
-        func_create = create_date_from_ts
+        use_date = True
     elif box == "timestamp":
-        func_create = create_timestamp_from_ts
-
-        if isinstance(freq, str):
-            freq = to_offset(freq)
+        use_ts = True
     elif box == "time":
-        func_create = create_time_from_ts
+        use_time = True
     elif box == "datetime":
-        func_create = create_datetime_from_ts
+        use_pydt = True
     else:
         raise ValueError(
             "box must be one of 'datetime', 'date', 'time' or 'timestamp'"
         )
 
-    if is_utc(tz) or tz is None:
-        use_utc = True
-    elif is_tzlocal(tz):
-        use_tzlocal = True
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-        if typ not in ["pytz", "dateutil"]:
-            # static/fixed; in this case we know that len(delta) == 1
-            use_fixed = True
-            delta = deltas[0]
-        else:
-            pos = trans.searchsorted(arr, side="right") - 1
-            use_pytz = typ == "pytz"
-
     for i in range(n):
+        # Analogous to: utc_val = stamps[i]
+        utc_val = (<int64_t*>cnp.PyArray_ITER_DATA(it))[0]
+
         new_tz = tz
-        value = arr[i]
 
-        if value == NPY_NAT:
-            result[i] = <object>NaT
+        if utc_val == NPY_NAT:
+            res_val = <object>NaT
+
         else:
-            if use_utc:
-                local_value = value
-            elif use_tzlocal:
-                local_value = tz_convert_utc_to_tzlocal(value, tz)
-            elif use_fixed:
-                local_value = value + delta
-            elif not use_pytz:
-                # i.e. dateutil
-                # no zone-name change for dateutil tzs - dst etc
-                # represented in single object.
-                local_value = value + deltas[pos[i]]
-            else:
-                # pytz
+
+            local_val = info.utc_val_to_local_val(utc_val, &pos)
+            if info.use_pytz:
                 # find right representation of dst etc in pytz timezone
-                new_tz = tz._tzinfos[tz._transition_info[pos[i]]]
-                local_value = value + deltas[pos[i]]
+                new_tz = tz._tzinfos[tz._transition_info[pos]]
+
+            pandas_datetime_to_datetimestruct(local_val, reso, &dts)
+
+            if use_ts:
+                res_val = create_timestamp_from_ts(
+                    utc_val, dts, new_tz, freq, fold, reso=reso
+                )
+            elif use_pydt:
+                res_val = datetime(
+                    dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.us,
+                    new_tz, fold=fold,
+                )
+            elif use_date:
+                res_val = date(dts.year, dts.month, dts.day)
+            else:
+                res_val = time(dts.hour, dts.min, dts.sec, dts.us, new_tz, fold=fold)
 
-            dt64_to_dtstruct(local_value, &dts)
-            result[i] = func_create(value, dts, new_tz, freq, fold)
+        # Note: we can index result directly instead of using PyArray_MultiIter_DATA
+        #  like we do for the other functions because result is known C-contiguous
+        #  and is the first argument to PyArray_MultiIterNew2.  The usual pattern
+        #  does not seem to work with object dtype.
+        #  See discussion at
+        #  github.com/pandas-dev/pandas/pull/46886#discussion_r860261305
+        res_flat[i] = res_val
+
+        cnp.PyArray_ITER_NEXT(it)
 
     return result
 
 
 # -------------------------------------------------------------------------
 
-cdef:
-    int RESO_NS = 0
-    int RESO_US = 1
-    int RESO_MS = 2
-    int RESO_SEC = 3
-    int RESO_MIN = 4
-    int RESO_HR = 5
-    int RESO_DAY = 6
-    int RESO_MTH = 7
-    int RESO_QTR = 8
-    int RESO_YR = 9
-
-
-cdef inline int _reso_stamp(npy_datetimestruct *dts):
-    if dts.us != 0:
+
+cdef inline c_Resolution _reso_stamp(npy_datetimestruct *dts):
+    if dts.ps != 0:
+        return c_Resolution.RESO_NS
+    elif dts.us != 0:
         if dts.us % 1000 == 0:
-            return RESO_MS
-        return RESO_US
+            return c_Resolution.RESO_MS
+        return c_Resolution.RESO_US
     elif dts.sec != 0:
-        return RESO_SEC
+        return c_Resolution.RESO_SEC
     elif dts.min != 0:
-        return RESO_MIN
+        return c_Resolution.RESO_MIN
     elif dts.hour != 0:
-        return RESO_HR
-    return RESO_DAY
+        return c_Resolution.RESO_HR
+    return c_Resolution.RESO_DAY
 
 
-def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def get_resolution(
+    ndarray stamps, tzinfo tz=None, NPY_DATETIMEUNIT reso=NPY_FR_ns
+) -> Resolution:
+    # stamps is int64_t, any ndim
     cdef:
-        Py_ssize_t i, n = len(stamps)
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t utc_val, local_val
+        Py_ssize_t i, n = stamps.size
+        Py_ssize_t pos = -1  # unused, avoid not-initialized warning
+        cnp.flatiter it = cnp.PyArray_IterNew(stamps)
+
         npy_datetimestruct dts
-        int reso = RESO_DAY, curr_reso
-        ndarray[int64_t] trans
-        int64_t[:] deltas
-        intp_t[:] pos
-        int64_t local_val, delta = NPY_NAT
-        bint use_utc = False, use_tzlocal = False, use_fixed = False
-
-    if is_utc(tz) or tz is None:
-        use_utc = True
-    elif is_tzlocal(tz):
-        use_tzlocal = True
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-        if typ not in ["pytz", "dateutil"]:
-            # static/fixed; in this case we know that len(delta) == 1
-            use_fixed = True
-            delta = deltas[0]
-        else:
-            pos = trans.searchsorted(stamps, side="right") - 1
+        c_Resolution pd_reso = c_Resolution.RESO_DAY, curr_reso
 
     for i in range(n):
-        if stamps[i] == NPY_NAT:
-            continue
-
-        if use_utc:
-            local_val = stamps[i]
-        elif use_tzlocal:
-            local_val = tz_convert_utc_to_tzlocal(stamps[i], tz)
-        elif use_fixed:
-            local_val = stamps[i] + delta
+        # Analogous to: utc_val = stamps[i]
+        utc_val = cnp.PyArray_GETITEM(stamps, cnp.PyArray_ITER_DATA(it))
+
+        if utc_val == NPY_NAT:
+            pass
         else:
-            local_val = stamps[i] + deltas[pos[i]]
+            local_val = info.utc_val_to_local_val(utc_val, &pos)
+
+            pandas_datetime_to_datetimestruct(local_val, reso, &dts)
+            curr_reso = _reso_stamp(&dts)
+            if curr_reso < pd_reso:
+                pd_reso = curr_reso
 
-        dt64_to_dtstruct(local_val, &dts)
-        curr_reso = _reso_stamp(&dts)
-        if curr_reso < reso:
-            reso = curr_reso
+        cnp.PyArray_ITER_NEXT(it)
 
-    return Resolution(reso)
+    return Resolution(pd_reso)
 
 
 # -------------------------------------------------------------------------
 
+
+@cython.cdivision(False)
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo tz):
+cpdef ndarray normalize_i8_timestamps(ndarray stamps, tzinfo tz, NPY_DATETIMEUNIT reso):
+    # stamps is int64_t, arbitrary ndim
     """
     Normalize each of the (nanosecond) timezone aware timestamps in the given
     array by rounding down to the beginning of the day (i.e. midnight).
@@ -282,57 +280,44 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
     ----------
     stamps : int64 ndarray
     tz : tzinfo or None
+    reso : NPY_DATETIMEUNIT
 
     Returns
     -------
     result : int64 ndarray of converted of normalized nanosecond timestamps
     """
     cdef:
-        Py_ssize_t i, n = len(stamps)
-        int64_t[:] result = np.empty(n, dtype=np.int64)
-        ndarray[int64_t] trans
-        int64_t[:] deltas
-        str typ
-        Py_ssize_t[:] pos
-        int64_t local_val, delta = NPY_NAT
-        bint use_utc = False, use_tzlocal = False, use_fixed = False
-
-    if is_utc(tz) or tz is None:
-        use_utc = True
-    elif is_tzlocal(tz):
-        use_tzlocal = True
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-        if typ not in ["pytz", "dateutil"]:
-            # static/fixed; in this case we know that len(delta) == 1
-            use_fixed = True
-            delta = deltas[0]
-        else:
-            pos = trans.searchsorted(stamps, side="right") - 1
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t utc_val, local_val, res_val
+        Py_ssize_t i, n = stamps.size
+        Py_ssize_t pos = -1  # unused, avoid not-initialized warning
+
+        ndarray result = cnp.PyArray_EMPTY(stamps.ndim, stamps.shape, cnp.NPY_INT64, 0)
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(result, stamps)
+        int64_t ppd = periods_per_day(reso)
 
     for i in range(n):
-        # TODO: reinstate nogil for use_utc case?
-        if stamps[i] == NPY_NAT:
-            result[i] = NPY_NAT
-            continue
-
-        if use_utc:
-            local_val = stamps[i]
-        elif use_tzlocal:
-            local_val = tz_convert_utc_to_tzlocal(stamps[i], tz)
-        elif use_fixed:
-            local_val = stamps[i] + delta
+        # Analogous to: utc_val = stamps[i]
+        utc_val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        if utc_val == NPY_NAT:
+            res_val = NPY_NAT
         else:
-            local_val = stamps[i] + deltas[pos[i]]
+            local_val = info.utc_val_to_local_val(utc_val, &pos)
+            res_val = local_val - (local_val % ppd)
 
-        result[i] = normalize_i8_stamp(local_val)
+        # Analogous to: result[i] = res_val
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
 
-    return result.base  # `.base` to access underlying ndarray
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
+def is_date_array_normalized(ndarray stamps, tzinfo tz, NPY_DATETIMEUNIT reso) -> bool:
+    # stamps is int64_t, arbitrary ndim
     """
     Check if all of the given (nanosecond) timestamps are normalized to
     midnight, i.e. hour == minute == second == 0.  If the optional timezone
@@ -342,47 +327,31 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
     ----------
     stamps : int64 ndarray
     tz : tzinfo or None
+    reso : NPY_DATETIMEUNIT
 
     Returns
     -------
     is_normalized : bool True if all stamps are normalized
     """
     cdef:
-        Py_ssize_t i, n = len(stamps)
-        ndarray[int64_t] trans
-        int64_t[:] deltas
-        intp_t[:] pos
-        int64_t local_val, delta = NPY_NAT
-        str typ
-        int64_t day_nanos = 24 * 3600 * 1_000_000_000
-        bint use_utc = False, use_tzlocal = False, use_fixed = False
-
-    if is_utc(tz) or tz is None:
-        use_utc = True
-    elif is_tzlocal(tz):
-        use_tzlocal = True
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-        if typ not in ["pytz", "dateutil"]:
-            # static/fixed; in this case we know that len(delta) == 1
-            use_fixed = True
-            delta = deltas[0]
-        else:
-            pos = trans.searchsorted(stamps, side="right") - 1
+        Localizer info = Localizer(tz, reso=reso)
+        int64_t utc_val, local_val
+        Py_ssize_t i, n = stamps.size
+        Py_ssize_t pos = -1  # unused, avoid not-initialized warning
+        cnp.flatiter it = cnp.PyArray_IterNew(stamps)
+        int64_t ppd = periods_per_day(reso)
 
     for i in range(n):
-        if use_utc:
-            local_val = stamps[i]
-        elif use_tzlocal:
-            local_val = tz_convert_utc_to_tzlocal(stamps[i], tz)
-        elif use_fixed:
-            local_val = stamps[i] + delta
-        else:
-            local_val = stamps[i] + deltas[pos[i]]
+        # Analogous to: utc_val = stamps[i]
+        utc_val = cnp.PyArray_GETITEM(stamps, cnp.PyArray_ITER_DATA(it))
+
+        local_val = info.utc_val_to_local_val(utc_val, &pos)
 
-        if local_val % day_nanos != 0:
+        if local_val % ppd != 0:
             return False
 
+        cnp.PyArray_ITER_NEXT(it)
+
     return True
 
 
@@ -391,46 +360,34 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
+def dt64arr_to_periodarr(
+    ndarray stamps, int freq, tzinfo tz, NPY_DATETIMEUNIT reso=NPY_FR_ns
+):
+    # stamps is int64_t, arbitrary ndim
     cdef:
-        Py_ssize_t n = len(stamps)
-        int64_t[:] result = np.empty(n, dtype=np.int64)
-        ndarray[int64_t] trans
-        int64_t[:] deltas
-        Py_ssize_t[:] pos
-        npy_datetimestruct dts
-        int64_t local_val, delta = NPY_NAT
-        bint use_utc = False, use_tzlocal = False, use_fixed = False
+        Localizer info = Localizer(tz, reso=reso)
+        Py_ssize_t i, n = stamps.size
+        Py_ssize_t pos = -1  # unused, avoid not-initialized warning
+        int64_t utc_val, local_val, res_val
 
-    if is_utc(tz) or tz is None:
-        use_utc = True
-    elif is_tzlocal(tz):
-        use_tzlocal = True
-    else:
-        trans, deltas, typ = get_dst_info(tz)
-        if typ not in ["pytz", "dateutil"]:
-            # static/fixed; in this case we know that len(delta) == 1
-            use_fixed = True
-            delta = deltas[0]
-        else:
-            pos = trans.searchsorted(stamps, side="right") - 1
+        npy_datetimestruct dts
+        ndarray result = cnp.PyArray_EMPTY(stamps.ndim, stamps.shape, cnp.NPY_INT64, 0)
+        cnp.broadcast mi = cnp.PyArray_MultiIterNew2(result, stamps)
 
     for i in range(n):
-        # TODO: reinstate nogil for use_utc case?
-        if stamps[i] == NPY_NAT:
-            result[i] = NPY_NAT
-            continue
-
-        if use_utc:
-            local_val = stamps[i]
-        elif use_tzlocal:
-            local_val = tz_convert_utc_to_tzlocal(stamps[i], tz)
-        elif use_fixed:
-            local_val = stamps[i] + delta
+        # Analogous to: utc_val = stamps[i]
+        utc_val = (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+
+        if utc_val == NPY_NAT:
+            res_val = NPY_NAT
         else:
-            local_val = stamps[i] + deltas[pos[i]]
+            local_val = info.utc_val_to_local_val(utc_val, &pos)
+            pandas_datetime_to_datetimestruct(local_val, reso, &dts)
+            res_val = get_period_ordinal(&dts, freq)
 
-        dt64_to_dtstruct(local_val, &dts)
-        result[i] = get_period_ordinal(&dts, freq)
+        # Analogous to: result[i] = res_val
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = res_val
 
-    return result.base  # .base to get underlying ndarray
+        cnp.PyArray_MultiIter_NEXT(mi)
+
+    return result
diff --git a/pandas/_libs/util.pxd b/pandas/_libs/util.pxd
index df88c896ac593..18009a1a25de4 100644
--- a/pandas/_libs/util.pxd
+++ b/pandas/_libs/util.pxd
@@ -1,18 +1,17 @@
 cimport numpy as cnp
+from libc.stdint cimport (
+    INT8_MAX,
+    INT8_MIN,
+    INT16_MAX,
+    INT16_MIN,
+    INT32_MAX,
+    INT32_MIN,
+    INT64_MAX,
+    INT64_MIN,
+    UINT8_MAX,
+    UINT16_MAX,
+    UINT32_MAX,
+    UINT64_MAX,
+)
 
 from pandas._libs.tslibs.util cimport *
-
-
-cdef extern from "src/headers/stdint.h":
-    enum: UINT8_MAX
-    enum: UINT16_MAX
-    enum: UINT32_MAX
-    enum: UINT64_MAX
-    enum: INT8_MIN
-    enum: INT8_MAX
-    enum: INT16_MIN
-    enum: INT16_MAX
-    enum: INT32_MAX
-    enum: INT32_MIN
-    enum: INT64_MAX
-    enum: INT64_MIN
diff --git a/pandas/_libs/window/aggregations.pyx b/pandas/_libs/window/aggregations.pyx
index 5ebb60dc7e41b..68c05f2bb2c98 100644
--- a/pandas/_libs/window/aggregations.pyx
+++ b/pandas/_libs/window/aggregations.pyx
@@ -1,8 +1,11 @@
 # cython: boundscheck=False, wraparound=False, cdivision=True
 
-import cython
-
-from libc.math cimport round
+cimport cython
+from libc.math cimport (
+    round,
+    signbit,
+    sqrt,
+)
 from libcpp.deque cimport deque
 
 from pandas._libs.algos cimport TiebreakEnumType
@@ -19,14 +22,8 @@ from numpy cimport (
 
 cnp.import_array()
 
-
-cdef extern from "../src/headers/cmath" namespace "std":
-    bint isnan(float64_t) nogil
-    bint notnan(float64_t) nogil
-    int signbit(float64_t) nogil
-    float64_t sqrt(float64_t x) nogil
-
 from pandas._libs.algos import is_monotonic
+
 from pandas._libs.dtypes cimport numeric_t
 
 
@@ -72,14 +69,19 @@ cdef bint is_monotonic_increasing_start_end_bounds(
 # Rolling sum
 
 
-cdef inline float64_t calc_sum(int64_t minp, int64_t nobs, float64_t sum_x) nogil:
+cdef inline float64_t calc_sum(int64_t minp, int64_t nobs, float64_t sum_x,
+                               int64_t num_consecutive_same_value, float64_t prev_value
+                               ) nogil:
     cdef:
         float64_t result
 
     if nobs == 0 == minp:
         result = 0
     elif nobs >= minp:
-        result = sum_x
+        if num_consecutive_same_value >= nobs:
+            result = prev_value * nobs
+        else:
+            result = sum_x
     else:
         result = NaN
 
@@ -87,20 +89,29 @@ cdef inline float64_t calc_sum(int64_t minp, int64_t nobs, float64_t sum_x) nogi
 
 
 cdef inline void add_sum(float64_t val, int64_t *nobs, float64_t *sum_x,
-                         float64_t *compensation) nogil:
+                         float64_t *compensation, int64_t *num_consecutive_same_value,
+                         float64_t *prev_value) nogil:
     """ add a value from the sum calc using Kahan summation """
 
     cdef:
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] + 1
         y = val - compensation[0]
         t = sum_x[0] + y
         compensation[0] = t - sum_x[0] - y
         sum_x[0] = t
 
+        # GH#42064, record num of same values to remove floating point artifacts
+        if val == prev_value[0]:
+            num_consecutive_same_value[0] += 1
+        else:
+            # reset to 1 (include current value itself)
+            num_consecutive_same_value[0] = 1
+        prev_value[0] = val
+
 
 cdef inline void remove_sum(float64_t val, int64_t *nobs, float64_t *sum_x,
                             float64_t *compensation) nogil:
@@ -110,7 +121,7 @@ cdef inline void remove_sum(float64_t val, int64_t *nobs, float64_t *sum_x,
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
         y = - val - compensation[0]
         t = sum_x[0] + y
@@ -122,9 +133,9 @@ def roll_sum(const float64_t[:] values, ndarray[int64_t] start,
              ndarray[int64_t] end, int64_t minp) -> np.ndarray:
     cdef:
         Py_ssize_t i, j
-        float64_t sum_x = 0, compensation_add = 0, compensation_remove = 0
-        int64_t s, e
-        int64_t nobs = 0, N = len(values)
+        float64_t sum_x, compensation_add, compensation_remove, prev_value
+        int64_t s, e, num_consecutive_same_value
+        int64_t nobs = 0, N = len(start)
         ndarray[float64_t] output
         bint is_monotonic_increasing_bounds
 
@@ -139,12 +150,16 @@ def roll_sum(const float64_t[:] values, ndarray[int64_t] start,
             s = start[i]
             e = end[i]
 
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
 
                 # setup
-
+                prev_value = values[s]
+                num_consecutive_same_value = 0
+                sum_x = compensation_add = compensation_remove = 0
+                nobs = 0
                 for j in range(s, e):
-                    add_sum(values[j], &nobs, &sum_x, &compensation_add)
+                    add_sum(values[j], &nobs, &sum_x, &compensation_add,
+                            &num_consecutive_same_value, &prev_value)
 
             else:
 
@@ -154,9 +169,10 @@ def roll_sum(const float64_t[:] values, ndarray[int64_t] start,
 
                 # calculate adds
                 for j in range(end[i - 1], e):
-                    add_sum(values[j], &nobs, &sum_x, &compensation_add)
+                    add_sum(values[j], &nobs, &sum_x, &compensation_add,
+                            &num_consecutive_same_value, &prev_value)
 
-            output[i] = calc_sum(minp, nobs, sum_x)
+            output[i] = calc_sum(minp, nobs, sum_x, num_consecutive_same_value, prev_value)
 
             if not is_monotonic_increasing_bounds:
                 nobs = 0
@@ -170,14 +186,17 @@ def roll_sum(const float64_t[:] values, ndarray[int64_t] start,
 # Rolling mean
 
 
-cdef inline float64_t calc_mean(int64_t minp, Py_ssize_t nobs,
-                                Py_ssize_t neg_ct, float64_t sum_x) nogil:
+cdef inline float64_t calc_mean(int64_t minp, Py_ssize_t nobs, Py_ssize_t neg_ct,
+                                float64_t sum_x, int64_t num_consecutive_same_value,
+                                float64_t prev_value) nogil:
     cdef:
         float64_t result
 
     if nobs >= minp and nobs > 0:
         result = sum_x / <float64_t>nobs
-        if neg_ct == 0 and result < 0:
+        if num_consecutive_same_value >= nobs:
+            result = prev_value
+        elif neg_ct == 0 and result < 0:
             # all positive
             result = 0
         elif neg_ct == nobs and result > 0:
@@ -191,13 +210,14 @@ cdef inline float64_t calc_mean(int64_t minp, Py_ssize_t nobs,
 
 
 cdef inline void add_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
-                          Py_ssize_t *neg_ct, float64_t *compensation) nogil:
+                          Py_ssize_t *neg_ct, float64_t *compensation,
+                          int64_t *num_consecutive_same_value, float64_t *prev_value) nogil:
     """ add a value from the mean calc using Kahan summation """
     cdef:
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] + 1
         y = val - compensation[0]
         t = sum_x[0] + y
@@ -206,6 +226,14 @@ cdef inline void add_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
         if signbit(val):
             neg_ct[0] = neg_ct[0] + 1
 
+        # GH#42064, record num of same values to remove floating point artifacts
+        if val == prev_value[0]:
+            num_consecutive_same_value[0] += 1
+        else:
+            # reset to 1 (include current value itself)
+            num_consecutive_same_value[0] = 1
+        prev_value[0] = val
+
 
 cdef inline void remove_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
                              Py_ssize_t *neg_ct, float64_t *compensation) nogil:
@@ -213,7 +241,7 @@ cdef inline void remove_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
     cdef:
         float64_t y, t
 
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
         y = - val - compensation[0]
         t = sum_x[0] + y
@@ -226,9 +254,9 @@ cdef inline void remove_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
 def roll_mean(const float64_t[:] values, ndarray[int64_t] start,
               ndarray[int64_t] end, int64_t minp) -> np.ndarray:
     cdef:
-        float64_t val, compensation_add = 0, compensation_remove = 0, sum_x = 0
-        int64_t s, e
-        Py_ssize_t nobs = 0, i, j, neg_ct = 0, N = len(values)
+        float64_t val, compensation_add, compensation_remove, sum_x, prev_value
+        int64_t s, e, num_consecutive_same_value
+        Py_ssize_t nobs, i, j, neg_ct, N = len(start)
         ndarray[float64_t] output
         bint is_monotonic_increasing_bounds
 
@@ -243,12 +271,17 @@ def roll_mean(const float64_t[:] values, ndarray[int64_t] start,
             s = start[i]
             e = end[i]
 
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
 
                 # setup
+                compensation_add = compensation_remove = sum_x = 0
+                nobs = neg_ct = 0
+                prev_value = values[s]
+                num_consecutive_same_value = 0
                 for j in range(s, e):
                     val = values[j]
-                    add_mean(val, &nobs, &sum_x, &neg_ct, &compensation_add)
+                    add_mean(val, &nobs, &sum_x, &neg_ct, &compensation_add,
+                             &num_consecutive_same_value, &prev_value)
 
             else:
 
@@ -260,9 +293,10 @@ def roll_mean(const float64_t[:] values, ndarray[int64_t] start,
                 # calculate adds
                 for j in range(end[i - 1], e):
                     val = values[j]
-                    add_mean(val, &nobs, &sum_x, &neg_ct, &compensation_add)
+                    add_mean(val, &nobs, &sum_x, &neg_ct, &compensation_add,
+                             &num_consecutive_same_value, &prev_value)
 
-            output[i] = calc_mean(minp, nobs, neg_ct, sum_x)
+            output[i] = calc_mean(minp, nobs, neg_ct, sum_x, num_consecutive_same_value, prev_value)
 
             if not is_monotonic_increasing_bounds:
                 nobs = 0
@@ -276,15 +310,15 @@ def roll_mean(const float64_t[:] values, ndarray[int64_t] start,
 
 
 cdef inline float64_t calc_var(int64_t minp, int ddof, float64_t nobs,
-                               float64_t ssqdm_x) nogil:
+                               float64_t ssqdm_x, int64_t num_consecutive_same_value) nogil:
     cdef:
         float64_t result
 
     # Variance is unchanged if no observation is added or removed
     if (nobs >= minp) and (nobs > ddof):
 
-        # pathological case
-        if nobs == 1:
+        # pathological case & repeatedly same values case
+        if nobs == 1 or num_consecutive_same_value >= nobs:
             result = 0
         else:
             result = ssqdm_x / (nobs - <float64_t>ddof)
@@ -295,16 +329,26 @@ cdef inline float64_t calc_var(int64_t minp, int ddof, float64_t nobs,
 
 
 cdef inline void add_var(float64_t val, float64_t *nobs, float64_t *mean_x,
-                         float64_t *ssqdm_x, float64_t *compensation) nogil:
+                         float64_t *ssqdm_x, float64_t *compensation,
+                         int64_t *num_consecutive_same_value, float64_t *prev_value) nogil:
     """ add a value from the var calc """
     cdef:
         float64_t delta, prev_mean, y, t
 
-    # `isnan` instead of equality as fix for GH-21813, msvc 2017 bug
-    if isnan(val):
+    # GH#21813, if msvc 2017 bug is resolved, we should be OK with != instead of `isnan`
+    if val != val:
         return
 
     nobs[0] = nobs[0] + 1
+
+    # GH#42064, record num of same values to remove floating point artifacts
+    if val == prev_value[0]:
+        num_consecutive_same_value[0] += 1
+    else:
+        # reset to 1 (include current value itself)
+        num_consecutive_same_value[0] = 1
+    prev_value[0] = val
+
     # Welford's method for the online variance-calculation
     # using Kahan summation
     # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
@@ -325,7 +369,7 @@ cdef inline void remove_var(float64_t val, float64_t *nobs, float64_t *mean_x,
     """ remove a value from the var calc """
     cdef:
         float64_t delta, prev_mean, y, t
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
         if nobs[0]:
             # Welford's method for the online variance-calculation
@@ -349,11 +393,10 @@ def roll_var(const float64_t[:] values, ndarray[int64_t] start,
     Numerically stable implementation using Welford's method.
     """
     cdef:
-        float64_t mean_x = 0, ssqdm_x = 0, nobs = 0, compensation_add = 0,
-        float64_t compensation_remove = 0,
-        float64_t val, prev, delta, mean_x_old
-        int64_t s, e
-        Py_ssize_t i, j, N = len(values)
+        float64_t mean_x, ssqdm_x, nobs, compensation_add,
+        float64_t compensation_remove, prev_value
+        int64_t s, e, num_consecutive_same_value
+        Py_ssize_t i, j, N = len(start)
         ndarray[float64_t] output
         bint is_monotonic_increasing_bounds
 
@@ -372,10 +415,15 @@ def roll_var(const float64_t[:] values, ndarray[int64_t] start,
 
             # Over the first window, observations can only be added
             # never removed
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
+
+                prev_value = values[s]
+                num_consecutive_same_value = 0
 
+                mean_x = ssqdm_x = nobs = compensation_add = compensation_remove = 0
                 for j in range(s, e):
-                    add_var(values[j], &nobs, &mean_x, &ssqdm_x, &compensation_add)
+                    add_var(values[j], &nobs, &mean_x, &ssqdm_x, &compensation_add,
+                            &num_consecutive_same_value, &prev_value)
 
             else:
 
@@ -389,9 +437,10 @@ def roll_var(const float64_t[:] values, ndarray[int64_t] start,
 
                 # calculate adds
                 for j in range(end[i - 1], e):
-                    add_var(values[j], &nobs, &mean_x, &ssqdm_x, &compensation_add)
+                    add_var(values[j], &nobs, &mean_x, &ssqdm_x, &compensation_add,
+                            &num_consecutive_same_value, &prev_value)
 
-            output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
+            output[i] = calc_var(minp, ddof, nobs, ssqdm_x, num_consecutive_same_value)
 
             if not is_monotonic_increasing_bounds:
                 nobs = 0.0
@@ -406,8 +455,9 @@ def roll_var(const float64_t[:] values, ndarray[int64_t] start,
 
 
 cdef inline float64_t calc_skew(int64_t minp, int64_t nobs,
-                                float64_t x, float64_t xx,
-                                float64_t xxx) nogil:
+                                float64_t x, float64_t xx, float64_t xxx,
+                                int64_t num_consecutive_same_value
+                                ) nogil:
     cdef:
         float64_t result, dnobs
         float64_t A, B, C, R
@@ -418,6 +468,12 @@ cdef inline float64_t calc_skew(int64_t minp, int64_t nobs,
         B = xx / dnobs - A * A
         C = xxx / dnobs - A * A * A - 3 * A * B
 
+        if nobs < 3:
+            result = NaN
+        # GH 42064 46431
+        # uniform case, force result to be 0
+        elif num_consecutive_same_value >= nobs:
+            result = 0.0
         # #18044: with uniform distribution, floating issue will
         #         cause B != 0. and cause the result is a very
         #         large number.
@@ -427,7 +483,7 @@ cdef inline float64_t calc_skew(int64_t minp, int64_t nobs,
         #         if the variance is less than 1e-14, it could be
         #         treat as zero, here we follow the original
         #         skew/kurt behaviour to check B <= 1e-14
-        if B <= 1e-14 or nobs < 3:
+        elif B <= 1e-14:
             result = NaN
         else:
             R = sqrt(B)
@@ -444,13 +500,16 @@ cdef inline void add_skew(float64_t val, int64_t *nobs,
                           float64_t *xxx,
                           float64_t *compensation_x,
                           float64_t *compensation_xx,
-                          float64_t *compensation_xxx) nogil:
+                          float64_t *compensation_xxx,
+                          int64_t *num_consecutive_same_value,
+                          float64_t *prev_value,
+                          ) nogil:
     """ add a value from the skew calc """
     cdef:
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] + 1
 
         y = val - compensation_x[0]
@@ -466,6 +525,14 @@ cdef inline void add_skew(float64_t val, int64_t *nobs,
         compensation_xxx[0] = t - xxx[0] - y
         xxx[0] = t
 
+        # GH#42064, record num of same values to remove floating point artifacts
+        if val == prev_value[0]:
+            num_consecutive_same_value[0] += 1
+        else:
+            # reset to 1 (include current value itself)
+            num_consecutive_same_value[0] = 1
+        prev_value[0] = val
+
 
 cdef inline void remove_skew(float64_t val, int64_t *nobs,
                              float64_t *x, float64_t *xx,
@@ -478,7 +545,7 @@ cdef inline void remove_skew(float64_t val, int64_t *nobs,
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
 
         y = - val - compensation_x[0]
@@ -500,12 +567,13 @@ def roll_skew(ndarray[float64_t] values, ndarray[int64_t] start,
     cdef:
         Py_ssize_t i, j
         float64_t val, prev, min_val, mean_val, sum_val = 0
-        float64_t compensation_xxx_add = 0, compensation_xxx_remove = 0
-        float64_t compensation_xx_add = 0, compensation_xx_remove = 0
-        float64_t compensation_x_add = 0, compensation_x_remove = 0
-        float64_t x = 0, xx = 0, xxx = 0
-        int64_t nobs = 0, N = len(values), nobs_mean = 0
-        int64_t s, e
+        float64_t compensation_xxx_add, compensation_xxx_remove
+        float64_t compensation_xx_add, compensation_xx_remove
+        float64_t compensation_x_add, compensation_x_remove
+        float64_t x, xx, xxx
+        float64_t prev_value
+        int64_t nobs = 0, N = len(start), V = len(values), nobs_mean = 0
+        int64_t s, e, num_consecutive_same_value
         ndarray[float64_t] output, mean_array, values_copy
         bint is_monotonic_increasing_bounds
 
@@ -518,16 +586,16 @@ def roll_skew(ndarray[float64_t] values, ndarray[int64_t] start,
     values_copy = np.copy(values)
 
     with nogil:
-        for i in range(0, N):
+        for i in range(0, V):
             val = values_copy[i]
-            if notnan(val):
+            if val == val:
                 nobs_mean += 1
                 sum_val += val
         mean_val = sum_val / nobs_mean
         # Other cases would lead to imprecision for smallest values
         if min_val - mean_val > -1e5:
             mean_val = round(mean_val)
-            for i in range(0, N):
+            for i in range(0, V):
                 values_copy[i] = values_copy[i] - mean_val
 
         for i in range(0, N):
@@ -537,12 +605,21 @@ def roll_skew(ndarray[float64_t] values, ndarray[int64_t] start,
 
             # Over the first window, observations can only be added
             # never removed
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
+
+                prev_value = values[s]
+                num_consecutive_same_value = 0
 
+                compensation_xxx_add = compensation_xxx_remove = 0
+                compensation_xx_add = compensation_xx_remove = 0
+                compensation_x_add = compensation_x_remove = 0
+                x = xx = xxx = 0
+                nobs = 0
                 for j in range(s, e):
                     val = values_copy[j]
                     add_skew(val, &nobs, &x, &xx, &xxx, &compensation_x_add,
-                             &compensation_xx_add, &compensation_xxx_add)
+                             &compensation_xx_add, &compensation_xxx_add,
+                             &num_consecutive_same_value, &prev_value)
 
             else:
 
@@ -558,9 +635,10 @@ def roll_skew(ndarray[float64_t] values, ndarray[int64_t] start,
                 for j in range(end[i - 1], e):
                     val = values_copy[j]
                     add_skew(val, &nobs, &x, &xx, &xxx, &compensation_x_add,
-                             &compensation_xx_add, &compensation_xxx_add)
+                             &compensation_xx_add, &compensation_xxx_add,
+                             &num_consecutive_same_value, &prev_value)
 
-            output[i] = calc_skew(minp, nobs, x, xx, xxx)
+            output[i] = calc_skew(minp, nobs, x, xx, xxx, num_consecutive_same_value)
 
             if not is_monotonic_increasing_bounds:
                 nobs = 0
@@ -576,35 +654,44 @@ def roll_skew(ndarray[float64_t] values, ndarray[int64_t] start,
 
 cdef inline float64_t calc_kurt(int64_t minp, int64_t nobs,
                                 float64_t x, float64_t xx,
-                                float64_t xxx, float64_t xxxx) nogil:
+                                float64_t xxx, float64_t xxxx,
+                                int64_t num_consecutive_same_value,
+                                ) nogil:
     cdef:
         float64_t result, dnobs
         float64_t A, B, C, D, R, K
 
     if nobs >= minp:
-        dnobs = <float64_t>nobs
-        A = x / dnobs
-        R = A * A
-        B = xx / dnobs - R
-        R = R * A
-        C = xxx / dnobs - R - 3 * A * B
-        R = R * A
-        D = xxxx / dnobs - R - 6 * B * A * A - 4 * C * A
-
-        # #18044: with uniform distribution, floating issue will
-        #         cause B != 0. and cause the result is a very
-        #         large number.
-        #
-        #         in core/nanops.py nanskew/nankurt call the function
-        #         _zero_out_fperr(m2) to fix floating error.
-        #         if the variance is less than 1e-14, it could be
-        #         treat as zero, here we follow the original
-        #         skew/kurt behaviour to check B <= 1e-14
-        if B <= 1e-14 or nobs < 4:
+        if nobs < 4:
             result = NaN
+        # GH 42064 46431
+        # uniform case, force result to be -3.
+        elif num_consecutive_same_value >= nobs:
+            result = -3.
         else:
-            K = (dnobs * dnobs - 1.) * D / (B * B) - 3 * ((dnobs - 1.) ** 2)
-            result = K / ((dnobs - 2.) * (dnobs - 3.))
+            dnobs = <float64_t>nobs
+            A = x / dnobs
+            R = A * A
+            B = xx / dnobs - R
+            R = R * A
+            C = xxx / dnobs - R - 3 * A * B
+            R = R * A
+            D = xxxx / dnobs - R - 6 * B * A * A - 4 * C * A
+
+            # #18044: with uniform distribution, floating issue will
+            #         cause B != 0. and cause the result is a very
+            #         large number.
+            #
+            #         in core/nanops.py nanskew/nankurt call the function
+            #         _zero_out_fperr(m2) to fix floating error.
+            #         if the variance is less than 1e-14, it could be
+            #         treat as zero, here we follow the original
+            #         skew/kurt behaviour to check B <= 1e-14
+            if B <= 1e-14:
+                result = NaN
+            else:
+                K = (dnobs * dnobs - 1.) * D / (B * B) - 3 * ((dnobs - 1.) ** 2)
+                result = K / ((dnobs - 2.) * (dnobs - 3.))
     else:
         result = NaN
 
@@ -617,13 +704,16 @@ cdef inline void add_kurt(float64_t val, int64_t *nobs,
                           float64_t *compensation_x,
                           float64_t *compensation_xx,
                           float64_t *compensation_xxx,
-                          float64_t *compensation_xxxx) nogil:
+                          float64_t *compensation_xxxx,
+                          int64_t *num_consecutive_same_value,
+                          float64_t *prev_value
+                          ) nogil:
     """ add a value from the kurotic calc """
     cdef:
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] + 1
 
         y = val - compensation_x[0]
@@ -643,6 +733,14 @@ cdef inline void add_kurt(float64_t val, int64_t *nobs,
         compensation_xxxx[0] = t - xxxx[0] - y
         xxxx[0] = t
 
+        # GH#42064, record num of same values to remove floating point artifacts
+        if val == prev_value[0]:
+            num_consecutive_same_value[0] += 1
+        else:
+            # reset to 1 (include current value itself)
+            num_consecutive_same_value[0] = 1
+        prev_value[0] = val
+
 
 cdef inline void remove_kurt(float64_t val, int64_t *nobs,
                              float64_t *x, float64_t *xx,
@@ -656,7 +754,7 @@ cdef inline void remove_kurt(float64_t val, int64_t *nobs,
         float64_t y, t
 
     # Not NaN
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
 
         y = - val - compensation_x[0]
@@ -682,12 +780,14 @@ def roll_kurt(ndarray[float64_t] values, ndarray[int64_t] start,
     cdef:
         Py_ssize_t i, j
         float64_t val, prev, mean_val, min_val, sum_val = 0
-        float64_t compensation_xxxx_add = 0, compensation_xxxx_remove = 0
-        float64_t compensation_xxx_remove = 0, compensation_xxx_add = 0
-        float64_t compensation_xx_remove = 0, compensation_xx_add = 0
-        float64_t compensation_x_remove = 0, compensation_x_add = 0
-        float64_t x = 0, xx = 0, xxx = 0, xxxx = 0
-        int64_t nobs = 0, s, e, N = len(values), nobs_mean = 0
+        float64_t compensation_xxxx_add, compensation_xxxx_remove
+        float64_t compensation_xxx_remove, compensation_xxx_add
+        float64_t compensation_xx_remove, compensation_xx_add
+        float64_t compensation_x_remove, compensation_x_add
+        float64_t x, xx, xxx, xxxx
+        float64_t prev_value
+        int64_t nobs, s, e, num_consecutive_same_value
+        int64_t N = len(start), V = len(values), nobs_mean = 0
         ndarray[float64_t] output, values_copy
         bint is_monotonic_increasing_bounds
 
@@ -700,16 +800,16 @@ def roll_kurt(ndarray[float64_t] values, ndarray[int64_t] start,
     min_val = np.nanmin(values)
 
     with nogil:
-        for i in range(0, N):
+        for i in range(0, V):
             val = values_copy[i]
-            if notnan(val):
+            if val == val:
                 nobs_mean += 1
                 sum_val += val
         mean_val = sum_val / nobs_mean
         # Other cases would lead to imprecision for smallest values
         if min_val - mean_val > -1e4:
             mean_val = round(mean_val)
-            for i in range(0, N):
+            for i in range(0, V):
                 values_copy[i] = values_copy[i] - mean_val
 
         for i in range(0, N):
@@ -719,12 +819,22 @@ def roll_kurt(ndarray[float64_t] values, ndarray[int64_t] start,
 
             # Over the first window, observations can only be added
             # never removed
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
+
+                prev_value = values[s]
+                num_consecutive_same_value = 0
 
+                compensation_xxxx_add = compensation_xxxx_remove = 0
+                compensation_xxx_remove = compensation_xxx_add = 0
+                compensation_xx_remove = compensation_xx_add = 0
+                compensation_x_remove = compensation_x_add = 0
+                x = xx = xxx = xxxx = 0
+                nobs = 0
                 for j in range(s, e):
                     add_kurt(values_copy[j], &nobs, &x, &xx, &xxx, &xxxx,
                              &compensation_x_add, &compensation_xx_add,
-                             &compensation_xxx_add, &compensation_xxxx_add)
+                             &compensation_xxx_add, &compensation_xxxx_add,
+                             &num_consecutive_same_value, &prev_value)
 
             else:
 
@@ -740,9 +850,10 @@ def roll_kurt(ndarray[float64_t] values, ndarray[int64_t] start,
                 for j in range(end[i - 1], e):
                     add_kurt(values_copy[j], &nobs, &x, &xx, &xxx, &xxxx,
                              &compensation_x_add, &compensation_xx_add,
-                             &compensation_xxx_add, &compensation_xxxx_add)
+                             &compensation_xxx_add, &compensation_xxxx_add,
+                             &num_consecutive_same_value, &prev_value)
 
-            output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx)
+            output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx, num_consecutive_same_value)
 
             if not is_monotonic_increasing_bounds:
                 nobs = 0
@@ -764,7 +875,7 @@ def roll_median_c(const float64_t[:] values, ndarray[int64_t] start,
         Py_ssize_t i, j
         bint err = False, is_monotonic_increasing_bounds
         int midpoint, ret = 0
-        int64_t nobs = 0, N = len(values), s, e, win
+        int64_t nobs = 0, N = len(start), s, e, win
         float64_t val, res, prev
         skiplist_t *sl
         ndarray[float64_t] output
@@ -791,12 +902,16 @@ def roll_median_c(const float64_t[:] values, ndarray[int64_t] start,
             s = start[i]
             e = end[i]
 
-            if i == 0 or not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
 
+                if i != 0:
+                    skiplist_destroy(sl)
+                    sl = skiplist_init(<int>win)
+                    nobs = 0
                 # setup
                 for j in range(s, e):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         err = skiplist_insert(sl, val) == -1
                         if err:
@@ -807,7 +922,7 @@ def roll_median_c(const float64_t[:] values, ndarray[int64_t] start,
                 # calculate adds
                 for j in range(end[i - 1], e):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         err = skiplist_insert(sl, val) == -1
                         if err:
@@ -816,7 +931,7 @@ def roll_median_c(const float64_t[:] values, ndarray[int64_t] start,
                 # calculate deletes
                 for j in range(start[i - 1], s):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         skiplist_remove(sl, val)
                         nobs -= 1
             if nobs >= minp:
@@ -948,7 +1063,7 @@ cdef _roll_min_max(ndarray[numeric_t] values,
     cdef:
         numeric_t ai
         int64_t curr_win_size, start
-        Py_ssize_t i, k, nobs = 0, N = len(values)
+        Py_ssize_t i, k, nobs = 0, N = len(starti)
         deque Q[int64_t]  # min/max always the front
         deque W[int64_t]  # track the whole window for nobs compute
         ndarray[float64_t, ndim=1] output
@@ -1031,7 +1146,7 @@ def roll_quantile(const float64_t[:] values, ndarray[int64_t] start,
     O(N log(window)) implementation using skip list
     """
     cdef:
-        Py_ssize_t i, j, s, e, N = len(values), idx
+        Py_ssize_t i, j, s, e, N = len(start), idx
         int ret = 0
         int64_t nobs = 0, win
         float64_t val, prev, midpoint, idx_with_fraction
@@ -1068,8 +1183,8 @@ def roll_quantile(const float64_t[:] values, ndarray[int64_t] start,
             s = start[i]
             e = end[i]
 
-            if i == 0 or not is_monotonic_increasing_bounds:
-                if not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
+                if i != 0:
                     nobs = 0
                     skiplist_destroy(skiplist)
                     skiplist = skiplist_init(<int>win)
@@ -1077,7 +1192,7 @@ def roll_quantile(const float64_t[:] values, ndarray[int64_t] start,
                 # setup
                 for j in range(s, e):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         skiplist_insert(skiplist, val)
 
@@ -1085,14 +1200,14 @@ def roll_quantile(const float64_t[:] values, ndarray[int64_t] start,
                 # calculate adds
                 for j in range(end[i - 1], e):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         skiplist_insert(skiplist, val)
 
                 # calculate deletes
                 for j in range(start[i - 1], s):
                     val = values[j]
-                    if notnan(val):
+                    if val == val:
                         skiplist_remove(skiplist, val)
                         nobs -= 1
             if nobs >= minp:
@@ -1160,7 +1275,7 @@ def roll_rank(const float64_t[:] values, ndarray[int64_t] start,
     derived from roll_quantile
     """
     cdef:
-        Py_ssize_t i, j, s, e, N = len(values), idx
+        Py_ssize_t i, j, s, e, N = len(start), idx
         float64_t rank_min = 0, rank = 0
         int64_t nobs = 0, win
         float64_t val
@@ -1193,8 +1308,8 @@ def roll_rank(const float64_t[:] values, ndarray[int64_t] start,
             s = start[i]
             e = end[i]
 
-            if i == 0 or not is_monotonic_increasing_bounds:
-                if not is_monotonic_increasing_bounds:
+            if i == 0 or not is_monotonic_increasing_bounds or s >= end[i - 1]:
+                if i != 0:
                     nobs = 0
                     skiplist_destroy(skiplist)
                     skiplist = skiplist_init(<int>win)
@@ -1202,7 +1317,7 @@ def roll_rank(const float64_t[:] values, ndarray[int64_t] start,
                 # setup
                 for j in range(s, e):
                     val = values[j] if ascending else -values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         rank = skiplist_insert(skiplist, val)
                         if rank == -1:
@@ -1229,14 +1344,14 @@ def roll_rank(const float64_t[:] values, ndarray[int64_t] start,
                 # calculate deletes
                 for j in range(start[i - 1], s):
                     val = values[j] if ascending else -values[j]
-                    if notnan(val):
+                    if val == val:
                         skiplist_remove(skiplist, val)
                         nobs -= 1
 
                 # calculate adds
                 for j in range(end[i - 1], e):
                     val = values[j] if ascending else -values[j]
-                    if notnan(val):
+                    if val == val:
                         nobs += 1
                         rank = skiplist_insert(skiplist, val)
                         if rank == -1:
@@ -1305,13 +1420,13 @@ def roll_apply(object obj,
 
 def roll_weighted_sum(
     const float64_t[:] values, const float64_t[:] weights, int minp
-) -> np.ndaray:
+) -> np.ndarray:
     return _roll_weighted_sum_mean(values, weights, minp, avg=0)
 
 
 def roll_weighted_mean(
     const float64_t[:] values, const float64_t[:] weights, int minp
-) -> np.ndaray:
+) -> np.ndarray:
     return _roll_weighted_sum_mean(values, weights, minp, avg=1)
 
 
@@ -1472,7 +1587,7 @@ cdef inline void add_weighted_var(float64_t val,
     cdef:
         float64_t temp, q, r
 
-    if isnan(val):
+    if val != val:
         return
 
     nobs[0] = nobs[0] + 1
@@ -1518,7 +1633,7 @@ cdef inline void remove_weighted_var(float64_t val,
     cdef:
         float64_t temp, q, r
 
-    if notnan(val):
+    if val == val:
         nobs[0] = nobs[0] - 1
 
         if nobs[0]:
@@ -1574,7 +1689,7 @@ def roll_weighted_var(const float64_t[:] values, const float64_t[:] weights,
 
     with nogil:
 
-        for i in range(win_n):
+        for i in range(min(win_n, n)):
             add_weighted_var(values[i], weights[i], &t,
                              &sum_w, &mean, &nobs)
 
@@ -1588,7 +1703,7 @@ def roll_weighted_var(const float64_t[:] values, const float64_t[:] weights,
             w = weights[i % win_n]
             pre_w = weights[(i - win_n) % win_n]
 
-            if notnan(val):
+            if val == val:
                 if pre_val == pre_val:
                     remove_weighted_var(pre_val, pre_w, &t,
                                         &sum_w, &mean, &nobs)
diff --git a/pandas/_libs/window/indexers.pyx b/pandas/_libs/window/indexers.pyx
index 4b3a858ade773..465865dec23c4 100644
--- a/pandas/_libs/window/indexers.pyx
+++ b/pandas/_libs/window/indexers.pyx
@@ -52,6 +52,9 @@ def calculate_variable_window_bounds(
         int64_t start_bound, end_bound, index_growth_sign = 1
         Py_ssize_t i, j
 
+    if num_values <= 0:
+        return np.empty(0, dtype='int64'), np.empty(0, dtype='int64')
+
     # default is 'right'
     if closed is None:
         closed = 'right'
diff --git a/pandas/_libs/writers.pyi b/pandas/_libs/writers.pyi
index 930322fcbeb77..611c0c7cd1512 100644
--- a/pandas/_libs/writers.pyi
+++ b/pandas/_libs/writers.pyi
@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import numpy as np
 
 from pandas._typing import ArrayLike
@@ -17,7 +15,7 @@ def max_len_string_array(
 ) -> int: ...
 def word_len(val: object) -> int: ...
 def string_array_replace_from_nan_rep(
-    arr: np.ndarray,  #  np.ndarray[object, ndim=1]
+    arr: np.ndarray,  # np.ndarray[object, ndim=1]
     nan_rep: object,
     replace: object = ...,
 ) -> None: ...
diff --git a/pandas/_libs/writers.pyx b/pandas/_libs/writers.pyx
index eac6ee4366e33..cd42b08a03474 100644
--- a/pandas/_libs/writers.pyx
+++ b/pandas/_libs/writers.pyx
@@ -1,4 +1,4 @@
-import cython
+cimport cython
 import numpy as np
 
 from cpython cimport (
diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 0dfe3345b38e6..e0e1b49abaaab 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -3,11 +3,11 @@
 import collections
 from datetime import datetime
 from decimal import Decimal
-from functools import wraps
 import operator
 import os
 import re
 import string
+from sys import byteorder
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -19,13 +19,14 @@
 
 import numpy as np
 
-from pandas._config.localization import (  # noqa:F401
+from pandas._config.localization import (
     can_set_locale,
     get_locales,
     set_locale,
 )
 
 from pandas._typing import Dtype
+from pandas.compat import pa_version_under1p01
 
 from pandas.core.dtypes.common import (
     is_float_dtype,
@@ -48,23 +49,24 @@
     Series,
     bdate_range,
 )
-from pandas._testing._io import (  # noqa:F401
+from pandas._testing._io import (
     close,
     network,
     round_trip_localpath,
     round_trip_pathlib,
     round_trip_pickle,
-    with_connectivity_check,
     write_to_compressed,
 )
-from pandas._testing._random import (  # noqa:F401
+from pandas._testing._random import (
     randbool,
     rands,
     rands_array,
-    randu_array,
 )
-from pandas._testing._warnings import assert_produces_warning  # noqa:F401
-from pandas._testing.asserters import (  # noqa:F401
+from pandas._testing._warnings import (
+    assert_produces_warning,
+    maybe_produces_warning,
+)
+from pandas._testing.asserters import (
     assert_almost_equal,
     assert_attr_equal,
     assert_categorical_equal,
@@ -89,11 +91,11 @@
     assert_timedelta_array_equal,
     raise_assert_detail,
 )
-from pandas._testing.compat import (  # noqa:F401
+from pandas._testing.compat import (
     get_dtype,
     get_obj,
 )
-from pandas._testing.contexts import (  # noqa:F401
+from pandas._testing.contexts import (
     RNGContext,
     decompress_file,
     ensure_clean,
@@ -168,6 +170,8 @@
     np.uint32,
 ]
 
+ENDIAN = {"little": "<", "big": ">"}[byteorder]
+
 NULL_OBJECTS = [None, np.nan, pd.NaT, float("nan"), pd.NA, Decimal("NaN")]
 NP_NAT_OBJECTS = [
     cls("NaT", unit)
@@ -189,13 +193,52 @@
     ]
 ]
 
+if not pa_version_under1p01:
+    import pyarrow as pa
+
+    UNSIGNED_INT_PYARROW_DTYPES = [pa.uint8(), pa.uint16(), pa.uint32(), pa.uint64()]
+    SIGNED_INT_PYARROW_DTYPES = [pa.int8(), pa.int16(), pa.int32(), pa.int64()]
+    ALL_INT_PYARROW_DTYPES = UNSIGNED_INT_PYARROW_DTYPES + SIGNED_INT_PYARROW_DTYPES
+
+    FLOAT_PYARROW_DTYPES = [pa.float32(), pa.float64()]
+    STRING_PYARROW_DTYPES = [pa.string(), pa.utf8()]
+
+    TIME_PYARROW_DTYPES = [
+        pa.time32("s"),
+        pa.time32("ms"),
+        pa.time64("us"),
+        pa.time64("ns"),
+    ]
+    DATE_PYARROW_DTYPES = [pa.date32(), pa.date64()]
+    DATETIME_PYARROW_DTYPES = [
+        pa.timestamp(unit=unit, tz=tz)
+        for unit in ["s", "ms", "us", "ns"]
+        for tz in [None, "UTC", "US/Pacific", "US/Eastern"]
+    ]
+    TIMEDELTA_PYARROW_DTYPES = [pa.duration(unit) for unit in ["s", "ms", "us", "ns"]]
+
+    BOOL_PYARROW_DTYPES = [pa.bool_()]
+
+    # TODO: Add container like pyarrow types:
+    #  https://arrow.apache.org/docs/python/api/datatypes.html#factory-functions
+    ALL_PYARROW_DTYPES = (
+        ALL_INT_PYARROW_DTYPES
+        + FLOAT_PYARROW_DTYPES
+        + TIME_PYARROW_DTYPES
+        + DATE_PYARROW_DTYPES
+        + DATETIME_PYARROW_DTYPES
+        + TIMEDELTA_PYARROW_DTYPES
+        + BOOL_PYARROW_DTYPES
+    )
+
+
 EMPTY_STRING_PATTERN = re.compile("^$")
 
 # set testing_mode
 _testing_mode_warnings = (DeprecationWarning, ResourceWarning)
 
 
-def set_testing_mode():
+def set_testing_mode() -> None:
     # set the testing mode filters
     testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
     if "deprecate" in testing_mode:
@@ -203,7 +246,7 @@ def set_testing_mode():
             warnings.simplefilter("always", category)
 
 
-def reset_testing_mode():
+def reset_testing_mode() -> None:
     # reset the testing mode filters
     testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
     if "deprecate" in testing_mode:
@@ -214,7 +257,7 @@ def reset_testing_mode():
 set_testing_mode()
 
 
-def reset_display_options():
+def reset_display_options() -> None:
     """
     Reset the display options for printing and representing objects.
     """
@@ -290,34 +333,30 @@ def to_array(obj):
 # Others
 
 
-def getCols(k):
+def getCols(k) -> str:
     return string.ascii_uppercase[:k]
 
 
 # make index
-def makeStringIndex(k=10, name=None):
+def makeStringIndex(k=10, name=None) -> Index:
     return Index(rands_array(nchars=10, size=k), name=name)
 
 
-def makeUnicodeIndex(k=10, name=None):
-    return Index(randu_array(nchars=10, size=k), name=name)
-
-
-def makeCategoricalIndex(k=10, n=3, name=None, **kwargs):
+def makeCategoricalIndex(k=10, n=3, name=None, **kwargs) -> CategoricalIndex:
     """make a length k index or n categories"""
-    x = rands_array(nchars=4, size=n)
+    x = rands_array(nchars=4, size=n, replace=False)
     return CategoricalIndex(
         Categorical.from_codes(np.arange(k) % n, categories=x), name=name, **kwargs
     )
 
 
-def makeIntervalIndex(k=10, name=None, **kwargs):
+def makeIntervalIndex(k=10, name=None, **kwargs) -> IntervalIndex:
     """make a length k IntervalIndex"""
     x = np.linspace(0, 100, num=(k + 1))
     return IntervalIndex.from_breaks(x, name=name, **kwargs)
 
 
-def makeBoolIndex(k=10, name=None):
+def makeBoolIndex(k=10, name=None) -> Index:
     if k == 1:
         return Index([True], name=name)
     elif k == 2:
@@ -325,7 +364,7 @@ def makeBoolIndex(k=10, name=None):
     return Index([False, True] + [False] * (k - 2), name=name)
 
 
-def makeNumericIndex(k=10, name=None, *, dtype):
+def makeNumericIndex(k=10, name=None, *, dtype) -> NumericIndex:
     dtype = pandas_dtype(dtype)
     assert isinstance(dtype, np.dtype)
 
@@ -343,21 +382,21 @@ def makeNumericIndex(k=10, name=None, *, dtype):
     return NumericIndex(values, dtype=dtype, name=name)
 
 
-def makeIntIndex(k=10, name=None):
+def makeIntIndex(k=10, name=None) -> Int64Index:
     base_idx = makeNumericIndex(k, name=name, dtype="int64")
     return Int64Index(base_idx)
 
 
-def makeUIntIndex(k=10, name=None):
+def makeUIntIndex(k=10, name=None) -> UInt64Index:
     base_idx = makeNumericIndex(k, name=name, dtype="uint64")
     return UInt64Index(base_idx)
 
 
-def makeRangeIndex(k=10, name=None, **kwargs):
+def makeRangeIndex(k=10, name=None, **kwargs) -> RangeIndex:
     return RangeIndex(0, k, 1, name=name, **kwargs)
 
 
-def makeFloatIndex(k=10, name=None):
+def makeFloatIndex(k=10, name=None) -> Float64Index:
     base_idx = makeNumericIndex(k, name=name, dtype="float64")
     return Float64Index(base_idx)
 
@@ -378,88 +417,11 @@ def makePeriodIndex(k: int = 10, name=None, **kwargs) -> PeriodIndex:
 
 
 def makeMultiIndex(k=10, names=None, **kwargs):
-    return MultiIndex.from_product((("foo", "bar"), (1, 2)), names=names, **kwargs)
-
-
-_names = [
-    "Alice",
-    "Bob",
-    "Charlie",
-    "Dan",
-    "Edith",
-    "Frank",
-    "George",
-    "Hannah",
-    "Ingrid",
-    "Jerry",
-    "Kevin",
-    "Laura",
-    "Michael",
-    "Norbert",
-    "Oliver",
-    "Patricia",
-    "Quinn",
-    "Ray",
-    "Sarah",
-    "Tim",
-    "Ursula",
-    "Victor",
-    "Wendy",
-    "Xavier",
-    "Yvonne",
-    "Zelda",
-]
-
-
-def _make_timeseries(start="2000-01-01", end="2000-12-31", freq="1D", seed=None):
-    """
-    Make a DataFrame with a DatetimeIndex
-
-    Parameters
-    ----------
-    start : str or Timestamp, default "2000-01-01"
-        The start of the index. Passed to date_range with `freq`.
-    end : str or Timestamp, default "2000-12-31"
-        The end of the index. Passed to date_range with `freq`.
-    freq : str or Freq
-        The frequency to use for the DatetimeIndex
-    seed : int, optional
-        The random state seed.
-
-        * name : object dtype with string names
-        * id : int dtype with
-        * x, y : float dtype
-
-    Examples
-    --------
-    >>> _make_timeseries()  # doctest: +SKIP
-                  id    name         x         y
-    timestamp
-    2000-01-01   982   Frank  0.031261  0.986727
-    2000-01-02  1025   Edith -0.086358 -0.032920
-    2000-01-03   982   Edith  0.473177  0.298654
-    2000-01-04  1009   Sarah  0.534344 -0.750377
-    2000-01-05   963   Zelda -0.271573  0.054424
-    ...          ...     ...       ...       ...
-    2000-12-27   980  Ingrid -0.132333 -0.422195
-    2000-12-28   972   Frank -0.376007 -0.298687
-    2000-12-29  1009  Ursula -0.865047 -0.503133
-    2000-12-30  1000  Hannah -0.063757 -0.507336
-    2000-12-31   972     Tim -0.869120  0.531685
-    """
-    index = pd.date_range(start=start, end=end, freq=freq, name="timestamp")
-    n = len(index)
-    state = np.random.RandomState(seed)
-    columns = {
-        "name": state.choice(_names, size=n),
-        "id": state.poisson(1000, size=n),
-        "x": state.rand(n) * 2 - 1,
-        "y": state.rand(n) * 2 - 1,
-    }
-    df = DataFrame(columns, index=index, columns=sorted(columns))
-    if df.index[-1] == end:
-        df = df.iloc[:-1]
-    return df
+    N = (k // 2) + 1
+    rng = range(N)
+    mi = MultiIndex.from_product([("foo", "bar"), rng], names=names, **kwargs)
+    assert len(mi) >= k  # GH#38795
+    return mi[:k]
 
 
 def index_subclass_makers_generator():
@@ -494,29 +456,35 @@ def all_timeseries_index_generator(k: int = 10) -> Iterable[Index]:
 
 
 # make series
-def makeFloatSeries(name=None):
+def make_rand_series(name=None, dtype=np.float64) -> Series:
     index = makeStringIndex(_N)
-    return Series(np.random.randn(_N), index=index, name=name)
+    data = np.random.randn(_N)
+    with np.errstate(invalid="ignore"):
+        data = data.astype(dtype, copy=False)
+    return Series(data, index=index, name=name)
 
 
-def makeStringSeries(name=None):
-    index = makeStringIndex(_N)
-    return Series(np.random.randn(_N), index=index, name=name)
+def makeFloatSeries(name=None) -> Series:
+    return make_rand_series(name=name)
+
 
+def makeStringSeries(name=None) -> Series:
+    return make_rand_series(name=name)
 
-def makeObjectSeries(name=None):
+
+def makeObjectSeries(name=None) -> Series:
     data = makeStringIndex(_N)
     data = Index(data, dtype=object)
     index = makeStringIndex(_N)
     return Series(data, index=index, name=name)
 
 
-def getSeriesData():
+def getSeriesData() -> dict[str, Series]:
     index = makeStringIndex(_N)
     return {c: Series(np.random.randn(_N), index=index) for c in getCols(_K)}
 
 
-def makeTimeSeries(nper=None, freq="B", name=None):
+def makeTimeSeries(nper=None, freq="B", name=None) -> Series:
     if nper is None:
         nper = _N
     return Series(
@@ -524,22 +492,22 @@ def makeTimeSeries(nper=None, freq="B", name=None):
     )
 
 
-def makePeriodSeries(nper=None, name=None):
+def makePeriodSeries(nper=None, name=None) -> Series:
     if nper is None:
         nper = _N
     return Series(np.random.randn(nper), index=makePeriodIndex(nper), name=name)
 
 
-def getTimeSeriesData(nper=None, freq="B"):
+def getTimeSeriesData(nper=None, freq="B") -> dict[str, Series]:
     return {c: makeTimeSeries(nper, freq) for c in getCols(_K)}
 
 
-def getPeriodData(nper=None):
+def getPeriodData(nper=None) -> dict[str, Series]:
     return {c: makePeriodSeries(nper) for c in getCols(_K)}
 
 
 # make frame
-def makeTimeDataFrame(nper=None, freq="B"):
+def makeTimeDataFrame(nper=None, freq="B") -> DataFrame:
     data = getTimeSeriesData(nper, freq)
     return DataFrame(data)
 
@@ -562,18 +530,23 @@ def getMixedTypeDict():
     return index, data
 
 
-def makeMixedDataFrame():
+def makeMixedDataFrame() -> DataFrame:
     return DataFrame(getMixedTypeDict()[1])
 
 
-def makePeriodFrame(nper=None):
+def makePeriodFrame(nper=None) -> DataFrame:
     data = getPeriodData(nper)
     return DataFrame(data)
 
 
 def makeCustomIndex(
-    nentries, nlevels, prefix="#", names=False, ndupe_l=None, idx_type=None
-):
+    nentries,
+    nlevels,
+    prefix="#",
+    names: bool | str | list[str] | None = False,
+    ndupe_l=None,
+    idx_type=None,
+) -> Index:
     """
     Create an index/multindex with given dimensions, levels, names, etc'
 
@@ -587,10 +560,10 @@ def makeCustomIndex(
        label will repeated at the corresponding level, you can specify just
        the first few, the rest will use the default ndupe_l of 1.
        len(ndupe_l) <= nlevels.
-    idx_type - "i"/"f"/"s"/"u"/"dt"/"p"/"td".
+    idx_type - "i"/"f"/"s"/"dt"/"p"/"td".
        If idx_type is not None, `idx_nlevels` must be 1.
        "i"/"f" creates an integer/float index,
-       "s"/"u" creates a string/unicode index
+       "s" creates a string
        "dt" create a datetime index.
        "td" create a datetime index.
 
@@ -620,7 +593,6 @@ def makeCustomIndex(
         "i": makeIntIndex,
         "f": makeFloatIndex,
         "s": makeStringIndex,
-        "u": makeUnicodeIndex,
         "dt": makeDateIndex,
         "td": makeTimedeltaIndex,
         "p": makePeriodIndex,
@@ -635,7 +607,7 @@ def makeCustomIndex(
     elif idx_type is not None:
         raise ValueError(
             f"{repr(idx_type)} is not a legal value for `idx_type`, "
-            "use  'i'/'f'/'s'/'u'/'dt'/'p'/'td'."
+            "use  'i'/'f'/'s'/'dt'/'p'/'td'."
         )
 
     if len(ndupe_l) < nlevels:
@@ -671,7 +643,8 @@ def keyfunc(x):
     # convert tuples to index
     if nentries == 1:
         # we have a single level of tuples, i.e. a regular Index
-        index = Index(tuples[0], name=names[0])
+        name = None if names is None else names[0]
+        index = Index(tuples[0], name=name)
     elif nlevels == 1:
         name = None if names is None else names[0]
         index = Index((x[0] for x in tuples), name=name)
@@ -693,7 +666,7 @@ def makeCustomDataframe(
     dtype=None,
     c_idx_type=None,
     r_idx_type=None,
-):
+) -> DataFrame:
     """
     Create a DataFrame using supplied parameters.
 
@@ -717,10 +690,10 @@ def makeCustomDataframe(
             nrows/ncol, the last label might have lower multiplicity.
     dtype - passed to the DataFrame constructor as is, in case you wish to
             have more control in conjunction with a custom `data_gen_f`
-    r_idx_type, c_idx_type -  "i"/"f"/"s"/"u"/"dt"/"td".
+    r_idx_type, c_idx_type -  "i"/"f"/"s"/"dt"/"td".
         If idx_type is not None, `idx_nlevels` must be 1.
         "i"/"f" creates an integer/float index,
-        "s"/"u" creates a string/unicode index
+        "s" creates a string index
         "dt" create a datetime index.
         "td" create a timedelta index.
 
@@ -755,10 +728,10 @@ def makeCustomDataframe(
     assert c_idx_nlevels > 0
     assert r_idx_nlevels > 0
     assert r_idx_type is None or (
-        r_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and r_idx_nlevels == 1
+        r_idx_type in ("i", "f", "s", "dt", "p", "td") and r_idx_nlevels == 1
     )
     assert c_idx_type is None or (
-        c_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and c_idx_nlevels == 1
+        c_idx_type in ("i", "f", "s", "dt", "p", "td") and c_idx_nlevels == 1
     )
 
     columns = makeCustomIndex(
@@ -814,72 +787,28 @@ def _gen_unique_rand(rng, _extra_size):
     return i.tolist(), j.tolist()
 
 
-def makeMissingDataframe(density=0.9, random_state=None):
+def makeMissingDataframe(density=0.9, random_state=None) -> DataFrame:
     df = makeDataFrame()
     i, j = _create_missing_idx(*df.shape, density=density, random_state=random_state)
     df.values[i, j] = np.nan
     return df
 
 
-def test_parallel(num_threads=2, kwargs_list=None):
-    """
-    Decorator to run the same function multiple times in parallel.
-
-    Parameters
-    ----------
-    num_threads : int, optional
-        The number of times the function is run in parallel.
-    kwargs_list : list of dicts, optional
-        The list of kwargs to update original
-        function kwargs on different threads.
-
-    Notes
-    -----
-    This decorator does not pass the return value of the decorated function.
-
-    Original from scikit-image:
-
-    https://github.com/scikit-image/scikit-image/pull/1519
-
-    """
-    assert num_threads > 0
-    has_kwargs_list = kwargs_list is not None
-    if has_kwargs_list:
-        assert len(kwargs_list) == num_threads
-    import threading
-
-    def wrapper(func):
-        @wraps(func)
-        def inner(*args, **kwargs):
-            if has_kwargs_list:
-                update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
-            else:
-                update_kwargs = lambda i: kwargs
-            threads = []
-            for i in range(num_threads):
-                updated_kwargs = update_kwargs(i)
-                thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
-                threads.append(thread)
-            for thread in threads:
-                thread.start()
-            for thread in threads:
-                thread.join()
-
-        return inner
-
-    return wrapper
-
-
 class SubclassedSeries(Series):
     _metadata = ["testattr", "name"]
 
     @property
     def _constructor(self):
-        return SubclassedSeries
+        # For testing, those properties return a generic callable, and not
+        # the actual class. In this case that is equivalent, but it is to
+        # ensure we don't rely on the property returning a class
+        # See https://github.com/pandas-dev/pandas/pull/46018 and
+        # https://github.com/pandas-dev/pandas/issues/32638 and linked issues
+        return lambda *args, **kwargs: SubclassedSeries(*args, **kwargs)
 
     @property
     def _constructor_expanddim(self):
-        return SubclassedDataFrame
+        return lambda *args, **kwargs: SubclassedDataFrame(*args, **kwargs)
 
 
 class SubclassedDataFrame(DataFrame):
@@ -887,11 +816,11 @@ class SubclassedDataFrame(DataFrame):
 
     @property
     def _constructor(self):
-        return SubclassedDataFrame
+        return lambda *args, **kwargs: SubclassedDataFrame(*args, **kwargs)
 
     @property
     def _constructor_sliced(self):
-        return SubclassedSeries
+        return lambda *args, **kwargs: SubclassedSeries(*args, **kwargs)
 
 
 class SubclassedCategorical(Categorical):
@@ -932,7 +861,7 @@ def skipna_wrapper(x):
     return skipna_wrapper
 
 
-def convert_rows_list_to_csv_str(rows_list: list[str]):
+def convert_rows_list_to_csv_str(rows_list: list[str]) -> str:
     """
     Convert list of CSV rows to single CSV-formatted string for current OS.
 
@@ -1105,3 +1034,128 @@ def shares_memory(left, right) -> bool:
         return shares_memory(arr, right)
 
     raise NotImplementedError(type(left), type(right))
+
+
+__all__ = [
+    "ALL_INT_EA_DTYPES",
+    "ALL_INT_NUMPY_DTYPES",
+    "ALL_NUMPY_DTYPES",
+    "ALL_REAL_NUMPY_DTYPES",
+    "all_timeseries_index_generator",
+    "assert_almost_equal",
+    "assert_attr_equal",
+    "assert_categorical_equal",
+    "assert_class_equal",
+    "assert_contains_all",
+    "assert_copy",
+    "assert_datetime_array_equal",
+    "assert_dict_equal",
+    "assert_equal",
+    "assert_extension_array_equal",
+    "assert_frame_equal",
+    "assert_index_equal",
+    "assert_indexing_slices_equivalent",
+    "assert_interval_array_equal",
+    "assert_is_sorted",
+    "assert_is_valid_plot_return_object",
+    "assert_metadata_equivalent",
+    "assert_numpy_array_equal",
+    "assert_period_array_equal",
+    "assert_produces_warning",
+    "assert_series_equal",
+    "assert_sp_array_equal",
+    "assert_timedelta_array_equal",
+    "at",
+    "BOOL_DTYPES",
+    "box_expected",
+    "BYTES_DTYPES",
+    "can_set_locale",
+    "close",
+    "COMPLEX_DTYPES",
+    "convert_rows_list_to_csv_str",
+    "DATETIME64_DTYPES",
+    "decompress_file",
+    "EMPTY_STRING_PATTERN",
+    "ENDIAN",
+    "ensure_clean",
+    "ensure_clean_dir",
+    "ensure_safe_environment_variables",
+    "equalContents",
+    "external_error_raised",
+    "FLOAT_EA_DTYPES",
+    "FLOAT_NUMPY_DTYPES",
+    "getCols",
+    "get_cython_table_params",
+    "get_dtype",
+    "getitem",
+    "get_locales",
+    "getMixedTypeDict",
+    "get_obj",
+    "get_op_from_name",
+    "getPeriodData",
+    "getSeriesData",
+    "getTimeSeriesData",
+    "iat",
+    "iloc",
+    "index_subclass_makers_generator",
+    "loc",
+    "makeBoolIndex",
+    "makeCategoricalIndex",
+    "makeCustomDataframe",
+    "makeCustomIndex",
+    "makeDataFrame",
+    "makeDateIndex",
+    "makeFloatIndex",
+    "makeFloatSeries",
+    "makeIntervalIndex",
+    "makeIntIndex",
+    "makeMissingDataframe",
+    "makeMixedDataFrame",
+    "makeMultiIndex",
+    "makeNumericIndex",
+    "makeObjectSeries",
+    "makePeriodFrame",
+    "makePeriodIndex",
+    "makePeriodSeries",
+    "make_rand_series",
+    "makeRangeIndex",
+    "makeStringIndex",
+    "makeStringSeries",
+    "makeTimeDataFrame",
+    "makeTimedeltaIndex",
+    "makeTimeSeries",
+    "makeUIntIndex",
+    "maybe_produces_warning",
+    "NARROW_NP_DTYPES",
+    "network",
+    "NP_NAT_OBJECTS",
+    "NULL_OBJECTS",
+    "OBJECT_DTYPES",
+    "raise_assert_detail",
+    "randbool",
+    "rands",
+    "reset_display_options",
+    "reset_testing_mode",
+    "RNGContext",
+    "round_trip_localpath",
+    "round_trip_pathlib",
+    "round_trip_pickle",
+    "setitem",
+    "set_locale",
+    "set_testing_mode",
+    "set_timezone",
+    "shares_memory",
+    "SIGNED_INT_EA_DTYPES",
+    "SIGNED_INT_NUMPY_DTYPES",
+    "STRING_DTYPES",
+    "SubclassedCategorical",
+    "SubclassedDataFrame",
+    "SubclassedSeries",
+    "TIMEDELTA64_DTYPES",
+    "to_array",
+    "UNSIGNED_INT_EA_DTYPES",
+    "UNSIGNED_INT_NUMPY_DTYPES",
+    "use_numexpr",
+    "with_csv_dialect",
+    "write_to_compressed",
+]
diff --git a/pandas/_testing/_io.py b/pandas/_testing/_io.py
index 097af99dbfd88..d1acdff8d2fd7 100644
--- a/pandas/_testing/_io.py
+++ b/pandas/_testing/_io.py
@@ -3,6 +3,9 @@
 import bz2
 from functools import wraps
 import gzip
+import io
+import socket
+import tarfile
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -29,8 +32,6 @@
         Series,
     )
 
-_RAISE_NETWORK_ERROR_DEFAULT = False
-
 # skip tests on exceptions with these messages
 _network_error_messages = (
     # 'urlopen error timed out',
@@ -70,10 +71,18 @@
 
 
 def _get_default_network_errors():
-    # Lazy import for http.client because it imports many things from the stdlib
+    # Lazy import for http.client & urllib.error
+    # because it imports many things from the stdlib
     import http.client
-
-    return (OSError, http.client.HTTPException, TimeoutError)
+    import urllib.error
+
+    return (
+        OSError,
+        http.client.HTTPException,
+        TimeoutError,
+        urllib.error.URLError,
+        socket.timeout,
+    )
 
 
 def optional_args(decorator):
@@ -108,7 +117,7 @@ def dec(f):
 def network(
     t,
     url="https://www.google.com/",
-    raise_on_error=_RAISE_NETWORK_ERROR_DEFAULT,
+    raise_on_error=False,
     check_before_test=False,
     error_classes=None,
     skip_errnos=_network_errno_vals,
@@ -163,8 +172,8 @@ def network(
     Tests decorated with @network will fail if it's possible to make a network
     connection to another URL (defaults to google.com)::
 
-      >>> from pandas import _testing as ts
-      >>> @ts.network
+      >>> from pandas import _testing as tm
+      >>> @tm.network
       ... def test_network():
       ...     with pd.io.common.urlopen("rabbit://bonanza.com"):
       ...         pass
@@ -175,10 +184,10 @@ def network(
 
       You can specify alternative URLs::
 
-        >>> @ts.network("https://www.yahoo.com/")
+        >>> @tm.network("https://www.yahoo.com/")
         ... def test_something_with_yahoo():
         ...    raise OSError("Failure Message")
-        >>> test_something_with_yahoo()
+        >>> test_something_with_yahoo()  # doctest: +SKIP
         Traceback (most recent call last):
             ...
         OSError: Failure Message
@@ -186,7 +195,7 @@ def network(
     If you set check_before_test, it will check the url first and not run the
     test on failure::
 
-        >>> @ts.network("failing://url.blaher", check_before_test=True)
+        >>> @tm.network("failing://url.blaher", check_before_test=True)
         ... def test_something():
         ...     print("I ran!")
         ...     raise ValueError("Failure")
@@ -196,7 +205,7 @@ def network(
 
     Errors not related to networking will always be raised.
     """
-    from pytest import skip
+    import pytest
 
     if error_classes is None:
         error_classes = _get_default_network_errors()
@@ -210,7 +219,9 @@ def wrapper(*args, **kwargs):
             and not raise_on_error
             and not can_connect(url, error_classes)
         ):
-            skip()
+            pytest.skip(
+                f"May not have network connectivity because cannot connect to {url}"
+            )
         try:
             return t(*args, **kwargs)
         except Exception as err:
@@ -220,30 +231,26 @@ def wrapper(*args, **kwargs):
                 errno = getattr(err.reason, "errno", None)  # type: ignore[attr-defined]
 
             if errno in skip_errnos:
-                skip(f"Skipping test due to known errno and error {err}")
+                pytest.skip(f"Skipping test due to known errno and error {err}")
 
             e_str = str(err)
 
             if any(m.lower() in e_str.lower() for m in _skip_on_messages):
-                skip(
+                pytest.skip(
                     f"Skipping test because exception message is known and error {err}"
                 )
 
-            if not isinstance(err, error_classes):
-                raise
-
-            if raise_on_error or can_connect(url, error_classes):
+            if not isinstance(err, error_classes) or raise_on_error:
                 raise
             else:
-                skip(f"Skipping test due to lack of connectivity and error {err}")
+                pytest.skip(
+                    f"Skipping test due to lack of connectivity and error {err}"
+                )
 
     return wrapper
 
 
-with_connectivity_check = network
-
-
-def can_connect(url, error_classes=None):
+def can_connect(url, error_classes=None) -> bool:
     """
     Try to connect to the given url. True if succeeds, False if OSError
     raised
@@ -263,8 +270,10 @@ def can_connect(url, error_classes=None):
         error_classes = _get_default_network_errors()
 
     try:
-        with urlopen(url):
-            pass
+        with urlopen(url, timeout=20) as response:
+            # Timeout just in case rate-limiting is applied
+            if response.status != 200:
+                return False
     except error_classes:
         return False
     else:
@@ -388,6 +397,14 @@ def write_to_compressed(compression, path, data, dest="test"):
         mode = "w"
         args = (dest, data)
         method = "writestr"
+    elif compression == "tar":
+        compress_method = tarfile.TarFile
+        mode = "w"
+        file = tarfile.TarInfo(name=dest)
+        bytes = io.BytesIO(data)
+        file.size = len(data)
+        args = (file, bytes)
+        method = "addfile"
     elif compression == "gzip":
         compress_method = gzip.GzipFile
     elif compression == "bz2":
@@ -407,7 +424,7 @@ def write_to_compressed(compression, path, data, dest="test"):
 # Plotting
 
 
-def close(fignum=None):
+def close(fignum=None) -> None:
     from matplotlib.pyplot import (
         close as _close,
         get_fignums,
diff --git a/pandas/_testing/_random.py b/pandas/_testing/_random.py
index a646d7639a4e6..880fffea21bd1 100644
--- a/pandas/_testing/_random.py
+++ b/pandas/_testing/_random.py
@@ -14,31 +14,19 @@ def randbool(size=(), p: float = 0.5):
 )
 
 
-def rands_array(nchars, size, dtype="O"):
+def rands_array(nchars, size, dtype="O", replace=True) -> np.ndarray:
     """
     Generate an array of byte strings.
     """
     retval = (
-        np.random.choice(RANDS_CHARS, size=nchars * np.prod(size))
+        np.random.choice(RANDS_CHARS, size=nchars * np.prod(size), replace=replace)
         .view((np.str_, nchars))
         .reshape(size)
     )
     return retval.astype(dtype)
 
 
-def randu_array(nchars, size, dtype="O"):
-    """
-    Generate an array of unicode strings.
-    """
-    retval = (
-        np.random.choice(RANDU_CHARS, size=nchars * np.prod(size))
-        .view((np.unicode_, nchars))
-        .reshape(size)
-    )
-    return retval.astype(dtype)
-
-
-def rands(nchars):
+def rands(nchars) -> str:
     """
     Generate one random byte string.
 
diff --git a/pandas/_testing/_warnings.py b/pandas/_testing/_warnings.py
index 44a62e607555e..a5b0d1e199863 100644
--- a/pandas/_testing/_warnings.py
+++ b/pandas/_testing/_warnings.py
@@ -1,9 +1,13 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
+from contextlib import (
+    contextmanager,
+    nullcontext,
+)
 import re
-import subprocess
+import sys
 from typing import (
+    Literal,
     Sequence,
     Type,
     cast,
@@ -13,23 +17,26 @@
 
 @contextmanager
 def assert_produces_warning(
-    expected_warning: type[Warning] | bool | None = Warning,
-    filter_level="always",
+    expected_warning: type[Warning] | bool | tuple[type[Warning], ...] | None = Warning,
+    filter_level: Literal[
+        "error", "ignore", "always", "default", "module", "once"
+    ] = "always",
     check_stacklevel: bool = True,
     raise_on_extra_warnings: bool = True,
     match: str | None = None,
 ):
     """
-    Context manager for running code expected to either raise a specific
-    warning, or not raise any warnings. Verifies that the code raises the
-    expected warning, and that it does not raise any other unexpected
+    Context manager for running code expected to either raise a specific warning,
+    multiple specific warnings, or not raise any warnings. Verifies that the code
+    raises the expected warning(s), and that it does not raise any other unexpected
     warnings. It is basically a wrapper around ``warnings.catch_warnings``.
 
     Parameters
     ----------
-    expected_warning : {Warning, False, None}, default Warning
+    expected_warning : {Warning, False, tuple[Warning, ...], None}, default Warning
         The type of Exception raised. ``exception.Warning`` is the base
-        class for all warnings. To check that no warning is returned,
+        class for all warnings. To raise multiple types of exceptions,
+        pass them as a tuple. To check that no warning is returned,
         specify ``False`` or ``None``.
     filter_level : str or None, default "always"
         Specifies whether warnings are ignored, displayed, or turned
@@ -97,6 +104,16 @@ class for all warnings. To check that no warning is returned,
             )
 
 
+def maybe_produces_warning(warning: type[Warning], condition: bool, **kwargs):
+    """
+    Return a context manager that possibly checks a warning based on the condition
+    """
+    if condition:
+        return assert_produces_warning(warning, **kwargs)
+    else:
+        return nullcontext()
+
+
 def _assert_caught_expected_warning(
     *,
     caught_warnings: Sequence[warnings.WarningMessage],
@@ -113,9 +130,7 @@ def _assert_caught_expected_warning(
         if issubclass(actual_warning.category, expected_warning):
             saw_warning = True
 
-            if check_stacklevel and issubclass(
-                actual_warning.category, (FutureWarning, DeprecationWarning)
-            ):
+            if check_stacklevel:
                 _assert_raised_with_correct_stacklevel(actual_warning)
 
             if match is not None:
@@ -141,7 +156,7 @@ def _assert_caught_expected_warning(
 def _assert_caught_no_extra_warnings(
     *,
     caught_warnings: Sequence[warnings.WarningMessage],
-    expected_warning: type[Warning] | bool | None,
+    expected_warning: type[Warning] | bool | tuple[type[Warning], ...] | None,
 ) -> None:
     """Assert that no extra warnings apart from the expected ones are caught."""
     extra_warnings = []
@@ -159,15 +174,9 @@ def _assert_caught_no_extra_warnings(
                 if any(msg in str(actual_warning.message) for msg in unclosed_ssl):
                     continue
                 # GH 44844: Matplotlib leaves font files open during the entire process
-                # Don't make CI flaky if ResourceWarning raised due to these open files.
-                try:
-                    lsof = subprocess.check_output(
-                        ["lsof", "-d", "0-25", "-F", "n"]
-                    ).decode("utf-8")
-                except (subprocess.CalledProcessError, FileNotFoundError):
-                    # FileNotFoundError for Windows
-                    lsof = ""
-                if re.search(r"\.ttf|\.ttc|\.otf", lsof):
+                # upon import. Don't make CI flaky if ResourceWarning raised
+                # due to these open files.
+                if any("matplotlib" in mod for mod in sys.modules):
                     continue
 
             extra_warnings.append(
@@ -185,7 +194,7 @@ def _assert_caught_no_extra_warnings(
 
 def _is_unexpected_warning(
     actual_warning: warnings.WarningMessage,
-    expected_warning: type[Warning] | bool | None,
+    expected_warning: type[Warning] | bool | tuple[type[Warning], ...] | None,
 ) -> bool:
     """Check if the actual warning issued is unexpected."""
     if actual_warning and not expected_warning:
diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
index ea75af20bb0b6..6c3b8960d6697 100644
--- a/pandas/_testing/asserters.py
+++ b/pandas/_testing/asserters.py
@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from typing import cast
+from typing import (
+    Literal,
+    cast,
+)
 import warnings
 
 import numpy as np
@@ -10,6 +13,7 @@
     no_default,
 )
 from pandas._libs.missing import is_matching_na
+from pandas._libs.sparse import SparseIndex
 import pandas._libs.testing as _testing
 from pandas.util._exceptions import find_stack_level
 
@@ -41,10 +45,7 @@
     Series,
     TimedeltaIndex,
 )
-from pandas.core.algorithms import (
-    safe_sort,
-    take_nd,
-)
+from pandas.core.algorithms import take_nd
 from pandas.core.arrays import (
     DatetimeArray,
     ExtensionArray,
@@ -54,6 +55,7 @@
 )
 from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
 from pandas.core.arrays.string_ import StringDtype
+from pandas.core.indexes.api import safe_sort_index
 
 from pandas.io.formats.printing import pprint_thing
 
@@ -61,12 +63,12 @@
 def assert_almost_equal(
     left,
     right,
-    check_dtype: bool | str = "equiv",
+    check_dtype: bool | Literal["equiv"] = "equiv",
     check_less_precise: bool | int | NoDefault = no_default,
     rtol: float = 1.0e-5,
     atol: float = 1.0e-8,
     **kwargs,
-):
+) -> None:
     """
     Check that the left and right objects are approximately equal.
 
@@ -112,12 +114,7 @@ def assert_almost_equal(
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        # https://github.com/python/mypy/issues/7642
-        # error: Argument 1 to "_get_tol_from_less_precise" has incompatible
-        # type "Union[bool, int, NoDefault]"; expected "Union[bool, int]"
-        rtol = atol = _get_tol_from_less_precise(
-            check_less_precise  # type: ignore[arg-type]
-        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
 
     if isinstance(left, Index):
         assert_index_equal(
@@ -169,9 +166,8 @@ def assert_almost_equal(
                 assert_class_equal(left, right, obj=obj)
 
         # if we have "equiv", this becomes True
-        check_dtype = bool(check_dtype)
         _testing.assert_almost_equal(
-            left, right, check_dtype=check_dtype, rtol=rtol, atol=atol, **kwargs
+            left, right, check_dtype=bool(check_dtype), rtol=rtol, atol=atol, **kwargs
         )
 
 
@@ -212,7 +208,7 @@ def _get_tol_from_less_precise(check_less_precise: bool | int) -> float:
             return 0.5e-5
     else:
         # Equivalent to setting checking_less_precise=<decimals>
-        return 0.5 * 10 ** -check_less_precise
+        return 0.5 * 10**-check_less_precise
 
 
 def _check_isinstance(left, right, cls):
@@ -243,7 +239,7 @@ def _check_isinstance(left, right, cls):
         )
 
 
-def assert_dict_equal(left, right, compare_keys: bool = True):
+def assert_dict_equal(left, right, compare_keys: bool = True) -> None:
 
     _check_isinstance(left, right, dict)
     _testing.assert_dict_equal(left, right, compare_keys=compare_keys)
@@ -345,12 +341,7 @@ def _get_ilevel_values(index, level):
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        # https://github.com/python/mypy/issues/7642
-        # error: Argument 1 to "_get_tol_from_less_precise" has incompatible
-        # type "Union[bool, int, NoDefault]"; expected "Union[bool, int]"
-        rtol = atol = _get_tol_from_less_precise(
-            check_less_precise  # type: ignore[arg-type]
-        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
 
     # instance validation
     _check_isinstance(left, right, Index)
@@ -374,8 +365,8 @@ def _get_ilevel_values(index, level):
 
     # If order doesn't matter then sort the index entries
     if not check_order:
-        left = Index(safe_sort(left))
-        right = Index(safe_sort(right))
+        left = safe_sort_index(left)
+        right = safe_sort_index(right)
 
     # MultiIndex special comparison for little-friendly error messages
     if left.nlevels > 1:
@@ -406,6 +397,9 @@ def _get_ilevel_values(index, level):
         if not left.equals(right):
             mismatch = left._values != right._values
 
+            if is_extension_array_dtype(mismatch):
+                mismatch = cast("ExtensionArray", mismatch).fillna(True)
+
             diff = np.sum(mismatch.astype(int)) * 100.0 / len(left)
             msg = f"{obj} values are different ({np.round(diff, 5)} %)"
             raise_assert_detail(obj, msg, left, right)
@@ -437,7 +431,7 @@ def _get_ilevel_values(index, level):
             assert_categorical_equal(left._values, right._values, obj=f"{obj} category")
 
 
-def assert_class_equal(left, right, exact: bool | str = True, obj="Input"):
+def assert_class_equal(left, right, exact: bool | str = True, obj="Input") -> None:
     """
     Checks classes are equal.
     """
@@ -464,7 +458,7 @@ def repr_class(x):
     raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
 
 
-def assert_attr_equal(attr: str, left, right, obj: str = "Attributes"):
+def assert_attr_equal(attr: str, left, right, obj: str = "Attributes") -> None:
     """
     Check attributes are equal. Both objects must have attribute.
 
@@ -483,11 +477,9 @@ def assert_attr_equal(attr: str, left, right, obj: str = "Attributes"):
     left_attr = getattr(left, attr)
     right_attr = getattr(right, attr)
 
-    if left_attr is right_attr:
-        return True
-    elif is_matching_na(left_attr, right_attr):
+    if left_attr is right_attr or is_matching_na(left_attr, right_attr):
         # e.g. both np.nan, both NaT, both pd.NA, ...
-        return True
+        return None
 
     try:
         result = left_attr == right_attr
@@ -499,14 +491,13 @@ def assert_attr_equal(attr: str, left, right, obj: str = "Attributes"):
     elif not isinstance(result, bool):
         result = result.all()
 
-    if result:
-        return True
-    else:
+    if not result:
         msg = f'Attribute "{attr}" are different'
         raise_assert_detail(obj, msg, left_attr, right_attr)
+    return None
 
 
-def assert_is_valid_plot_return_object(objs):
+def assert_is_valid_plot_return_object(objs) -> None:
     import matplotlib.pyplot as plt
 
     if isinstance(objs, (Series, np.ndarray)):
@@ -525,7 +516,7 @@ def assert_is_valid_plot_return_object(objs):
         assert isinstance(objs, (plt.Artist, tuple, dict)), msg
 
 
-def assert_is_sorted(seq):
+def assert_is_sorted(seq) -> None:
     """Assert that the sequence is sorted."""
     if isinstance(seq, (Index, Series)):
         seq = seq.values
@@ -535,7 +526,7 @@ def assert_is_sorted(seq):
 
 def assert_categorical_equal(
     left, right, check_dtype=True, check_category_order=True, obj="Categorical"
-):
+) -> None:
     """
     Test that Categoricals are equivalent.
 
@@ -590,7 +581,9 @@ def assert_categorical_equal(
     assert_attr_equal("ordered", left, right, obj=obj)
 
 
-def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray"):
+def assert_interval_array_equal(
+    left, right, exact="equiv", obj="IntervalArray"
+) -> None:
     """
     Test that two IntervalArrays are equivalent.
 
@@ -619,14 +612,16 @@ def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray")
     assert_attr_equal("closed", left, right, obj=obj)
 
 
-def assert_period_array_equal(left, right, obj="PeriodArray"):
+def assert_period_array_equal(left, right, obj="PeriodArray") -> None:
     _check_isinstance(left, right, PeriodArray)
 
     assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
     assert_attr_equal("freq", left, right, obj=obj)
 
 
-def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=True):
+def assert_datetime_array_equal(
+    left, right, obj="DatetimeArray", check_freq=True
+) -> None:
     __tracebackhide__ = True
     _check_isinstance(left, right, DatetimeArray)
 
@@ -636,7 +631,9 @@ def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=Tru
     assert_attr_equal("tz", left, right, obj=obj)
 
 
-def assert_timedelta_array_equal(left, right, obj="TimedeltaArray", check_freq=True):
+def assert_timedelta_array_equal(
+    left, right, obj="TimedeltaArray", check_freq=True
+) -> None:
     __tracebackhide__ = True
     _check_isinstance(left, right, TimedeltaArray)
     assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
@@ -686,12 +683,12 @@ def assert_numpy_array_equal(
     left,
     right,
     strict_nan=False,
-    check_dtype=True,
+    check_dtype: bool | Literal["equiv"] = True,
     err_msg=None,
     check_same=None,
     obj="numpy array",
     index_values=None,
-):
+) -> None:
     """
     Check that 'np.ndarray' is equivalent.
 
@@ -765,13 +762,13 @@ def _raise(left, right, err_msg):
 def assert_extension_array_equal(
     left,
     right,
-    check_dtype=True,
+    check_dtype: bool | Literal["equiv"] = True,
     index_values=None,
     check_less_precise=no_default,
     check_exact=False,
     rtol: float = 1.0e-5,
     atol: float = 1.0e-8,
-):
+) -> None:
     """
     Check that left and right ExtensionArrays are equal.
 
@@ -848,8 +845,8 @@ def assert_extension_array_equal(
         left_na, right_na, obj="ExtensionArray NA mask", index_values=index_values
     )
 
-    left_valid = np.asarray(left[~left_na].astype(object))
-    right_valid = np.asarray(right[~right_na].astype(object))
+    left_valid = left[~left_na].to_numpy(dtype=object)
+    right_valid = right[~right_na].to_numpy(dtype=object)
     if check_exact:
         assert_numpy_array_equal(
             left_valid, right_valid, obj="ExtensionArray", index_values=index_values
@@ -858,7 +855,7 @@ def assert_extension_array_equal(
         _testing.assert_almost_equal(
             left_valid,
             right_valid,
-            check_dtype=check_dtype,
+            check_dtype=bool(check_dtype),
             rtol=rtol,
             atol=atol,
             obj="ExtensionArray",
@@ -870,10 +867,10 @@ def assert_extension_array_equal(
 def assert_series_equal(
     left,
     right,
-    check_dtype=True,
-    check_index_type="equiv",
+    check_dtype: bool | Literal["equiv"] = True,
+    check_index_type: bool | Literal["equiv"] = "equiv",
     check_series_type=True,
-    check_less_precise=no_default,
+    check_less_precise: bool | int | NoDefault = no_default,
     check_names=True,
     check_exact=False,
     check_datetimelike_compat=False,
@@ -886,7 +883,8 @@ def assert_series_equal(
     obj="Series",
     *,
     check_index=True,
-):
+    check_like=False,
+) -> None:
     """
     Check that left and right Series are equal.
 
@@ -951,6 +949,11 @@ def assert_series_equal(
         Whether to check index equivalence. If False, then compare only values.
 
         .. versionadded:: 1.3.0
+    check_like : bool, default False
+        If True, ignore the order of the index. Must be False if check_index is False.
+        Note: same labels must be with the same data.
+
+        .. versionadded:: 1.5.0
 
     Examples
     --------
@@ -961,6 +964,9 @@ def assert_series_equal(
     """
     __tracebackhide__ = True
 
+    if not check_index and check_like:
+        raise ValueError("check_like must be False if check_index is False")
+
     if check_less_precise is not no_default:
         warnings.warn(
             "The 'check_less_precise' keyword in testing.assert_*_equal "
@@ -995,11 +1001,15 @@ def assert_series_equal(
             check_names=check_names,
             check_exact=check_exact,
             check_categorical=check_categorical,
+            check_order=not check_like,
             rtol=rtol,
             atol=atol,
             obj=f"{obj}.index",
         )
 
+    if check_like:
+        left, right = left.reindex_like(right), right
+
     if check_freq and isinstance(left.index, (DatetimeIndex, TimedeltaIndex)):
         lidx = left.index
         ridx = right.index
@@ -1064,7 +1074,7 @@ def assert_series_equal(
             right._values,
             rtol=rtol,
             atol=atol,
-            check_dtype=check_dtype,
+            check_dtype=bool(check_dtype),
             obj=str(obj),
             index_values=np.asarray(left.index),
         )
@@ -1100,7 +1110,7 @@ def assert_series_equal(
             right._values,
             rtol=rtol,
             atol=atol,
-            check_dtype=check_dtype,
+            check_dtype=bool(check_dtype),
             obj=str(obj),
             index_values=np.asarray(left.index),
         )
@@ -1125,8 +1135,8 @@ def assert_series_equal(
 def assert_frame_equal(
     left,
     right,
-    check_dtype=True,
-    check_index_type="equiv",
+    check_dtype: bool | Literal["equiv"] = True,
+    check_index_type: bool | Literal["equiv"] = "equiv",
     check_column_type="equiv",
     check_frame_type=True,
     check_less_precise=no_default,
@@ -1141,12 +1151,12 @@ def assert_frame_equal(
     rtol=1.0e-5,
     atol=1.0e-8,
     obj="DataFrame",
-):
+) -> None:
     """
     Check that left and right DataFrame are equal.
 
     This function is intended to compare two DataFrames and output any
-    differences. Is is mostly intended for use in unit tests.
+    differences. It is mostly intended for use in unit tests.
     Additional parameters allow varying the strictness of the
     equality checks performed.
 
@@ -1344,10 +1354,11 @@ def assert_frame_equal(
                 rtol=rtol,
                 atol=atol,
                 check_index=False,
+                check_flags=False,
             )
 
 
-def assert_equal(left, right, **kwargs):
+def assert_equal(left, right, **kwargs) -> None:
     """
     Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
 
@@ -1388,7 +1399,7 @@ def assert_equal(left, right, **kwargs):
         assert_almost_equal(left, right)
 
 
-def assert_sp_array_equal(left, right):
+def assert_sp_array_equal(left, right) -> None:
     """
     Check that the left and right SparseArray are equal.
 
@@ -1402,8 +1413,8 @@ def assert_sp_array_equal(left, right):
     assert_numpy_array_equal(left.sp_values, right.sp_values)
 
     # SparseIndex comparison
-    assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
-    assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
+    assert isinstance(left.sp_index, SparseIndex)
+    assert isinstance(right.sp_index, SparseIndex)
 
     left_index = left.sp_index
     right_index = right.sp_index
@@ -1421,12 +1432,12 @@ def assert_sp_array_equal(left, right):
     assert_numpy_array_equal(left.to_dense(), right.to_dense())
 
 
-def assert_contains_all(iterable, dic):
+def assert_contains_all(iterable, dic) -> None:
     for k in iterable:
         assert k in dic, f"Did not contain item: {repr(k)}"
 
 
-def assert_copy(iter1, iter2, **eql_kwargs):
+def assert_copy(iter1, iter2, **eql_kwargs) -> None:
     """
     iter1, iter2: iterables that produce elements
     comparable with assert_almost_equal
@@ -1458,7 +1469,7 @@ def is_extension_array_dtype_and_needs_i8_conversion(left_dtype, right_dtype) ->
     return is_extension_array_dtype(left_dtype) and needs_i8_conversion(right_dtype)
 
 
-def assert_indexing_slices_equivalent(ser: Series, l_slc: slice, i_slc: slice):
+def assert_indexing_slices_equivalent(ser: Series, l_slc: slice, i_slc: slice) -> None:
     """
     Check that ser.iloc[i_slc] matches ser.loc[l_slc] and, if applicable,
     ser[l_slc].
@@ -1472,7 +1483,7 @@ def assert_indexing_slices_equivalent(ser: Series, l_slc: slice, i_slc: slice):
         assert_series_equal(ser[l_slc], expected)
 
 
-def assert_metadata_equivalent(left, right):
+def assert_metadata_equivalent(left, right) -> None:
     """
     Check that ._metadata attributes are equivalent.
     """
diff --git a/pandas/_testing/contexts.py b/pandas/_testing/contexts.py
index 5a77c06d65d07..e64adb06bea7a 100644
--- a/pandas/_testing/contexts.py
+++ b/pandas/_testing/contexts.py
@@ -3,14 +3,14 @@
 from contextlib import contextmanager
 import os
 from pathlib import Path
-import random
 from shutil import rmtree
-import string
 import tempfile
 from typing import (
     IO,
     Any,
+    Iterator,
 )
+import uuid
 
 import numpy as np
 
@@ -20,7 +20,7 @@
 
 
 @contextmanager
-def decompress_file(path, compression):
+def decompress_file(path, compression) -> Iterator[IO[bytes]]:
     """
     Open a compressed file and return a file object.
 
@@ -41,7 +41,7 @@ def decompress_file(path, compression):
 
 
 @contextmanager
-def set_timezone(tz: str):
+def set_timezone(tz: str) -> Iterator[None]:
     """
     Context manager for temporarily setting a timezone.
 
@@ -107,9 +107,7 @@ def ensure_clean(filename=None, return_filelike: bool = False, **kwargs: Any):
 
     if filename is None:
         filename = ""
-    filename = (
-        "".join(random.choices(string.ascii_letters + string.digits, k=30)) + filename
-    )
+    filename = str(uuid.uuid4()) + filename
     path = folder / filename
 
     path.touch()
@@ -129,7 +127,7 @@ def ensure_clean(filename=None, return_filelike: bool = False, **kwargs: Any):
 
 
 @contextmanager
-def ensure_clean_dir():
+def ensure_clean_dir() -> Iterator[str]:
     """
     Get a temporary directory path and agrees to remove on close.
 
@@ -148,7 +146,7 @@ def ensure_clean_dir():
 
 
 @contextmanager
-def ensure_safe_environment_variables():
+def ensure_safe_environment_variables() -> Iterator[None]:
     """
     Get a context manager to safely set environment variables
 
@@ -164,7 +162,7 @@ def ensure_safe_environment_variables():
 
 
 @contextmanager
-def with_csv_dialect(name, **kwargs):
+def with_csv_dialect(name, **kwargs) -> Iterator[None]:
     """
     Context manager to temporarily register a CSV dialect for parsing CSV.
 
@@ -198,7 +196,7 @@ def with_csv_dialect(name, **kwargs):
 
 
 @contextmanager
-def use_numexpr(use, min_elements=None):
+def use_numexpr(use, min_elements=None) -> Iterator[None]:
     from pandas.core.computation import expressions as expr
 
     if min_elements is None:
@@ -231,14 +229,14 @@ class RNGContext:
         np.random.randn()
     """
 
-    def __init__(self, seed):
+    def __init__(self, seed) -> None:
         self.seed = seed
 
-    def __enter__(self):
+    def __enter__(self) -> None:
 
         self.start_state = np.random.get_state()
         np.random.seed(self.seed)
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
 
         np.random.set_state(self.start_state)
diff --git a/pandas/_typing.py b/pandas/_typing.py
index 5c8f0be39f712..03fb5fcb1b0d4 100644
--- a/pandas/_typing.py
+++ b/pandas/_typing.py
@@ -10,7 +10,6 @@
     TYPE_CHECKING,
     Any,
     Callable,
-    Collection,
     Dict,
     Hashable,
     Iterator,
@@ -35,10 +34,12 @@
     import numpy.typing as npt
 
     from pandas._libs import (
+        NaTType,
         Period,
         Timedelta,
         Timestamp,
     )
+    from pandas._libs.tslibs import BaseOffset
 
     from pandas.core.dtypes.dtypes import ExtensionDtype
 
@@ -63,15 +64,25 @@
     from pandas.core.window.rolling import BaseWindow
 
     from pandas.io.formats.format import EngFormatter
-    from pandas.tseries.offsets import DateOffset
+
+    ScalarLike_co = Union[
+        int,
+        float,
+        complex,
+        str,
+        bytes,
+        np.generic,
+    ]
 
     # numpy compatible types
-    NumpyValueArrayLike = Union[npt._ScalarLike_co, npt.ArrayLike]
-    NumpySorter = Optional[npt._ArrayLikeInt_co]
+    NumpyValueArrayLike = Union[ScalarLike_co, npt.ArrayLike]
+    # Name "npt._ArrayLikeInt_co" is not defined  [name-defined]
+    NumpySorter = Optional[npt._ArrayLikeInt_co]  # type: ignore[name-defined]
 
 else:
     npt: Any = None
 
+HashableT = TypeVar("HashableT", bound=Hashable)
 
 # array-like
 
@@ -80,20 +91,20 @@
 
 # scalars
 
-PythonScalar = Union[str, int, float, bool]
+PythonScalar = Union[str, float, bool]
 DatetimeLikeScalar = Union["Period", "Timestamp", "Timedelta"]
 PandasScalar = Union["Period", "Timestamp", "Timedelta", "Interval"]
-Scalar = Union[PythonScalar, PandasScalar]
+Scalar = Union[PythonScalar, PandasScalar, np.datetime64, np.timedelta64, datetime]
 IntStrT = TypeVar("IntStrT", int, str)
 
 
 # timestamp and timedelta convertible types
 
 TimestampConvertibleTypes = Union[
-    "Timestamp", datetime, np.datetime64, int, np.int64, float, str
+    "Timestamp", datetime, np.datetime64, np.int64, float, str
 ]
 TimedeltaConvertibleTypes = Union[
-    "Timedelta", timedelta, np.timedelta64, int, np.int64, float, str
+    "Timedelta", timedelta, np.timedelta64, np.int64, float, str
 ]
 Timezone = Union[str, tzinfo]
 
@@ -103,15 +114,17 @@
 # passed in, a DataFrame is always returned.
 NDFrameT = TypeVar("NDFrameT", bound="NDFrame")
 
+NumpyIndexT = TypeVar("NumpyIndexT", np.ndarray, "Index")
+
 Axis = Union[str, int]
 IndexLabel = Union[Hashable, Sequence[Hashable]]
-Level = Union[Hashable, int]
+Level = Hashable
 Shape = Tuple[int, ...]
 Suffixes = Tuple[Optional[str], Optional[str]]
 Ordered = Optional[bool]
 JSONSerializable = Optional[Union[PythonScalar, List, Dict]]
-Frequency = Union[str, "DateOffset"]
-Axes = Collection[Any]
+Frequency = Union[str, "BaseOffset"]
+Axes = Union[AnyArrayLike, List, range]
 
 RandomState = Union[
     int,
@@ -122,15 +135,23 @@
 ]
 
 # dtypes
-NpDtype = Union[str, np.dtype, type_t[Union[str, float, int, complex, bool, object]]]
+NpDtype = Union[str, np.dtype, type_t[Union[str, complex, bool, object]]]
 Dtype = Union["ExtensionDtype", NpDtype]
 AstypeArg = Union["ExtensionDtype", "npt.DTypeLike"]
 # DtypeArg specifies all allowable dtypes in a functions its dtype argument
 DtypeArg = Union[Dtype, Dict[Hashable, Dtype]]
 DtypeObj = Union[np.dtype, "ExtensionDtype"]
 
+# converters
+ConvertersArg = Dict[Hashable, Callable[[Dtype], Dtype]]
+
+# parse_dates
+ParseDatesArg = Union[
+    bool, List[Hashable], List[List[Hashable]], Dict[Hashable, List[Hashable]]
+]
+
 # For functions like rename that convert one label to another
-Renamer = Union[Mapping[Hashable, Any], Callable[[Hashable], Hashable]]
+Renamer = Union[Mapping[Any, Hashable], Callable[[Any], Hashable]]
 
 # to maintain type information across generic functions and parametrization
 T = TypeVar("T")
@@ -244,10 +265,8 @@ def closed(self) -> bool:
 # compression keywords and compression
 CompressionDict = Dict[str, Any]
 CompressionOptions = Optional[
-    Union[Literal["infer", "gzip", "bz2", "zip", "xz", "zstd"], CompressionDict]
+    Union[Literal["infer", "gzip", "bz2", "zip", "xz", "zstd", "tar"], CompressionDict]
 ]
-XMLParsers = Literal["lxml", "etree"]
-
 
 # types in DataFrameFormatter
 FormattersType = Union[
@@ -290,5 +309,32 @@ def closed(self) -> bool:
 else:
     TakeIndexer = Any
 
+# Shared by functions such as drop and astype
+IgnoreRaise = Literal["ignore", "raise"]
+
 # Windowing rank methods
 WindowingRankType = Literal["average", "min", "max"]
+
+# read_csv engines
+CSVEngine = Literal["c", "python", "pyarrow", "python-fwf"]
+
+# read_xml parsers
+XMLParsers = Literal["lxml", "etree"]
+
+# Interval closed type
+IntervalLeftRight = Literal["left", "right"]
+IntervalClosedType = Union[IntervalLeftRight, Literal["both", "neither"]]
+
+# datetime and NaTType
+DatetimeNaTType = Union[datetime, "NaTType"]
+DateTimeErrorChoices = Union[IgnoreRaise, Literal["coerce"]]
+
+# sort_index
+SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"]
+NaPosition = Literal["first", "last"]
+
+# quantile interpolation
+QuantileInterpolation = Literal["linear", "lower", "higher", "midpoint", "nearest"]
+
+# plotting
+PlottingOrientation = Literal["horizontal", "vertical"]
diff --git a/pandas/_version.py b/pandas/_version.py
index fbec4a694d721..923b268919671 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -199,7 +199,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # refs/heads/ and refs/tags/ prefixes that would let us distinguish
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
-        # "stabilization", as well as "HEAD" and "master".
+        # "stabilization", as well as "HEAD" and "main".
         tags = {r for r in refs if re.search(r"\d", r)}
         if verbose:
             print("discarding '%s', no digits" % ",".join(refs - tags))
diff --git a/pandas/api/__init__.py b/pandas/api/__init__.py
index 80202b3569862..9d4f721225d93 100644
--- a/pandas/api/__init__.py
+++ b/pandas/api/__init__.py
@@ -1,6 +1,14 @@
 """ public toolkit API """
-from pandas.api import (  # noqa:F401
+from pandas.api import (
     extensions,
     indexers,
+    interchange,
     types,
 )
+
+__all__ = [
+    "interchange",
+    "extensions",
+    "indexers",
+    "types",
+]
diff --git a/pandas/api/interchange/__init__.py b/pandas/api/interchange/__init__.py
new file mode 100644
index 0000000000000..2f3a73bc46b31
--- /dev/null
+++ b/pandas/api/interchange/__init__.py
@@ -0,0 +1,8 @@
+"""
+Public API for DataFrame interchange protocol.
+"""
+
+from pandas.core.interchange.dataframe_protocol import DataFrame
+from pandas.core.interchange.from_dataframe import from_dataframe
+
+__all__ = ["from_dataframe", "DataFrame"]
diff --git a/pandas/arrays/__init__.py b/pandas/arrays/__init__.py
index 89d362eb77e68..3a8e80a6b5d2b 100644
--- a/pandas/arrays/__init__.py
+++ b/pandas/arrays/__init__.py
@@ -4,6 +4,7 @@
 See :ref:`extending.extension-types` for more.
 """
 from pandas.core.arrays import (
+    ArrowExtensionArray,
     ArrowStringArray,
     BooleanArray,
     Categorical,
@@ -19,6 +20,7 @@
 )
 
 __all__ = [
+    "ArrowExtensionArray",
     "ArrowStringArray",
     "BooleanArray",
     "Categorical",
diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index f9b16419917f2..80f66c945ba27 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -7,26 +7,38 @@
 Other items:
 * platform checker
 """
+from __future__ import annotations
+
+import os
 import platform
 import sys
+from typing import TYPE_CHECKING
 
 from pandas._typing import F
 from pandas.compat.numpy import (
     is_numpy_dev,
-    np_version_under1p19,
-    np_version_under1p20,
+    np_version_under1p21,
 )
 from pandas.compat.pyarrow import (
     pa_version_under1p01,
     pa_version_under2p0,
     pa_version_under3p0,
     pa_version_under4p0,
+    pa_version_under5p0,
+    pa_version_under6p0,
+    pa_version_under7p0,
+    pa_version_under8p0,
+    pa_version_under9p0,
 )
 
+if TYPE_CHECKING:
+    import lzma
+
 PY39 = sys.version_info >= (3, 9)
 PY310 = sys.version_info >= (3, 10)
+PY311 = sys.version_info >= (3, 11)
 PYPY = platform.python_implementation() == "PyPy"
-IS64 = sys.maxsize > 2 ** 32
+IS64 = sys.maxsize > 2**32
 
 
 def set_function_name(f: F, name: str, cls) -> F:
@@ -89,7 +101,7 @@ def is_platform_mac() -> bool:
 
 def is_platform_arm() -> bool:
     """
-    Checking if he running platform use ARM architecture.
+    Checking if the running platform use ARM architecture.
 
     Returns
     -------
@@ -101,7 +113,20 @@ def is_platform_arm() -> bool:
     )
 
 
-def get_lzma_file():
+def is_ci_environment() -> bool:
+    """
+    Checking if running in a continuous integration environment by checking
+    the PANDAS_CI environment variable.
+
+    Returns
+    -------
+    bool
+        True if the running in a continuous integration environment.
+    """
+    return os.environ.get("PANDAS_CI", "0") == "1"
+
+
+def get_lzma_file() -> type[lzma.LZMAFile]:
     """
     Importing the `LZMAFile` class from the `lzma` module.
 
@@ -128,10 +153,14 @@ def get_lzma_file():
 
 __all__ = [
     "is_numpy_dev",
-    "np_version_under1p19",
-    "np_version_under1p20",
+    "np_version_under1p21",
     "pa_version_under1p01",
     "pa_version_under2p0",
     "pa_version_under3p0",
     "pa_version_under4p0",
+    "pa_version_under5p0",
+    "pa_version_under6p0",
+    "pa_version_under7p0",
+    "pa_version_under8p0",
+    "pa_version_under9p0",
 ]
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index a2be663504abe..3caa92758dd52 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -5,36 +5,48 @@
 import types
 import warnings
 
+from pandas.util._exceptions import find_stack_level
+
 from pandas.util.version import Version
 
 # Update install.rst when updating versions!
 
 VERSIONS = {
-    "bs4": "4.8.2",
-    "bottleneck": "1.3.1",
-    "fsspec": "0.7.4",
+    "bs4": "4.9.3",
+    "blosc": "1.21.0",
+    "bottleneck": "1.3.2",
+    "brotli": "0.7.0",
     "fastparquet": "0.4.0",
-    "gcsfs": "0.6.0",
-    "lxml.etree": "4.5.0",
+    "fsspec": "2021.07.0",
+    "html5lib": "1.1",
+    "hypothesis": "6.13.0",
+    "gcsfs": "2021.07.0",
+    "jinja2": "3.0.0",
+    "lxml.etree": "4.6.3",
     "matplotlib": "3.3.2",
-    "numexpr": "2.7.1",
+    "numba": "0.53.1",
+    "numexpr": "2.7.3",
     "odfpy": "1.4.1",
-    "openpyxl": "3.0.3",
-    "pandas_gbq": "0.14.0",
+    "openpyxl": "3.0.7",
+    "pandas_gbq": "0.15.0",
+    "psycopg2": "2.8.6",  # (dt dec pq3 ext lo64)
+    "pymysql": "1.0.2",
     "pyarrow": "1.0.1",
+    "pyreadstat": "1.1.2",
     "pytest": "6.0",
-    "pyxlsb": "1.0.6",
-    "s3fs": "0.4.0",
-    "scipy": "1.4.1",
-    "sqlalchemy": "1.4.0",
+    "pyxlsb": "1.0.8",
+    "s3fs": "2021.08.0",
+    "scipy": "1.7.1",
+    "snappy": "0.6.0",
+    "sqlalchemy": "1.4.16",
     "tables": "3.6.1",
-    "tabulate": "0.8.7",
-    "xarray": "0.15.1",
+    "tabulate": "0.8.9",
+    "xarray": "0.19.0",
     "xlrd": "2.0.1",
     "xlwt": "1.3.0",
-    "xlsxwriter": "1.2.2",
-    "numba": "0.50.1",
+    "xlsxwriter": "1.4.3",
     "zstandard": "0.15.2",
+    "tzdata": "2022.1",
 }
 
 # A mapping from import name to package name (on PyPI) for packages where
@@ -43,11 +55,14 @@
 INSTALL_MAPPING = {
     "bs4": "beautifulsoup4",
     "bottleneck": "Bottleneck",
+    "brotli": "brotlipy",
+    "jinja2": "Jinja2",
     "lxml.etree": "lxml",
     "odf": "odfpy",
     "pandas_gbq": "pandas-gbq",
+    "snappy": "python-snappy",
     "sqlalchemy": "SQLAlchemy",
-    "jinja2": "Jinja2",
+    "tables": "pytables",
 }
 
 
@@ -58,7 +73,17 @@ def get_version(module: types.ModuleType) -> str:
         version = getattr(module, "__VERSION__", None)
 
     if version is None:
+        if module.__name__ == "brotli":
+            # brotli doesn't contain attributes to confirm it's version
+            return ""
+        if module.__name__ == "snappy":
+            # snappy doesn't contain attributes to confirm it's version
+            # See https://github.com/andrix/python-snappy/pull/119
+            return ""
         raise ImportError(f"Can't determine version for {module.__name__}")
+    if module.__name__ == "psycopg2":
+        # psycopg2 appends " (dt dec pq3 ext lo64)" to it's version
+        version = version.split()[0]
     return version
 
 
@@ -130,13 +155,17 @@ def import_optional_dependency(
     minimum_version = min_version if min_version is not None else VERSIONS.get(parent)
     if minimum_version:
         version = get_version(module_to_get)
-        if Version(version) < Version(minimum_version):
+        if version and Version(version) < Version(minimum_version):
             msg = (
                 f"Pandas requires version '{minimum_version}' or newer of '{parent}' "
                 f"(version '{version}' currently installed)."
             )
             if errors == "warn":
-                warnings.warn(msg, UserWarning)
+                warnings.warn(
+                    msg,
+                    UserWarning,
+                    stacklevel=find_stack_level(),
+                )
                 return None
             elif errors == "raise":
                 raise ImportError(msg)
diff --git a/pandas/compat/chainmap.py b/pandas/compat/chainmap.py
index 9af7962fe4ad0..5bec8e5fa1913 100644
--- a/pandas/compat/chainmap.py
+++ b/pandas/compat/chainmap.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import (
     ChainMap,
     TypeVar,
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index c6666551ffad6..6f31358dabe86 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -6,12 +6,12 @@
 # numpy versioning
 _np_version = np.__version__
 _nlv = Version(_np_version)
-np_version_under1p19 = _nlv < Version("1.19")
-np_version_under1p20 = _nlv < Version("1.20")
+np_version_under1p21 = _nlv < Version("1.21")
 np_version_under1p22 = _nlv < Version("1.22")
-np_version_is1p22 = _nlv == Version("1.22")
+np_version_gte1p22 = _nlv >= Version("1.22")
+np_version_gte1p24 = _nlv >= Version("1.24")
 is_numpy_dev = _nlv.dev is not None
-_min_numpy_ver = "1.18.5"
+_min_numpy_ver = "1.20.3"
 
 if is_numpy_dev or not np_version_under1p22:
     np_percentile_argname = "method"
diff --git a/pandas/compat/numpy/function.py b/pandas/compat/numpy/function.py
index cea1b80d340c8..140d41782e6d3 100644
--- a/pandas/compat/numpy/function.py
+++ b/pandas/compat/numpy/function.py
@@ -17,7 +17,11 @@
 """
 from __future__ import annotations
 
-from typing import Any
+from typing import (
+    Any,
+    TypeVar,
+    overload,
+)
 
 from numpy import ndarray
 
@@ -25,6 +29,7 @@
     is_bool,
     is_integer,
 )
+from pandas._typing import Axis
 from pandas.errors import UnsupportedFunctionCall
 from pandas.util._validators import (
     validate_args,
@@ -32,6 +37,8 @@
     validate_kwargs,
 )
 
+AxisNoneT = TypeVar("AxisNoneT", Axis, None)
+
 
 class CompatValidator:
     def __init__(
@@ -40,7 +47,7 @@ def __init__(
         fname=None,
         method: str | None = None,
         max_fname_arg_count=None,
-    ):
+    ) -> None:
         self.fname = fname
         self.method = method
         self.defaults = defaults
@@ -84,7 +91,7 @@ def __call__(
 )
 
 
-def process_skipna(skipna, args):
+def process_skipna(skipna: bool | ndarray | None, args) -> tuple[bool, Any]:
     if isinstance(skipna, ndarray) or skipna is None:
         args = (skipna,) + args
         skipna = True
@@ -92,7 +99,7 @@ def process_skipna(skipna, args):
     return skipna, args
 
 
-def validate_argmin_with_skipna(skipna, args, kwargs):
+def validate_argmin_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool:
     """
     If 'Series.argmin' is called via the 'numpy' library, the third parameter
     in its signature is 'out', which takes either an ndarray or 'None', so
@@ -104,7 +111,7 @@ def validate_argmin_with_skipna(skipna, args, kwargs):
     return skipna
 
 
-def validate_argmax_with_skipna(skipna, args, kwargs):
+def validate_argmax_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool:
     """
     If 'Series.argmax' is called via the 'numpy' library, the third parameter
     in its signature is 'out', which takes either an ndarray or 'None', so
@@ -137,7 +144,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
 )
 
 
-def validate_argsort_with_ascending(ascending, args, kwargs):
+def validate_argsort_with_ascending(ascending: bool | int | None, args, kwargs) -> bool:
     """
     If 'Categorical.argsort' is called via the 'numpy' library, the first
     parameter in its signature is 'axis', which takes either an integer or
@@ -149,7 +156,8 @@ def validate_argsort_with_ascending(ascending, args, kwargs):
         ascending = True
 
     validate_argsort_kind(args, kwargs, max_fname_arg_count=3)
-    return ascending
+    # error: Incompatible return value type (got "int", expected "bool")
+    return ascending  # type: ignore[return-value]
 
 
 CLIP_DEFAULTS: dict[str, Any] = {"out": None}
@@ -158,7 +166,19 @@ def validate_argsort_with_ascending(ascending, args, kwargs):
 )
 
 
-def validate_clip_with_axis(axis, args, kwargs):
+@overload
+def validate_clip_with_axis(axis: ndarray, args, kwargs) -> None:
+    ...
+
+
+@overload
+def validate_clip_with_axis(axis: AxisNoneT, args, kwargs) -> AxisNoneT:
+    ...
+
+
+def validate_clip_with_axis(
+    axis: ndarray | AxisNoneT, args, kwargs
+) -> AxisNoneT | None:
     """
     If 'NDFrame.clip' is called via the numpy library, the third parameter in
     its signature is 'out', which can takes an ndarray, so check if the 'axis'
@@ -167,10 +187,14 @@ def validate_clip_with_axis(axis, args, kwargs):
     """
     if isinstance(axis, ndarray):
         args = (axis,) + args
-        axis = None
+        # error: Incompatible types in assignment (expression has type "None",
+        # variable has type "Union[ndarray[Any, Any], str, int]")
+        axis = None  # type: ignore[assignment]
 
     validate_clip(args, kwargs)
-    return axis
+    # error: Incompatible return value type (got "Union[ndarray[Any, Any],
+    # str, int]", expected "Union[str, int, None]")
+    return axis  # type: ignore[return-value]
 
 
 CUM_FUNC_DEFAULTS: dict[str, Any] = {}
@@ -184,7 +208,7 @@ def validate_clip_with_axis(axis, args, kwargs):
 )
 
 
-def validate_cum_func_with_skipna(skipna, args, kwargs, name):
+def validate_cum_func_with_skipna(skipna, args, kwargs, name) -> bool:
     """
     If this function is called via the 'numpy' library, the third parameter in
     its signature is 'dtype', which takes either a 'numpy' dtype or 'None', so
@@ -288,7 +312,7 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
 validate_take = CompatValidator(TAKE_DEFAULTS, fname="take", method="kwargs")
 
 
-def validate_take_with_convert(convert, args, kwargs):
+def validate_take_with_convert(convert: ndarray | bool | None, args, kwargs) -> bool:
     """
     If this function is called via the 'numpy' library, the third parameter in
     its signature is 'axis', which takes either an ndarray or 'None', so check
diff --git a/pandas/compat/pickle_compat.py b/pandas/compat/pickle_compat.py
index 2333324a7e22d..813e8de72f96e 100644
--- a/pandas/compat/pickle_compat.py
+++ b/pandas/compat/pickle_compat.py
@@ -7,7 +7,10 @@
 import copy
 import io
 import pickle as pkl
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    Iterator,
+)
 import warnings
 
 import numpy as np
@@ -221,7 +224,7 @@ def load_newobj(self):
         arr = np.array([], dtype="m8[ns]")
         obj = cls.__new__(cls, arr, arr.dtype)
     elif cls is BlockManager and not args:
-        obj = cls.__new__(cls, (), [], False)
+        obj = cls.__new__(cls, (), [], None, False)
     else:
         obj = cls.__new__(cls, *args)
 
@@ -291,7 +294,7 @@ def loads(
 
 
 @contextlib.contextmanager
-def patch_pickle():
+def patch_pickle() -> Iterator[None]:
     """
     Temporarily patch pickle to use our unpickler.
     """
diff --git a/pandas/compat/pyarrow.py b/pandas/compat/pyarrow.py
index e6ac0c59e789a..6965865acb5da 100644
--- a/pandas/compat/pyarrow.py
+++ b/pandas/compat/pyarrow.py
@@ -1,5 +1,7 @@
 """ support pyarrow compatibility across versions """
 
+from __future__ import annotations
+
 from pandas.util.version import Version
 
 try:
@@ -13,6 +15,9 @@
     pa_version_under4p0 = _palv < Version("4.0.0")
     pa_version_under5p0 = _palv < Version("5.0.0")
     pa_version_under6p0 = _palv < Version("6.0.0")
+    pa_version_under7p0 = _palv < Version("7.0.0")
+    pa_version_under8p0 = _palv < Version("8.0.0")
+    pa_version_under9p0 = _palv < Version("9.0.0")
 except ImportError:
     pa_version_under1p01 = True
     pa_version_under2p0 = True
@@ -20,3 +25,6 @@
     pa_version_under4p0 = True
     pa_version_under5p0 = True
     pa_version_under6p0 = True
+    pa_version_under7p0 = True
+    pa_version_under8p0 = True
+    pa_version_under9p0 = True
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 9009484f8d386..cf735bf535ddd 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -17,7 +17,6 @@
 - Dtypes
 - Misc
 """
-# pyright: reportUntypedFunctionDecorator = false
 
 from collections import abc
 from datetime import (
@@ -30,6 +29,7 @@
 from decimal import Decimal
 import operator
 import os
+from typing import Callable
 
 from dateutil.tz import (
     tzlocal,
@@ -75,6 +75,19 @@
     del pa
     has_pyarrow = True
 
+zoneinfo = None
+if pd.compat.PY39:
+    # Import "zoneinfo" could not be resolved (reportMissingImports)
+    import zoneinfo  # type: ignore[no-redef]
+
+    # Although zoneinfo can be imported in Py39, it is effectively
+    # "not available" without tzdata/IANA tz data.
+    # We will set zoneinfo to not found in this case
+    try:
+        zoneinfo.ZoneInfo("UTC")  # type: ignore[attr-defined]
+    except zoneinfo.ZoneInfoNotFoundError:  # type: ignore[attr-defined]
+        zoneinfo = None
+
 # Until https://github.com/numpy/numpy/issues/19078 is sorted out, just suppress
 suppress_npdev_promotion_warning = pytest.mark.filterwarnings(
     "ignore:Promotion of numbers and bools:FutureWarning"
@@ -86,7 +99,7 @@
 # pytest
 
 
-def pytest_addoption(parser):
+def pytest_addoption(parser) -> None:
     parser.addoption("--skip-slow", action="https://github.com/store_true", help="skip slow tests")
     parser.addoption("--skip-network", action="https://github.com/store_true", help="skip network tests")
     parser.addoption("--skip-db", action="https://github.com/store_true", help="skip db tests")
@@ -101,12 +114,29 @@ def pytest_addoption(parser):
     )
 
 
+def ignore_doctest_warning(item: pytest.Item, path: str, message: str) -> None:
+    """Ignore doctest warning.
+
+    Parameters
+    ----------
+    item : pytest.Item
+        pytest test item.
+    path : str
+        Module path to Python object, e.g. "pandas.core.frame.DataFrame.append". A
+        warning will be filtered when item.name ends with in given path. So it is
+        sufficient to specify e.g. "DataFrame.append".
+    message : str
+        Message to be filtered.
+    """
+    if item.name.endswith(path):
+        item.add_marker(pytest.mark.filterwarnings(f"ignore:{message}"))
+
+
 def pytest_collection_modifyitems(items, config):
     skip_slow = config.getoption("--skip-slow")
     only_slow = config.getoption("--only-slow")
     skip_network = config.getoption("--skip-network")
     skip_db = config.getoption("--skip-db")
-    run_high_memory = config.getoption("--run-high-memory")
 
     marks = [
         (pytest.mark.slow, "slow", skip_slow, "--skip-slow"),
@@ -114,7 +144,34 @@ def pytest_collection_modifyitems(items, config):
         (pytest.mark.db, "db", skip_db, "--skip-db"),
     ]
 
+    # Warnings from doctests that can be ignored; place reason in comment above.
+    # Each entry specifies (path, message) - see the ignore_doctest_warning function
+    ignored_doctest_warnings = [
+        # Deprecations where the docstring will emit a warning
+        ("DataFrame.append", "The frame.append method is deprecated"),
+        ("Series.append", "The series.append method is deprecated"),
+        ("dtypes.common.is_categorical", "is_categorical is deprecated"),
+        ("Categorical.replace", "Categorical.replace is deprecated"),
+        ("dtypes.common.is_extension_type", "'is_extension_type' is deprecated"),
+        ("Index.is_mixed", "Index.is_mixed is deprecated"),
+        ("MultiIndex._is_lexsorted", "MultiIndex.is_lexsorted is deprecated"),
+        # Docstring divides by zero to show behavior difference
+        ("missing.mask_zero_div_zero", "divide by zero encountered"),
+        # Docstring demonstrates the call raises a warning
+        ("_validators.validate_axis_style_args", "Use named arguments"),
+    ]
+
     for item in items:
+        if config.getoption("--doctest-modules") or config.getoption(
+            "--doctest-cython", default=False
+        ):
+            # autouse=True for the add_doctest_imports can lead to expensive teardowns
+            # since doctest_namespace is a session fixture
+            item.add_marker(pytest.mark.usefixtures("add_doctest_imports"))
+
+            for path, message in ignored_doctest_warnings:
+                ignore_doctest_warning(item, path, message)
+
         # mark all tests in the pandas/tests/frame directory with "arraymanager"
         if "/frame/" in item.nodeid:
             item.add_marker(pytest.mark.arraymanager)
@@ -133,13 +190,6 @@ def pytest_collection_modifyitems(items, config):
         if only_slow and "slow" not in item.keywords:
             item.add_marker(pytest.mark.skip("skipping due to --only-slow"))
 
-        if "high_memory" in item.keywords and not run_high_memory:
-            item.add_marker(
-                pytest.mark.skip(
-                    "skipping high memory test since --run-high-memory was not set"
-                )
-            )
-
 
 # Hypothesis
 hypothesis.settings.register_profile(
@@ -149,7 +199,9 @@ def pytest_collection_modifyitems(items, config):
     # is too short for a specific test, (a) try to make it faster, and (b)
     # if it really is slow add `@settings(deadline=...)` with a working value,
     # or `deadline=None` to entirely disable timeouts for that test.
-    deadline=500,
+    # 2022-02-09: Changed deadline from 500 -> None. Deadline leads to
+    # non-actionable, flaky CI failures (# GH 24641, 44969, 45118, 44969)
+    deadline=None,
     suppress_health_check=(hypothesis.HealthCheck.too_slow,),
 )
 hypothesis.settings.load_profile("ci")
@@ -187,26 +239,26 @@ def pytest_collection_modifyitems(items, config):
     )
 
 
+@pytest.fixture
+def add_doctest_imports(doctest_namespace) -> None:
+    """
+    Make `np` and `pd` names available for doctests.
+    """
+    doctest_namespace["np"] = np
+    doctest_namespace["pd"] = pd
+
+
 # ----------------------------------------------------------------
 # Autouse fixtures
 # ----------------------------------------------------------------
 @pytest.fixture(autouse=True)
-def configure_tests():
+def configure_tests() -> None:
     """
     Configure settings for all tests and test modules.
     """
     pd.set_option("chained_assignment", "raise")
 
 
-@pytest.fixture(autouse=True)
-def add_imports(doctest_namespace):
-    """
-    Make `np` and `pd` names available for doctests.
-    """
-    doctest_namespace["np"] = np
-    doctest_namespace["pd"] = pd
-
-
 # ----------------------------------------------------------------
 # Common arguments
 # ----------------------------------------------------------------
@@ -221,6 +273,14 @@ def axis(request):
 axis_frame = axis
 
 
+@pytest.fixture(params=[1, "columns"], ids=lambda x: f"axis={repr(x)}")
+def axis_1(request):
+    """
+    Fixture for returning aliases of axis 1 of a DataFrame.
+    """
+    return request.param
+
+
 @pytest.fixture(params=[True, False, None])
 def observed(request):
     """
@@ -282,6 +342,7 @@ def other_closed(request):
         "bz2",
         "zip",
         "xz",
+        "tar",
         pytest.param("zstd", marks=td.skip_if_no("zstandard")),
     ]
 )
@@ -298,6 +359,7 @@ def compression(request):
         "bz2",
         "zip",
         "xz",
+        "tar",
         pytest.param("zstd", marks=td.skip_if_no("zstandard")),
     ]
 )
@@ -431,7 +493,7 @@ def dict_subclass():
     """
 
     class TestSubDict(dict):
-        def __init__(self, *args, **kwargs):
+        def __init__(self, *args, **kwargs) -> None:
             dict.__init__(self, *args, **kwargs)
 
     return TestSubDict
@@ -444,7 +506,7 @@ def non_dict_mapping_subclass():
     """
 
     class TestNonDictMapping(abc.Mapping):
-        def __init__(self, underlying_dict):
+        def __init__(self, underlying_dict) -> None:
             self._data = underlying_dict
 
         def __getitem__(self, key):
@@ -477,7 +539,7 @@ def multiindex_year_month_day_dataframe_random_data():
 
 
 @pytest.fixture
-def lexsorted_two_level_string_multiindex():
+def lexsorted_two_level_string_multiindex() -> MultiIndex:
     """
     2-level MultiIndex, lexsorted, with string names.
     """
@@ -489,7 +551,9 @@ def lexsorted_two_level_string_multiindex():
 
 
 @pytest.fixture
-def multiindex_dataframe_random_data(lexsorted_two_level_string_multiindex):
+def multiindex_dataframe_random_data(
+    lexsorted_two_level_string_multiindex,
+) -> DataFrame:
     """DataFrame with 2 level MultiIndex with random data"""
     index = lexsorted_two_level_string_multiindex
     return DataFrame(
@@ -529,7 +593,6 @@ def _create_mi_with_dt64tz_level():
 
 
 indices_dict = {
-    "unicode": tm.makeUnicodeIndex(100),
     "string": tm.makeStringIndex(100),
     "datetime": tm.makeDateIndex(100),
     "datetime-tz": tm.makeDateIndex(100, tz="US/Pacific"),
@@ -539,6 +602,8 @@ def _create_mi_with_dt64tz_level():
     "uint": tm.makeUIntIndex(100),
     "range": tm.makeRangeIndex(100),
     "float": tm.makeFloatIndex(100),
+    "complex64": tm.makeFloatIndex(100).astype("complex64"),
+    "complex128": tm.makeFloatIndex(100).astype("complex128"),
     "num_int64": tm.makeNumericIndex(100, dtype="int64"),
     "num_int32": tm.makeNumericIndex(100, dtype="int32"),
     "num_int16": tm.makeNumericIndex(100, dtype="int16"),
@@ -549,7 +614,8 @@ def _create_mi_with_dt64tz_level():
     "num_uint8": tm.makeNumericIndex(100, dtype="uint8"),
     "num_float64": tm.makeNumericIndex(100, dtype="float64"),
     "num_float32": tm.makeNumericIndex(100, dtype="float32"),
-    "bool": tm.makeBoolIndex(10),
+    "bool-object": tm.makeBoolIndex(10).astype(object),
+    "bool-dtype": Index(np.random.randn(10) < 0),
     "categorical": tm.makeCategoricalIndex(100),
     "interval": tm.makeIntervalIndex(100),
     "empty": Index([]),
@@ -604,27 +670,12 @@ def index_flat(request):
 index_flat2 = index_flat
 
 
-@pytest.fixture(
-    params=[
-        key
-        for key in indices_dict
-        if not isinstance(indices_dict[key], MultiIndex) and indices_dict[key].is_unique
-    ]
-)
-def index_flat_unique(request):
-    """
-    index_flat with uniqueness requirement.
-    """
-    key = request.param
-    return indices_dict[key].copy()
-
-
 @pytest.fixture(
     params=[
         key
         for key in indices_dict
         if not (
-            key in ["int", "uint", "range", "empty", "repeats"]
+            key in ["int", "uint", "range", "empty", "repeats", "bool-dtype"]
             or key.startswith("num_")
         )
         and not isinstance(indices_dict[key], MultiIndex)
@@ -641,7 +692,7 @@ def index_with_missing(request):
     """
 
     # GH 35538. Use deep copy to avoid illusive bug on np-dev
-    # Azure pipeline that writes into indices_dict despite copy
+    # GHA pipeline that writes into indices_dict despite copy
     ind = indices_dict[request.param].copy(deep=True)
     vals = ind.values
     if request.param in ["tuples", "mi-with-dt64tz-level", "multi"]:
@@ -660,7 +711,7 @@ def index_with_missing(request):
 # Series'
 # ----------------------------------------------------------------
 @pytest.fixture
-def string_series():
+def string_series() -> Series:
     """
     Fixture for Series of floats with Index of unique strings
     """
@@ -670,7 +721,7 @@ def string_series():
 
 
 @pytest.fixture
-def object_series():
+def object_series() -> Series:
     """
     Fixture for Series of dtype object with Index of unique strings
     """
@@ -680,7 +731,7 @@ def object_series():
 
 
 @pytest.fixture
-def datetime_series():
+def datetime_series() -> Series:
     """
     Fixture for Series of floats with DatetimeIndex
     """
@@ -703,7 +754,7 @@ def _create_series(index):
 
 
 @pytest.fixture
-def series_with_simple_index(index):
+def series_with_simple_index(index) -> Series:
     """
     Fixture for tests on series with changing types of indices.
     """
@@ -711,7 +762,7 @@ def series_with_simple_index(index):
 
 
 @pytest.fixture
-def series_with_multilevel_index():
+def series_with_multilevel_index() -> Series:
     """
     Fixture with a Series with a 2-level MultiIndex.
     """
@@ -728,7 +779,7 @@ def series_with_multilevel_index():
 
 
 _narrow_series = {
-    f"{dtype.__name__}-series": tm.makeFloatSeries(name="a").astype(dtype)
+    f"{dtype.__name__}-series": tm.make_rand_series(name="a", dtype=dtype)
     for dtype in tm.NARROW_NP_DTYPES
 }
 
@@ -749,7 +800,7 @@ def index_or_series_obj(request):
 # DataFrames
 # ----------------------------------------------------------------
 @pytest.fixture
-def int_frame():
+def int_frame() -> DataFrame:
     """
     Fixture for DataFrame of ints with index of unique strings
 
@@ -778,7 +829,7 @@ def int_frame():
 
 
 @pytest.fixture
-def datetime_frame():
+def datetime_frame() -> DataFrame:
     """
     Fixture for DataFrame of floats with DatetimeIndex
 
@@ -807,7 +858,7 @@ def datetime_frame():
 
 
 @pytest.fixture
-def float_frame():
+def float_frame() -> DataFrame:
     """
     Fixture for DataFrame of floats with index of unique strings
 
@@ -836,7 +887,7 @@ def float_frame():
 
 
 @pytest.fixture
-def mixed_type_frame():
+def mixed_type_frame() -> DataFrame:
     """
     Fixture for DataFrame of float/int/string columns with RangeIndex
     Columns are ['a', 'b', 'c', 'float32', 'int32'].
@@ -854,7 +905,7 @@ def mixed_type_frame():
 
 
 @pytest.fixture
-def rand_series_with_duplicate_datetimeindex():
+def rand_series_with_duplicate_datetimeindex() -> Series:
     """
     Fixture for Series with a DatetimeIndex that has duplicates.
     """
@@ -1090,7 +1141,7 @@ def strict_data_files(pytestconfig):
 
 
 @pytest.fixture
-def datapath(strict_data_files):
+def datapath(strict_data_files: str) -> Callable[..., str]:
     """
     Get the path to a data file.
 
@@ -1125,7 +1176,7 @@ def deco(*args):
 
 
 @pytest.fixture
-def iris(datapath):
+def iris(datapath) -> DataFrame:
     """
     The iris dataset as a DataFrame.
     """
@@ -1155,6 +1206,8 @@ def iris(datapath):
     timezone(timedelta(hours=1)),
     timezone(timedelta(hours=-1), name="foo"),
 ]
+if zoneinfo is not None:
+    TIMEZONES.extend([zoneinfo.ZoneInfo("US/Pacific"), zoneinfo.ZoneInfo("UTC")])
 TIMEZONE_IDS = [repr(i) for i in TIMEZONES]
 
 
@@ -1180,7 +1233,12 @@ def tz_aware_fixture(request):
 tz_aware_fixture2 = tz_aware_fixture
 
 
-@pytest.fixture(params=["utc", "dateutil/UTC", utc, tzutc(), timezone.utc])
+_UTCS = ["utc", "dateutil/UTC", utc, tzutc(), timezone.utc]
+if zoneinfo is not None:
+    _UTCS.append(zoneinfo.ZoneInfo("UTC"))
+
+
+@pytest.fixture(params=_UTCS)
 def utc_fixture(request):
     """
     Fixture to provide variants of UTC timezone strings and tzinfo objects.
@@ -1308,7 +1366,7 @@ def timedelta64_dtype(request):
 
 
 @pytest.fixture
-def fixed_now_ts():
+def fixed_now_ts() -> Timestamp:
     """
     Fixture emits fixed Timestamp.now()
     """
@@ -1545,10 +1603,50 @@ def any_numpy_dtype(request):
     return request.param
 
 
+@pytest.fixture(
+    params=tm.ALL_REAL_NUMPY_DTYPES
+    + tm.COMPLEX_DTYPES
+    + tm.ALL_INT_EA_DTYPES
+    + tm.FLOAT_EA_DTYPES
+)
+def any_numeric_dtype(request):
+    """
+    Parameterized fixture for all numeric dtypes.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * float
+    * 'float32'
+    * 'float64'
+    * complex
+    * 'complex64'
+    * 'complex128'
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    * 'Float32'
+    * 'Float64'
+    """
+    return request.param
+
+
 # categoricals are handled separately
 _any_skipna_inferred_dtype = [
     ("string", ["a", np.nan, "c"]),
     ("string", ["a", pd.NA, "c"]),
+    ("mixed", ["a", pd.NaT, "c"]),  # pd.NaT not considered valid by is_string_array
     ("bytes", [b"a", np.nan, b"c"]),
     ("empty", [np.nan, np.nan, np.nan]),
     ("empty", []),
@@ -1659,7 +1757,7 @@ def spmatrix(request):
     params=[
         getattr(pd.offsets, o)
         for o in pd.offsets.__all__
-        if issubclass(getattr(pd.offsets, o), pd.offsets.Tick)
+        if issubclass(getattr(pd.offsets, o), pd.offsets.Tick) and o != "Tick"
     ]
 )
 def tick_classes(request):
@@ -1689,7 +1787,7 @@ class TestMemoryFS(MemoryFileSystem):
         protocol = "testmem"
         test = [None]
 
-        def __init__(self, **kwargs):
+        def __init__(self, **kwargs) -> None:
             self.test[0] = kwargs.pop("test", None)
             super().__init__(**kwargs)
 
@@ -1727,6 +1825,14 @@ def indexer_sli(request):
     return request.param
 
 
+@pytest.fixture(params=[tm.loc, tm.iloc])
+def indexer_li(request):
+    """
+    Parametrize over loc.__getitem__, iloc.__getitem__
+    """
+    return request.param
+
+
 @pytest.fixture(params=[tm.setitem, tm.iloc])
 def indexer_si(request):
     """
@@ -1751,9 +1857,25 @@ def indexer_al(request):
     return request.param
 
 
+@pytest.fixture(params=[tm.iat, tm.iloc])
+def indexer_ial(request):
+    """
+    Parametrize over iat.__setitem__, iloc.__setitem__
+    """
+    return request.param
+
+
 @pytest.fixture
-def using_array_manager(request):
+def using_array_manager():
     """
     Fixture to check if the array manager is being used.
     """
     return pd.options.mode.data_manager == "array"
+
+
+@pytest.fixture
+def using_copy_on_write() -> bool:
+    """
+    Fixture to check if Copy-on-Write is enabled.
+    """
+    return pd.options.mode.copy_on_write and pd.options.mode.data_manager == "block"
diff --git a/pandas/core/_numba/executor.py b/pandas/core/_numba/executor.py
index 0b59d0717a476..13d8b52bae39c 100644
--- a/pandas/core/_numba/executor.py
+++ b/pandas/core/_numba/executor.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -10,16 +11,13 @@
 from pandas._typing import Scalar
 from pandas.compat._optional import import_optional_dependency
 
-from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
-    get_jit_arguments,
-)
-
 
+@functools.lru_cache(maxsize=None)
 def generate_shared_aggregator(
     func: Callable[..., Scalar],
-    engine_kwargs: dict[str, bool] | None,
-    cache_key_str: str,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
 ):
     """
     Generate a Numba function that loops over the columns 2D object and applies
@@ -29,22 +27,17 @@ def generate_shared_aggregator(
     ----------
     func : function
         aggregation function to be applied to each column
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
-    cache_key_str: str
-        string to access the compiled function of the form
-        <caller_type>_<aggregation_type> e.g. rolling_mean, groupby_mean
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs, None)
-
-    cache_key = (func, cache_key_str)
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     if TYPE_CHECKING:
         import numba
     else:
diff --git a/pandas/core/_numba/kernels/mean_.py b/pandas/core/_numba/kernels/mean_.py
index 8f67dd9b51c06..725989e093441 100644
--- a/pandas/core/_numba/kernels/mean_.py
+++ b/pandas/core/_numba/kernels/mean_.py
@@ -16,8 +16,14 @@
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
 def add_mean(
-    val: float, nobs: int, sum_x: float, neg_ct: int, compensation: float
-) -> tuple[int, float, int, float]:
+    val: float,
+    nobs: int,
+    sum_x: float,
+    neg_ct: int,
+    compensation: float,
+    num_consecutive_same_value: int,
+    prev_value: float,
+) -> tuple[int, float, int, float, int, float]:
     if not np.isnan(val):
         nobs += 1
         y = val - compensation
@@ -26,7 +32,14 @@ def add_mean(
         sum_x = t
         if val < 0:
             neg_ct += 1
-    return nobs, sum_x, neg_ct, compensation
+
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+
+    return nobs, sum_x, neg_ct, compensation, num_consecutive_same_value, prev_value
 
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
@@ -68,10 +81,26 @@ def sliding_mean(
         s = start[i]
         e = end[i]
         if i == 0 or not is_monotonic_increasing_bounds:
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+
             for j in range(s, e):
                 val = values[j]
-                nobs, sum_x, neg_ct, compensation_add = add_mean(
-                    val, nobs, sum_x, neg_ct, compensation_add
+                (
+                    nobs,
+                    sum_x,
+                    neg_ct,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_mean(
+                    val,
+                    nobs,
+                    sum_x,
+                    neg_ct,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
         else:
             for j in range(start[i - 1], s):
@@ -82,13 +111,28 @@ def sliding_mean(
 
             for j in range(end[i - 1], e):
                 val = values[j]
-                nobs, sum_x, neg_ct, compensation_add = add_mean(
-                    val, nobs, sum_x, neg_ct, compensation_add
+                (
+                    nobs,
+                    sum_x,
+                    neg_ct,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_mean(
+                    val,
+                    nobs,
+                    sum_x,
+                    neg_ct,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
 
         if nobs >= min_periods and nobs > 0:
             result = sum_x / nobs
-            if neg_ct == 0 and result < 0:
+            if num_consecutive_same_value >= nobs:
+                result = prev_value
+            elif neg_ct == 0 and result < 0:
                 result = 0
             elif neg_ct == nobs and result > 0:
                 result = 0
diff --git a/pandas/core/_numba/kernels/shared.py b/pandas/core/_numba/kernels/shared.py
index ec25e78a8d897..6e6bcef590d06 100644
--- a/pandas/core/_numba/kernels/shared.py
+++ b/pandas/core/_numba/kernels/shared.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import numba
 import numpy as np
 
diff --git a/pandas/core/_numba/kernels/sum_.py b/pandas/core/_numba/kernels/sum_.py
index c2e81b4990ba9..056897189fe67 100644
--- a/pandas/core/_numba/kernels/sum_.py
+++ b/pandas/core/_numba/kernels/sum_.py
@@ -16,15 +16,27 @@
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
 def add_sum(
-    val: float, nobs: int, sum_x: float, compensation: float
-) -> tuple[int, float, float]:
+    val: float,
+    nobs: int,
+    sum_x: float,
+    compensation: float,
+    num_consecutive_same_value: int,
+    prev_value: float,
+) -> tuple[int, float, float, int, float]:
     if not np.isnan(val):
         nobs += 1
         y = val - compensation
         t = sum_x + y
         compensation = t - sum_x - y
         sum_x = t
-    return nobs, sum_x, compensation
+
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+
+    return nobs, sum_x, compensation, num_consecutive_same_value, prev_value
 
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
@@ -63,10 +75,24 @@ def sliding_sum(
         s = start[i]
         e = end[i]
         if i == 0 or not is_monotonic_increasing_bounds:
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+
             for j in range(s, e):
                 val = values[j]
-                nobs, sum_x, compensation_add = add_sum(
-                    val, nobs, sum_x, compensation_add
+                (
+                    nobs,
+                    sum_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_sum(
+                    val,
+                    nobs,
+                    sum_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
         else:
             for j in range(start[i - 1], s):
@@ -77,14 +103,28 @@ def sliding_sum(
 
             for j in range(end[i - 1], e):
                 val = values[j]
-                nobs, sum_x, compensation_add = add_sum(
-                    val, nobs, sum_x, compensation_add
+                (
+                    nobs,
+                    sum_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_sum(
+                    val,
+                    nobs,
+                    sum_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
 
-        if nobs == 0 == nobs:
+        if nobs == 0 == min_periods:
             result = 0.0
         elif nobs >= min_periods:
-            result = sum_x
+            if num_consecutive_same_value >= nobs:
+                result = prev_value * nobs
+            else:
+                result = sum_x
         else:
             result = np.nan
 
diff --git a/pandas/core/_numba/kernels/var_.py b/pandas/core/_numba/kernels/var_.py
index 2e5660673701b..b1c72832d249b 100644
--- a/pandas/core/_numba/kernels/var_.py
+++ b/pandas/core/_numba/kernels/var_.py
@@ -16,9 +16,22 @@
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
 def add_var(
-    val: float, nobs: int, mean_x: float, ssqdm_x: float, compensation: float
-) -> tuple[int, float, float, float]:
+    val: float,
+    nobs: int,
+    mean_x: float,
+    ssqdm_x: float,
+    compensation: float,
+    num_consecutive_same_value: int,
+    prev_value: float,
+) -> tuple[int, float, float, float, int, float]:
     if not np.isnan(val):
+
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+
         nobs += 1
         prev_mean = mean_x - compensation
         y = val - compensation
@@ -30,7 +43,7 @@ def add_var(
         else:
             mean_x = 0
         ssqdm_x += (val - prev_mean) * (val - mean_x)
-    return nobs, mean_x, ssqdm_x, compensation
+    return nobs, mean_x, ssqdm_x, compensation, num_consecutive_same_value, prev_value
 
 
 @numba.jit(nopython=True, nogil=True, parallel=False)
@@ -79,10 +92,27 @@ def sliding_var(
         s = start[i]
         e = end[i]
         if i == 0 or not is_monotonic_increasing_bounds:
+
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+
             for j in range(s, e):
                 val = values[j]
-                nobs, mean_x, ssqdm_x, compensation_add = add_var(
-                    val, nobs, mean_x, ssqdm_x, compensation_add
+                (
+                    nobs,
+                    mean_x,
+                    ssqdm_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_var(
+                    val,
+                    nobs,
+                    mean_x,
+                    ssqdm_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
         else:
             for j in range(start[i - 1], s):
@@ -93,12 +123,25 @@ def sliding_var(
 
             for j in range(end[i - 1], e):
                 val = values[j]
-                nobs, mean_x, ssqdm_x, compensation_add = add_var(
-                    val, nobs, mean_x, ssqdm_x, compensation_add
+                (
+                    nobs,
+                    mean_x,
+                    ssqdm_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
+                ) = add_var(
+                    val,
+                    nobs,
+                    mean_x,
+                    ssqdm_x,
+                    compensation_add,
+                    num_consecutive_same_value,
+                    prev_value,
                 )
 
         if nobs >= min_periods and nobs > ddof:
-            if nobs == 1:
+            if nobs == 1 or num_consecutive_same_value >= nobs:
                 result = 0.0
             else:
                 result = ssqdm_x / (nobs - ddof)
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 320207d1a26d5..9f67b8d4e20cd 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -4,6 +4,7 @@
 """
 from __future__ import annotations
 
+import inspect
 import operator
 from textwrap import dedent
 from typing import (
@@ -11,11 +12,11 @@
     Hashable,
     Literal,
     Sequence,
-    Union,
     cast,
     final,
+    overload,
 )
-from warnings import warn
+import warnings
 
 import numpy as np
 
@@ -30,7 +31,6 @@
     ArrayLike,
     DtypeObj,
     IndexLabel,
-    Scalar,
     TakeIndexer,
     npt,
 )
@@ -59,11 +59,13 @@
     is_numeric_dtype,
     is_object_dtype,
     is_scalar,
+    is_signed_integer_dtype,
     is_timedelta64_dtype,
     needs_i8_conversion,
 )
 from pandas.core.dtypes.concat import concat_compat
 from pandas.core.dtypes.dtypes import (
+    BaseMaskedDtype,
     ExtensionDtype,
     PandasDtype,
 )
@@ -100,12 +102,12 @@
         Categorical,
         DataFrame,
         Index,
+        MultiIndex,
         Series,
     )
     from pandas.core.arrays import (
-        DatetimeArray,
+        BaseMaskedArray,
         ExtensionArray,
-        TimedeltaArray,
     )
 
 
@@ -138,21 +140,31 @@ def _ensure_data(values: ArrayLike) -> np.ndarray:
         # extract_array would raise
         values = extract_array(values, extract_numpy=True)
 
-    # we check some simple dtypes first
     if is_object_dtype(values.dtype):
         return ensure_object(np.asarray(values))
 
+    elif isinstance(values.dtype, BaseMaskedDtype):
+        # i.e. BooleanArray, FloatingArray, IntegerArray
+        values = cast("BaseMaskedArray", values)
+        if not values._hasna:
+            # No pd.NAs -> We can avoid an object-dtype cast (and copy) GH#41816
+            #  recurse to avoid re-implementing logic for eg bool->uint8
+            return _ensure_data(values._data)
+        return np.asarray(values)
+
+    elif is_categorical_dtype(values.dtype):
+        # NB: cases that go through here should NOT be using _reconstruct_data
+        #  on the back-end.
+        values = cast("Categorical", values)
+        return values.codes
+
     elif is_bool_dtype(values.dtype):
         if isinstance(values, np.ndarray):
             # i.e. actually dtype == np.dtype("bool")
             return np.asarray(values).view("uint8")
         else:
-            # i.e. all-bool Categorical, BooleanArray
-            try:
-                return np.asarray(values).astype("uint8", copy=False)
-            except (TypeError, ValueError):
-                # GH#42107 we have pd.NAs present
-                return np.asarray(values)
+            # e.g. Sparse[bool, False]  # TODO: no test cases get here
+            return np.asarray(values).astype("uint8", copy=False)
 
     elif is_integer_dtype(values.dtype):
         return np.asarray(values)
@@ -167,10 +179,7 @@ def _ensure_data(values: ArrayLike) -> np.ndarray:
         return np.asarray(values)
 
     elif is_complex_dtype(values.dtype):
-        # Incompatible return value type (got "Tuple[Union[Any, ExtensionArray,
-        # ndarray[Any, Any]], Union[Any, ExtensionDtype]]", expected
-        # "Tuple[ndarray[Any, Any], Union[dtype[Any], ExtensionDtype]]")
-        return values  # type: ignore[return-value]
+        return cast(np.ndarray, values)
 
     # datetimelike
     elif needs_i8_conversion(values.dtype):
@@ -180,11 +189,6 @@ def _ensure_data(values: ArrayLike) -> np.ndarray:
         npvalues = cast(np.ndarray, npvalues)
         return npvalues
 
-    elif is_categorical_dtype(values.dtype):
-        values = cast("Categorical", values)
-        values = values.codes
-        return values
-
     # we have failed, return object
     values = np.asarray(values, dtype=object)
     return ensure_object(values)
@@ -211,19 +215,13 @@ def _reconstruct_data(
         return values
 
     if not isinstance(dtype, np.dtype):
-        # i.e. ExtensionDtype
+        # i.e. ExtensionDtype; note we have ruled out above the possibility
+        #  that values.dtype == dtype
         cls = dtype.construct_array_type()
-        if isinstance(values, cls) and values.dtype == dtype:
-            return values
 
         values = cls._from_sequence(values, dtype=dtype)
-    elif is_bool_dtype(dtype):
-        values = values.astype(dtype, copy=False)
 
-        # we only support object dtypes bool Index
-        if isinstance(original, ABCIndex):
-            values = values.astype(object, copy=False)
-    elif dtype is not None:
+    else:
         if is_datetime64_dtype(dtype):
             dtype = np.dtype("datetime64[ns]")
         elif is_timedelta64_dtype(dtype):
@@ -286,25 +284,6 @@ def _get_hashtable_algo(values: np.ndarray):
     return htable, values
 
 
-def _get_values_for_rank(values: ArrayLike) -> np.ndarray:
-
-    values = _ensure_data(values)
-    if values.dtype.kind in ["i", "u", "f"]:
-        # rank_t includes only object, int64, uint64, float64
-        dtype = values.dtype.kind + "8"
-        values = values.astype(dtype, copy=False)
-    return values
-
-
-def _get_data_algo(values: ArrayLike):
-    values = _get_values_for_rank(values)
-
-    ndtype = _check_object_for_strings(values)
-    htable = _hashtables.get(ndtype, _hashtables["object"])
-
-    return htable, values
-
-
 def _check_object_for_strings(values: np.ndarray) -> str:
     """
     Check if we can use string hashtable instead of object hashtable.
@@ -335,8 +314,9 @@ def _check_object_for_strings(values: np.ndarray) -> str:
 
 def unique(values):
     """
-    Hash table-based unique. Uniques are returned in order
-    of appearance. This does NOT sort.
+    Return unique values based on a hash table.
+
+    Uniques are returned in order of appearance. This does NOT sort.
 
     Significantly faster than numpy.unique for long enough sequences.
     Includes NA values.
@@ -426,6 +406,11 @@ def unique(values):
     >>> pd.unique([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")])
     array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
     """
+    return unique_with_mask(values)
+
+
+def unique_with_mask(values, mask: npt.NDArray[np.bool_] | None = None):
+    """See algorithms.unique for docs. Takes a mask for masked arrays."""
     values = _ensure_arraylike(values)
 
     if is_extension_array_dtype(values.dtype):
@@ -436,9 +421,16 @@ def unique(values):
     htable, values = _get_hashtable_algo(values)
 
     table = htable(len(values))
-    uniques = table.unique(values)
-    uniques = _reconstruct_data(uniques, original.dtype, original)
-    return uniques
+    if mask is None:
+        uniques = table.unique(values)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        return uniques
+
+    else:
+        uniques, mask = table.unique(values, mask=mask)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        assert mask is not None  # for mypy
+        return uniques, mask.astype("bool")
 
 
 unique1d = unique
@@ -470,37 +462,52 @@ def isin(comps: AnyArrayLike, values: AnyArrayLike) -> npt.NDArray[np.bool_]:
         )
 
     if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
+        orig_values = values
         values = _ensure_arraylike(list(values))
+
+        if (
+            len(values) > 0
+            and is_numeric_dtype(values)
+            and not is_signed_integer_dtype(comps)
+        ):
+            # GH#46485 Use object to avoid upcast to float64 later
+            # TODO: Share with _find_common_type_compat
+            values = construct_1d_object_array_from_listlike(list(orig_values))
+
     elif isinstance(values, ABCMultiIndex):
         # Avoid raising in extract_array
         values = np.array(values)
     else:
         values = extract_array(values, extract_numpy=True, extract_range=True)
 
-    comps = _ensure_arraylike(comps)
-    comps = extract_array(comps, extract_numpy=True)
-    if not isinstance(comps, np.ndarray):
+    comps_array = _ensure_arraylike(comps)
+    comps_array = extract_array(comps_array, extract_numpy=True)
+    if not isinstance(comps_array, np.ndarray):
         # i.e. Extension Array
-        return comps.isin(values)
+        return comps_array.isin(values)
 
-    elif needs_i8_conversion(comps.dtype):
+    elif needs_i8_conversion(comps_array.dtype):
         # Dispatch to DatetimeLikeArrayMixin.isin
-        return pd_array(comps).isin(values)
-    elif needs_i8_conversion(values.dtype) and not is_object_dtype(comps.dtype):
-        # e.g. comps are integers and values are datetime64s
-        return np.zeros(comps.shape, dtype=bool)
+        return pd_array(comps_array).isin(values)
+    elif needs_i8_conversion(values.dtype) and not is_object_dtype(comps_array.dtype):
+        # e.g. comps_array are integers and values are datetime64s
+        return np.zeros(comps_array.shape, dtype=bool)
         # TODO: not quite right ... Sparse/Categorical
     elif needs_i8_conversion(values.dtype):
-        return isin(comps, values.astype(object))
+        return isin(comps_array, values.astype(object))
 
     elif isinstance(values.dtype, ExtensionDtype):
-        return isin(np.asarray(comps), np.asarray(values))
+        return isin(np.asarray(comps_array), np.asarray(values))
 
     # GH16012
     # Ensure np.in1d doesn't get object types or it *may* throw an exception
     # Albeit hashmap has O(1) look-up (vs. O(logn) in sorted array),
     # in1d is faster for small sizes
-    if len(comps) > 1_000_000 and len(values) <= 26 and not is_object_dtype(comps):
+    if (
+        len(comps_array) > 1_000_000
+        and len(values) <= 26
+        and not is_object_dtype(comps_array)
+    ):
         # If the values include nan we need to check for nan explicitly
         # since np.nan it not equal to np.nan
         if isna(values).any():
@@ -512,20 +519,20 @@ def f(c, v):
             f = np.in1d
 
     else:
-        common = np.find_common_type([values.dtype, comps.dtype], [])
+        common = np.find_common_type([values.dtype, comps_array.dtype], [])
         values = values.astype(common, copy=False)
-        comps = comps.astype(common, copy=False)
+        comps_array = comps_array.astype(common, copy=False)
         f = htable.ismember
 
-    return f(comps, values)
+    return f(comps_array, values)
 
 
 def factorize_array(
     values: np.ndarray,
-    na_sentinel: int = -1,
+    na_sentinel: int | None = -1,
     size_hint: int | None = None,
-    na_value=None,
-    mask: np.ndarray | None = None,
+    na_value: object = None,
+    mask: npt.NDArray[np.bool_] | None = None,
 ) -> tuple[npt.NDArray[np.intp], np.ndarray]:
     """
     Factorize a numpy array to codes and uniques.
@@ -553,13 +560,32 @@ def factorize_array(
     codes : ndarray[np.intp]
     uniques : ndarray
     """
-    hash_klass, values = _get_data_algo(values)
+    ignore_na = na_sentinel is not None
+    if not ignore_na:
+        na_sentinel = -1
+
+    original = values
+    if values.dtype.kind in ["m", "M"]:
+        # _get_hashtable_algo will cast dt64/td64 to i8 via _ensure_data, so we
+        #  need to do the same to na_value. We are assuming here that the passed
+        #  na_value is an appropriately-typed NaT.
+        # e.g. test_where_datetimelike_categorical
+        na_value = iNaT
+
+    hash_klass, values = _get_hashtable_algo(values)
 
     table = hash_klass(size_hint or len(values))
     uniques, codes = table.factorize(
-        values, na_sentinel=na_sentinel, na_value=na_value, mask=mask
+        values,
+        na_sentinel=na_sentinel,
+        na_value=na_value,
+        mask=mask,
+        ignore_na=ignore_na,
     )
 
+    # re-cast e.g. i8->dt64/td64, uint8->bool
+    uniques = _reconstruct_data(uniques, original.dtype, original)
+
     codes = ensure_platform_int(codes)
     return codes, uniques
 
@@ -589,7 +615,8 @@ def factorize_array(
 def factorize(
     values,
     sort: bool = False,
-    na_sentinel: int | None = -1,
+    na_sentinel: int | None | lib.NoDefault = lib.no_default,
+    use_na_sentinel: bool | lib.NoDefault = lib.no_default,
     size_hint: int | None = None,
 ) -> tuple[np.ndarray, np.ndarray | Index]:
     """
@@ -607,7 +634,19 @@ def factorize(
         Value to mark "not found". If None, will not drop the NaN
         from the uniques of the values.
 
+        .. deprecated:: 1.5.0
+            The na_sentinel argument is deprecated and
+            will be removed in a future version of pandas. Specify use_na_sentinel as
+            either True or False.
+
         .. versionchanged:: 1.1.2
+
+    use_na_sentinel : bool, default True
+        If True, the sentinel -1 will be used for NaN values. If False,
+        NaN values will be encoded as non-negative integers and will not drop the
+        NaN from the uniques of the values.
+
+        .. versionadded:: 1.5.0
     {size_hint}\
 
     Returns
@@ -630,6 +669,10 @@ def factorize(
     cut : Discretize continuous-valued array.
     unique : Find the unique value in an array.
 
+    Notes
+    -----
+    Reference :ref:`the user guide <reshaping.factorize>` for more examples.
+
     Examples
     --------
     These examples all show factorize as a top-level method like
@@ -651,8 +694,8 @@ def factorize(
     >>> uniques
     array(['a', 'b', 'c'], dtype=object)
 
-    Missing values are indicated in `codes` with `na_sentinel`
-    (``-1`` by default). Note that missing values are never
+    When ``use_na_sentinel=True`` (the default), missing values are indicated in
+    the `codes` with the sentinel value ``-1`` and missing values are not
     included in `uniques`.
 
     >>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b'])
@@ -687,16 +730,16 @@ def factorize(
     Index(['a', 'c'], dtype='object')
 
     If NaN is in the values, and we want to include NaN in the uniques of the
-    values, it can be achieved by setting ``na_sentinel=None``.
+    values, it can be achieved by setting ``use_na_sentinel=False``.
 
     >>> values = np.array([1, 2, 1, np.nan])
-    >>> codes, uniques = pd.factorize(values)  # default: na_sentinel=-1
+    >>> codes, uniques = pd.factorize(values)  # default: use_na_sentinel=True
     >>> codes
     array([ 0,  1,  0, -1])
     >>> uniques
     array([1., 2.])
 
-    >>> codes, uniques = pd.factorize(values, na_sentinel=None)
+    >>> codes, uniques = pd.factorize(values, use_na_sentinel=False)
     >>> codes
     array([0, 1, 0, 2])
     >>> uniques
@@ -711,6 +754,11 @@ def factorize(
     # responsible only for factorization. All data coercion, sorting and boxing
     # should happen here.
 
+    # GH#46910 deprecated na_sentinel in favor of use_na_sentinel:
+    #   na_sentinel=None corresponds to use_na_sentinel=False
+    #   na_sentinel=-1 correspond to use_na_sentinel=True
+    # Other na_sentinel values will not be supported when the deprecation is enforced.
+    na_sentinel = resolve_na_sentinel(na_sentinel, use_na_sentinel)
     if isinstance(values, ABCRangeIndex):
         return values.factorize(sort=sort)
 
@@ -721,66 +769,145 @@ def factorize(
 
     # GH35667, if na_sentinel=None, we will not dropna NaNs from the uniques
     # of values, assign na_sentinel=-1 to replace code value for NaN.
-    dropna = True
-    if na_sentinel is None:
-        na_sentinel = -1
-        dropna = False
+    dropna = na_sentinel is not None
 
     if (
         isinstance(values, (ABCDatetimeArray, ABCTimedeltaArray))
         and values.freq is not None
     ):
+        # The presence of 'freq' means we can fast-path sorting and know there
+        #  aren't NAs
         codes, uniques = values.factorize(sort=sort)
-        if isinstance(original, ABCIndex):
-            uniques = original._shallow_copy(uniques, name=None)
-        elif isinstance(original, ABCSeries):
-            from pandas import Index
-
-            uniques = Index(uniques)
-        return codes, uniques
-
-    if not isinstance(values.dtype, np.dtype):
-        # i.e. ExtensionDtype
-        codes, uniques = values.factorize(na_sentinel=na_sentinel)
-        dtype = original.dtype
+        return _re_wrap_factorize(original, uniques, codes)
+
+    elif not isinstance(values.dtype, np.dtype):
+        if (
+            na_sentinel == -1 or na_sentinel is None
+        ) and "use_na_sentinel" in inspect.signature(values.factorize).parameters:
+            # Avoid using catch_warnings when possible
+            # GH#46910 - TimelikeOps has deprecated signature
+            codes, uniques = values.factorize(  # type: ignore[call-arg]
+                use_na_sentinel=na_sentinel is not None
+            )
+        else:
+            na_sentinel_arg = -1 if na_sentinel is None else na_sentinel
+            with warnings.catch_warnings():
+                # We've already warned above
+                warnings.filterwarnings("ignore", ".*use_na_sentinel.*", FutureWarning)
+                codes, uniques = values.factorize(na_sentinel=na_sentinel_arg)
+
     else:
-        dtype = values.dtype
-        values = _ensure_data(values)
-        na_value: Scalar
-
-        if original.dtype.kind in ["m", "M"]:
-            # Note: factorize_array will cast NaT bc it has a __int__
-            #  method, but will not cast the more-correct dtype.type("nat")
-            na_value = iNaT
+        values = np.asarray(values)  # convert DTA/TDA/MultiIndex
+        # TODO: pass na_sentinel=na_sentinel to factorize_array. When sort is True and
+        #       na_sentinel is None we append NA on the end because safe_sort does not
+        #       handle null values in uniques.
+        if na_sentinel is None and sort:
+            na_sentinel_arg = -1
+        elif na_sentinel is None:
+            na_sentinel_arg = None
         else:
-            na_value = None
+            na_sentinel_arg = na_sentinel
+
+        if not dropna and not sort and is_object_dtype(values):
+            # factorize can now handle differentiating various types of null values.
+            # These can only occur when the array has object dtype.
+            # However, for backwards compatibility we only use the null for the
+            # provided dtype. This may be revisited in the future, see GH#48476.
+            null_mask = isna(values)
+            if null_mask.any():
+                na_value = na_value_for_dtype(values.dtype, compat=False)
+                # Don't modify (potentially user-provided) array
+                values = np.where(null_mask, na_value, values)
 
         codes, uniques = factorize_array(
-            values, na_sentinel=na_sentinel, size_hint=size_hint, na_value=na_value
+            values,
+            na_sentinel=na_sentinel_arg,
+            size_hint=size_hint,
         )
 
     if sort and len(uniques) > 0:
+        if na_sentinel is None:
+            # TODO: Can remove when na_sentinel=na_sentinel as in TODO above
+            na_sentinel = -1
         uniques, codes = safe_sort(
             uniques, codes, na_sentinel=na_sentinel, assume_unique=True, verify=False
         )
 
-    code_is_na = codes == na_sentinel
-    if not dropna and code_is_na.any():
-        # na_value is set based on the dtype of uniques, and compat set to False is
-        # because we do not want na_value to be 0 for integers
-        na_value = na_value_for_dtype(uniques.dtype, compat=False)
-        uniques = np.append(uniques, [na_value])
-        codes = np.where(code_is_na, len(uniques) - 1, codes)
+    if not dropna and sort:
+        # TODO: Can remove entire block when na_sentinel=na_sentinel as in TODO above
+        if na_sentinel is None:
+            na_sentinel_arg = -1
+        else:
+            na_sentinel_arg = na_sentinel
+        code_is_na = codes == na_sentinel_arg
+        if code_is_na.any():
+            # na_value is set based on the dtype of uniques, and compat set to False is
+            # because we do not want na_value to be 0 for integers
+            na_value = na_value_for_dtype(uniques.dtype, compat=False)
+            uniques = np.append(uniques, [na_value])
+            codes = np.where(code_is_na, len(uniques) - 1, codes)
 
-    uniques = _reconstruct_data(uniques, dtype, original)
+    uniques = _reconstruct_data(uniques, original.dtype, original)
 
-    # return original tenor
-    if isinstance(original, ABCIndex):
-        if original.dtype.kind in ["m", "M"] and isinstance(uniques, np.ndarray):
-            original._data = cast(
-                "Union[DatetimeArray, TimedeltaArray]", original._data
+    return _re_wrap_factorize(original, uniques, codes)
+
+
+def resolve_na_sentinel(
+    na_sentinel: int | None | lib.NoDefault,
+    use_na_sentinel: bool | lib.NoDefault,
+) -> int | None:
+    """
+    Determine value of na_sentinel for factorize methods.
+
+    See GH#46910 for details on the deprecation.
+
+    Parameters
+    ----------
+    na_sentinel : int, None, or lib.no_default
+        Value passed to the method.
+    use_na_sentinel : bool or lib.no_default
+        Value passed to the method.
+
+    Returns
+    -------
+    Resolved value of na_sentinel.
+    """
+    if na_sentinel is not lib.no_default and use_na_sentinel is not lib.no_default:
+        raise ValueError(
+            "Cannot specify both `na_sentinel` and `use_na_sentile`; "
+            f"got `na_sentinel={na_sentinel}` and `use_na_sentinel={use_na_sentinel}`"
+        )
+    if na_sentinel is lib.no_default:
+        result = -1 if use_na_sentinel is lib.no_default or use_na_sentinel else None
+    else:
+        if na_sentinel is None:
+            msg = (
+                "Specifying `na_sentinel=None` is deprecated, specify "
+                "`use_na_sentinel=False` instead."
+            )
+        elif na_sentinel == -1:
+            msg = (
+                "Specifying `na_sentinel=-1` is deprecated, specify "
+                "`use_na_sentinel=True` instead."
+            )
+        else:
+            msg = (
+                "Specifying the specific value to use for `na_sentinel` is "
+                "deprecated and will be removed in a future version of pandas. "
+                "Specify `use_na_sentinel=True` to use the sentinel value -1, and "
+                "`use_na_sentinel=False` to encode NaN values."
             )
-            uniques = type(original._data)._simple_new(uniques, dtype=original.dtype)
+        warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
+        result = na_sentinel
+    return result
+
+
+def _re_wrap_factorize(original, uniques, codes: np.ndarray):
+    """
+    Wrap factorize results in Series or Index depending on original type.
+    """
+    if isinstance(original, ABCIndex):
+        uniques = ensure_wrapped_if_datetimelike(uniques)
         uniques = original._shallow_copy(uniques, name=None)
     elif isinstance(original, ABCSeries):
         from pandas import Index
@@ -820,7 +947,10 @@ def value_counts(
     -------
     Series
     """
-    from pandas.core.series import Series
+    from pandas import (
+        Index,
+        Series,
+    )
 
     name = getattr(values, "name", None)
 
@@ -856,9 +986,16 @@ def value_counts(
             counts = result._values
 
         else:
+            values = _ensure_arraylike(values)
             keys, counts = value_counts_arraylike(values, dropna)
 
-            result = Series(counts, index=keys, name=name)
+            # For backwards compatibility, we let Index do its normal type
+            #  inference, _except_ for if if infers from object to bool.
+            idx = Index._with_infer(keys)
+            if idx.dtype == bool and keys.dtype == object:
+                idx = idx.astype(object)
+
+            result = Series(counts, index=idx, name=name)
 
     if sort:
         result = result.sort_values(ascending=ascending)
@@ -870,30 +1007,32 @@ def value_counts(
 
 
 # Called once from SparseArray, otherwise could be private
-def value_counts_arraylike(values, dropna: bool):
+def value_counts_arraylike(
+    values: np.ndarray, dropna: bool, mask: npt.NDArray[np.bool_] | None = None
+) -> tuple[ArrayLike, npt.NDArray[np.int64]]:
     """
     Parameters
     ----------
-    values : arraylike
+    values : np.ndarray
     dropna : bool
+    mask : np.ndarray[bool] or None, default None
 
     Returns
     -------
-    uniques : np.ndarray or ExtensionArray
-    counts : np.ndarray
+    uniques : np.ndarray
+    counts : np.ndarray[np.int64]
     """
-    values = _ensure_arraylike(values)
     original = values
     values = _ensure_data(values)
 
-    keys, counts = htable.value_count(values, dropna)
+    keys, counts = htable.value_count(values, dropna, mask=mask)
 
     if needs_i8_conversion(original.dtype):
         # datetime, timedelta, or period
 
         if dropna:
-            msk = keys != iNaT
-            keys, counts = keys[msk], counts[msk]
+            mask = keys != iNaT
+            keys, counts = keys[mask], counts[mask]
 
     res_keys = _reconstruct_data(keys, original.dtype, original)
     return res_keys, counts
@@ -924,7 +1063,9 @@ def duplicated(
     return htable.duplicated(values, keep=keep)
 
 
-def mode(values: ArrayLike, dropna: bool = True) -> ArrayLike:
+def mode(
+    values: ArrayLike, dropna: bool = True, mask: npt.NDArray[np.bool_] | None = None
+) -> ArrayLike:
     """
     Returns the mode(s) of an array.
 
@@ -945,17 +1086,19 @@ def mode(values: ArrayLike, dropna: bool = True) -> ArrayLike:
     if needs_i8_conversion(values.dtype):
         # Got here with ndarray; dispatch to DatetimeArray/TimedeltaArray.
         values = ensure_wrapped_if_datetimelike(values)
-        # error: Item "ndarray[Any, Any]" of "Union[ExtensionArray,
-        # ndarray[Any, Any]]" has no attribute "_mode"
-        return values._mode(dropna=dropna)  # type: ignore[union-attr]
+        values = cast("ExtensionArray", values)
+        return values._mode(dropna=dropna)
 
     values = _ensure_data(values)
 
-    npresult = htable.mode(values, dropna=dropna)
+    npresult = htable.mode(values, dropna=dropna, mask=mask)
     try:
         npresult = np.sort(npresult)
     except TypeError as err:
-        warn(f"Unable to sort modes: {err}")
+        warnings.warn(
+            f"Unable to sort modes: {err}",
+            stacklevel=find_stack_level(),
+        )
 
     result = _reconstruct_data(npresult, original.dtype, original)
     return result
@@ -993,7 +1136,8 @@ def rank(
         (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1).
     """
     is_datetimelike = needs_i8_conversion(values.dtype)
-    values = _get_values_for_rank(values)
+    values = _ensure_data(values)
+
     if values.ndim == 1:
         ranks = algos.rank_1d(
             values,
@@ -1020,11 +1164,11 @@ def rank(
 
 
 def checked_add_with_arr(
-    arr: np.ndarray,
-    b,
+    arr: npt.NDArray[np.int64],
+    b: int | npt.NDArray[np.int64],
     arr_mask: npt.NDArray[np.bool_] | None = None,
     b_mask: npt.NDArray[np.bool_] | None = None,
-) -> np.ndarray:
+) -> npt.NDArray[np.int64]:
     """
     Perform array addition that checks for underflow and overflow.
 
@@ -1035,7 +1179,7 @@ def checked_add_with_arr(
 
     Parameters
     ----------
-    arr : array addend.
+    arr : np.ndarray[int64] addend.
     b : array or scalar addend.
     arr_mask : np.ndarray[bool] or None, default None
         array indicating which elements to exclude from checking
@@ -1068,7 +1212,13 @@ def checked_add_with_arr(
     elif arr_mask is not None:
         not_nan = np.logical_not(arr_mask)
     elif b_mask is not None:
-        not_nan = np.logical_not(b2_mask)
+        # error: Argument 1 to "__call__" of "_UFunc_Nin1_Nout1" has
+        # incompatible type "Optional[ndarray[Any, dtype[bool_]]]";
+        # expected "Union[_SupportsArray[dtype[Any]], _NestedSequence
+        # [_SupportsArray[dtype[Any]]], bool, int, float, complex, str
+        # , bytes, _NestedSequence[Union[bool, int, float, complex, str
+        # , bytes]]]"
+        not_nan = np.logical_not(b2_mask)  # type: ignore[arg-type]
     else:
         not_nan = np.empty(arr.shape, dtype=bool)
         not_nan.fill(True)
@@ -1097,7 +1247,12 @@ def checked_add_with_arr(
 
     if to_raise:
         raise OverflowError("Overflow in int64 addition")
-    return arr + b
+
+    result = arr + b
+    if arr_mask is not None or b2_mask is not None:
+        np.putmask(result, ~not_nan, iNaT)
+
+    return result
 
 
 # --------------- #
@@ -1106,7 +1261,7 @@ def checked_add_with_arr(
 
 
 class SelectN:
-    def __init__(self, obj, n: int, keep: str):
+    def __init__(self, obj, n: int, keep: str) -> None:
         self.obj = obj
         self.n = n
         self.keep = keep
@@ -1167,18 +1322,6 @@ def compute(self, method: str) -> Series:
         dropped = self.obj.dropna()
         nan_index = self.obj.drop(dropped.index)
 
-        if is_extension_array_dtype(dropped.dtype):
-            # GH#41816 bc we have dropped NAs above, MaskedArrays can use the
-            #  numpy logic.
-            from pandas.core.arrays import BaseMaskedArray
-
-            arr = dropped._values
-            if isinstance(arr, BaseMaskedArray):
-                ser = type(dropped)(arr._data, index=dropped.index, name=dropped.name)
-
-                result = type(self)(ser, n=self.n, keep=self.keep).compute(method)
-                return result.astype(arr.dtype)
-
         # slow method
         if n >= len(self.obj):
             ascending = method == "nsmallest"
@@ -1201,7 +1344,6 @@ def compute(self, method: str) -> Series:
             arr = arr[::-1]
 
         nbase = n
-        findex = len(self.obj)
         narr = len(arr)
         n = min(n, narr)
 
@@ -1214,6 +1356,11 @@ def compute(self, method: str) -> Series:
         if self.keep != "all":
             inds = inds[:n]
             findex = nbase
+        else:
+            if len(inds) < nbase and len(nan_index) + len(inds) >= nbase:
+                findex = len(nan_index) + len(inds)
+            else:
+                findex = len(inds)
 
         if self.keep == "last":
             # reverse indices
@@ -1238,7 +1385,7 @@ class SelectNFrame(SelectN):
     nordered : DataFrame
     """
 
-    def __init__(self, obj: DataFrame, n: int, keep: str, columns: IndexLabel):
+    def __init__(self, obj: DataFrame, n: int, keep: str, columns: IndexLabel) -> None:
         super().__init__(obj, n, keep)
         if not is_list_like(columns) or isinstance(columns, tuple):
             columns = [columns]
@@ -1397,20 +1544,20 @@ def take(
 
     Examples
     --------
-    >>> from pandas.api.extensions import take
+    >>> import pandas as pd
 
     With the default ``allow_fill=False``, negative numbers indicate
     positional indices from the right.
 
-    >>> take(np.array([10, 20, 30]), [0, 0, -1])
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1])
     array([10, 10, 30])
 
     Setting ``allow_fill=True`` will place `fill_value` in those positions.
 
-    >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True)
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True)
     array([10., 10., nan])
 
-    >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True,
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True,
     ...      fill_value=-10)
     array([ 10,  10, -10])
     """
@@ -1571,7 +1718,7 @@ def diff(arr, n: int, axis: int = 0):
                 raise ValueError(f"cannot diff {type(arr).__name__} on axis={axis}")
             return op(arr, arr.shift(n))
         else:
-            warn(
+            warnings.warn(
                 "dtype lost in 'diff()'. In the future this will raise a "
                 "TypeError. Convert to a suitable dtype prior to calling 'diff'.",
                 FutureWarning,
@@ -1651,7 +1798,7 @@ def safe_sort(
     na_sentinel: int = -1,
     assume_unique: bool = False,
     verify: bool = True,
-) -> np.ndarray | tuple[np.ndarray, np.ndarray]:
+) -> np.ndarray | MultiIndex | tuple[np.ndarray | MultiIndex, np.ndarray]:
     """
     Sort ``values`` and reorder corresponding ``codes``.
 
@@ -1680,7 +1827,7 @@ def safe_sort(
 
     Returns
     -------
-    ordered : ndarray
+    ordered : ndarray or MultiIndex
         Sorted ``values``
     new_codes : ndarray
         Reordered ``codes``; returned when ``codes`` is not None.
@@ -1698,6 +1845,8 @@ def safe_sort(
         raise TypeError(
             "Only list-like objects are allowed to be passed to safe_sort as values"
         )
+    original_values = values
+    is_mi = isinstance(original_values, ABCMultiIndex)
 
     if not isinstance(values, (np.ndarray, ABCExtensionArray)):
         # don't convert to string types
@@ -1709,6 +1858,7 @@ def safe_sort(
         values = np.asarray(values, dtype=dtype)  # type: ignore[arg-type]
 
     sorter = None
+    ordered: np.ndarray | MultiIndex
 
     if (
         not is_extension_array_dtype(values)
@@ -1718,13 +1868,17 @@ def safe_sort(
     else:
         try:
             sorter = values.argsort()
-            ordered = values.take(sorter)
+            if is_mi:
+                # Operate on original object instead of casted array (MultiIndex)
+                ordered = original_values.take(sorter)
+            else:
+                ordered = values.take(sorter)
         except TypeError:
             # Previous sorters failed or were not applicable, try `_sort_mixed`
             # which would work, but which fails for special case of 1d arrays
             # with tuples.
             if values.size and isinstance(values[0], tuple):
-                ordered = _sort_tuples(values)
+                ordered = _sort_tuples(values, original_values)
             else:
                 ordered = _sort_mixed(values)
 
@@ -1745,7 +1899,7 @@ def safe_sort(
 
     if sorter is None:
         # mixed types
-        hash_klass, values = _get_data_algo(values)
+        hash_klass, values = _get_hashtable_algo(values)
         t = hash_klass(len(values))
         t.map_locations(values)
         sorter = ensure_platform_int(t.lookup(ordered))
@@ -1778,24 +1932,41 @@ def safe_sort(
 def _sort_mixed(values) -> np.ndarray:
     """order ints before strings in 1d arrays, safe in py3"""
     str_pos = np.array([isinstance(x, str) for x in values], dtype=bool)
-    nums = np.sort(values[~str_pos])
+    none_pos = np.array([x is None for x in values], dtype=bool)
+    nums = np.sort(values[~str_pos & ~none_pos])
     strs = np.sort(values[str_pos])
-    return np.concatenate([nums, np.asarray(strs, dtype=object)])
+    return np.concatenate(
+        [nums, np.asarray(strs, dtype=object), np.array(values[none_pos])]
+    )
+
+
+@overload
+def _sort_tuples(values: np.ndarray, original_values: np.ndarray) -> np.ndarray:
+    ...
+
+
+@overload
+def _sort_tuples(values: np.ndarray, original_values: MultiIndex) -> MultiIndex:
+    ...
 
 
-def _sort_tuples(values: np.ndarray) -> np.ndarray:
+def _sort_tuples(
+    values: np.ndarray, original_values: np.ndarray | MultiIndex
+) -> np.ndarray | MultiIndex:
     """
     Convert array of tuples (1d) to array or array (2d).
     We need to keep the columns separately as they contain different types and
     nans (can't use `np.sort` as it may fail when str and nan are mixed in a
     column as types cannot be compared).
+    We have to apply the indexer to the original values to keep the dtypes in
+    case of MultiIndexes
     """
     from pandas.core.internals.construction import to_arrays
     from pandas.core.sorting import lexsort_indexer
 
     arrays, _ = to_arrays(values, None)
     indexer = lexsort_indexer(arrays, orders=True)
-    return values[indexer]
+    return original_values[indexer]
 
 
 def union_with_duplicates(lvals: ArrayLike, rvals: ArrayLike) -> ArrayLike:
diff --git a/pandas/core/api.py b/pandas/core/api.py
index cf082d2013d3b..3d2547fcea230 100644
--- a/pandas/core/api.py
+++ b/pandas/core/api.py
@@ -1,5 +1,3 @@
-# flake8: noqa:F401
-
 from pandas._libs import (
     NaT,
     Period,
@@ -27,6 +25,7 @@
     value_counts,
 )
 from pandas.core.arrays import Categorical
+from pandas.core.arrays.arrow import ArrowDtype
 from pandas.core.arrays.boolean import BooleanDtype
 from pandas.core.arrays.floating import (
     Float32Dtype,
@@ -84,3 +83,66 @@
 
 # DataFrame needs to be imported after NamedAgg to avoid a circular import
 from pandas.core.frame import DataFrame  # isort:skip
+
+__all__ = [
+    "array",
+    "ArrowDtype",
+    "bdate_range",
+    "BooleanDtype",
+    "Categorical",
+    "CategoricalDtype",
+    "CategoricalIndex",
+    "DataFrame",
+    "DateOffset",
+    "date_range",
+    "DatetimeIndex",
+    "DatetimeTZDtype",
+    "factorize",
+    "Flags",
+    "Float32Dtype",
+    "Float64Dtype",
+    "Float64Index",
+    "Grouper",
+    "Index",
+    "IndexSlice",
+    "Int16Dtype",
+    "Int32Dtype",
+    "Int64Dtype",
+    "Int64Index",
+    "Int8Dtype",
+    "Interval",
+    "IntervalDtype",
+    "IntervalIndex",
+    "interval_range",
+    "isna",
+    "isnull",
+    "MultiIndex",
+    "NA",
+    "NamedAgg",
+    "NaT",
+    "notna",
+    "notnull",
+    "NumericIndex",
+    "Period",
+    "PeriodDtype",
+    "PeriodIndex",
+    "period_range",
+    "RangeIndex",
+    "Series",
+    "set_eng_float_format",
+    "StringDtype",
+    "Timedelta",
+    "TimedeltaIndex",
+    "timedelta_range",
+    "Timestamp",
+    "to_datetime",
+    "to_numeric",
+    "to_timedelta",
+    "UInt16Dtype",
+    "UInt32Dtype",
+    "UInt64Dtype",
+    "UInt64Index",
+    "UInt8Dtype",
+    "unique",
+    "value_counts",
+]
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index 64ee843f1d946..4987a18ae2027 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -32,9 +32,17 @@
     AggObjType,
     Axis,
     NDFrameT,
+    npt,
+)
+from pandas.errors import (
+    DataError,
+    SpecificationError,
 )
 from pandas.util._decorators import cache_readonly
-from pandas.util._exceptions import find_stack_level
+from pandas.util._exceptions import (
+    find_stack_level,
+    rewrite_warning,
+)
 
 from pandas.core.dtypes.cast import is_nested_object
 from pandas.core.dtypes.common import (
@@ -50,11 +58,7 @@
 )
 
 from pandas.core.algorithms import safe_sort
-from pandas.core.base import (
-    DataError,
-    SelectionMixin,
-    SpecificationError,
-)
+from pandas.core.base import SelectionMixin
 import pandas.core.common as com
 from pandas.core.construction import (
     create_series_with_explicit_dtype,
@@ -113,7 +117,7 @@ def __init__(
         result_type: str | None,
         args,
         kwargs,
-    ):
+    ) -> None:
         self.obj = obj
         self.raw = raw
         self.args = args or ()
@@ -173,7 +177,15 @@ def agg(self) -> DataFrame | Series | None:
         if callable(arg):
             f = com.get_cython_func(arg)
             if f and not args and not kwargs:
-                return getattr(obj, f)()
+                # GH#50538
+                old_msg = "The default value of numeric_only"
+                new_msg = (
+                    f"The operation {arg} failed on a column. If any error is "
+                    f"raised, this will raise an exception in a future version "
+                    f"of pandas. Drop these columns to avoid this warning."
+                )
+                with rewrite_warning(old_msg, FutureWarning, new_msg):
+                    return getattr(obj, f)()
 
         # caller can react
         return None
@@ -234,8 +246,12 @@ def transform(self) -> DataFrame | Series:
             and not obj.empty
         ):
             raise ValueError("Transform function failed")
+        # error: Argument 1 to "__get__" of "AxisProperty" has incompatible type
+        # "Union[Series, DataFrame, GroupBy[Any], SeriesGroupBy,
+        # DataFrameGroupBy, BaseWindow, Resampler]"; expected "Union[DataFrame,
+        # Series]"
         if not isinstance(result, (ABCSeries, ABCDataFrame)) or not result.index.equals(
-            obj.index
+            obj.index  # type:ignore[arg-type]
         ):
             raise ValueError("Function did not transform")
 
@@ -304,7 +320,14 @@ def transform_str_or_callable(self, func) -> DataFrame | Series:
         if not args and not kwargs:
             f = com.get_cython_func(func)
             if f:
-                return getattr(obj, f)()
+                old_msg = "The default value of numeric_only"
+                new_msg = (
+                    f"The operation {func} failed on a column. If any error is "
+                    f"raised, this will raise an exception in a future version "
+                    f"of pandas. Drop these columns to avoid this warning."
+                )
+                with rewrite_warning(old_msg, FutureWarning, new_msg):
+                    return getattr(obj, f)()
 
         # Two possible ways to use a UDF - apply or call directly
         try:
@@ -325,6 +348,9 @@ def agg_list_like(self) -> DataFrame | Series:
         obj = self.obj
         arg = cast(List[AggFuncTypeBase], self.f)
 
+        if getattr(obj, "axis", 0) == 1:
+            raise NotImplementedError("axis other than 0 is not supported")
+
         if not isinstance(obj, SelectionMixin):
             # i.e. obj is Series or DataFrame
             selected_obj = obj
@@ -456,6 +482,9 @@ def agg_dict_like(self) -> DataFrame | Series:
         obj = self.obj
         arg = cast(AggFuncTypeDict, self.f)
 
+        if getattr(obj, "axis", 0) == 1:
+            raise NotImplementedError("axis other than 0 is not supported")
+
         if not isinstance(obj, SelectionMixin):
             # i.e. obj is Series or DataFrame
             selected_obj = obj
@@ -539,7 +568,12 @@ def apply_str(self) -> DataFrame | Series:
         func = getattr(obj, f, None)
         if callable(func):
             sig = inspect.getfullargspec(func)
-            if "axis" in sig.args:
+            arg_names = (*sig.args, *sig.kwonlyargs)
+            if self.axis != 0 and (
+                "axis" not in arg_names or f in ("corrwith", "mad", "skew")
+            ):
+                raise ValueError(f"Operation {f} does not support axis=1")
+            elif "axis" in arg_names:
                 self.kwargs["axis"] = self.axis
             elif self.axis != 0:
                 raise ValueError(f"Operation {f} does not support axis=1")
@@ -584,18 +618,17 @@ def normalize_dictlike_arg(
                 cols_sorted = list(safe_sort(list(cols)))
                 raise KeyError(f"Column(s) {cols_sorted} do not exist")
 
-        is_aggregator = lambda x: isinstance(x, (list, tuple, dict))
+        aggregator_types = (list, tuple, dict)
 
         # if we have a dict of any non-scalars
         # eg. {'A' : ['mean']}, normalize all to
         # be list-likes
         # Cannot use func.values() because arg may be a Series
-        if any(is_aggregator(x) for _, x in func.items()):
+        if any(isinstance(x, aggregator_types) for _, x in func.items()):
             new_func: AggFuncTypeDict = {}
             for k, v in func.items():
-                if not is_aggregator(v):
-                    # mypy can't realize v is not a list here
-                    new_func[k] = [v]  # type:ignore[list-item]
+                if not isinstance(v, aggregator_types):
+                    new_func[k] = [v]
                 else:
                     new_func[k] = v
             func = new_func
@@ -639,7 +672,11 @@ class NDFrameApply(Apply):
 
     @property
     def index(self) -> Index:
-        return self.obj.index
+        # error: Argument 1 to "__get__" of "AxisProperty" has incompatible type
+        # "Union[Series, DataFrame, GroupBy[Any], SeriesGroupBy,
+        # DataFrameGroupBy, BaseWindow, Resampler]"; expected "Union[DataFrame,
+        # Series]"
+        return self.obj.index  # type:ignore[arg-type]
 
     @property
     def agg_axis(self) -> Index:
@@ -776,7 +813,10 @@ def apply_empty_result(self):
 
         if not should_reduce:
             try:
-                r = self.f(Series([], dtype=np.float64))
+                if self.axis == 0:
+                    r = self.f(Series([], dtype=np.float64))
+                else:
+                    r = self.f(Series(index=self.columns, dtype=np.float64))
             except Exception:
                 pass
             else:
@@ -996,7 +1036,7 @@ def series_generator(self):
                 # GH#35462 re-pin mgr in case setitem changed it
                 ser._mgr = mgr
                 mgr.set_values(arr)
-                ser.name = name
+                object.__setattr__(ser, "_name", name)
                 yield ser
 
     @property
@@ -1053,7 +1093,7 @@ def __init__(
         convert_dtype: bool,
         args,
         kwargs,
-    ):
+    ) -> None:
         self.convert_dtype = convert_dtype
 
         super().__init__(
@@ -1079,6 +1119,7 @@ def apply(self) -> DataFrame | Series:
             # if we are a string, try to dispatch
             return self.apply_str()
 
+        # self.f is Callable
         return self.apply_standard()
 
     def agg(self):
@@ -1116,7 +1157,8 @@ def apply_empty_result(self) -> Series:
         )
 
     def apply_standard(self) -> DataFrame | Series:
-        f = self.f
+        # caller is responsible for ensuring that f is Callable
+        f = cast(Callable, self.f)
         obj = self.obj
 
         with np.errstate(all="ignore"):
@@ -1129,14 +1171,9 @@ def apply_standard(self) -> DataFrame | Series:
                 mapped = obj._values.map(f)
             else:
                 values = obj.astype(object)._values
-                # error: Argument 2 to "map_infer" has incompatible type
-                # "Union[Callable[..., Any], str, List[Union[Callable[..., Any], str]],
-                # Dict[Hashable, Union[Union[Callable[..., Any], str],
-                # List[Union[Callable[..., Any], str]]]]]"; expected
-                # "Callable[[Any], Any]"
                 mapped = lib.map_infer(
                     values,
-                    f,  # type: ignore[arg-type]
+                    f,
                     convert=self.convert_dtype,
                 )
 
@@ -1157,7 +1194,7 @@ def __init__(
         func: AggFuncType,
         args,
         kwargs,
-    ):
+    ) -> None:
         kwargs = kwargs.copy()
         self.axis = obj.obj._get_axis_number(kwargs.get("axis", 0))
         super().__init__(
@@ -1186,7 +1223,7 @@ def __init__(
         func: AggFuncType,
         args,
         kwargs,
-    ):
+    ) -> None:
         super().__init__(
             obj,
             func,
@@ -1205,7 +1242,7 @@ def transform(self):
 
 def reconstruct_func(
     func: AggFuncType | None, **kwargs
-) -> tuple[bool, AggFuncType | None, list[str] | None, list[int] | None]:
+) -> tuple[bool, AggFuncType | None, list[str] | None, npt.NDArray[np.intp] | None]:
     """
     This is the internal function to reconstruct func given if there is relabeling
     or not and also normalize the keyword to get new order of columns.
@@ -1232,7 +1269,7 @@ def reconstruct_func(
     relabelling: bool, if there is relabelling or not
     func: normalized and mangled func
     columns: list of column names
-    order: list of columns indices
+    order: array of columns indices
 
     Examples
     --------
@@ -1244,7 +1281,7 @@ def reconstruct_func(
     """
     relabeling = func is None and is_multi_agg_with_relabel(**kwargs)
     columns: list[str] | None = None
-    order: list[int] | None = None
+    order: npt.NDArray[np.intp] | None = None
 
     if not relabeling:
         if isinstance(func, list) and len(func) > len(set(func)):
@@ -1291,7 +1328,9 @@ def is_multi_agg_with_relabel(**kwargs) -> bool:
     )
 
 
-def normalize_keyword_aggregation(kwargs: dict) -> tuple[dict, list[str], list[int]]:
+def normalize_keyword_aggregation(
+    kwargs: dict,
+) -> tuple[dict, list[str], npt.NDArray[np.intp]]:
     """
     Normalize user-provided "named aggregation" kwargs.
     Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
@@ -1345,9 +1384,7 @@ def normalize_keyword_aggregation(kwargs: dict) -> tuple[dict, list[str], list[i
 
     # get the new index of columns by comparison
     col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
-    # error: Incompatible return value type (got "Tuple[defaultdict[Any, Any],
-    # Any, ndarray]", expected "Tuple[Dict[Any, Any], List[str], List[int]]")
-    return aggspec, columns, col_idx_order  # type: ignore[return-value]
+    return aggspec, columns, col_idx_order
 
 
 def _make_unique_kwarg_list(
diff --git a/pandas/core/array_algos/masked_reductions.py b/pandas/core/array_algos/masked_reductions.py
index 66a3152de1499..3e59a267f7191 100644
--- a/pandas/core/array_algos/masked_reductions.py
+++ b/pandas/core/array_algos/masked_reductions.py
@@ -2,15 +2,14 @@
 masked_reductions.py is for reduction algorithms using a mask-based approach
 for missing values.
 """
+from __future__ import annotations
 
-from typing import (
-    Callable,
-    Optional,
-)
+from typing import Callable
 
 import numpy as np
 
 from pandas._libs import missing as libmissing
+from pandas._typing import npt
 
 from pandas.core.nanops import check_below_min_count
 
@@ -18,11 +17,11 @@
 def _sumprod(
     func: Callable,
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
     min_count: int = 0,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     """
     Sum or product for 1D masked array.
@@ -33,7 +32,7 @@ def _sumprod(
     values : np.ndarray
         Numpy array with the values (can be of any dtype that support the
         operation).
-    mask : np.ndarray
+    mask : np.ndarray[bool]
         Boolean numpy array (True values indicate missing values).
     skipna : bool, default True
         Whether to skip NA.
@@ -58,11 +57,11 @@ def _sumprod(
 
 def sum(
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
     min_count: int = 0,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     return _sumprod(
         np.sum, values=values, mask=mask, skipna=skipna, min_count=min_count, axis=axis
@@ -71,11 +70,11 @@ def sum(
 
 def prod(
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
     min_count: int = 0,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     return _sumprod(
         np.prod, values=values, mask=mask, skipna=skipna, min_count=min_count, axis=axis
@@ -85,10 +84,10 @@ def prod(
 def _minmax(
     func: Callable,
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     """
     Reduction for 1D masked array.
@@ -99,7 +98,7 @@ def _minmax(
     values : np.ndarray
         Numpy array with the values (can be of any dtype that support the
         operation).
-    mask : np.ndarray
+    mask : np.ndarray[bool]
         Boolean numpy array (True values indicate missing values).
     skipna : bool, default True
         Whether to skip NA.
@@ -122,26 +121,26 @@ def _minmax(
 
 def min(
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     return _minmax(np.min, values=values, mask=mask, skipna=skipna, axis=axis)
 
 
 def max(
     values: np.ndarray,
-    mask: np.ndarray,
+    mask: npt.NDArray[np.bool_],
     *,
     skipna: bool = True,
-    axis: Optional[int] = None,
+    axis: int | None = None,
 ):
     return _minmax(np.max, values=values, mask=mask, skipna=skipna, axis=axis)
 
 
 # TODO: axis kwarg
-def mean(values: np.ndarray, mask: np.ndarray, skipna: bool = True):
+def mean(values: np.ndarray, mask: npt.NDArray[np.bool_], skipna: bool = True):
     if not values.size or mask.all():
         return libmissing.NA
     _sum = _sumprod(np.sum, values=values, mask=mask, skipna=skipna)
diff --git a/pandas/core/array_algos/putmask.py b/pandas/core/array_algos/putmask.py
index 24a0f83dbb313..17622e78d1b12 100644
--- a/pandas/core/array_algos/putmask.py
+++ b/pandas/core/array_algos/putmask.py
@@ -1,5 +1,5 @@
 """
-EA-compatible analogue to to np.putmask
+EA-compatible analogue to np.putmask
 """
 from __future__ import annotations
 
@@ -12,13 +12,9 @@
     ArrayLike,
     npt,
 )
+from pandas.compat import np_version_under1p21
 
-from pandas.core.dtypes.cast import (
-    can_hold_element,
-    convert_scalar_for_putitemlike,
-    find_common_type,
-    infer_dtype_from,
-)
+from pandas.core.dtypes.cast import infer_dtype_from
 from pandas.core.dtypes.common import is_list_like
 
 from pandas.core.arrays import ExtensionArray
@@ -37,9 +33,6 @@ def putmask_inplace(values: ArrayLike, mask: npt.NDArray[np.bool_], value: Any)
     value : Any
     """
 
-    if lib.is_scalar(value) and isinstance(values, np.ndarray):
-        value = convert_scalar_for_putitemlike(value, values.dtype)
-
     if (
         not isinstance(values, np.ndarray)
         or (values.dtype == object and not lib.is_scalar(value))
@@ -60,59 +53,6 @@ def putmask_inplace(values: ArrayLike, mask: npt.NDArray[np.bool_], value: Any)
         np.putmask(values, mask, value)
 
 
-def putmask_smart(values: np.ndarray, mask: npt.NDArray[np.bool_], new) -> np.ndarray:
-    """
-    Return a new ndarray, try to preserve dtype if possible.
-
-    Parameters
-    ----------
-    values : np.ndarray
-        `values`, updated in-place.
-    mask : np.ndarray[bool]
-        Applies to both sides (array like).
-    new : listlike `new values` aligned with `values`
-
-    Returns
-    -------
-    values : ndarray with updated values
-        this *may* be a copy of the original
-
-    See Also
-    --------
-    np.putmask
-    """
-    # we cannot use np.asarray() here as we cannot have conversions
-    # that numpy does when numeric are mixed with strings
-
-    # see if we are only masking values that if putted
-    # will work in the current dtype
-    try:
-        nn = new[mask]
-    except TypeError:
-        # TypeError: only integer scalar arrays can be converted to a scalar index
-        pass
-    else:
-        # We only get to putmask_smart when we cannot hold 'new' in values.
-        #  The "smart" part of putmask_smart is checking if we can hold new[mask]
-        #  in values, in which case we can still avoid the need to cast.
-        if can_hold_element(values, nn):
-            values[mask] = nn
-            return values
-
-    new = np.asarray(new)
-
-    if values.dtype.kind == new.dtype.kind:
-        # preserves dtype if possible
-        np.putmask(values, mask, new)
-        return values
-
-    dtype = find_common_type([values.dtype, new.dtype])
-    values = values.astype(dtype)
-
-    np.putmask(values, mask, new)
-    return values
-
-
 def putmask_without_repeat(
     values: np.ndarray, mask: npt.NDArray[np.bool_], new: Any
 ) -> None:
@@ -126,13 +66,19 @@ def putmask_without_repeat(
     mask : np.ndarray[bool]
     new : Any
     """
+    if np_version_under1p21:
+        new = setitem_datetimelike_compat(values, mask.sum(), new)
+
     if getattr(new, "ndim", 0) >= 1:
         new = new.astype(values.dtype, copy=False)
 
     # TODO: this prob needs some better checking for 2D cases
     nlocs = mask.sum()
     if nlocs > 0 and is_list_like(new) and getattr(new, "ndim", 1) == 1:
-        if nlocs == len(new):
+        shape = np.shape(new)
+        # np.shape compat for if setitem_datetimelike_compat
+        #  changed arraylike to list e.g. test_where_dt64_2d
+        if nlocs == shape[-1]:
             # GH#30567
             # If length of ``new`` is less than the length of ``values``,
             # `np.putmask` would first repeat the ``new`` array and then
@@ -141,7 +87,7 @@ def putmask_without_repeat(
             # to place in the masked locations of ``values``
             np.place(values, mask, new)
             # i.e. values[mask] = new
-        elif mask.shape[-1] == len(new) or len(new) == 1:
+        elif mask.shape[-1] == shape[-1] or shape[-1] == 1:
             np.putmask(values, mask, new)
         else:
             raise ValueError("cannot assign mismatch length to masked array")
diff --git a/pandas/core/array_algos/quantile.py b/pandas/core/array_algos/quantile.py
index 64cd43a3e77cb..d3d9cb1b29b9a 100644
--- a/pandas/core/array_algos/quantile.py
+++ b/pandas/core/array_algos/quantile.py
@@ -2,7 +2,6 @@
 
 import numpy as np
 
-from pandas._libs import lib
 from pandas._typing import (
     ArrayLike,
     Scalar,
@@ -75,6 +74,14 @@ def quantile_with_mask(
 
     Quantile is computed along axis=1.
     """
+    assert values.shape == mask.shape
+    if values.ndim == 1:
+        # unsqueeze, operate, re-squeeze
+        values = np.atleast_2d(values)
+        mask = np.atleast_2d(mask)
+        res_values = quantile_with_mask(values, mask, fill_value, qs, interpolation)
+        return res_values[0]
+
     assert values.ndim == 2
 
     is_empty = values.shape[1] == 0
@@ -104,7 +111,7 @@ def _nanpercentile_1d(
     mask: npt.NDArray[np.bool_],
     qs: npt.NDArray[np.float64],
     na_value: Scalar,
-    interpolation,
+    interpolation: str,
 ) -> Scalar | np.ndarray:
     """
     Wrapper for np.percentile that skips missing values, specialized to
@@ -128,9 +135,19 @@ def _nanpercentile_1d(
     values = values[~mask]
 
     if len(values) == 0:
-        return np.array([na_value] * len(qs), dtype=values.dtype)
+        # Can't pass dtype=values.dtype here bc we might have na_value=np.nan
+        #  with values.dtype=int64 see test_quantile_empty
+        # equiv: 'np.array([na_value] * len(qs))' but much faster
+        return np.full(len(qs), na_value)
 
-    return np.percentile(values, qs, **{np_percentile_argname: interpolation})
+    return np.percentile(
+        values,
+        qs,
+        # error: No overload variant of "percentile" matches argument
+        # types "ndarray[Any, Any]", "ndarray[Any, dtype[floating[_64Bit]]]"
+        # , "Dict[str, str]"  [call-overload]
+        **{np_percentile_argname: interpolation},  # type: ignore[call-overload]
+    )
 
 
 def _nanpercentile(
@@ -139,7 +156,7 @@ def _nanpercentile(
     *,
     na_value,
     mask: npt.NDArray[np.bool_],
-    interpolation,
+    interpolation: str,
 ):
     """
     Wrapper for np.percentile that skips missing values.
@@ -173,16 +190,35 @@ def _nanpercentile(
         #  have float result at this point, not i8
         return result.astype(values.dtype)
 
-    if not lib.is_scalar(mask) and mask.any():
+    if mask.any():
         # Caller is responsible for ensuring mask shape match
         assert mask.shape == values.shape
         result = [
             _nanpercentile_1d(val, m, qs, na_value, interpolation=interpolation)
             for (val, m) in zip(list(values), list(mask))
         ]
-        result = np.array(result, dtype=values.dtype, copy=False).T
+        if values.dtype.kind == "f":
+            # preserve itemsize
+            result = np.array(result, dtype=values.dtype, copy=False).T
+        else:
+            result = np.array(result, copy=False).T
+            if (
+                result.dtype != values.dtype
+                and not mask.all()
+                and (result == result.astype(values.dtype, copy=False)).all()
+            ):
+                # mask.all() will never get cast back to int
+                # e.g. values id integer dtype and result is floating dtype,
+                #  only cast back to integer dtype if result values are all-integer.
+                result = result.astype(values.dtype, copy=False)
         return result
     else:
         return np.percentile(
-            values, qs, axis=1, **{np_percentile_argname: interpolation}
+            values,
+            qs,
+            axis=1,
+            # error: No overload variant of "percentile" matches argument types
+            # "ndarray[Any, Any]", "ndarray[Any, dtype[floating[_64Bit]]]",
+            # "int", "Dict[str, str]"  [call-overload]
+            **{np_percentile_argname: interpolation},  # type: ignore[call-overload]
         )
diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py
index e26bb9fb6ebad..466eeb768f5f9 100644
--- a/pandas/core/array_algos/replace.py
+++ b/pandas/core/array_algos/replace.py
@@ -15,6 +15,7 @@
 from pandas._typing import (
     ArrayLike,
     Scalar,
+    npt,
 )
 
 from pandas.core.dtypes.common import (
@@ -42,7 +43,7 @@ def should_use_regex(regex: bool, to_replace: Any) -> bool:
 
 
 def compare_or_regex_search(
-    a: ArrayLike, b: Scalar | Pattern, regex: bool, mask: np.ndarray
+    a: ArrayLike, b: Scalar | Pattern, regex: bool, mask: npt.NDArray[np.bool_]
 ) -> ArrayLike | bool:
     """
     Compare two array-like inputs of the same shape or two scalar values
@@ -116,7 +117,9 @@ def _check_comparison_types(
     return result
 
 
-def replace_regex(values: ArrayLike, rx: re.Pattern, value, mask: np.ndarray | None):
+def replace_regex(
+    values: ArrayLike, rx: re.Pattern, value, mask: npt.NDArray[np.bool_] | None
+) -> None:
     """
     Parameters
     ----------
diff --git a/pandas/core/array_algos/take.py b/pandas/core/array_algos/take.py
index c4b8f833f4ad3..188725f003f1e 100644
--- a/pandas/core/array_algos/take.py
+++ b/pandas/core/array_algos/take.py
@@ -94,6 +94,12 @@ def take_nd(
     """
     if fill_value is lib.no_default:
         fill_value = na_value_for_dtype(arr.dtype, compat=False)
+    elif isinstance(arr.dtype, np.dtype) and arr.dtype.kind in "mM":
+        dtype, fill_value = maybe_promote(arr.dtype, fill_value)
+        if arr.dtype != dtype:
+            # EA.take is strict about returning a new object of the same type
+            # so for that case cast upfront
+            arr = arr.astype(dtype)
 
     if not isinstance(arr, np.ndarray):
         # i.e. ExtensionArray,
diff --git a/pandas/core/array_algos/transforms.py b/pandas/core/array_algos/transforms.py
index 27aebb9911e83..93b029c21760e 100644
--- a/pandas/core/array_algos/transforms.py
+++ b/pandas/core/array_algos/transforms.py
@@ -2,6 +2,8 @@
 transforms.py is for shape-preserving functions.
 """
 
+from __future__ import annotations
+
 import numpy as np
 
 
diff --git a/pandas/core/arraylike.py b/pandas/core/arraylike.py
index e505d97d04a47..280a599de84ed 100644
--- a/pandas/core/arraylike.py
+++ b/pandas/core/arraylike.py
@@ -4,6 +4,8 @@
     Index
     ExtensionArray
 """
+from __future__ import annotations
+
 import operator
 from typing import Any
 import warnings
@@ -265,10 +267,8 @@ def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any)
         return result
 
     # Determine if we should defer.
-
-    # error: "Type[ndarray]" has no attribute "__array_ufunc__"
     no_defer = (
-        np.ndarray.__array_ufunc__,  # type: ignore[attr-defined]
+        np.ndarray.__array_ufunc__,
         cls.__array_ufunc__,
     )
 
diff --git a/pandas/core/arrays/__init__.py b/pandas/core/arrays/__init__.py
index e301e82a0ee75..79be8760db931 100644
--- a/pandas/core/arrays/__init__.py
+++ b/pandas/core/arrays/__init__.py
@@ -1,3 +1,4 @@
+from pandas.core.arrays.arrow import ArrowExtensionArray
 from pandas.core.arrays.base import (
     ExtensionArray,
     ExtensionOpsMixin,
@@ -21,6 +22,7 @@
 from pandas.core.arrays.timedeltas import TimedeltaArray
 
 __all__ = [
+    "ArrowExtensionArray",
     "ExtensionArray",
     "ExtensionOpsMixin",
     "ExtensionScalarOpsMixin",
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index a40be5a988f26..f17d343024915 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -65,12 +65,13 @@
 )
 
 if TYPE_CHECKING:
-
     from pandas._typing import (
         NumpySorter,
         NumpyValueArrayLike,
     )
 
+    from pandas import Series
+
 
 def ravel_compat(meth: F) -> F:
     """
@@ -99,6 +100,12 @@ class NDArrayBackedExtensionArray(NDArrayBacked, ExtensionArray):
 
     _ndarray: np.ndarray
 
+    # scalar used to denote NA value inside our self._ndarray, e.g. -1
+    #  for Categorical, iNaT for Period. Outside of object dtype,
+    #  self.isna() should be exactly locations in self._ndarray with
+    #  _internal_fill_value.
+    _internal_fill_value: Any
+
     def _box_func(self, x):
         """
         Wrap numpy type in our dtype.type if necessary.
@@ -173,22 +180,30 @@ def equals(self, other) -> bool:
             return False
         return bool(array_equivalent(self._ndarray, other._ndarray))
 
+    @classmethod
+    def _from_factorized(cls, values, original):
+        assert values.dtype == original._ndarray.dtype
+        return original._from_backing_data(values)
+
     def _values_for_argsort(self) -> np.ndarray:
         return self._ndarray
 
+    def _values_for_factorize(self):
+        return self._ndarray, self._internal_fill_value
+
     # Signature of "argmin" incompatible with supertype "ExtensionArray"
-    def argmin(self, axis: int = 0, skipna: bool = True):  # type:ignore[override]
+    def argmin(self, axis: int = 0, skipna: bool = True):  # type: ignore[override]
         # override base class by adding axis keyword
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self.isna().any():
+        if not skipna and self._hasna:
             raise NotImplementedError
         return nargminmax(self, "argmin", axis=axis)
 
     # Signature of "argmax" incompatible with supertype "ExtensionArray"
-    def argmax(self, axis: int = 0, skipna: bool = True):  # type:ignore[override]
+    def argmax(self, axis: int = 0, skipna: bool = True):  # type: ignore[override]
         # override base class by adding axis keyword
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self.isna().any():
+        if not skipna and self._hasna:
             raise NotImplementedError
         return nargminmax(self, "argmax", axis=axis)
 
@@ -208,10 +223,8 @@ def _concat_same_type(
             raise ValueError("to_concat must have the same dtype (tz)", dtypes)
 
         new_values = [x._ndarray for x in to_concat]
-        new_values = np.concatenate(new_values, axis=axis)
-        # error: Argument 1 to "_from_backing_data" of "NDArrayBackedExtensionArray" has
-        # incompatible type "List[ndarray]"; expected "ndarray"
-        return to_concat[0]._from_backing_data(new_values)  # type: ignore[arg-type]
+        new_arr = np.concatenate(new_values, axis=axis)
+        return to_concat[0]._from_backing_data(new_arr)
 
     @doc(ExtensionArray.searchsorted)
     def searchsorted(
@@ -220,12 +233,16 @@ def searchsorted(
         side: Literal["left", "right"] = "left",
         sorter: NumpySorter = None,
     ) -> npt.NDArray[np.intp] | np.intp:
+        # TODO(2.0): use _validate_setitem_value once dt64tz mismatched-timezone
+        #  deprecation is enforced
         npvalue = self._validate_searchsorted_value(value)
         return self._ndarray.searchsorted(npvalue, side=side, sorter=sorter)
 
     def _validate_searchsorted_value(
         self, value: NumpyValueArrayLike | ExtensionArray
     ) -> NumpyValueArrayLike:
+        # TODO(2.0): after deprecation in datetimelikearraymixin is enforced,
+        #  we can remove this and use _validate_setitem_value directly
         if isinstance(value, ExtensionArray):
             return value.to_numpy()
         else:
@@ -244,7 +261,7 @@ def _validate_shift_value(self, fill_value):
         #  we can remove this and use validate_fill_value directly
         return self._validate_scalar(fill_value)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         key = check_array_indexer(self, key)
         value = self._validate_setitem_value(value)
         self._ndarray[key] = value
@@ -313,11 +330,12 @@ def fillna(
                 # TODO: check value is None
                 # (for now) when self.ndim == 2, we assume axis=0
                 func = missing.get_fill_func(method, ndim=self.ndim)
-                new_values, _ = func(self._ndarray.T.copy(), limit=limit, mask=mask.T)
-                new_values = new_values.T
+                npvalues = self._ndarray.T.copy()
+                func(npvalues, limit=limit, mask=mask.T)
+                npvalues = npvalues.T
 
                 # TODO: PandasArray didn't used to copy, need tests for this
-                new_values = self._from_backing_data(new_values)
+                new_values = self._from_backing_data(npvalues)
             else:
                 # fill with value
                 new_values = self.copy()
@@ -360,7 +378,7 @@ def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
         np.putmask(self._ndarray, mask, value)
 
     def _where(
-        self: NDArrayBackedExtensionArrayT, mask: np.ndarray, value
+        self: NDArrayBackedExtensionArrayT, mask: npt.NDArray[np.bool_], value
     ) -> NDArrayBackedExtensionArrayT:
         """
         Analogue to np.where(mask, self, value)
@@ -417,7 +435,7 @@ def insert(
     #  These are not part of the EA API, but we implement them because
     #  pandas assumes they're there.
 
-    def value_counts(self, dropna: bool = True):
+    def value_counts(self, dropna: bool = True) -> Series:
         """
         Return a Series containing counts of unique values.
 
@@ -457,22 +475,22 @@ def _quantile(
     ) -> NDArrayBackedExtensionArrayT:
         # TODO: disable for Categorical if not ordered?
 
-        # asarray needed for Sparse, see GH#24600
         mask = np.asarray(self.isna())
-        mask = np.atleast_2d(mask)
-
-        arr = np.atleast_2d(self._ndarray)
-        # TODO: something NDArrayBacked-specific instead of _values_for_factorize[1]?
-        fill_value = self._values_for_factorize()[1]
+        arr = self._ndarray
+        fill_value = self._internal_fill_value
 
         res_values = quantile_with_mask(arr, mask, fill_value, qs, interpolation)
 
-        result = type(self)._from_factorized(res_values, self)
-        if self.ndim == 1:
-            assert result.shape == (1, len(qs)), result.shape
-            result = result[0]
+        res_values = self._cast_quantile_result(res_values)
+        return self._from_backing_data(res_values)
 
-        return result
+    # TODO: see if we can share this with other dispatch-wrapping methods
+    def _cast_quantile_result(self, res_values: np.ndarray) -> np.ndarray:
+        """
+        Cast the result of quantile_with_mask to an appropriate dtype
+        to pass to _from_backing_data in _quantile.
+        """
+        return res_values
 
     # ------------------------------------------------------------------------
     # numpy-like methods
diff --git a/pandas/core/arrays/_ranges.py b/pandas/core/arrays/_ranges.py
index 3909875e5660a..3bef3e59d5687 100644
--- a/pandas/core/arrays/_ranges.py
+++ b/pandas/core/arrays/_ranges.py
@@ -14,14 +14,15 @@
     Timestamp,
     iNaT,
 )
+from pandas._typing import npt
 
 
 def generate_regular_range(
-    start: Timestamp | Timedelta,
-    end: Timestamp | Timedelta,
-    periods: int,
+    start: Timestamp | Timedelta | None,
+    end: Timestamp | Timedelta | None,
+    periods: int | None,
     freq: BaseOffset,
-):
+) -> npt.NDArray[np.intp]:
     """
     Generate a range of dates or timestamps with the spans between dates
     described by the given `freq` DateOffset.
@@ -32,7 +33,7 @@ def generate_regular_range(
         First point of produced date range.
     end : Timedelta, Timestamp or None
         Last point of produced date range.
-    periods : int
+    periods : int or None
         Number of periods in produced date range.
     freq : Tick
         Describes space between dates in produced date range.
@@ -45,15 +46,15 @@ def generate_regular_range(
     iend = end.value if end is not None else None
     stride = freq.nanos
 
-    if periods is None:
+    if periods is None and istart is not None and iend is not None:
         b = istart
         # cannot just use e = Timestamp(end) + 1 because arange breaks when
         # stride is too large, see GH10887
         e = b + (iend - b) // stride * stride + stride // 2 + 1
-    elif istart is not None:
+    elif istart is not None and periods is not None:
         b = istart
         e = _generate_range_overflow_safe(b, periods, stride, side="start")
-    elif iend is not None:
+    elif iend is not None and periods is not None:
         e = iend + stride
         b = _generate_range_overflow_safe(e, periods, stride, side="end")
     else:
diff --git a/pandas/core/arrays/arrow/__init__.py b/pandas/core/arrays/arrow/__init__.py
new file mode 100644
index 0000000000000..e7fa6fae0a5a1
--- /dev/null
+++ b/pandas/core/arrays/arrow/__init__.py
@@ -0,0 +1,4 @@
+from pandas.core.arrays.arrow.array import ArrowExtensionArray
+from pandas.core.arrays.arrow.dtype import ArrowDtype
+
+__all__ = ["ArrowDtype", "ArrowExtensionArray"]
diff --git a/pandas/core/arrays/arrow/_arrow_utils.py b/pandas/core/arrays/arrow/_arrow_utils.py
new file mode 100644
index 0000000000000..6e6ef6a2c20a8
--- /dev/null
+++ b/pandas/core/arrays/arrow/_arrow_utils.py
@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+import pyarrow
+
+from pandas.errors import PerformanceWarning
+from pandas.util._exceptions import find_stack_level
+
+
+def fallback_performancewarning(version: str | None = None) -> None:
+    """
+    Raise a PerformanceWarning for falling back to ExtensionArray's
+    non-pyarrow method
+    """
+    msg = "Falling back on a non-pyarrow code path which may decrease performance."
+    if version is not None:
+        msg += f" Upgrade to pyarrow >={version} to possibly suppress this warning."
+    warnings.warn(msg, PerformanceWarning, stacklevel=find_stack_level())
+
+
+def pyarrow_array_to_numpy_and_mask(
+    arr, dtype: np.dtype
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Convert a primitive pyarrow.Array to a numpy array and boolean mask based
+    on the buffers of the Array.
+
+    At the moment pyarrow.BooleanArray is not supported.
+
+    Parameters
+    ----------
+    arr : pyarrow.Array
+    dtype : numpy.dtype
+
+    Returns
+    -------
+    (data, mask)
+        Tuple of two numpy arrays with the raw data (with specified dtype) and
+        a boolean mask (validity mask, so False means missing)
+    """
+    dtype = np.dtype(dtype)
+
+    buflist = arr.buffers()
+    # Since Arrow buffers might contain padding and the data might be offset,
+    # the buffer gets sliced here before handing it to numpy.
+    # See also https://github.com/pandas-dev/pandas/issues/40896
+    offset = arr.offset * dtype.itemsize
+    length = len(arr) * dtype.itemsize
+    data_buf = buflist[1][offset : offset + length]
+    data = np.frombuffer(data_buf, dtype=dtype)
+    bitmask = buflist[0]
+    if bitmask is not None:
+        mask = pyarrow.BooleanArray.from_buffers(
+            pyarrow.bool_(), len(arr), [None, bitmask], offset=arr.offset
+        )
+        mask = np.asarray(mask)
+    else:
+        mask = np.ones(len(arr), dtype=bool)
+    return data, mask
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
new file mode 100644
index 0000000000000..4dfd8942c283f
--- /dev/null
+++ b/pandas/core/arrays/arrow/array.py
@@ -0,0 +1,1086 @@
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+)
+
+import numpy as np
+
+from pandas._libs import lib
+from pandas._typing import (
+    Dtype,
+    PositionalIndexer,
+    TakeIndexer,
+    npt,
+)
+from pandas.compat import (
+    pa_version_under1p01,
+    pa_version_under2p0,
+    pa_version_under3p0,
+    pa_version_under4p0,
+    pa_version_under5p0,
+    pa_version_under6p0,
+    pa_version_under7p0,
+)
+from pandas.util._decorators import (
+    deprecate_nonkeyword_arguments,
+    doc,
+)
+
+from pandas.core.dtypes.common import (
+    is_array_like,
+    is_bool_dtype,
+    is_integer,
+    is_integer_dtype,
+    is_scalar,
+)
+from pandas.core.dtypes.missing import isna
+
+from pandas.core.algorithms import resolve_na_sentinel
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.indexers import (
+    check_array_indexer,
+    unpack_tuple_and_ellipses,
+    validate_indices,
+)
+
+if not pa_version_under1p01:
+    import pyarrow as pa
+    import pyarrow.compute as pc
+
+    from pandas.core.arrays.arrow._arrow_utils import fallback_performancewarning
+    from pandas.core.arrays.arrow.dtype import ArrowDtype
+
+    ARROW_CMP_FUNCS = {
+        "eq": pc.equal,
+        "ne": pc.not_equal,
+        "lt": pc.less,
+        "gt": pc.greater,
+        "le": pc.less_equal,
+        "ge": pc.greater_equal,
+    }
+
+    ARROW_LOGICAL_FUNCS = {
+        "and": NotImplemented if pa_version_under2p0 else pc.and_kleene,
+        "rand": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.and_kleene(y, x),
+        "or": NotImplemented if pa_version_under2p0 else pc.or_kleene,
+        "ror": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.or_kleene(y, x),
+        "xor": NotImplemented if pa_version_under2p0 else pc.xor,
+        "rxor": NotImplemented if pa_version_under2p0 else lambda x, y: pc.xor(y, x),
+    }
+
+    def cast_for_truediv(
+        arrow_array: pa.ChunkedArray, pa_object: pa.Array | pa.Scalar
+    ) -> pa.ChunkedArray:
+        # Ensure int / int -> float mirroring Python/Numpy behavior
+        # as pc.divide_checked(int, int) -> int
+        if pa.types.is_integer(arrow_array.type) and pa.types.is_integer(
+            pa_object.type
+        ):
+            return arrow_array.cast(pa.float64())
+        return arrow_array
+
+    def floordiv_compat(
+        left: pa.ChunkedArray | pa.Array | pa.Scalar,
+        right: pa.ChunkedArray | pa.Array | pa.Scalar,
+    ) -> pa.ChunkedArray:
+        # Ensure int // int -> int mirroring Python/Numpy behavior
+        # as pc.floor(pc.divide_checked(int, int)) -> float
+        result = pc.floor(pc.divide_checked(left, right))
+        if pa.types.is_integer(left.type) and pa.types.is_integer(right.type):
+            result = result.cast(left.type)
+        return result
+
+    ARROW_ARITHMETIC_FUNCS = {
+        "add": NotImplemented if pa_version_under2p0 else pc.add_checked,
+        "radd": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.add_checked(y, x),
+        "sub": NotImplemented if pa_version_under2p0 else pc.subtract_checked,
+        "rsub": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.subtract_checked(y, x),
+        "mul": NotImplemented if pa_version_under2p0 else pc.multiply_checked,
+        "rmul": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.multiply_checked(y, x),
+        "truediv": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.divide_checked(cast_for_truediv(x, y), y),
+        "rtruediv": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: pc.divide_checked(y, cast_for_truediv(x, y)),
+        "floordiv": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: floordiv_compat(x, y),
+        "rfloordiv": NotImplemented
+        if pa_version_under2p0
+        else lambda x, y: floordiv_compat(y, x),
+        "mod": NotImplemented,
+        "rmod": NotImplemented,
+        "divmod": NotImplemented,
+        "rdivmod": NotImplemented,
+        "pow": NotImplemented if pa_version_under4p0 else pc.power_checked,
+        "rpow": NotImplemented
+        if pa_version_under4p0
+        else lambda x, y: pc.power_checked(y, x),
+    }
+
+if TYPE_CHECKING:
+    from pandas import Series
+
+ArrowExtensionArrayT = TypeVar("ArrowExtensionArrayT", bound="ArrowExtensionArray")
+
+
+def to_pyarrow_type(
+    dtype: ArrowDtype | pa.DataType | Dtype | None,
+) -> pa.DataType | None:
+    """
+    Convert dtype to a pyarrow type instance.
+    """
+    if isinstance(dtype, ArrowDtype):
+        pa_dtype = dtype.pyarrow_dtype
+    elif isinstance(dtype, pa.DataType):
+        pa_dtype = dtype
+    elif dtype:
+        # Accepts python types too
+        pa_dtype = pa.from_numpy_dtype(dtype)
+    else:
+        pa_dtype = None
+    return pa_dtype
+
+
+class ArrowExtensionArray(OpsMixin, ExtensionArray):
+    """
+    Pandas ExtensionArray backed by a PyArrow ChunkedArray.
+
+    .. warning::
+
+       ArrowExtensionArray is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+    Parameters
+    ----------
+    values : pyarrow.Array or pyarrow.ChunkedArray
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    Returns
+    -------
+    ArrowExtensionArray
+
+    Notes
+    -----
+    Most methods are implemented using `pyarrow compute functions. <https://arrow.apache.org/docs/python/api/compute.html>`__
+    Some methods may either raise an exception or raise a ``PerformanceWarning`` if an
+    associated compute function is not available based on the installed version of PyArrow.
+
+    Please install the latest version of PyArrow to enable the best functionality and avoid
+    potential bugs in prior versions of PyArrow.
+
+    Examples
+    --------
+    Create an ArrowExtensionArray with :func:`pandas.array`:
+
+    >>> pd.array([1, 1, None], dtype="int64[pyarrow]")
+    <ArrowExtensionArray>
+    [1, 1, <NA>]
+    Length: 3, dtype: int64[pyarrow]
+    """  # noqa: E501 (http link too long)
+
+    _data: pa.ChunkedArray
+    _dtype: ArrowDtype
+
+    def __init__(self, values: pa.Array | pa.ChunkedArray) -> None:
+        if pa_version_under1p01:
+            msg = "pyarrow>=1.0.0 is required for PyArrow backed ArrowExtensionArray."
+            raise ImportError(msg)
+        if isinstance(values, pa.Array):
+            self._data = pa.chunked_array([values])
+        elif isinstance(values, pa.ChunkedArray):
+            self._data = values
+        else:
+            raise ValueError(
+                f"Unsupported type '{type(values)}' for ArrowExtensionArray"
+            )
+        self._dtype = ArrowDtype(self._data.type)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None = None, copy=False):
+        """
+        Construct a new ExtensionArray from a sequence of scalars.
+        """
+        pa_dtype = to_pyarrow_type(dtype)
+        is_cls = isinstance(scalars, cls)
+        if is_cls or isinstance(scalars, (pa.Array, pa.ChunkedArray)):
+            if is_cls:
+                scalars = scalars._data
+            if pa_dtype:
+                scalars = scalars.cast(pa_dtype)
+            return cls(scalars)
+        else:
+            return cls(
+                pa.chunked_array(pa.array(scalars, type=pa_dtype, from_pandas=True))
+            )
+
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings, *, dtype: Dtype | None = None, copy=False
+    ):
+        """
+        Construct a new ExtensionArray from a sequence of strings.
+        """
+        pa_type = to_pyarrow_type(dtype)
+        if pa_type is None:
+            # Let pyarrow try to infer or raise
+            scalars = strings
+        elif pa.types.is_timestamp(pa_type):
+            from pandas.core.tools.datetimes import to_datetime
+
+            scalars = to_datetime(strings, errors="raise")
+        elif pa.types.is_date(pa_type):
+            from pandas.core.tools.datetimes import to_datetime
+
+            scalars = to_datetime(strings, errors="raise").date
+        elif pa.types.is_duration(pa_type):
+            from pandas.core.tools.timedeltas import to_timedelta
+
+            scalars = to_timedelta(strings, errors="raise")
+        elif pa.types.is_time(pa_type):
+            from pandas.core.tools.times import to_time
+
+            # "coerce" to allow "null times" (None) to not raise
+            scalars = to_time(strings, errors="coerce")
+        elif pa.types.is_boolean(pa_type):
+            from pandas.core.arrays import BooleanArray
+
+            scalars = BooleanArray._from_sequence_of_strings(strings).to_numpy()
+        elif (
+            pa.types.is_integer(pa_type)
+            or pa.types.is_floating(pa_type)
+            or pa.types.is_decimal(pa_type)
+        ):
+            from pandas.core.tools.numeric import to_numeric
+
+            scalars = to_numeric(strings, errors="raise")
+        else:
+            raise NotImplementedError(
+                f"Converting strings to {pa_type} is not implemented."
+            )
+        return cls._from_sequence(scalars, dtype=pa_type, copy=copy)
+
+    def __getitem__(self, item: PositionalIndexer):
+        """Select a subset of self.
+
+        Parameters
+        ----------
+        item : int, slice, or ndarray
+            * int: The position in 'self' to get.
+            * slice: A slice object, where 'start', 'stop', and 'step' are
+              integers or None
+            * ndarray: A 1-d boolean NumPy ndarray the same length as 'self'
+
+        Returns
+        -------
+        item : scalar or ExtensionArray
+
+        Notes
+        -----
+        For scalar ``item``, return a scalar value suitable for the array's
+        type. This should be an instance of ``self.dtype.type``.
+        For slice ``key``, return an instance of ``ExtensionArray``, even
+        if the slice is length 0 or 1.
+        For a boolean mask, return an instance of ``ExtensionArray``, filtered
+        to the values where ``item`` is True.
+        """
+        item = check_array_indexer(self, item)
+
+        if isinstance(item, np.ndarray):
+            if not len(item):
+                # Removable once we migrate StringDtype[pyarrow] to ArrowDtype[string]
+                if self._dtype.name == "string" and self._dtype.storage == "pyarrow":
+                    pa_dtype = pa.string()
+                else:
+                    pa_dtype = self._dtype.pyarrow_dtype
+                return type(self)(pa.chunked_array([], type=pa_dtype))
+            elif is_integer_dtype(item.dtype):
+                return self.take(item)
+            elif is_bool_dtype(item.dtype):
+                return type(self)(self._data.filter(item))
+            else:
+                raise IndexError(
+                    "Only integers, slices and integer or "
+                    "boolean arrays are valid indices."
+                )
+        elif isinstance(item, tuple):
+            item = unpack_tuple_and_ellipses(item)
+
+        # error: Non-overlapping identity check (left operand type:
+        # "Union[Union[int, integer[Any]], Union[slice, List[int],
+        # ndarray[Any, Any]]]", right operand type: "ellipsis")
+        if item is Ellipsis:  # type: ignore[comparison-overlap]
+            # TODO: should be handled by pyarrow?
+            item = slice(None)
+
+        if is_scalar(item) and not is_integer(item):
+            # e.g. "foo" or 2.5
+            # exception message copied from numpy
+            raise IndexError(
+                r"only integers, slices (`:`), ellipsis (`...`), numpy.newaxis "
+                r"(`None`) and integer or boolean arrays are valid indices"
+            )
+        # We are not an array indexer, so maybe e.g. a slice or integer
+        # indexer. We dispatch to pyarrow.
+        value = self._data[item]
+        if isinstance(value, pa.ChunkedArray):
+            return type(self)(value)
+        else:
+            scalar = value.as_py()
+            if scalar is None:
+                return self._dtype.na_value
+            else:
+                return scalar
+
+    def __arrow_array__(self, type=None):
+        """Convert myself to a pyarrow ChunkedArray."""
+        return self._data
+
+    def __invert__(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        if pa_version_under2p0:
+            raise NotImplementedError("__invert__ not implement for pyarrow < 2.0")
+        return type(self)(pc.invert(self._data))
+
+    def __neg__(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        return type(self)(pc.negate_checked(self._data))
+
+    def __pos__(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        return type(self)(self._data)
+
+    def __abs__(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        return type(self)(pc.abs_checked(self._data))
+
+    def _cmp_method(self, other, op):
+        from pandas.arrays import BooleanArray
+
+        pc_func = ARROW_CMP_FUNCS[op.__name__]
+        if isinstance(other, ArrowExtensionArray):
+            result = pc_func(self._data, other._data)
+        elif isinstance(other, (np.ndarray, list)):
+            result = pc_func(self._data, other)
+        elif is_scalar(other):
+            try:
+                result = pc_func(self._data, pa.scalar(other))
+            except (pa.lib.ArrowNotImplementedError, pa.lib.ArrowInvalid):
+                mask = isna(self) | isna(other)
+                valid = ~mask
+                result = np.zeros(len(self), dtype="bool")
+                result[valid] = op(np.array(self)[valid], other)
+                return BooleanArray(result, mask)
+        else:
+            raise NotImplementedError(
+                f"{op.__name__} not implemented for {type(other)}"
+            )
+
+        if pa_version_under2p0:
+            result = result.to_pandas().values
+        else:
+            result = result.to_numpy()
+        return BooleanArray._from_sequence(result)
+
+    def _evaluate_op_method(self, other, op, arrow_funcs):
+        pc_func = arrow_funcs[op.__name__]
+        if pc_func is NotImplemented:
+            raise NotImplementedError(f"{op.__name__} not implemented.")
+        if isinstance(other, ArrowExtensionArray):
+            result = pc_func(self._data, other._data)
+        elif isinstance(other, (np.ndarray, list)):
+            result = pc_func(self._data, pa.array(other, from_pandas=True))
+        elif is_scalar(other):
+            result = pc_func(self._data, pa.scalar(other))
+        else:
+            raise NotImplementedError(
+                f"{op.__name__} not implemented for {type(other)}"
+            )
+        return type(self)(result)
+
+    def _logical_method(self, other, op):
+        return self._evaluate_op_method(other, op, ARROW_LOGICAL_FUNCS)
+
+    def _arith_method(self, other, op):
+        return self._evaluate_op_method(other, op, ARROW_ARITHMETIC_FUNCS)
+
+    def equals(self, other) -> bool:
+        if not isinstance(other, ArrowExtensionArray):
+            return False
+        # I'm told that pyarrow makes __eq__ behave like pandas' equals;
+        #  TODO: is this documented somewhere?
+        return self._data == other._data
+
+    @property
+    def dtype(self) -> ArrowDtype:
+        """
+        An instance of 'ExtensionDtype'.
+        """
+        return self._dtype
+
+    @property
+    def nbytes(self) -> int:
+        """
+        The number of bytes needed to store this object in memory.
+        """
+        return self._data.nbytes
+
+    def __len__(self) -> int:
+        """
+        Length of this array.
+
+        Returns
+        -------
+        length : int
+        """
+        return len(self._data)
+
+    @property
+    def _hasna(self) -> bool:
+        return self._data.null_count > 0
+
+    def isna(self) -> npt.NDArray[np.bool_]:
+        """
+        Boolean NumPy array indicating if each value is missing.
+
+        This should return a 1-D array the same length as 'self'.
+        """
+        if pa_version_under2p0:
+            return self._data.is_null().to_pandas().values
+        else:
+            return self._data.is_null().to_numpy()
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def argsort(
+        self,
+        ascending: bool = True,
+        kind: str = "quicksort",
+        na_position: str = "last",
+        *args,
+        **kwargs,
+    ) -> np.ndarray:
+        order = "ascending" if ascending else "descending"
+        null_placement = {"last": "at_end", "first": "at_start"}.get(na_position, None)
+        if null_placement is None or pa_version_under7p0:
+            # Although pc.array_sort_indices exists in version 6
+            # there's a bug that affects the pa.ChunkedArray backing
+            # https://issues.apache.org/jira/browse/ARROW-12042
+            fallback_performancewarning("7")
+            return super().argsort(
+                ascending=ascending, kind=kind, na_position=na_position
+            )
+
+        result = pc.array_sort_indices(
+            self._data, order=order, null_placement=null_placement
+        )
+        if pa_version_under2p0:
+            np_result = result.to_pandas().values
+        else:
+            np_result = result.to_numpy()
+        return np_result.astype(np.intp, copy=False)
+
+    def _argmin_max(self, skipna: bool, method: str) -> int:
+        if self._data.length() in (0, self._data.null_count) or (
+            self._hasna and not skipna
+        ):
+            # For empty or all null, pyarrow returns -1 but pandas expects TypeError
+            # For skipna=False and data w/ null, pandas expects NotImplementedError
+            # let ExtensionArray.arg{max|min} raise
+            return getattr(super(), f"arg{method}")(skipna=skipna)
+
+        if pa_version_under6p0:
+            raise NotImplementedError(
+                f"arg{method} only implemented for pyarrow version >= 6.0"
+            )
+
+        value = getattr(pc, method)(self._data, skip_nulls=skipna)
+        return pc.index(self._data, value).as_py()
+
+    def argmin(self, skipna: bool = True) -> int:
+        return self._argmin_max(skipna, "min")
+
+    def argmax(self, skipna: bool = True) -> int:
+        return self._argmin_max(skipna, "max")
+
+    def copy(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        """
+        Return a shallow copy of the array.
+
+        Underlying ChunkedArray is immutable, so a deep copy is unnecessary.
+
+        Returns
+        -------
+        type(self)
+        """
+        return type(self)(self._data)
+
+    def dropna(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        """
+        Return ArrowExtensionArray without NA values.
+
+        Returns
+        -------
+        ArrowExtensionArray
+        """
+        if pa_version_under6p0:
+            fallback_performancewarning(version="6")
+            return super().dropna()
+        else:
+            return type(self)(pc.drop_null(self._data))
+
+    def isin(self, values) -> npt.NDArray[np.bool_]:
+        if pa_version_under2p0:
+            fallback_performancewarning(version="2")
+            return super().isin(values)
+
+        # for an empty value_set pyarrow 3.0.0 segfaults and pyarrow 2.0.0 returns True
+        # for null values, so we short-circuit to return all False array.
+        if not len(values):
+            return np.zeros(len(self), dtype=bool)
+
+        kwargs = {}
+        if pa_version_under3p0:
+            # in pyarrow 2.0.0 skip_null is ignored but is a required keyword and raises
+            # with unexpected keyword argument in pyarrow 3.0.0+
+            kwargs["skip_null"] = True
+
+        result = pc.is_in(
+            self._data, value_set=pa.array(values, from_pandas=True), **kwargs
+        )
+        # pyarrow 2.0.0 returned nulls, so we explicitly specify dtype to convert nulls
+        # to False
+        return np.array(result, dtype=np.bool_)
+
+    def _values_for_factorize(self) -> tuple[np.ndarray, Any]:
+        """
+        Return an array and missing value suitable for factorization.
+
+        Returns
+        -------
+        values : ndarray
+        na_value : pd.NA
+
+        Notes
+        -----
+        The values returned by this method are also used in
+        :func:`pandas.util.hash_pandas_object`.
+        """
+        if pa_version_under2p0:
+            values = self._data.to_pandas().values
+        else:
+            values = self._data.to_numpy()
+        return values, self.dtype.na_value
+
+    @doc(ExtensionArray.factorize)
+    def factorize(
+        self,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
+    ) -> tuple[np.ndarray, ExtensionArray]:
+        resolved_na_sentinel = resolve_na_sentinel(na_sentinel, use_na_sentinel)
+        if pa_version_under4p0:
+            encoded = self._data.dictionary_encode()
+        else:
+            null_encoding = "mask" if resolved_na_sentinel is not None else "encode"
+            encoded = self._data.dictionary_encode(null_encoding=null_encoding)
+        indices = pa.chunked_array(
+            [c.indices for c in encoded.chunks], type=encoded.type.index_type
+        ).to_pandas()
+        if indices.dtype.kind == "f":
+            indices[np.isnan(indices)] = (
+                resolved_na_sentinel if resolved_na_sentinel is not None else -1
+            )
+        indices = indices.astype(np.int64, copy=False)
+
+        if encoded.num_chunks:
+            uniques = type(self)(encoded.chunk(0).dictionary)
+            if resolved_na_sentinel is None and pa_version_under4p0:
+                # TODO: share logic with BaseMaskedArray.factorize
+                # Insert na with the proper code
+                na_mask = indices.values == -1
+                na_index = na_mask.argmax()
+                if na_mask[na_index]:
+                    na_code = 0 if na_index == 0 else indices[:na_index].max() + 1
+                    uniques = uniques.insert(na_code, self.dtype.na_value)
+                    indices[indices >= na_code] += 1
+                    indices[indices == -1] = na_code
+        else:
+            uniques = type(self)(pa.array([], type=encoded.type.value_type))
+
+        return indices.values, uniques
+
+    def reshape(self, *args, **kwargs):
+        raise NotImplementedError(
+            f"{type(self)} does not support reshape "
+            f"as backed by a 1D pyarrow.ChunkedArray."
+        )
+
+    def take(
+        self,
+        indices: TakeIndexer,
+        allow_fill: bool = False,
+        fill_value: Any = None,
+    ) -> ArrowExtensionArray:
+        """
+        Take elements from an array.
+
+        Parameters
+        ----------
+        indices : sequence of int or one-dimensional np.ndarray of int
+            Indices to be taken.
+        allow_fill : bool, default False
+            How to handle negative values in `indices`.
+
+            * False: negative values in `indices` indicate positional indices
+              from the right (the default). This is similar to
+              :func:`numpy.take`.
+
+            * True: negative values in `indices` indicate
+              missing values. These values are set to `fill_value`. Any other
+              other negative values raise a ``ValueError``.
+
+        fill_value : any, optional
+            Fill value to use for NA-indices when `allow_fill` is True.
+            This may be ``None``, in which case the default NA value for
+            the type, ``self.dtype.na_value``, is used.
+
+            For many ExtensionArrays, there will be two representations of
+            `fill_value`: a user-facing "boxed" scalar, and a low-level
+            physical NA value. `fill_value` should be the user-facing version,
+            and the implementation should handle translating that to the
+            physical version for processing the take if necessary.
+
+        Returns
+        -------
+        ExtensionArray
+
+        Raises
+        ------
+        IndexError
+            When the indices are out of bounds for the array.
+        ValueError
+            When `indices` contains negative values other than ``-1``
+            and `allow_fill` is True.
+
+        See Also
+        --------
+        numpy.take
+        api.extensions.take
+
+        Notes
+        -----
+        ExtensionArray.take is called by ``Series.__getitem__``, ``.loc``,
+        ``iloc``, when `indices` is a sequence of values. Additionally,
+        it's called by :meth:`Series.reindex`, or any other method
+        that causes realignment, with a `fill_value`.
+        """
+        # TODO: Remove once we got rid of the (indices < 0) check
+        if not is_array_like(indices):
+            indices_array = np.asanyarray(indices)
+        else:
+            # error: Incompatible types in assignment (expression has type
+            # "Sequence[int]", variable has type "ndarray")
+            indices_array = indices  # type: ignore[assignment]
+
+        if len(self._data) == 0 and (indices_array >= 0).any():
+            raise IndexError("cannot do a non-empty take")
+        if indices_array.size > 0 and indices_array.max() >= len(self._data):
+            raise IndexError("out of bounds value in 'indices'.")
+
+        if allow_fill:
+            fill_mask = indices_array < 0
+            if fill_mask.any():
+                validate_indices(indices_array, len(self._data))
+                # TODO(ARROW-9433): Treat negative indices as NULL
+                indices_array = pa.array(indices_array, mask=fill_mask)
+                result = self._data.take(indices_array)
+                if isna(fill_value):
+                    return type(self)(result)
+                # TODO: ArrowNotImplementedError: Function fill_null has no
+                # kernel matching input types (array[string], scalar[string])
+                result = type(self)(result)
+                result[fill_mask] = fill_value
+                return result
+                # return type(self)(pc.fill_null(result, pa.scalar(fill_value)))
+            else:
+                # Nothing to fill
+                return type(self)(self._data.take(indices))
+        else:  # allow_fill=False
+            # TODO(ARROW-9432): Treat negative indices as indices from the right.
+            if (indices_array < 0).any():
+                # Don't modify in-place
+                indices_array = np.copy(indices_array)
+                indices_array[indices_array < 0] += len(self._data)
+            return type(self)(self._data.take(indices_array))
+
+    def unique(self: ArrowExtensionArrayT) -> ArrowExtensionArrayT:
+        """
+        Compute the ArrowExtensionArray of unique values.
+
+        Returns
+        -------
+        ArrowExtensionArray
+        """
+        if pa_version_under2p0:
+            fallback_performancewarning(version="2")
+            return super().unique()
+        else:
+            return type(self)(pc.unique(self._data))
+
+    def value_counts(self, dropna: bool = True) -> Series:
+        """
+        Return a Series containing counts of each unique value.
+
+        Parameters
+        ----------
+        dropna : bool, default True
+            Don't include counts of missing values.
+
+        Returns
+        -------
+        counts : Series
+
+        See Also
+        --------
+        Series.value_counts
+        """
+        from pandas import (
+            Index,
+            Series,
+        )
+
+        vc = self._data.value_counts()
+
+        values = vc.field(0)
+        counts = vc.field(1)
+        if dropna and self._data.null_count > 0:
+            mask = values.is_valid()
+            values = values.filter(mask)
+            counts = counts.filter(mask)
+
+        # No missing values so we can adhere to the interface and return a numpy array.
+        counts = np.array(counts)
+
+        index = Index(type(self)(values))
+
+        return Series(counts, index=index).astype("Int64")
+
+    @classmethod
+    def _concat_same_type(
+        cls: type[ArrowExtensionArrayT], to_concat
+    ) -> ArrowExtensionArrayT:
+        """
+        Concatenate multiple ArrowExtensionArrays.
+
+        Parameters
+        ----------
+        to_concat : sequence of ArrowExtensionArrays
+
+        Returns
+        -------
+        ArrowExtensionArray
+        """
+        chunks = [array for ea in to_concat for array in ea._data.iterchunks()]
+        arr = pa.chunked_array(chunks)
+        return cls(arr)
+
+    def _reduce(self, name: str, *, skipna: bool = True, **kwargs):
+        """
+        Return a scalar result of performing the reduction operation.
+
+        Parameters
+        ----------
+        name : str
+            Name of the function, supported values are:
+            { any, all, min, max, sum, mean, median, prod,
+            std, var, sem, kurt, skew }.
+        skipna : bool, default True
+            If True, skip NaN values.
+        **kwargs
+            Additional keyword arguments passed to the reduction function.
+            Currently, `ddof` is the only supported kwarg.
+
+        Returns
+        -------
+        scalar
+
+        Raises
+        ------
+        TypeError : subclass does not define reductions
+        """
+        if name == "sem":
+
+            def pyarrow_meth(data, skipna, **kwargs):
+                numerator = pc.stddev(data, skip_nulls=skipna, **kwargs)
+                denominator = pc.sqrt_checked(
+                    pc.subtract_checked(
+                        pc.count(self._data, skip_nulls=skipna), kwargs["ddof"]
+                    )
+                )
+                return pc.divide_checked(numerator, denominator)
+
+        else:
+            pyarrow_name = {
+                "median": "approximate_median",
+                "prod": "product",
+                "std": "stddev",
+                "var": "variance",
+            }.get(name, name)
+            # error: Incompatible types in assignment
+            # (expression has type "Optional[Any]", variable has type
+            # "Callable[[Any, Any, KwArg(Any)], Any]")
+            pyarrow_meth = getattr(pc, pyarrow_name, None)  # type: ignore[assignment]
+            if pyarrow_meth is None:
+                # Let ExtensionArray._reduce raise the TypeError
+                return super()._reduce(name, skipna=skipna, **kwargs)
+        try:
+            result = pyarrow_meth(self._data, skip_nulls=skipna, **kwargs)
+        except (AttributeError, NotImplementedError, TypeError) as err:
+            msg = (
+                f"'{type(self).__name__}' with dtype {self.dtype} "
+                f"does not support reduction '{name}' with pyarrow "
+                f"version {pa.__version__}. '{name}' may be supported by "
+                f"upgrading pyarrow."
+            )
+            raise TypeError(msg) from err
+        if pc.is_null(result).as_py():
+            return self.dtype.na_value
+        return result.as_py()
+
+    def __setitem__(self, key: int | slice | np.ndarray, value: Any) -> None:
+        """Set one or more values inplace.
+
+        Parameters
+        ----------
+        key : int, ndarray, or slice
+            When called from, e.g. ``Series.__setitem__``, ``key`` will be
+            one of
+
+            * scalar int
+            * ndarray of integers.
+            * boolean ndarray
+            * slice object
+
+        value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
+            value or values to be set of ``key``.
+
+        Returns
+        -------
+        None
+        """
+        key = check_array_indexer(self, key)
+        indices = self._indexing_key_to_indices(key)
+        value = self._maybe_convert_setitem_value(value)
+
+        argsort = np.argsort(indices)
+        indices = indices[argsort]
+
+        if is_scalar(value):
+            value = np.broadcast_to(value, len(self))
+        elif len(indices) != len(value):
+            raise ValueError("Length of indexer and values mismatch")
+        else:
+            value = np.asarray(value)[argsort]
+
+        self._data = self._set_via_chunk_iteration(indices=indices, value=value)
+
+    def _indexing_key_to_indices(
+        self, key: int | slice | np.ndarray
+    ) -> npt.NDArray[np.intp]:
+        """
+        Convert indexing key for self into positional indices.
+
+        Parameters
+        ----------
+        key : int | slice | np.ndarray
+
+        Returns
+        -------
+        npt.NDArray[np.intp]
+        """
+        n = len(self)
+        if isinstance(key, slice):
+            indices = np.arange(n)[key]
+        elif is_integer(key):
+            # error: Invalid index type "List[Union[int, ndarray[Any, Any]]]"
+            # for "ndarray[Any, dtype[signedinteger[Any]]]"; expected type
+            # "Union[SupportsIndex, _SupportsArray[dtype[Union[bool_,
+            # integer[Any]]]], _NestedSequence[_SupportsArray[dtype[Union
+            # [bool_, integer[Any]]]]], _NestedSequence[Union[bool, int]]
+            # , Tuple[Union[SupportsIndex, _SupportsArray[dtype[Union[bool_
+            # , integer[Any]]]], _NestedSequence[_SupportsArray[dtype[Union
+            # [bool_, integer[Any]]]]], _NestedSequence[Union[bool, int]]], ...]]"
+            indices = np.arange(n)[[key]]  # type: ignore[index]
+        elif is_bool_dtype(key):
+            key = np.asarray(key)
+            if len(key) != n:
+                raise ValueError("Length of indexer and values mismatch")
+            indices = key.nonzero()[0]
+        else:
+            key = np.asarray(key)
+            indices = np.arange(n)[key]
+        return indices
+
+    # TODO: redefine _rank using pc.rank with pyarrow 9.0
+
+    def _quantile(
+        self: ArrowExtensionArrayT, qs: npt.NDArray[np.float64], interpolation: str
+    ) -> ArrowExtensionArrayT:
+        """
+        Compute the quantiles of self for each quantile in `qs`.
+
+        Parameters
+        ----------
+        qs : np.ndarray[float64]
+        interpolation: str
+
+        Returns
+        -------
+        same type as self
+        """
+        if pa_version_under4p0:
+            raise NotImplementedError(
+                "quantile only supported for pyarrow version >= 4.0"
+            )
+        result = pc.quantile(self._data, q=qs, interpolation=interpolation)
+        return type(self)(result)
+
+    def _mode(self: ArrowExtensionArrayT, dropna: bool = True) -> ArrowExtensionArrayT:
+        """
+        Returns the mode(s) of the ExtensionArray.
+
+        Always returns `ExtensionArray` even if only one value.
+
+        Parameters
+        ----------
+        dropna : bool, default True
+            Don't consider counts of NA values.
+            Not implemented by pyarrow.
+
+        Returns
+        -------
+        same type as self
+            Sorted, if possible.
+        """
+        if pa_version_under6p0:
+            raise NotImplementedError("mode only supported for pyarrow version >= 6.0")
+        modes = pc.mode(self._data, pc.count_distinct(self._data).as_py())
+        values = modes.field(0)
+        counts = modes.field(1)
+        # counts sorted descending i.e counts[0] = max
+        mask = pc.equal(counts, counts[0])
+        most_common = values.filter(mask)
+        return type(self)(most_common)
+
+    def _maybe_convert_setitem_value(self, value):
+        """Maybe convert value to be pyarrow compatible."""
+        # TODO: Make more robust like ArrowStringArray._maybe_convert_setitem_value
+        return value
+
+    def _set_via_chunk_iteration(
+        self, indices: npt.NDArray[np.intp], value: npt.NDArray[Any]
+    ) -> pa.ChunkedArray:
+        """
+        Loop through the array chunks and set the new values while
+        leaving the chunking layout unchanged.
+
+        Parameters
+        ----------
+        indices : npt.NDArray[np.intp]
+            Position indices for the underlying ChunkedArray.
+
+        value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
+            value or values to be set of ``key``.
+
+        Notes
+        -----
+        Assumes that indices is sorted. Caller is responsible for sorting.
+        """
+        new_data = []
+        stop = 0
+        for chunk in self._data.iterchunks():
+            start, stop = stop, stop + len(chunk)
+            if len(indices) == 0 or stop <= indices[0]:
+                new_data.append(chunk)
+            else:
+                n = int(np.searchsorted(indices, stop, side="left"))
+                c_ind = indices[:n] - start
+                indices = indices[n:]
+                n = len(c_ind)
+                c_value, value = value[:n], value[n:]
+                new_data.append(self._replace_with_indices(chunk, c_ind, c_value))
+        return pa.chunked_array(new_data)
+
+    @classmethod
+    def _replace_with_indices(
+        cls,
+        chunk: pa.Array,
+        indices: npt.NDArray[np.intp],
+        value: npt.NDArray[Any],
+    ) -> pa.Array:
+        """
+        Replace items selected with a set of positional indices.
+
+        Analogous to pyarrow.compute.replace_with_mask, except that replacement
+        positions are identified via indices rather than a mask.
+
+        Parameters
+        ----------
+        chunk : pa.Array
+        indices : npt.NDArray[np.intp]
+        value : npt.NDArray[Any]
+            Replacement value(s).
+
+        Returns
+        -------
+        pa.Array
+        """
+        n = len(indices)
+
+        if n == 0:
+            return chunk
+
+        start, stop = indices[[0, -1]]
+
+        if (stop - start) == (n - 1):
+            # fast path for a contiguous set of indices
+            arrays = [
+                chunk[:start],
+                pa.array(value, type=chunk.type, from_pandas=True),
+                chunk[stop + 1 :],
+            ]
+            arrays = [arr for arr in arrays if len(arr)]
+            if len(arrays) == 1:
+                return arrays[0]
+            return pa.concat_arrays(arrays)
+
+        mask = np.zeros(len(chunk), dtype=np.bool_)
+        mask[indices] = True
+
+        if pa_version_under5p0:
+            arr = chunk.to_numpy(zero_copy_only=False)
+            arr[mask] = value
+            return pa.array(arr, type=chunk.type)
+
+        if isna(value).all():
+            return pc.if_else(mask, None, chunk)
+
+        return pc.replace_with_mask(chunk, mask, value)
diff --git a/pandas/core/arrays/arrow/dtype.py b/pandas/core/arrays/arrow/dtype.py
new file mode 100644
index 0000000000000..48e2c5bdda2f8
--- /dev/null
+++ b/pandas/core/arrays/arrow/dtype.py
@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import re
+
+import numpy as np
+
+from pandas._typing import DtypeObj
+from pandas.compat import pa_version_under1p01
+from pandas.util._decorators import cache_readonly
+
+from pandas.core.dtypes.base import (
+    StorageExtensionDtype,
+    register_extension_dtype,
+)
+
+if not pa_version_under1p01:
+    import pyarrow as pa
+
+
+@register_extension_dtype
+class ArrowDtype(StorageExtensionDtype):
+    """
+    An ExtensionDtype for PyArrow data types.
+
+    .. warning::
+
+       ArrowDtype is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+    While most ``dtype`` arguments can accept the "string"
+    constructor, e.g. ``"int64[pyarrow]"``, ArrowDtype is useful
+    if the data type contains parameters like ``pyarrow.timestamp``.
+
+    Parameters
+    ----------
+    pyarrow_dtype : pa.DataType
+        An instance of a `pyarrow.DataType <https://arrow.apache.org/docs/python/api/datatypes.html#factory-functions>`__.
+
+    Attributes
+    ----------
+    pyarrow_dtype
+
+    Methods
+    -------
+    None
+
+    Returns
+    -------
+    ArrowDtype
+
+    Examples
+    --------
+    >>> import pyarrow as pa
+    >>> pd.ArrowDtype(pa.int64())
+    int64[pyarrow]
+
+    Types with parameters must be constructed with ArrowDtype.
+
+    >>> pd.ArrowDtype(pa.timestamp("s", tz="America/New_York"))
+    timestamp[s, tz=America/New_York][pyarrow]
+    >>> pd.ArrowDtype(pa.list_(pa.int64()))
+    list<item: int64>[pyarrow]
+    """  # noqa: E501
+
+    _metadata = ("storage", "pyarrow_dtype")  # type: ignore[assignment]
+
+    def __init__(self, pyarrow_dtype: pa.DataType) -> None:
+        super().__init__("pyarrow")
+        if pa_version_under1p01:
+            raise ImportError("pyarrow>=1.0.1 is required for ArrowDtype")
+        if not isinstance(pyarrow_dtype, pa.DataType):
+            raise ValueError(
+                f"pyarrow_dtype ({pyarrow_dtype}) must be an instance "
+                f"of a pyarrow.DataType. Got {type(pyarrow_dtype)} instead."
+            )
+        self.pyarrow_dtype = pyarrow_dtype
+
+    def __repr__(self) -> str:
+        return self.name
+
+    @property
+    def type(self):
+        """
+        Returns pyarrow.DataType.
+        """
+        return type(self.pyarrow_dtype)
+
+    @property
+    def name(self) -> str:  # type: ignore[override]
+        """
+        A string identifying the data type.
+        """
+        return f"{str(self.pyarrow_dtype)}[{self.storage}]"
+
+    @cache_readonly
+    def numpy_dtype(self) -> np.dtype:
+        """Return an instance of the related numpy dtype"""
+        try:
+            return np.dtype(self.pyarrow_dtype.to_pandas_dtype())
+        except (NotImplementedError, TypeError):
+            return np.dtype(object)
+
+    @cache_readonly
+    def kind(self) -> str:
+        return self.numpy_dtype.kind
+
+    @cache_readonly
+    def itemsize(self) -> int:
+        """Return the number of bytes in this dtype"""
+        return self.numpy_dtype.itemsize
+
+    @classmethod
+    def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        from pandas.core.arrays.arrow import ArrowExtensionArray
+
+        return ArrowExtensionArray
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> ArrowDtype:
+        """
+        Construct this type from a string.
+
+        Parameters
+        ----------
+        string : str
+            string should follow the format f"{pyarrow_type}[pyarrow]"
+            e.g. int64[pyarrow]
+        """
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
+        if not string.endswith("[pyarrow]"):
+            raise TypeError(f"'{string}' must end with '[pyarrow]'")
+        if string == "string[pyarrow]":
+            # Ensure Registry.find skips ArrowDtype to use StringDtype instead
+            raise TypeError("string[pyarrow] should be constructed by StringDtype")
+        base_type = string.split("[pyarrow]")[0]
+        try:
+            pa_dtype = pa.type_for_alias(base_type)
+        except ValueError as err:
+            has_parameters = re.search(r"\[.*\]", base_type)
+            if has_parameters:
+                raise NotImplementedError(
+                    "Passing pyarrow type specific parameters "
+                    f"({has_parameters.group()}) in the string is not supported. "
+                    "Please construct an ArrowDtype object with a pyarrow_dtype "
+                    "instance with specific parameters."
+                ) from err
+            raise TypeError(f"'{base_type}' is not a valid pyarrow data type.") from err
+        return cls(pa_dtype)
+
+    @property
+    def _is_numeric(self) -> bool:
+        """
+        Whether columns with this dtype should be considered numeric.
+        """
+        # TODO: pa.types.is_boolean?
+        return (
+            pa.types.is_integer(self.pyarrow_dtype)
+            or pa.types.is_floating(self.pyarrow_dtype)
+            or pa.types.is_decimal(self.pyarrow_dtype)
+        )
+
+    @property
+    def _is_boolean(self) -> bool:
+        """
+        Whether this dtype should be considered boolean.
+        """
+        return pa.types.is_boolean(self.pyarrow_dtype)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        # We unwrap any masked dtypes, find the common dtype we would use
+        #  for that, then re-mask the result.
+        # Mirrors BaseMaskedDtype
+        from pandas.core.dtypes.cast import find_common_type
+
+        new_dtype = find_common_type(
+            [
+                dtype.numpy_dtype if isinstance(dtype, ArrowDtype) else dtype
+                for dtype in dtypes
+            ]
+        )
+        if not isinstance(new_dtype, np.dtype):
+            return None
+        try:
+            pa_dtype = pa.from_numpy_dtype(new_dtype)
+            return type(self)(pa_dtype)
+        except NotImplementedError:
+            return None
+
+    def __from_arrow__(self, array: pa.Array | pa.ChunkedArray):
+        """
+        Construct IntegerArray/FloatingArray from pyarrow Array/ChunkedArray.
+        """
+        array_class = self.construct_array_type()
+        return array_class(array)
diff --git a/pandas/core/arrays/_arrow_utils.py b/pandas/core/arrays/arrow/extension_types.py
similarity index 65%
rename from pandas/core/arrays/_arrow_utils.py
rename to pandas/core/arrays/arrow/extension_types.py
index 6214693f22975..c9badb2bd305b 100644
--- a/pandas/core/arrays/_arrow_utils.py
+++ b/pandas/core/arrays/arrow/extension_types.py
@@ -1,52 +1,16 @@
+from __future__ import annotations
+
 import json
 
-import numpy as np
 import pyarrow
 
-from pandas.core.arrays.interval import VALID_CLOSED
-
+from pandas._typing import IntervalClosedType
 
-def pyarrow_array_to_numpy_and_mask(arr, dtype):
-    """
-    Convert a primitive pyarrow.Array to a numpy array and boolean mask based
-    on the buffers of the Array.
-
-    At the moment pyarrow.BooleanArray is not supported.
-
-    Parameters
-    ----------
-    arr : pyarrow.Array
-    dtype : numpy.dtype
-
-    Returns
-    -------
-    (data, mask)
-        Tuple of two numpy arrays with the raw data (with specified dtype) and
-        a boolean mask (validity mask, so False means missing)
-    """
-    dtype = np.dtype(dtype)
-
-    buflist = arr.buffers()
-    # Since Arrow buffers might contain padding and the data might be offset,
-    # the buffer gets sliced here before handing it to numpy.
-    # See also https://github.com/pandas-dev/pandas/issues/40896
-    offset = arr.offset * dtype.itemsize
-    length = len(arr) * dtype.itemsize
-    data_buf = buflist[1][offset : offset + length]
-    data = np.frombuffer(data_buf, dtype=dtype)
-    bitmask = buflist[0]
-    if bitmask is not None:
-        mask = pyarrow.BooleanArray.from_buffers(
-            pyarrow.bool_(), len(arr), [None, bitmask], offset=arr.offset
-        )
-        mask = np.asarray(mask)
-    else:
-        mask = np.ones(len(arr), dtype=bool)
-    return data, mask
+from pandas.core.arrays.interval import VALID_CLOSED
 
 
 class ArrowPeriodType(pyarrow.ExtensionType):
-    def __init__(self, freq):
+    def __init__(self, freq) -> None:
         # attributes need to be set first before calling
         # super init (as that calls serialize)
         self._freq = freq
@@ -56,12 +20,12 @@ def __init__(self, freq):
     def freq(self):
         return self._freq
 
-    def __arrow_ext_serialize__(self):
+    def __arrow_ext_serialize__(self) -> bytes:
         metadata = {"freq": self.freq}
         return json.dumps(metadata).encode()
 
     @classmethod
-    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+    def __arrow_ext_deserialize__(cls, storage_type, serialized) -> ArrowPeriodType:
         metadata = json.loads(serialized.decode())
         return ArrowPeriodType(metadata["freq"])
 
@@ -71,7 +35,7 @@ def __eq__(self, other):
         else:
             return NotImplemented
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((str(self), self.freq))
 
     def to_pandas_dtype(self):
@@ -86,11 +50,11 @@ def to_pandas_dtype(self):
 
 
 class ArrowIntervalType(pyarrow.ExtensionType):
-    def __init__(self, subtype, closed):
+    def __init__(self, subtype, closed: IntervalClosedType) -> None:
         # attributes need to be set first before calling
         # super init (as that calls serialize)
         assert closed in VALID_CLOSED
-        self._closed = closed
+        self._closed: IntervalClosedType = closed
         if not isinstance(subtype, pyarrow.DataType):
             subtype = pyarrow.type_for_alias(str(subtype))
         self._subtype = subtype
@@ -103,15 +67,15 @@ def subtype(self):
         return self._subtype
 
     @property
-    def closed(self):
+    def closed(self) -> IntervalClosedType:
         return self._closed
 
-    def __arrow_ext_serialize__(self):
+    def __arrow_ext_serialize__(self) -> bytes:
         metadata = {"subtype": str(self.subtype), "closed": self.closed}
         return json.dumps(metadata).encode()
 
     @classmethod
-    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+    def __arrow_ext_deserialize__(cls, storage_type, serialized) -> ArrowIntervalType:
         metadata = json.loads(serialized.decode())
         subtype = pyarrow.type_for_alias(metadata["subtype"])
         closed = metadata["closed"]
@@ -127,7 +91,7 @@ def __eq__(self, other):
         else:
             return NotImplemented
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((str(self), str(self.subtype), self.closed))
 
     def to_pandas_dtype(self):
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index c16c404d56295..be44c7e4b562e 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -8,11 +8,13 @@
 """
 from __future__ import annotations
 
+import inspect
 import operator
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    ClassVar,
     Iterator,
     Literal,
     Sequence,
@@ -20,6 +22,7 @@
     cast,
     overload,
 )
+import warnings
 
 import numpy as np
 
@@ -43,7 +46,9 @@
     Appender,
     Substitution,
     cache_readonly,
+    deprecate_nonkeyword_arguments,
 )
+from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import (
     validate_bool_kwarg,
     validate_fillna_kwargs,
@@ -75,6 +80,7 @@
     isin,
     mode,
     rank,
+    resolve_na_sentinel,
     unique,
 )
 from pandas.core.array_algos.quantile import quantile_with_mask
@@ -180,7 +186,7 @@ class ExtensionArray:
     * dropna
     * unique
     * factorize / _values_for_factorize
-    * argsort / _values_for_argsort
+    * argsort, argmax, argmin / _values_for_argsort
     * searchsorted
 
     The remaining methods implemented on this class should be performant,
@@ -427,7 +433,7 @@ def __contains__(self, item: object) -> bool | np.bool_:
             if not self._can_hold_na:
                 return False
             elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
-                return self._hasnans
+                return self._hasna
             else:
                 return False
         else:
@@ -455,11 +461,29 @@ def __ne__(self, other: Any) -> ArrayLike:  # type: ignore[override]
         """
         return ~(self == other)
 
+    def __init_subclass__(cls, **kwargs) -> None:
+        factorize = getattr(cls, "factorize")
+        if (
+            "use_na_sentinel" not in inspect.signature(factorize).parameters
+            # TimelikeOps uses old factorize args to ensure we don't break things
+            and cls.__name__ not in ("TimelikeOps", "DatetimeArray", "TimedeltaArray")
+        ):
+            # See GH#46910 for details on the deprecation
+            name = cls.__name__
+            warnings.warn(
+                f"The `na_sentinel` argument of `{name}.factorize` is deprecated. "
+                f"In the future, pandas will use the `use_na_sentinel` argument "
+                f"instead.  Add this argument to `{name}.factorize` to be compatible "
+                f"with future versions of pandas and silence this warning.",
+                DeprecationWarning,
+                stacklevel=find_stack_level(),
+            )
+
     def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Convert to a NumPy ndarray.
@@ -516,7 +540,9 @@ def size(self) -> int:
         """
         The number of elements in the array.
         """
-        return np.prod(self.shape)
+        # error: Incompatible return value type (got "signedinteger[_64Bit]",
+        # expected "int")  [return-value]
+        return np.prod(self.shape)  # type: ignore[return-value]
 
     @property
     def ndim(self) -> int:
@@ -606,7 +632,7 @@ def isna(self) -> np.ndarray | ExtensionArraySupportsAnyAll:
         raise AbstractMethodError(self)
 
     @property
-    def _hasnans(self) -> bool:
+    def _hasna(self) -> bool:
         # GH#22680
         """
         Equivalent to `self.isna().any()`.
@@ -628,10 +654,21 @@ def _values_for_argsort(self) -> np.ndarray:
         See Also
         --------
         ExtensionArray.argsort : Return the indices that would sort this array.
+
+        Notes
+        -----
+        The caller is responsible for *not* modifying these values in-place, so
+        it is safe for implementors to give views on `self`.
+
+        Functions that use this (e.g. ExtensionArray.argsort) should ignore
+        entries with missing values in the original array (according to `self.isna()`).
+        This means that the corresponding entries in the returned array don't need to
+        be modified to sort correctly.
         """
-        # Note: this is used in `ExtensionArray.argsort`.
+        # Note: this is used in `ExtensionArray.argsort/argmin/argmax`.
         return np.array(self)
 
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def argsort(
         self,
         ascending: bool = True,
@@ -666,7 +703,8 @@ def argsort(
         # Implementor note: You have two places to override the behavior of
         # argsort.
         # 1. _values_for_argsort : construct the values passed to np.argsort
-        # 2. argsort : total control over sorting.
+        # 2. argsort : total control over sorting. In case of overriding this,
+        #    it is recommended to also override argmax/argmin
         ascending = nv.validate_argsort_with_ascending(ascending, args, kwargs)
 
         values = self._values_for_argsort()
@@ -697,8 +735,12 @@ def argmin(self, skipna: bool = True) -> int:
         --------
         ExtensionArray.argmax
         """
+        # Implementor note: You have two places to override the behavior of
+        # argmin.
+        # 1. _values_for_argsort : construct the values used in nargminmax
+        # 2. argmin itself : total control over sorting.
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self._hasnans:
+        if not skipna and self._hasna:
             raise NotImplementedError
         return nargminmax(self, "argmin")
 
@@ -721,17 +763,21 @@ def argmax(self, skipna: bool = True) -> int:
         --------
         ExtensionArray.argmin
         """
+        # Implementor note: You have two places to override the behavior of
+        # argmax.
+        # 1. _values_for_argsort : construct the values used in nargminmax
+        # 2. argmax itself : total control over sorting.
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self._hasnans:
+        if not skipna and self._hasna:
             raise NotImplementedError
         return nargminmax(self, "argmax")
 
     def fillna(
-        self,
+        self: ExtensionArrayT,
         value: object | ArrayLike | None = None,
         method: FillnaOptions | None = None,
         limit: int | None = None,
-    ):
+    ) -> ExtensionArrayT:
         """
         Fill NA/NaN values using the specified method.
 
@@ -770,8 +816,9 @@ def fillna(
         if mask.any():
             if method is not None:
                 func = missing.get_fill_func(method)
-                new_values, _ = func(self.astype(object), limit=limit, mask=mask)
-                new_values = self._from_sequence(new_values, dtype=self.dtype)
+                npvalues = self.astype(object)
+                func(npvalues, limit=limit, mask=mask)
+                new_values = self._from_sequence(npvalues, dtype=self.dtype)
             else:
                 # fill with value
                 new_values = self.copy()
@@ -940,7 +987,7 @@ def equals(self, other: object) -> bool:
             equal_na = self.isna() & other.isna()  # type: ignore[operator]
             return bool((equal_values | equal_na).all())
 
-    def isin(self, values) -> np.ndarray:
+    def isin(self, values) -> npt.NDArray[np.bool_]:
         """
         Pointwise comparison for set containment in the given values.
 
@@ -980,7 +1027,11 @@ def _values_for_factorize(self) -> tuple[np.ndarray, Any]:
         """
         return self.astype(object), np.nan
 
-    def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
+    def factorize(
+        self,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
+    ) -> tuple[np.ndarray, ExtensionArray]:
         """
         Encode the extension array as an enumerated type.
 
@@ -989,6 +1040,18 @@ def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
         na_sentinel : int, default -1
             Value to use in the `codes` array to indicate missing values.
 
+            .. deprecated:: 1.5.0
+                The na_sentinel argument is deprecated and
+                will be removed in a future version of pandas. Specify use_na_sentinel
+                as either True or False.
+
+        use_na_sentinel : bool, default True
+            If True, the sentinel -1 will be used for NaN values. If False,
+            NaN values will be encoded as non-negative integers and will not drop the
+            NaN from the uniques of the values.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         codes : ndarray
@@ -1019,10 +1082,11 @@ def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
         #    original ExtensionArray.
         # 2. ExtensionArray.factorize.
         #    Complete control over factorization.
+        resolved_na_sentinel = resolve_na_sentinel(na_sentinel, use_na_sentinel)
         arr, na_value = self._values_for_factorize()
 
         codes, uniques = factorize_array(
-            arr, na_sentinel=na_sentinel, na_value=na_value
+            arr, na_sentinel=resolved_na_sentinel, na_value=na_value
         )
 
         uniques_ea = self._from_factorized(uniques, self)
@@ -1074,7 +1138,9 @@ def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
 
     @Substitution(klass="ExtensionArray")
     @Appender(_extension_array_shared_docs["repeat"])
-    def repeat(self, repeats: int | Sequence[int], axis: int | None = None):
+    def repeat(
+        self: ExtensionArrayT, repeats: int | Sequence[int], axis: int | None = None
+    ) -> ExtensionArrayT:
         nv.validate_repeat((), {"axis": axis})
         ind = np.arange(len(self)).repeat(repeats)
         return self.take(ind)
@@ -1375,10 +1441,11 @@ def _reduce(self, name: str, *, skipna: bool = True, **kwargs):
     # https://github.com/python/typeshed/issues/2148#issuecomment-520783318
     # Incompatible types in assignment (expression has type "None", base class
     # "object" defined the type as "Callable[[object], int]")
-    __hash__: None  # type: ignore[assignment]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
     # ------------------------------------------------------------------------
-    # Non-Optimized Default Methods
+    # Non-Optimized Default Methods; in the case of the private methods here,
+    #  these are not guaranteed to be stable across pandas versions.
 
     def tolist(self) -> list:
         """
@@ -1491,10 +1558,11 @@ def _fill_mask_inplace(
         ExtensionArray.fillna
         """
         func = missing.get_fill_func(method)
+        npvalues = self.astype(object)
         # NB: if we don't copy mask here, it may be altered inplace, which
         #  would mess up the `self[mask] = ...` below.
-        new_values, _ = func(self.astype(object), limit=limit, mask=mask.copy())
-        new_values = self._from_sequence(new_values, dtype=self.dtype)
+        func(npvalues, limit=limit, mask=mask.copy())
+        new_values = self._from_sequence(npvalues, dtype=self.dtype)
         self[mask] = new_values[mask]
         return
 
@@ -1534,6 +1602,9 @@ def _empty(cls, shape: Shape, dtype: ExtensionDtype):
         ExtensionDtype.empty
             ExtensionDtype.empty is the 'official' public version of this API.
         """
+        # Implementer note: while ExtensionDtype.empty is the public way to
+        # call this method, it is still required to implement this `_empty`
+        # method as well (it is called internally in pandas)
         obj = cls._from_sequence([], dtype=dtype)
 
         taker = np.broadcast_to(np.intp(-1), shape)
@@ -1559,25 +1630,12 @@ def _quantile(
         -------
         same type as self
         """
-        # asarray needed for Sparse, see GH#24600
         mask = np.asarray(self.isna())
-        mask = np.atleast_2d(mask)
-
-        arr = np.atleast_2d(np.asarray(self))
+        arr = np.asarray(self)
         fill_value = np.nan
 
         res_values = quantile_with_mask(arr, mask, fill_value, qs, interpolation)
-
-        if self.ndim == 2:
-            # i.e. DatetimeArray
-            result = type(self)._from_sequence(res_values)
-
-        else:
-            # shape[0] should be 1 as long as EAs are 1D
-            assert res_values.shape == (1, len(qs)), res_values.shape
-            result = type(self)._from_sequence(res_values[0])
-
-        return result
+        return type(self)._from_sequence(res_values)
 
     def _mode(self: ExtensionArrayT, dropna: bool = True) -> ExtensionArrayT:
         """
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index d501af6212ce3..35b9de3f7af93 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -3,7 +3,7 @@
 import numbers
 from typing import (
     TYPE_CHECKING,
-    overload,
+    cast,
 )
 
 import numpy as np
@@ -13,30 +13,19 @@
     missing as libmissing,
 )
 from pandas._typing import (
-    ArrayLike,
-    AstypeArg,
     Dtype,
     DtypeObj,
-    npt,
     type_t,
 )
 
 from pandas.core.dtypes.common import (
-    is_bool_dtype,
-    is_float_dtype,
-    is_integer_dtype,
     is_list_like,
     is_numeric_dtype,
-    pandas_dtype,
-)
-from pandas.core.dtypes.dtypes import (
-    ExtensionDtype,
-    register_extension_dtype,
 )
+from pandas.core.dtypes.dtypes import register_extension_dtype
 from pandas.core.dtypes.missing import isna
 
 from pandas.core import ops
-from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.masked import (
     BaseMaskedArray,
     BaseMaskedDtype,
@@ -45,6 +34,8 @@
 if TYPE_CHECKING:
     import pyarrow
 
+    from pandas._typing import npt
+
 
 @register_extension_dtype
 class BooleanDtype(BaseMaskedDtype):
@@ -151,18 +142,6 @@ def __from_arrow__(
         else:
             return BooleanArray._concat_same_type(results)
 
-    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
-        # Handle only boolean + np.bool_ -> boolean, since other cases like
-        # Int64 + boolean -> Int64 will be handled by the other type
-        if all(
-            isinstance(t, BooleanDtype)
-            or (isinstance(t, np.dtype) and (np.issubdtype(t, np.bool_)))
-            for t in dtypes
-        ):
-            return BooleanDtype()
-        else:
-            return None
-
 
 def coerce_to_array(
     values, mask=None, copy: bool = False
@@ -214,7 +193,9 @@ def coerce_to_array(
         if inferred_dtype not in ("boolean", "empty") + integer_like:
             raise TypeError("Need to pass bool-like values")
 
-        mask_values = isna(values_object)
+        # mypy does not narrow the type of mask_values to npt.NDArray[np.bool_]
+        # within this branch, it assumes it can also be None
+        mask_values = cast("npt.NDArray[np.bool_]", isna(values_object))
         values = np.zeros(len(values), dtype=bool)
         values[~mask_values] = values_object[~mask_values].astype(bool)
 
@@ -228,7 +209,7 @@ def coerce_to_array(
             raise TypeError("Need to pass bool-like values")
 
     if mask is None and mask_values is None:
-        mask = np.zeros(len(values), dtype=bool)
+        mask = np.zeros(values.shape, dtype=bool)
     elif mask is None:
         mask = mask_values
     else:
@@ -311,7 +292,9 @@ class BooleanArray(BaseMaskedArray):
     _TRUE_VALUES = {"True", "TRUE", "true", "1", "1.0"}
     _FALSE_VALUES = {"False", "FALSE", "false", "0", "0.0"}
 
-    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
+    def __init__(
+        self, values: np.ndarray, mask: np.ndarray, copy: bool = False
+    ) -> None:
         if not (isinstance(values, np.ndarray) and values.dtype == np.bool_):
             raise TypeError(
                 "values should be boolean numpy array. Use "
@@ -324,15 +307,6 @@ def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
     def dtype(self) -> BooleanDtype:
         return self._dtype
 
-    @classmethod
-    def _from_sequence(
-        cls, scalars, *, dtype: Dtype | None = None, copy: bool = False
-    ) -> BooleanArray:
-        if dtype:
-            assert dtype == "boolean"
-        values, mask = coerce_to_array(scalars, copy=copy)
-        return BooleanArray(values, mask)
-
     @classmethod
     def _from_sequence_of_strings(
         cls,
@@ -361,96 +335,21 @@ def map_string(s):
 
     _HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)
 
-    def _coerce_to_array(self, value) -> tuple[np.ndarray, np.ndarray]:
-        return coerce_to_array(value)
-
-    @overload
-    def astype(self, dtype: npt.DTypeLike, copy: bool = ...) -> np.ndarray:
-        ...
-
-    @overload
-    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray:
-        ...
-
-    @overload
-    def astype(self, dtype: AstypeArg, copy: bool = ...) -> ArrayLike:
-        ...
-
-    def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
-
-        """
-        Cast to a NumPy array or ExtensionArray with 'dtype'.
-
-        Parameters
-        ----------
-        dtype : str or dtype
-            Typecode or data-type to which the array is cast.
-        copy : bool, default True
-            Whether to copy the data, even if not necessary. If False,
-            a copy is made only if the old dtype does not match the
-            new dtype.
-
-        Returns
-        -------
-        ndarray or ExtensionArray
-            NumPy ndarray, BooleanArray or IntegerArray with 'dtype' for its dtype.
-
-        Raises
-        ------
-        TypeError
-            if incompatible type with an BooleanDtype, equivalent of same_kind
-            casting
-        """
-        dtype = pandas_dtype(dtype)
-
-        if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy)
-
-        if is_bool_dtype(dtype):
-            # astype_nansafe converts np.nan to True
-            if self._hasna:
-                raise ValueError("cannot convert float NaN to bool")
-            else:
-                return self._data.astype(dtype, copy=copy)
-
-        # for integer, error if there are missing values
-        if is_integer_dtype(dtype) and self._hasna:
-            raise ValueError("cannot convert NA to integer")
-
-        # for float dtype, ensure we use np.nan before casting (numpy cannot
-        # deal with pd.NA)
-        na_value = self._na_value
-        if is_float_dtype(dtype):
-            na_value = np.nan
-        # coerce
-        return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
-
-    def _values_for_argsort(self) -> np.ndarray:
-        """
-        Return values for sorting.
-
-        Returns
-        -------
-        ndarray
-            The transformed values should maintain the ordering between values
-            within the array.
-
-        See Also
-        --------
-        ExtensionArray.argsort : Return the indices that would sort this array.
-        """
-        data = self._data.copy()
-        data[self._mask] = -1
-        return data
+    @classmethod
+    def _coerce_to_array(
+        cls, value, *, dtype: DtypeObj, copy: bool = False
+    ) -> tuple[np.ndarray, np.ndarray]:
+        if dtype:
+            assert dtype == "boolean"
+        return coerce_to_array(value, copy=copy)
 
     def _logical_method(self, other, op):
 
         assert op.__name__ in {"or_", "ror_", "and_", "rand_", "xor", "rxor"}
-        other_is_booleanarray = isinstance(other, BooleanArray)
         other_is_scalar = lib.is_scalar(other)
         mask = None
 
-        if other_is_booleanarray:
+        if isinstance(other, BooleanArray):
             other, mask = other._data, other._mask
         elif is_list_like(other):
             other = np.asarray(other, dtype="bool")
@@ -467,69 +366,15 @@ def _logical_method(self, other, op):
             )
 
         if not other_is_scalar and len(self) != len(other):
-            raise ValueError("Lengths must match to compare")
+            raise ValueError("Lengths must match")
 
         if op.__name__ in {"or_", "ror_"}:
             result, mask = ops.kleene_or(self._data, other, self._mask, mask)
         elif op.__name__ in {"and_", "rand_"}:
             result, mask = ops.kleene_and(self._data, other, self._mask, mask)
-        elif op.__name__ in {"xor", "rxor"}:
-            result, mask = ops.kleene_xor(self._data, other, self._mask, mask)
-
-        # error: Argument 2 to "BooleanArray" has incompatible type "Optional[Any]";
-        # expected "ndarray"
-        return BooleanArray(result, mask)  # type: ignore[arg-type]
-
-    def _arith_method(self, other, op):
-        mask = None
-        op_name = op.__name__
-
-        if isinstance(other, BooleanArray):
-            other, mask = other._data, other._mask
-
-        elif is_list_like(other):
-            other = np.asarray(other)
-            if other.ndim > 1:
-                raise NotImplementedError("can only perform ops with 1-d structures")
-            if len(self) != len(other):
-                raise ValueError("Lengths must match")
-
-        # nans propagate
-        if mask is None:
-            mask = self._mask
-            if other is libmissing.NA:
-                mask |= True
-        else:
-            mask = self._mask | mask
-
-        if other is libmissing.NA:
-            # if other is NA, the result will be all NA and we can't run the
-            # actual op, so we need to choose the resulting dtype manually
-            if op_name in {"floordiv", "rfloordiv", "mod", "rmod", "pow", "rpow"}:
-                dtype = "int8"
-            elif op_name in {"truediv", "rtruediv"}:
-                dtype = "float64"
-            else:
-                dtype = "bool"
-            result = np.zeros(len(self._data), dtype=dtype)
         else:
-            if op_name in {"pow", "rpow"} and isinstance(other, np.bool_):
-                # Avoid DeprecationWarning: In future, it will be an error
-                #  for 'np.bool_' scalars to be interpreted as an index
-                other = bool(other)
-
-            with np.errstate(all="ignore"):
-                result = op(self._data, other)
-
-        # divmod returns a tuple
-        if op_name == "divmod":
-            div, mod = result
-            return (
-                self._maybe_mask_result(div, mask, other, "floordiv"),
-                self._maybe_mask_result(mod, mask, other, "mod"),
-            )
-
-        return self._maybe_mask_result(result, mask, other, op_name)
+            # i.e. xor, rxor
+            result, mask = ops.kleene_xor(self._data, other, self._mask, mask)
 
-    def __abs__(self):
-        return self.copy()
+        # i.e. BooleanArray
+        return self._maybe_mask_result(result, mask)
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 7e83cc93bb5a5..7219573ac1521 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -7,6 +7,7 @@
 from typing import (
     TYPE_CHECKING,
     Hashable,
+    Literal,
     Sequence,
     TypeVar,
     Union,
@@ -26,11 +27,13 @@
 from pandas._libs import (
     NaT,
     algos as libalgos,
-    hashtable as htable,
     lib,
 )
 from pandas._libs.arrays import NDArrayBacked
-from pandas._libs.lib import no_default
+from pandas._libs.lib import (
+    NoDefault,
+    no_default,
+)
 from pandas._typing import (
     ArrayLike,
     AstypeArg,
@@ -43,16 +46,13 @@
 )
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import (
-    cache_readonly,
     deprecate_kwarg,
+    deprecate_nonkeyword_arguments,
 )
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import validate_bool_kwarg
 
-from pandas.core.dtypes.cast import (
-    coerce_indexer_dtype,
-    maybe_cast_to_extension_array,
-)
+from pandas.core.dtypes.cast import coerce_indexer_dtype
 from pandas.core.dtypes.common import (
     ensure_int64,
     ensure_platform_int,
@@ -64,7 +64,6 @@
     is_hashable,
     is_integer_dtype,
     is_list_like,
-    is_object_dtype,
     is_scalar,
     is_timedelta64_dtype,
     needs_i8_conversion,
@@ -119,7 +118,11 @@
 from pandas.io.formats import console
 
 if TYPE_CHECKING:
-    from pandas import Index
+    from pandas import (
+        DataFrame,
+        Index,
+        Series,
+    )
 
 
 CategoricalT = TypeVar("CategoricalT", bound="Categorical")
@@ -198,7 +201,7 @@ def func(self, other):
     return func
 
 
-def contains(cat, key, container):
+def contains(cat, key, container) -> bool:
     """
     Helper for membership check for ``key`` in ``cat``.
 
@@ -370,7 +373,7 @@ def __init__(
         dtype: Dtype | None = None,
         fastpath: bool = False,
         copy: bool = True,
-    ):
+    ) -> None:
 
         dtype = CategoricalDtype._from_values_or_dtype(
             values, categories, ordered, dtype
@@ -451,9 +454,7 @@ def __init__(
             dtype = CategoricalDtype(categories, dtype.ordered)
 
         elif is_categorical_dtype(values.dtype):
-            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
-            # attribute "_codes"
-            old_codes = extract_array(values)._codes  # type: ignore[union-attr]
+            old_codes = extract_array(values)._codes
             codes = recode_for_categories(
                 old_codes, values.dtype.categories, dtype.categories, copy=copy
             )
@@ -469,9 +470,7 @@ def __init__(
 
         dtype = CategoricalDtype(ordered=False).update_dtype(dtype)
         arr = coerce_indexer_dtype(codes, dtype.categories)
-        # error: Argument 1 to "__init__" of "NDArrayBacked" has incompatible
-        # type "Union[ExtensionArray, ndarray]"; expected "ndarray"
-        super().__init__(arr, dtype)  # type: ignore[arg-type]
+        super().__init__(arr, dtype)
 
     @property
     def dtype(self) -> CategoricalDtype:
@@ -480,6 +479,13 @@ def dtype(self) -> CategoricalDtype:
         """
         return self._dtype
 
+    @property
+    def _internal_fill_value(self) -> int:
+        # using the specific numpy integer instead of python int to get
+        #  the correct dtype back from _quantile in the all-NA case
+        dtype = self._ndarray.dtype
+        return dtype.type(-1)
+
     @property
     def _constructor(self) -> type[Categorical]:
         return Categorical
@@ -561,13 +567,6 @@ def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
 
         return result
 
-    @cache_readonly
-    def itemsize(self) -> int:
-        """
-        return the size of a single category
-        """
-        return self.categories.itemsize
-
     def to_list(self):
         """
         Alias for tolist.
@@ -646,7 +645,7 @@ def _from_inferred_categories(
     @classmethod
     def from_codes(
         cls, codes, categories=None, ordered=None, dtype: Dtype | None = None
-    ):
+    ) -> Categorical:
         """
         Make a Categorical type from codes and categories or dtype.
 
@@ -714,7 +713,7 @@ def from_codes(
     # Categories/Codes/Ordered
 
     @property
-    def categories(self):
+    def categories(self) -> Index:
         """
         The categories of this categorical.
 
@@ -745,16 +744,15 @@ def categories(self):
         return self.dtype.categories
 
     @categories.setter
-    def categories(self, categories):
-        new_dtype = CategoricalDtype(categories, ordered=self.ordered)
-        if self.dtype.categories is not None and len(self.dtype.categories) != len(
-            new_dtype.categories
-        ):
-            raise ValueError(
-                "new categories need to have the same number of "
-                "items as the old categories!"
-            )
-        super().__init__(self._ndarray, new_dtype)
+    def categories(self, categories) -> None:
+        warn(
+            "Setting categories in-place is deprecated and will raise in a "
+            "future version. Use rename_categories instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+        self._set_categories(categories)
 
     @property
     def ordered(self) -> Ordered:
@@ -815,7 +813,7 @@ def _set_categories(self, categories, fastpath=False):
         ):
             raise ValueError(
                 "new categories need to have the same number of "
-                "items than the old categories!"
+                "items as the old categories!"
             )
 
         super().__init__(self._ndarray, new_dtype)
@@ -836,7 +834,24 @@ def _set_dtype(self, dtype: CategoricalDtype) -> Categorical:
         codes = recode_for_categories(self.codes, self.categories, dtype.categories)
         return type(self)(codes, dtype=dtype, fastpath=True)
 
-    def set_ordered(self, value, inplace=False):
+    @overload
+    def set_ordered(
+        self, value, *, inplace: NoDefault | Literal[False] = ...
+    ) -> Categorical:
+        ...
+
+    @overload
+    def set_ordered(self, value, *, inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def set_ordered(self, value, *, inplace: bool) -> Categorical | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "value"])
+    def set_ordered(
+        self, value, inplace: bool | NoDefault = no_default
+    ) -> Categorical | None:
         """
         Set the ordered attribute to the boolean value.
 
@@ -847,15 +862,40 @@ def set_ordered(self, value, inplace=False):
         inplace : bool, default False
            Whether or not to set the ordered attribute in-place or return
            a copy of this categorical with ordered set to the value.
+
+           .. deprecated:: 1.5.0
+
         """
+        if inplace is not no_default:
+            warn(
+                "The `inplace` parameter in pandas.Categorical."
+                "set_ordered is deprecated and will be removed in "
+                "a future version. setting ordered-ness on categories will always "
+                "return a new Categorical object.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+        else:
+            inplace = False
+
         inplace = validate_bool_kwarg(inplace, "inplace")
         new_dtype = CategoricalDtype(self.categories, ordered=value)
         cat = self if inplace else self.copy()
         NDArrayBacked.__init__(cat, cat._ndarray, new_dtype)
         if not inplace:
             return cat
+        return None
 
-    def as_ordered(self, inplace=False):
+    @overload
+    def as_ordered(self, *, inplace: NoDefault | Literal[False] = ...) -> Categorical:
+        ...
+
+    @overload
+    def as_ordered(self, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def as_ordered(self, inplace: bool | NoDefault = no_default) -> Categorical | None:
         """
         Set the Categorical to be ordered.
 
@@ -865,15 +905,29 @@ def as_ordered(self, inplace=False):
            Whether or not to set the ordered attribute in-place or return
            a copy of this categorical with ordered set to True.
 
+           .. deprecated:: 1.5.0
+
         Returns
         -------
         Categorical or None
             Ordered Categorical or None if ``inplace=True``.
         """
-        inplace = validate_bool_kwarg(inplace, "inplace")
+        if inplace is not no_default:
+            inplace = validate_bool_kwarg(inplace, "inplace")
         return self.set_ordered(True, inplace=inplace)
 
-    def as_unordered(self, inplace=False):
+    @overload
+    def as_unordered(self, *, inplace: NoDefault | Literal[False] = ...) -> Categorical:
+        ...
+
+    @overload
+    def as_unordered(self, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def as_unordered(
+        self, inplace: bool | NoDefault = no_default
+    ) -> Categorical | None:
         """
         Set the Categorical to be unordered.
 
@@ -883,12 +937,15 @@ def as_unordered(self, inplace=False):
            Whether or not to set the ordered attribute in-place or return
            a copy of this categorical with ordered set to False.
 
+           .. deprecated:: 1.5.0
+
         Returns
         -------
         Categorical or None
             Unordered Categorical or None if ``inplace=True``.
         """
-        inplace = validate_bool_kwarg(inplace, "inplace")
+        if inplace is not no_default:
+            inplace = validate_bool_kwarg(inplace, "inplace")
         return self.set_ordered(False, inplace=inplace)
 
     def set_categories(
@@ -953,7 +1010,7 @@ def set_categories(
                 "a future version. Removing unused categories will always "
                 "return a new Categorical object.",
                 FutureWarning,
-                stacklevel=2,
+                stacklevel=find_stack_level(),
             )
         else:
             inplace = False
@@ -980,7 +1037,22 @@ def set_categories(
         if not inplace:
             return cat
 
-    def rename_categories(self, new_categories, inplace=no_default):
+    @overload
+    def rename_categories(
+        self, new_categories, *, inplace: Literal[False] | NoDefault = ...
+    ) -> Categorical:
+        ...
+
+    @overload
+    def rename_categories(self, new_categories, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "new_categories"]
+    )
+    def rename_categories(
+        self, new_categories, inplace: bool | NoDefault = no_default
+    ) -> Categorical | None:
         """
         Rename categories.
 
@@ -1062,13 +1134,14 @@ def rename_categories(self, new_categories, inplace=no_default):
         cat = self if inplace else self.copy()
 
         if is_dict_like(new_categories):
-            cat.categories = [new_categories.get(item, item) for item in cat.categories]
+            new_categories = [new_categories.get(item, item) for item in cat.categories]
         elif callable(new_categories):
-            cat.categories = [new_categories(item) for item in cat.categories]
-        else:
-            cat.categories = new_categories
+            new_categories = [new_categories(item) for item in cat.categories]
+
+        cat._set_categories(new_categories)
         if not inplace:
             return cat
+        return None
 
     def reorder_categories(self, new_categories, ordered=None, inplace=no_default):
         """
@@ -1131,7 +1204,22 @@ def reorder_categories(self, new_categories, ordered=None, inplace=no_default):
             simplefilter("ignore")
             return self.set_categories(new_categories, ordered=ordered, inplace=inplace)
 
-    def add_categories(self, new_categories, inplace=no_default):
+    @overload
+    def add_categories(
+        self, new_categories, *, inplace: Literal[False] | NoDefault = ...
+    ) -> Categorical:
+        ...
+
+    @overload
+    def add_categories(self, new_categories, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "new_categories"]
+    )
+    def add_categories(
+        self, new_categories, inplace: bool | NoDefault = no_default
+    ) -> Categorical | None:
         """
         Add new categories.
 
@@ -1206,6 +1294,7 @@ def add_categories(self, new_categories, inplace=no_default):
         NDArrayBacked.__init__(cat, codes, new_dtype)
         if not inplace:
             return cat
+        return None
 
     def remove_categories(self, removals, inplace=no_default):
         """
@@ -1287,7 +1376,20 @@ def remove_categories(self, removals, inplace=no_default):
                 new_categories, ordered=self.ordered, rename=False, inplace=inplace
             )
 
-    def remove_unused_categories(self, inplace=no_default):
+    @overload
+    def remove_unused_categories(
+        self, *, inplace: Literal[False] | NoDefault = ...
+    ) -> Categorical:
+        ...
+
+    @overload
+    def remove_unused_categories(self, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def remove_unused_categories(
+        self, inplace: bool | NoDefault = no_default
+    ) -> Categorical | None:
         """
         Remove categories which are not used.
 
@@ -1355,12 +1457,13 @@ def remove_unused_categories(self, inplace=no_default):
         NDArrayBacked.__init__(cat, new_codes, new_dtype)
         if not inplace:
             return cat
+        return None
 
     # ------------------------------------------------------------------
 
     def map(self, mapper):
         """
-        Map categories using input correspondence (dict, Series, or function).
+        Map categories using an input mapping or function.
 
         Maps the categories to new categories. If the mapping correspondence is
         one-to-one the result is a :class:`~pandas.Categorical` which has the
@@ -1484,7 +1587,7 @@ def _validate_scalar(self, fill_value):
             raise TypeError(
                 "Cannot setitem on a Categorical with a new "
                 f"category ({fill_value}), set the categories first"
-            )
+            ) from None
         return fill_value
 
     # -------------------------------------------------------------
@@ -1517,6 +1620,12 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
         if result is not NotImplemented:
             return result
 
+        if "out" in kwargs:
+            # e.g. test_numpy_ufuncs_out
+            return arraylike.dispatch_ufunc_with_out(
+                self, ufunc, method, *inputs, **kwargs
+            )
+
         if method == "reduce":
             # e.g. TestCategoricalAnalytics::test_min_max_ordered
             result = arraylike.dispatch_reduction_ufunc(
@@ -1532,7 +1641,7 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
             f"the numpy op {ufunc.__name__}"
         )
 
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         """Necessary for making this object picklable"""
         if not isinstance(state, dict):
             return super().__setstate__(state)
@@ -1618,7 +1727,7 @@ def notna(self) -> np.ndarray:
 
     notnull = notna
 
-    def value_counts(self, dropna: bool = True):
+    def value_counts(self, dropna: bool = True) -> Series:
         """
         Return a Series containing counts of each category.
 
@@ -1701,7 +1810,7 @@ def _internal_get_values(self):
             return self.categories.astype("object").take(self._codes, fill_value=np.nan)
         return np.array(self)
 
-    def check_for_ordered(self, op):
+    def check_for_ordered(self, op) -> None:
         """assert that we are ordered"""
         if not self.ordered:
             raise TypeError(
@@ -1710,6 +1819,7 @@ def check_for_ordered(self, op):
                 "Categorical to an ordered one\n"
             )
 
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def argsort(self, ascending=True, kind="quicksort", **kwargs):
         """
         Return the indices that would sort the Categorical.
@@ -1763,9 +1873,26 @@ def argsort(self, ascending=True, kind="quicksort", **kwargs):
         """
         return super().argsort(ascending=ascending, kind=kind, **kwargs)
 
+    @overload
+    def sort_values(
+        self,
+        *,
+        inplace: Literal[False] = ...,
+        ascending: bool = ...,
+        na_position: str = ...,
+    ) -> Categorical:
+        ...
+
+    @overload
+    def sort_values(
+        self, *, inplace: Literal[True], ascending: bool = ..., na_position: str = ...
+    ) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def sort_values(
         self, inplace: bool = False, ascending: bool = True, na_position: str = "last"
-    ):
+    ) -> Categorical | None:
         """
         Sort the Categorical by category value returning a new
         Categorical by default.
@@ -1845,11 +1972,11 @@ def sort_values(
 
         sorted_idx = nargsort(self, ascending=ascending, na_position=na_position)
 
-        if inplace:
-            self._codes[:] = self._codes[sorted_idx]
-        else:
+        if not inplace:
             codes = self._codes[sorted_idx]
             return self._from_backing_data(codes)
+        self._codes[:] = self._codes[sorted_idx]
+        return None
 
     def _rank(
         self,
@@ -1905,11 +2032,6 @@ def _values_for_rank(self):
             )
         return values
 
-    def view(self, dtype=None):
-        if dtype is not None:
-            raise NotImplementedError(dtype)
-        return self._from_backing_data(self._ndarray)
-
     def to_dense(self) -> np.ndarray:
         """
         Return my 'dense' representation
@@ -1959,7 +2081,9 @@ def _unbox_scalar(self, key) -> int:
 
     # ------------------------------------------------------------------
 
-    def take_nd(self, indexer, allow_fill: bool = False, fill_value=None):
+    def take_nd(
+        self, indexer, allow_fill: bool = False, fill_value=None
+    ) -> Categorical:
         # GH#27745 deprecate alias that other EAs dont have
         warn(
             "Categorical.take_nd is deprecated, use Categorical.take instead",
@@ -1994,7 +2118,7 @@ def _formatter(self, boxed: bool = False):
         # Defer to CategoricalFormatter's formatter.
         return None
 
-    def _tidy_repr(self, max_vals=10, footer=True) -> str:
+    def _tidy_repr(self, max_vals: int = 10, footer: bool = True) -> str:
         """
         a short repr displaying only max_vals and an optional (but default
         footer)
@@ -2009,7 +2133,7 @@ def _tidy_repr(self, max_vals=10, footer=True) -> str:
 
         return str(result)
 
-    def _repr_categories(self):
+    def _repr_categories(self) -> list[str]:
         """
         return the base repr for the categories
         """
@@ -2263,14 +2387,15 @@ def mode(self, dropna: bool = True) -> Categorical:
 
     def _mode(self, dropna: bool = True) -> Categorical:
         codes = self._codes
+        mask = None
         if dropna:
-            good = self._codes != -1
-            codes = self._codes[good]
+            mask = self.isna()
 
-        codes = htable.mode(codes, dropna)
-        codes.sort()
-        codes = coerce_indexer_dtype(codes, self.dtype.categories)
-        return self._from_backing_data(codes)
+        res_codes = algorithms.mode(codes, mask=mask)
+        res_codes = cast(np.ndarray, res_codes)
+        assert res_codes.dtype == codes.dtype
+        res = self._from_backing_data(res_codes)
+        return res
 
     # ------------------------------------------------------------------
     # ExtensionArray Interface
@@ -2306,14 +2431,10 @@ def unique(self):
         unique_codes = unique1d(self.codes)
         return self._from_backing_data(unique_codes)
 
-    def _values_for_factorize(self):
-        return self._ndarray, -1
-
-    @classmethod
-    def _from_factorized(cls, uniques, original):
-        return original._constructor(
-            original.categories.take(uniques), dtype=original.dtype
-        )
+    def _cast_quantile_result(self, res_values: np.ndarray) -> np.ndarray:
+        # make sure we have correct itemsize for resulting codes
+        assert res_values.dtype == self._ndarray.dtype
+        return res_values
 
     def equals(self, other: object) -> bool:
         """
@@ -2410,7 +2531,7 @@ def is_dtype_equal(self, other) -> bool:
         except (AttributeError, TypeError):
             return False
 
-    def describe(self):
+    def describe(self) -> DataFrame:
         """
         Describes this Categorical
 
@@ -2484,7 +2605,18 @@ def isin(self, values) -> npt.NDArray[np.bool_]:
         code_values = code_values[null_mask | (code_values >= 0)]
         return algorithms.isin(self.codes, code_values)
 
-    def replace(self, to_replace, value, inplace: bool = False):
+    @overload
+    def replace(
+        self, to_replace, value, *, inplace: Literal[False] = ...
+    ) -> Categorical:
+        ...
+
+    @overload
+    def replace(self, to_replace, value, *, inplace: Literal[True]) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "value"])
+    def replace(self, to_replace, value, inplace: bool = False) -> Categorical | None:
         """
         Replaces all instances of one value with another
 
@@ -2713,7 +2845,7 @@ class CategoricalAccessor(PandasDelegate, PandasObject, NoNewAttributesMixin):
     Categories (3, object): ['a', 'b', 'c']
     """
 
-    def __init__(self, data):
+    def __init__(self, data) -> None:
         self._validate(data)
         self._parent = data.values
         self._index = data.index
@@ -2732,7 +2864,7 @@ def _delegate_property_set(self, name, new_values):
         return setattr(self._parent, name, new_values)
 
     @property
-    def codes(self):
+    def codes(self) -> Series:
         """
         Return Series of codes as well as the index.
         """
@@ -2763,13 +2895,6 @@ def _get_codes_for_values(values, categories: Index) -> np.ndarray:
         codes = _get_codes_for_values(flat, categories)
         return codes.reshape(values.shape)
 
-    if isinstance(categories.dtype, ExtensionDtype) and is_object_dtype(values):
-        # Support inferring the correct extension dtype from an array of
-        # scalar objects. e.g.
-        # Categorical(array[Period, Period], categories=PeriodIndex(...))
-        cls = categories.dtype.construct_array_type()
-        values = maybe_cast_to_extension_array(cls, values)
-
     codes = categories.get_indexer_for(values)
     return coerce_indexer_dtype(codes, categories)
 
@@ -2838,6 +2963,7 @@ def factorize_from_iterable(values) -> tuple[np.ndarray, Index]:
     if not is_list_like(values):
         raise TypeError("Input must be list-like")
 
+    categories: Index
     if is_categorical_dtype(values):
         values = extract_array(values)
         # The Categorical we want to build has the same categories
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 58596437b6a3f..471ecc5950dd9 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -25,6 +25,7 @@
     algos,
     lib,
 )
+from pandas._libs.arrays import NDArrayBacked
 from pandas._libs.tslibs import (
     BaseOffset,
     IncompatibleFrequency,
@@ -35,14 +36,17 @@
     Tick,
     Timestamp,
     delta_to_nanoseconds,
+    get_unit_from_dtype,
     iNaT,
     ints_to_pydatetime,
+    ints_to_pytimedelta,
     to_offset,
 )
 from pandas._libs.tslibs.fields import (
     RoundTo,
     round_nsint64,
 )
+from pandas._libs.tslibs.np_datetime import compare_mismatched_resolutions
 from pandas._libs.tslibs.timestamps import integer_op_not_supported
 from pandas._typing import (
     ArrayLike,
@@ -87,7 +91,14 @@
     is_unsigned_integer_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    ExtensionDtype,
+)
+from pandas.core.dtypes.generic import (
+    ABCCategorical,
+    ABCMultiIndex,
+)
 from pandas.core.dtypes.missing import (
     is_valid_na_for_dtype,
     isna,
@@ -108,9 +119,12 @@
     NDArrayBackedExtensionArray,
     ravel_compat,
 )
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.arrays.integer import IntegerArray
 import pandas.core.common as com
 from pandas.core.construction import (
     array as pd_array,
+    ensure_wrapped_if_datetimelike,
     extract_array,
 )
 from pandas.core.indexers import (
@@ -129,6 +143,7 @@
 
     from pandas.core.arrays import (
         DatetimeArray,
+        PeriodArray,
         TimedeltaArray,
     )
 
@@ -167,7 +182,7 @@ class DatetimeLikeArrayMixin(OpsMixin, NDArrayBackedExtensionArray):
     def _can_hold_na(self) -> bool:
         return True
 
-    def __init__(self, data, dtype: Dtype | None = None, freq=None, copy=False):
+    def __init__(self, data, dtype: Dtype | None = None, freq=None, copy=False) -> None:
         raise AbstractMethodError(self)
 
     @property
@@ -293,7 +308,9 @@ def asi8(self) -> npt.NDArray[np.int64]:
     # ----------------------------------------------------------------
     # Rendering Methods
 
-    def _format_native_types(self, *, na_rep="NaT", date_format=None):
+    def _format_native_types(
+        self, *, na_rep="NaT", date_format=None
+    ) -> npt.NDArray[np.object_]:
         """
         Helper method for astype when converting to strings.
 
@@ -388,11 +405,16 @@ def __setitem__(  # type: ignore[override]
         # to a period in from_sequence). For DatetimeArray, it's Timestamp...
         # I don't know if mypy can do that, possibly with Generics.
         # https://mypy.readthedocs.io/en/latest/generics.html
+
         no_op = check_setitem_lengths(key, value, self)
+
+        # Calling super() before the no_op short-circuit means that we raise
+        #  on invalid 'value' even if this is a no-op, e.g. wrong-dtype empty array.
+        super().__setitem__(key, value)
+
         if no_op:
             return
 
-        super().__setitem__(key, value)
         self._maybe_clear_freq()
 
     def _maybe_clear_freq(self):
@@ -409,17 +431,21 @@ def astype(self, dtype, copy: bool = True):
 
         if is_object_dtype(dtype):
             if self.dtype.kind == "M":
+                self = cast("DatetimeArray", self)
                 # *much* faster than self._box_values
                 #  for e.g. test_get_loc_tuple_monotonic_above_size_cutoff
-                i8data = self.asi8.ravel()
+                i8data = self.asi8
                 converted = ints_to_pydatetime(
                     i8data,
-                    # error: "DatetimeLikeArrayMixin" has no attribute "tz"
-                    tz=self.tz,  # type: ignore[attr-defined]
+                    tz=self.tz,
                     freq=self.freq,
                     box="timestamp",
+                    reso=self._reso,
                 )
-                return converted.reshape(self.shape)
+                return converted
+
+            elif self.dtype.kind == "m":
+                return ints_to_pytimedelta(self._ndarray, box=True)
 
             return self._box_values(self.asi8.ravel()).reshape(self.shape)
 
@@ -430,19 +456,41 @@ def astype(self, dtype, copy: bool = True):
         elif is_integer_dtype(dtype):
             # we deliberately ignore int32 vs. int64 here.
             # See https://github.com/pandas-dev/pandas/issues/24381 for more.
-            warnings.warn(
-                f"casting {self.dtype} values to int64 with .astype(...) is "
-                "deprecated and will raise in a future version. "
-                "Use .view(...) instead.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-
             values = self.asi8
 
             if is_unsigned_integer_dtype(dtype):
                 # Again, we ignore int32 vs. int64
                 values = values.view("uint64")
+                if dtype != np.uint64:
+                    # GH#45034
+                    warnings.warn(
+                        f"The behavior of .astype from {self.dtype} to {dtype} is "
+                        "deprecated. In a future version, this astype will return "
+                        "exactly the specified dtype instead of uint64, and will "
+                        "raise if that conversion overflows.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+                elif (self.asi8 < 0).any():
+                    # GH#45034
+                    warnings.warn(
+                        f"The behavior of .astype from {self.dtype} to {dtype} is "
+                        "deprecated. In a future version, this astype will "
+                        "raise if the conversion overflows, as it did in this "
+                        "case with negative int64 values.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+            elif dtype != np.int64:
+                # GH#45034
+                warnings.warn(
+                    f"The behavior of .astype from {self.dtype} to {dtype} is "
+                    "deprecated. In a future version, this astype will return "
+                    "exactly the specified dtype instead of int64, and will "
+                    "raise if that conversion overflows.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
 
             if copy:
                 values = values.copy()
@@ -515,16 +563,6 @@ def copy(self: DatetimeLikeArrayT, order="C") -> DatetimeLikeArrayT:
         new_obj._freq = self.freq
         return new_obj
 
-    def _values_for_factorize(self):
-        # int64 instead of int ensures we have a "view" method
-        return self._ndarray, np.int64(iNaT)
-
-    @classmethod
-    def _from_factorized(
-        cls: type[DatetimeLikeArrayT], values, original: DatetimeLikeArrayT
-    ) -> DatetimeLikeArrayT:
-        return cls(values, dtype=original.dtype)
-
     # ------------------------------------------------------------------
     # Validation Methods
     # TODO: try to de-duplicate these, ensure identical behavior
@@ -849,7 +887,7 @@ def _isnan(self) -> npt.NDArray[np.bool_]:
         return self.asi8 == iNaT
 
     @property  # NB: override with cache_readonly in immutable subclasses
-    def _hasnans(self) -> bool:
+    def _hasna(self) -> bool:
         """
         return if I have any nans; enables various perf speedups
         """
@@ -874,7 +912,7 @@ def _maybe_mask_results(
 
         This is an internal routine.
         """
-        if self._hasnans:
+        if self._hasna:
             if convert:
                 result = result.astype(convert)
             if fill_value is None:
@@ -893,7 +931,7 @@ def freq(self):
         return self._freq
 
     @freq.setter
-    def freq(self, value):
+    def freq(self, value) -> None:
         if value is not None:
             value = to_offset(value)
             self._validate_frequency(self, value)
@@ -915,9 +953,9 @@ def freqstr(self) -> str | None:
     @property  # NB: override with cache_readonly in immutable subclasses
     def inferred_freq(self) -> str | None:
         """
-        Tries to return a string representing a frequency guess,
-        generated by infer_freq.  Returns None if it can't autodetect the
-        frequency.
+        Tries to return a string representing a frequency generated by infer_freq.
+
+        Returns None if it can't autodetect the frequency.
         """
         if self.ndim != 1:
             return None
@@ -932,7 +970,7 @@ def _resolution_obj(self) -> Resolution | None:
         if freqstr is None:
             return None
         try:
-            return Resolution.get_reso_from_freq(freqstr)
+            return Resolution.get_reso_from_freqstr(freqstr)
         except KeyError:
             return None
 
@@ -1028,6 +1066,24 @@ def _cmp_method(self, other, op):
                 )
             return result
 
+        if other is NaT:
+            if op is operator.ne:
+                result = np.ones(self.shape, dtype=bool)
+            else:
+                result = np.zeros(self.shape, dtype=bool)
+            return result
+
+        if not is_period_dtype(self.dtype):
+            self = cast(TimelikeOps, self)
+            if self._reso != other._reso:
+                if not isinstance(other, type(self)):
+                    # i.e. Timedelta/Timestamp, cast to ndarray and let
+                    #  compare_mismatched_resolutions handle broadcasting
+                    other_arr = np.array(other.asm8)
+                else:
+                    other_arr = other._ndarray
+                return compare_mismatched_resolutions(self._ndarray, other_arr, op)
+
         other_vals = self._unbox(other)
         # GH#37462 comparison on i8 values is almost 2x faster than M8/m8
         result = op(self._ndarray.view("i8"), other_vals.view("i8"))
@@ -1055,26 +1111,131 @@ def _cmp_method(self, other, op):
     __divmod__ = make_invalid_op("__divmod__")
     __rdivmod__ = make_invalid_op("__rdivmod__")
 
-    def _add_datetimelike_scalar(self, other):
-        # Overridden by TimedeltaArray
-        raise TypeError(f"cannot add {type(self).__name__} and {type(other).__name__}")
+    @final
+    def _add_datetimelike_scalar(self, other) -> DatetimeArray:
+        if not is_timedelta64_dtype(self.dtype):
+            raise TypeError(
+                f"cannot add {type(self).__name__} and {type(other).__name__}"
+            )
 
-    _add_datetime_arraylike = _add_datetimelike_scalar
+        self = cast("TimedeltaArray", self)
+
+        from pandas.core.arrays import DatetimeArray
+        from pandas.core.arrays.datetimes import tz_to_dtype
 
-    def _sub_datetimelike_scalar(self, other):
-        # Overridden by DatetimeArray
         assert other is not NaT
-        raise TypeError(f"cannot subtract a datelike from a {type(self).__name__}")
+        other = Timestamp(other)
+        if other is NaT:
+            # In this case we specifically interpret NaT as a datetime, not
+            # the timedelta interpretation we would get by returning self + NaT
+            result = self._ndarray + NaT.to_datetime64().astype(f"M8[{self._unit}]")
+            # Preserve our resolution
+            return DatetimeArray._simple_new(result, dtype=result.dtype)
+
+        if self._reso != other._reso:
+            raise NotImplementedError(
+                "Addition between TimedeltaArray and Timestamp with mis-matched "
+                "resolutions is not yet supported."
+            )
+
+        i8 = self.asi8
+        result = checked_add_with_arr(i8, other.value, arr_mask=self._isnan)
+        dtype = tz_to_dtype(tz=other.tz, unit=self._unit)
+        res_values = result.view(f"M8[{self._unit}]")
+        return DatetimeArray._simple_new(res_values, dtype=dtype, freq=self.freq)
+
+    @final
+    def _add_datetime_arraylike(self, other) -> DatetimeArray:
+        if not is_timedelta64_dtype(self.dtype):
+            raise TypeError(
+                f"cannot add {type(self).__name__} and {type(other).__name__}"
+            )
+
+        # At this point we have already checked that other.dtype is datetime64
+        other = ensure_wrapped_if_datetimelike(other)
+        # defer to DatetimeArray.__add__
+        return other + self
+
+    @final
+    def _sub_datetimelike_scalar(self, other: datetime | np.datetime64):
+        if self.dtype.kind != "M":
+            raise TypeError(f"cannot subtract a datelike from a {type(self).__name__}")
+
+        self = cast("DatetimeArray", self)
+        # subtract a datetime from myself, yielding a ndarray[timedelta64[ns]]
+
+        # error: Non-overlapping identity check (left operand type: "Union[datetime,
+        # datetime64]", right operand type: "NaTType")  [comparison-overlap]
+        assert other is not NaT  # type: ignore[comparison-overlap]
+        other = Timestamp(other)
+        # error: Non-overlapping identity check (left operand type: "Timestamp",
+        # right operand type: "NaTType")
+        if other is NaT:  # type: ignore[comparison-overlap]
+            return self - NaT
+
+        try:
+            self._assert_tzawareness_compat(other)
+        except TypeError as err:
+            new_message = str(err).replace("compare", "subtract")
+            raise type(err)(new_message) from err
+
+        i8 = self.asi8
+        result = checked_add_with_arr(i8, -other.value, arr_mask=self._isnan)
+        return result.view("timedelta64[ns]")
 
-    _sub_datetime_arraylike = _sub_datetimelike_scalar
+    @final
+    def _sub_datetime_arraylike(self, other):
+        if self.dtype.kind != "M":
+            raise TypeError(f"cannot subtract a datelike from a {type(self).__name__}")
 
-    def _sub_period(self, other):
-        # Overridden by PeriodArray
-        raise TypeError(f"cannot subtract Period from a {type(self).__name__}")
+        if len(self) != len(other):
+            raise ValueError("cannot add indices of unequal length")
 
-    def _add_period(self, other: Period):
-        # Overridden by TimedeltaArray
-        raise TypeError(f"cannot add Period to a {type(self).__name__}")
+        self = cast("DatetimeArray", self)
+        other = ensure_wrapped_if_datetimelike(other)
+
+        try:
+            self._assert_tzawareness_compat(other)
+        except TypeError as err:
+            new_message = str(err).replace("compare", "subtract")
+            raise type(err)(new_message) from err
+
+        self_i8 = self.asi8
+        other_i8 = other.asi8
+        new_values = checked_add_with_arr(
+            self_i8, -other_i8, arr_mask=self._isnan, b_mask=other._isnan
+        )
+        return new_values.view("timedelta64[ns]")
+
+    @final
+    def _sub_period(self, other: Period) -> npt.NDArray[np.object_]:
+        if not is_period_dtype(self.dtype):
+            raise TypeError(f"cannot subtract Period from a {type(self).__name__}")
+
+        # If the operation is well-defined, we return an object-dtype ndarray
+        # of DateOffsets.  Null entries are filled with pd.NaT
+        self._check_compatible_with(other)
+        new_i8_data = checked_add_with_arr(
+            self.asi8, -other.ordinal, arr_mask=self._isnan
+        )
+        new_data = np.array([self.freq.base * x for x in new_i8_data])
+
+        if self._hasna:
+            new_data[self._isnan] = NaT
+
+        return new_data
+
+    @final
+    def _add_period(self, other: Period) -> PeriodArray:
+        if not is_timedelta64_dtype(self.dtype):
+            raise TypeError(f"cannot add Period to a {type(self).__name__}")
+
+        # We will wrap in a PeriodArray and defer to the reversed operation
+        from pandas.core.arrays.period import PeriodArray
+
+        i8vals = np.broadcast_to(other.ordinal, self.shape)
+        parr = PeriodArray(i8vals, freq=other.freq)
+        return parr + self
 
     def _add_offset(self, offset):
         raise AbstractMethodError(self)
@@ -1089,14 +1250,15 @@ def _add_timedeltalike_scalar(self, other):
         """
         if isna(other):
             # i.e np.timedelta64("NaT"), not recognized by delta_to_nanoseconds
-            new_values = np.empty(self.shape, dtype="i8")
+            new_values = np.empty(self.shape, dtype="i8").view(self._ndarray.dtype)
             new_values.fill(iNaT)
-            return type(self)(new_values, dtype=self.dtype)
+            return type(self)._simple_new(new_values, dtype=self.dtype)
+
+        # PeriodArray overrides, so we only get here with DTA/TDA
+        # error: "DatetimeLikeArrayMixin" has no attribute "_reso"
+        inc = delta_to_nanoseconds(other, reso=self._reso)  # type: ignore[attr-defined]
 
-        inc = delta_to_nanoseconds(other)
         new_values = checked_add_with_arr(self.asi8, inc, arr_mask=self._isnan)
-        new_values = new_values.view("i8")
-        new_values = self._maybe_mask_results(new_values)
         new_values = new_values.view(self._ndarray.dtype)
 
         new_freq = None
@@ -1109,7 +1271,9 @@ def _add_timedeltalike_scalar(self, other):
             new_values, dtype=self.dtype, freq=new_freq
         )
 
-    def _add_timedelta_arraylike(self, other):
+    def _add_timedelta_arraylike(
+        self, other: TimedeltaArray | npt.NDArray[np.timedelta64]
+    ):
         """
         Add a delta of a TimedeltaIndex
 
@@ -1122,21 +1286,14 @@ def _add_timedelta_arraylike(self, other):
         if len(self) != len(other):
             raise ValueError("cannot add indices of unequal length")
 
-        if isinstance(other, np.ndarray):
-            # ndarray[timedelta64]; wrap in TimedeltaIndex for op
-            from pandas.core.arrays import TimedeltaArray
-
-            other = TimedeltaArray._from_sequence(other)
+        other = ensure_wrapped_if_datetimelike(other)
+        other = cast("TimedeltaArray", other)
 
         self_i8 = self.asi8
         other_i8 = other.asi8
         new_values = checked_add_with_arr(
             self_i8, other_i8, arr_mask=self._isnan, b_mask=other._isnan
         )
-        if self._hasnans or other._hasnans:
-            mask = self._isnan | other._isnan
-            np.putmask(new_values, mask, iNaT)
-
         return type(self)(new_values, dtype=self.dtype)
 
     @final
@@ -1148,12 +1305,14 @@ def _add_nat(self):
             raise TypeError(
                 f"Cannot add {type(self).__name__} and {type(NaT).__name__}"
             )
+        self = cast("TimedeltaArray | DatetimeArray", self)
 
         # GH#19124 pd.NaT is treated like a timedelta for both timedelta
         # and datetime dtypes
         result = np.empty(self.shape, dtype=np.int64)
         result.fill(iNaT)
-        return type(self)(result, dtype=self.dtype, freq=None)
+        result = result.view(self._ndarray.dtype)  # preserve reso
+        return type(self)._simple_new(result, dtype=self.dtype, freq=None)
 
     @final
     def _sub_nat(self):
@@ -1170,12 +1329,27 @@ def _sub_nat(self):
         result.fill(iNaT)
         return result.view("timedelta64[ns]")
 
-    def _sub_period_array(self, other):
-        # Overridden by PeriodArray
-        raise TypeError(
-            f"cannot subtract {other.dtype}-dtype from {type(self).__name__}"
+    @final
+    def _sub_period_array(self, other: PeriodArray) -> npt.NDArray[np.object_]:
+        if not is_period_dtype(self.dtype):
+            raise TypeError(
+                f"cannot subtract {other.dtype}-dtype from {type(self).__name__}"
+            )
+
+        self = cast("PeriodArray", self)
+        self._require_matching_freq(other)
+
+        new_i8_values = checked_add_with_arr(
+            self.asi8, -other.asi8, arr_mask=self._isnan, b_mask=other._isnan
         )
 
+        new_values = np.array([self.freq.base * x for x in new_i8_values])
+        if self._hasna or other._hasna:
+            mask = self._isnan | other._isnan
+            new_values[mask] = NaT
+        return new_values
+
+    @final
     def _addsub_object_array(self, other: np.ndarray, op):
         """
         Add or subtract array-like of DateOffset objects
@@ -1198,6 +1372,7 @@ def _addsub_object_array(self, other: np.ndarray, op):
             "Adding/subtracting object-dtype array to "
             f"{type(self).__name__} not vectorized.",
             PerformanceWarning,
+            stacklevel=find_stack_level(),
         )
 
         # Caller is responsible for broadcasting if necessary
@@ -1209,13 +1384,7 @@ def _addsub_object_array(self, other: np.ndarray, op):
             res_values = op(self.astype("O"), np.asarray(other))
 
         result = pd_array(res_values.ravel())
-        # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no attribute
-        # "reshape"
-        result = extract_array(
-            result, extract_numpy=True
-        ).reshape(  # type: ignore[union-attr]
-            self.shape
-        )
+        result = extract_array(result, extract_numpy=True).reshape(self.shape)
         return result
 
     def _time_shift(
@@ -1277,7 +1446,9 @@ def __add__(self, other):
             # as is_integer returns True for these
             if not is_period_dtype(self.dtype):
                 raise integer_op_not_supported(self)
-            result = self._time_shift(other)
+            result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+                other * self.freq.n, operator.add
+            )
 
         # array-like others
         elif is_timedelta64_dtype(other_dtype):
@@ -1292,7 +1463,9 @@ def __add__(self, other):
         elif is_integer_dtype(other_dtype):
             if not is_period_dtype(self.dtype):
                 raise integer_op_not_supported(self)
-            result = self._addsub_int_array(other, operator.add)
+            result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+                other * self.freq.n, operator.add
+            )
         else:
             # Includes Categorical, other ExtensionArrays
             # For PeriodDtype, if self is a TimedeltaArray and other is a
@@ -1331,7 +1504,9 @@ def __sub__(self, other):
             # as is_integer returns True for these
             if not is_period_dtype(self.dtype):
                 raise integer_op_not_supported(self)
-            result = self._time_shift(-other)
+            result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+                other * self.freq.n, operator.sub
+            )
 
         elif isinstance(other, Period):
             result = self._sub_period(other)
@@ -1352,7 +1527,9 @@ def __sub__(self, other):
         elif is_integer_dtype(other_dtype):
             if not is_period_dtype(self.dtype):
                 raise integer_op_not_supported(self)
-            result = self._addsub_int_array(other, operator.sub)
+            result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+                other * self.freq.n, operator.sub
+            )
         else:
             # Includes ExtensionArrays, float_dtype
             return NotImplemented
@@ -1398,7 +1575,7 @@ def __rsub__(self, other):
         # We get here with e.g. datetime objects
         return -(self - other)
 
-    def __iadd__(self, other):
+    def __iadd__(self: DatetimeLikeArrayT, other) -> DatetimeLikeArrayT:
         result = self + other
         self[:] = result[:]
 
@@ -1407,7 +1584,7 @@ def __iadd__(self, other):
             self._freq = result.freq
         return self
 
-    def __isub__(self, other):
+    def __isub__(self: DatetimeLikeArrayT, other) -> DatetimeLikeArrayT:
         result = self - other
         self[:] = result[:]
 
@@ -1536,12 +1713,11 @@ def median(self, *, axis: int | None = None, skipna: bool = True, **kwargs):
         return self._wrap_reduction_result(axis, result)
 
     def _mode(self, dropna: bool = True):
-        values = self
+        mask = None
         if dropna:
-            mask = values.isna()
-            values = values[~mask]
+            mask = self.isna()
 
-        i8modes = mode(values.view("i8"))
+        i8modes = mode(self.view("i8"), mask=mask)
         npmodes = i8modes.view(self._ndarray.dtype)
         npmodes = cast(np.ndarray, npmodes)
         return self._from_backing_data(npmodes)
@@ -1565,6 +1741,14 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
         of the string format can be found in `python string format
         doc <%(URL)s>`__.
 
+        Formats supported by the C `strftime` API but not by the python string format
+        doc (such as `"%%R"`, `"%%r"`) are not officially supported and should be
+        preferably replaced with their supported equivalents (such as `"%%H:%%M"`,
+        `"%%I:%%M:%%S %%p"`).
+
+        Note that `PeriodIndex` support additional directives, detailed in
+        `Period.strftime`.
+
         Parameters
         ----------
         date_format : str
@@ -1581,6 +1765,8 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
         DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
         DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
         DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
+        Timestamp.strftime : Format a single Timestamp.
+        Period.strftime : Format a single Period.
 
         Examples
         --------
@@ -1748,6 +1934,94 @@ class TimelikeOps(DatetimeLikeArrayMixin):
     Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
     """
 
+    _default_dtype: np.dtype
+
+    def __init__(self, values, dtype=None, freq=lib.no_default, copy: bool = False):
+        values = extract_array(values, extract_numpy=True)
+        if isinstance(values, IntegerArray):
+            values = values.to_numpy("int64", na_value=iNaT)
+
+        inferred_freq = getattr(values, "_freq", None)
+        explicit_none = freq is None
+        freq = freq if freq is not lib.no_default else None
+
+        if isinstance(values, type(self)):
+            if explicit_none:
+                # don't inherit from values
+                pass
+            elif freq is None:
+                freq = values.freq
+            elif freq and values.freq:
+                freq = to_offset(freq)
+                freq, _ = validate_inferred_freq(freq, values.freq, False)
+
+            if dtype is not None:
+                dtype = pandas_dtype(dtype)
+                if not is_dtype_equal(dtype, values.dtype):
+                    # TODO: we only have tests for this for DTA, not TDA (2022-07-01)
+                    raise TypeError(
+                        f"dtype={dtype} does not match data dtype {values.dtype}"
+                    )
+
+            dtype = values.dtype
+            values = values._ndarray
+
+        elif dtype is None:
+            dtype = self._default_dtype
+
+        if not isinstance(values, np.ndarray):
+            raise ValueError(
+                f"Unexpected type '{type(values).__name__}'. 'values' must be a "
+                f"{type(self).__name__}, ndarray, or Series or Index "
+                "containing one of those."
+            )
+        if values.ndim not in [1, 2]:
+            raise ValueError("Only 1-dimensional input arrays are supported.")
+
+        if values.dtype == "i8":
+            # for compat with datetime/timedelta/period shared methods,
+            #  we can sometimes get here with int64 values.  These represent
+            #  nanosecond UTC (or tz-naive) unix timestamps
+            values = values.view(self._default_dtype)
+
+        dtype = self._validate_dtype(values, dtype)
+
+        if freq == "infer":
+            raise ValueError(
+                f"Frequency inference not allowed in {type(self).__name__}.__init__. "
+                "Use 'pd.array()' instead."
+            )
+
+        if copy:
+            values = values.copy()
+        if freq:
+            freq = to_offset(freq)
+
+        NDArrayBacked.__init__(self, values=values, dtype=dtype)
+        self._freq = freq
+
+        if inferred_freq is None and freq is not None:
+            type(self)._validate_frequency(self, freq)
+
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        raise AbstractMethodError(cls)
+
+    # --------------------------------------------------------------
+
+    @cache_readonly
+    def _reso(self) -> int:
+        return get_unit_from_dtype(self._ndarray.dtype)
+
+    @cache_readonly
+    def _unit(self) -> str:
+        # e.g. "ns", "us", "ms"
+        # error: Argument 1 to "dtype_to_unit" has incompatible type
+        # "ExtensionDtype"; expected "Union[DatetimeTZDtype, dtype[Any]]"
+        return dtype_to_unit(self.dtype)  # type: ignore[arg-type]
+
+    # --------------------------------------------------------------
+
     def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
         if (
             ufunc in [np.isnan, np.isinf, np.isfinite]
@@ -1772,7 +2046,8 @@ def _round(self, freq, mode, ambiguous, nonexistent):
 
         values = self.view("i8")
         values = cast(np.ndarray, values)
-        nanos = to_offset(freq).nanos
+        nanos = to_offset(freq).nanos  # raises on non-fixed frequencies
+        nanos = delta_to_nanoseconds(to_offset(freq), self._reso)
         result_i8 = round_nsint64(values, mode, nanos)
         result = self._maybe_mask_results(result_i8, fill_value=iNaT)
         result = result.view(self._ndarray.dtype)
@@ -1793,11 +2068,11 @@ def ceil(self, freq, ambiguous="raise", nonexistent="raise"):
     # --------------------------------------------------------------
     # Reductions
 
-    def any(self, *, axis: int | None = None, skipna: bool = True):
+    def any(self, *, axis: int | None = None, skipna: bool = True) -> bool:
         # GH#34479 discussion of desired behavior long-term
         return nanops.nanany(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
 
-    def all(self, *, axis: int | None = None, skipna: bool = True):
+    def all(self, *, axis: int | None = None, skipna: bool = True) -> bool:
         # GH#34479 discussion of desired behavior long-term
         return nanops.nanall(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
 
@@ -1838,7 +2113,12 @@ def _with_freq(self, freq):
 
     # --------------------------------------------------------------
 
-    def factorize(self, na_sentinel=-1, sort: bool = False):
+    # GH#46910 - Keep old signature to test we don't break things for EA library authors
+    def factorize(  # type:ignore[override]
+        self,
+        na_sentinel: int = -1,
+        sort: bool = False,
+    ):
         if self.freq is not None:
             # We must be unique, so can short-circuit (and retain freq)
             codes = np.arange(len(self), dtype=np.intp)
@@ -1855,7 +2135,47 @@ def factorize(self, na_sentinel=-1, sort: bool = False):
 # Shared Constructor Helpers
 
 
-def validate_periods(periods):
+def ensure_arraylike_for_datetimelike(data, copy: bool, cls_name: str):
+    if not hasattr(data, "dtype"):
+        # e.g. list, tuple
+        if np.ndim(data) == 0:
+            # i.e. generator
+            data = list(data)
+        data = np.asarray(data)
+        copy = False
+    elif isinstance(data, ABCMultiIndex):
+        raise TypeError(f"Cannot create a {cls_name} from a MultiIndex.")
+    else:
+        data = extract_array(data, extract_numpy=True)
+
+    if isinstance(data, IntegerArray):
+        data = data.to_numpy("int64", na_value=iNaT)
+        copy = False
+    elif not isinstance(data, (np.ndarray, ExtensionArray)):
+        # GH#24539 e.g. xarray, dask object
+        data = np.asarray(data)
+
+    elif isinstance(data, ABCCategorical):
+        # GH#18664 preserve tz in going DTI->Categorical->DTI
+        # TODO: cases where we need to do another pass through maybe_convert_dtype,
+        #  e.g. the categories are timedelta64s
+        data = data.categories.take(data.codes, fill_value=NaT)._values
+        copy = False
+
+    return data, copy
+
+
+@overload
+def validate_periods(periods: None) -> None:
+    ...
+
+
+@overload
+def validate_periods(periods: float) -> int:
+    ...
+
+
+def validate_periods(periods: float | None) -> int | None:
     """
     If a `periods` argument is passed to the Datetime/Timedelta Array/Index
     constructor, cast it to an integer.
@@ -1878,10 +2198,14 @@ def validate_periods(periods):
             periods = int(periods)
         elif not lib.is_integer(periods):
             raise TypeError(f"periods must be a number, got {periods}")
-    return periods
+    # error: Incompatible return value type (got "Optional[float]",
+    # expected "Optional[int]")
+    return periods  # type: ignore[return-value]
 
 
-def validate_inferred_freq(freq, inferred_freq, freq_infer):
+def validate_inferred_freq(
+    freq, inferred_freq, freq_infer
+) -> tuple[BaseOffset | None, bool]:
     """
     If the user passes a freq and another freq is inferred from passed data,
     require that they match.
@@ -1942,3 +2266,21 @@ def maybe_infer_freq(freq):
             freq_infer = True
             freq = None
     return freq, freq_infer
+
+
+def dtype_to_unit(dtype: DatetimeTZDtype | np.dtype) -> str:
+    """
+    Return the unit str corresponding to the dtype's resolution.
+
+    Parameters
+    ----------
+    dtype : DatetimeTZDtype or np.dtype
+        If np.dtype, we assume it is a datetime64 dtype.
+
+    Returns
+    -------
+    str
+    """
+    if isinstance(dtype, DatetimeTZDtype):
+        return dtype.unit
+    return np.datetime_data(dtype)[0]
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 647698f472978..f1ddba0cefe35 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -9,6 +9,7 @@
 from typing import (
     TYPE_CHECKING,
     Literal,
+    cast,
 )
 import warnings
 
@@ -18,35 +19,39 @@
     lib,
     tslib,
 )
-from pandas._libs.arrays import NDArrayBacked
 from pandas._libs.tslibs import (
     BaseOffset,
     NaT,
     NaTType,
     Resolution,
     Timestamp,
-    conversion,
+    astype_overflowsafe,
     fields,
     get_resolution,
-    iNaT,
+    get_unit_from_dtype,
     ints_to_pydatetime,
     is_date_array_normalized,
+    is_supported_unit,
+    is_unitless,
     normalize_i8_timestamps,
     timezones,
     to_offset,
+    tz_convert_from_utc,
     tzconversion,
 )
 from pandas._typing import npt
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    OutOfBoundsDatetime,
+    PerformanceWarning,
+)
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import validate_inclusive
 
-from pandas.core.dtypes.cast import astype_dt64_to_dt64tz
+from pandas.core.dtypes.astype import astype_dt64_to_dt64tz
 from pandas.core.dtypes.common import (
     DT64NS_DTYPE,
     INT64_DTYPE,
     is_bool_dtype,
-    is_categorical_dtype,
     is_datetime64_any_dtype,
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
@@ -62,18 +67,11 @@
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
-from pandas.core.dtypes.generic import ABCMultiIndex
 from pandas.core.dtypes.missing import isna
 
-from pandas.core.algorithms import checked_add_with_arr
-from pandas.core.arrays import (
-    ExtensionArray,
-    datetimelike as dtl,
-)
+from pandas.core.arrays import datetimelike as dtl
 from pandas.core.arrays._ranges import generate_regular_range
-from pandas.core.arrays.integer import IntegerArray
 import pandas.core.common as com
-from pandas.core.construction import extract_array
 
 from pandas.tseries.frequencies import get_period_alias
 from pandas.tseries.offsets import (
@@ -93,22 +91,23 @@
 _midnight = time(0, 0)
 
 
-def tz_to_dtype(tz):
+def tz_to_dtype(tz: tzinfo | None, unit: str = "ns"):
     """
     Return a datetime64[ns] dtype appropriate for the given timezone.
 
     Parameters
     ----------
     tz : tzinfo or None
+    unit : str, default "ns"
 
     Returns
     -------
     np.dtype or Datetime64TZDType
     """
     if tz is None:
-        return DT64NS_DTYPE
+        return np.dtype(f"M8[{unit}]")
     else:
-        return DatetimeTZDtype(tz=tz)
+        return DatetimeTZDtype(tz=tz, unit=unit)
 
 
 def _field_accessor(name: str, field: str, docstring=None):
@@ -126,20 +125,20 @@ def f(self):
                     month_kw = kwds.get("startingMonth", kwds.get("month", 12))
 
                 result = fields.get_start_end_field(
-                    values, field, self.freqstr, month_kw
+                    values, field, self.freqstr, month_kw, reso=self._reso
                 )
             else:
-                result = fields.get_date_field(values, field)
+                result = fields.get_date_field(values, field, reso=self._reso)
 
             # these return a boolean by-definition
             return result
 
         if field in self._object_ops:
-            result = fields.get_date_name_field(values, field)
+            result = fields.get_date_name_field(values, field, reso=self._reso)
             result = self._maybe_mask_results(result, fill_value=None)
 
         else:
-            result = fields.get_date_field(values, field)
+            result = fields.get_date_field(values, field, reso=self._reso)
             result = self._maybe_mask_results(
                 result, fill_value=None, convert="float64"
             )
@@ -187,11 +186,15 @@ class DatetimeArray(dtl.TimelikeOps, dtl.DatelikeOps):
     """
 
     _typ = "datetimearray"
-    _scalar_type = Timestamp
+    _internal_fill_value = np.datetime64("NaT", "ns")
     _recognized_scalars = (datetime, np.datetime64)
     _is_recognized_dtype = is_datetime64_any_dtype
     _infer_matches = ("datetime", "datetime64", "date")
 
+    @property
+    def _scalar_type(self) -> type[Timestamp]:
+        return Timestamp
+
     # define my properties & methods for delegation
     _bool_ops: list[str] = [
         "is_month_start",
@@ -248,87 +251,33 @@ class DatetimeArray(dtl.TimelikeOps, dtl.DatelikeOps):
     # Constructors
 
     _dtype: np.dtype | DatetimeTZDtype
-    _freq = None
-
-    def __init__(self, values, dtype=DT64NS_DTYPE, freq=None, copy: bool = False):
-        values = extract_array(values, extract_numpy=True)
-        if isinstance(values, IntegerArray):
-            values = values.to_numpy("int64", na_value=iNaT)
-
-        inferred_freq = getattr(values, "_freq", None)
-
-        if isinstance(values, type(self)):
-            # validation
-            dtz = getattr(dtype, "tz", None)
-            if dtz and values.tz is None:
-                dtype = DatetimeTZDtype(tz=dtype.tz)
-            elif dtz and values.tz:
-                if not timezones.tz_compare(dtz, values.tz):
-                    msg = (
-                        "Timezone of the array and 'dtype' do not match. "
-                        f"'{dtz}' != '{values.tz}'"
-                    )
-                    raise TypeError(msg)
-            elif values.tz:
-                dtype = values.dtype
-
-            if freq is None:
-                freq = values.freq
-            values = values._ndarray
-
-        if not isinstance(values, np.ndarray):
-            raise ValueError(
-                f"Unexpected type '{type(values).__name__}'. 'values' must be "
-                "a DatetimeArray, ndarray, or Series or Index containing one of those."
-            )
-        if values.ndim not in [1, 2]:
-            raise ValueError("Only 1-dimensional input arrays are supported.")
-
-        if values.dtype == "i8":
-            # for compat with datetime/timedelta/period shared methods,
-            #  we can sometimes get here with int64 values.  These represent
-            #  nanosecond UTC (or tz-naive) unix timestamps
-            values = values.view(DT64NS_DTYPE)
-
-        if values.dtype != DT64NS_DTYPE:
-            raise ValueError(
-                "The dtype of 'values' is incorrect. Must be 'datetime64[ns]'. "
-                f"Got {values.dtype} instead."
-            )
+    _freq: BaseOffset | None = None
+    _default_dtype = DT64NS_DTYPE  # used in TimeLikeOps.__init__
 
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        # used in TimeLikeOps.__init__
+        _validate_dt64_dtype(values.dtype)
         dtype = _validate_dt64_dtype(dtype)
-
-        if freq == "infer":
-            raise ValueError(
-                "Frequency inference not allowed in DatetimeArray.__init__. "
-                "Use 'pd.array()' instead."
-            )
-
-        if copy:
-            values = values.copy()
-        if freq:
-            freq = to_offset(freq)
-        if getattr(dtype, "tz", None):
-            # https://github.com/pandas-dev/pandas/issues/18595
-            # Ensure that we have a standard timezone for pytz objects.
-            # Without this, things like adding an array of timedeltas and
-            # a  tz-aware Timestamp (with a tz specific to its datetime) will
-            # be incorrect(ish?) for the array as a whole
-            dtype = DatetimeTZDtype(tz=timezones.tz_standardize(dtype.tz))
-
-        NDArrayBacked.__init__(self, values=values, dtype=dtype)
-        self._freq = freq
-
-        if inferred_freq is None and freq is not None:
-            type(self)._validate_frequency(self, freq)
+        return dtype
 
     # error: Signature of "_simple_new" incompatible with supertype "NDArrayBacked"
     @classmethod
     def _simple_new(  # type: ignore[override]
-        cls, values: np.ndarray, freq: BaseOffset | None = None, dtype=DT64NS_DTYPE
+        cls,
+        values: np.ndarray,
+        freq: BaseOffset | None = None,
+        dtype=DT64NS_DTYPE,
     ) -> DatetimeArray:
         assert isinstance(values, np.ndarray)
-        assert values.dtype == DT64NS_DTYPE
+        assert dtype.kind == "M"
+        if isinstance(dtype, np.dtype):
+            assert dtype == values.dtype
+            assert not is_unitless(dtype)
+        else:
+            # DatetimeTZDtype. If we have e.g. DatetimeTZDtype[us, UTC],
+            #  then values.dtype should be M8[us].
+            assert dtype._reso == get_unit_from_dtype(values.dtype)
 
         result = super()._simple_new(values, dtype)
         result._freq = freq
@@ -345,7 +294,7 @@ def _from_sequence_not_strict(
         dtype=None,
         copy: bool = False,
         tz=None,
-        freq=lib.no_default,
+        freq: str | BaseOffset | lib.NoDefault | None = lib.no_default,
         dayfirst: bool = False,
         yearfirst: bool = False,
         ambiguous="raise",
@@ -442,53 +391,57 @@ def _generate_range(
                     end = end.tz_localize(None)
 
             if isinstance(freq, Tick):
-                values = generate_regular_range(start, end, periods, freq)
+                i8values = generate_regular_range(start, end, periods, freq)
             else:
                 xdr = generate_range(start=start, end=end, periods=periods, offset=freq)
-                values = np.array([x.value for x in xdr], dtype=np.int64)
+                i8values = np.array([x.value for x in xdr], dtype=np.int64)
 
-            _tz = start.tz if start is not None else end.tz
-            values = values.view("M8[ns]")
-            index = cls._simple_new(values, freq=freq, dtype=tz_to_dtype(_tz))
+            endpoint_tz = start.tz if start is not None else end.tz
 
-            if tz is not None and index.tz is None:
-                arr = tzconversion.tz_localize_to_utc(
-                    index.asi8, tz, ambiguous=ambiguous, nonexistent=nonexistent
-                )
+            if tz is not None and endpoint_tz is None:
 
-                index = cls(arr)
+                if not timezones.is_utc(tz):
+                    # short-circuit tz_localize_to_utc which would make
+                    #  an unnecessary copy with UTC but be a no-op.
+                    i8values = tzconversion.tz_localize_to_utc(
+                        i8values, tz, ambiguous=ambiguous, nonexistent=nonexistent
+                    )
 
-                # index is localized datetime64 array -> have to convert
+                # i8values is localized datetime64 array -> have to convert
                 # start/end as well to compare
                 if start is not None:
-                    start = start.tz_localize(tz, ambiguous, nonexistent).asm8
+                    start = start.tz_localize(tz, ambiguous, nonexistent)
                 if end is not None:
-                    end = end.tz_localize(tz, ambiguous, nonexistent).asm8
+                    end = end.tz_localize(tz, ambiguous, nonexistent)
         else:
             # Create a linearly spaced date_range in local time
             # Nanosecond-granularity timestamps aren't always correctly
             # representable with doubles, so we limit the range that we
             # pass to np.linspace as much as possible
-            arr = (
+            i8values = (
                 np.linspace(0, end.value - start.value, periods, dtype="int64")
                 + start.value
             )
-            dtype = tz_to_dtype(tz)
-            arr = arr.astype("M8[ns]", copy=False)
-            index = cls._simple_new(arr, freq=None, dtype=dtype)
+            if i8values.dtype != "i8":
+                # 2022-01-09 I (brock) am not sure if it is possible for this
+                #  to overflow and cast to e.g. f8, but if it does we need to cast
+                i8values = i8values.astype("i8")
 
         if start == end:
             if not left_inclusive and not right_inclusive:
-                index = index[1:-1]
+                i8values = i8values[1:-1]
         else:
+            start_i8 = Timestamp(start).value
+            end_i8 = Timestamp(end).value
             if not left_inclusive or not right_inclusive:
-                if not left_inclusive and len(index) and index[0] == start:
-                    index = index[1:]
-                if not right_inclusive and len(index) and index[-1] == end:
-                    index = index[:-1]
+                if not left_inclusive and len(i8values) and i8values[0] == start_i8:
+                    i8values = i8values[1:]
+                if not right_inclusive and len(i8values) and i8values[-1] == end_i8:
+                    i8values = i8values[:-1]
 
+        dt64_values = i8values.view("datetime64[ns]")
         dtype = tz_to_dtype(tz)
-        return cls._simple_new(index._ndarray, freq=freq, dtype=dtype)
+        return cls._simple_new(dt64_values, freq=freq, dtype=dtype)
 
     # -----------------------------------------------------------------
     # DatetimeLike Interface
@@ -527,13 +480,10 @@ def _check_compatible_with(self, other, setitem: bool = False):
     # -----------------------------------------------------------------
     # Descriptive Properties
 
-    def _box_func(self, x) -> Timestamp | NaTType:
-        if isinstance(x, np.datetime64):
-            # GH#42228
-            # Argument 1 to "signedinteger" has incompatible type "datetime64";
-            # expected "Union[SupportsInt, Union[str, bytes], SupportsIndex]"
-            x = np.int64(x)  # type: ignore[arg-type]
-        ts = Timestamp(x, tz=self.tz)
+    def _box_func(self, x: np.datetime64) -> Timestamp | NaTType:
+        # GH#42228
+        value = x.view("i8")
+        ts = Timestamp._from_value_and_reso(value, reso=self._reso, tz=self.tz)
         # Non-overlapping identity check (left operand type: "Timestamp",
         # right operand type: "NaTType")
         if ts is not NaT:  # type: ignore[comparison-overlap]
@@ -570,7 +520,7 @@ def dtype(self) -> np.dtype | DatetimeTZDtype:  # type: ignore[override]
     @property
     def tz(self) -> tzinfo | None:
         """
-        Return timezone, if any.
+        Return the timezone.
 
         Returns
         -------
@@ -600,11 +550,11 @@ def is_normalized(self) -> bool:
         """
         Returns True if all of the dates are at midnight ("no time")
         """
-        return is_date_array_normalized(self.asi8, self.tz)
+        return is_date_array_normalized(self.asi8, self.tz, reso=self._reso)
 
     @property  # NB: override with cache_readonly in immutable subclasses
     def _resolution_obj(self) -> Resolution:
-        return get_resolution(self.asi8, self.tz)
+        return get_resolution(self.asi8, self.tz, reso=self._reso)
 
     # ----------------------------------------------------------------
     # Array-Like / EA-Interface Methods
@@ -638,7 +588,11 @@ def __iter__(self):
                 start_i = i * chunksize
                 end_i = min((i + 1) * chunksize, length)
                 converted = ints_to_pydatetime(
-                    data[start_i:end_i], tz=self.tz, freq=self.freq, box="timestamp"
+                    data[start_i:end_i],
+                    tz=self.tz,
+                    freq=self.freq,
+                    box="timestamp",
+                    reso=self._reso,
                 )
                 yield from converted
 
@@ -654,10 +608,40 @@ def astype(self, dtype, copy: bool = True):
                 return self.copy()
             return self
 
+        elif (
+            self.tz is None
+            and is_datetime64_dtype(dtype)
+            and not is_unitless(dtype)
+            and is_supported_unit(get_unit_from_dtype(dtype))
+        ):
+            # unit conversion e.g. datetime64[s]
+            res_values = astype_overflowsafe(self._ndarray, dtype, copy=True)
+            return type(self)._simple_new(res_values, dtype=res_values.dtype)
+            # TODO: preserve freq?
+
         elif is_datetime64_ns_dtype(dtype):
             return astype_dt64_to_dt64tz(self, dtype, copy, via_utc=False)
 
-        elif self.tz is None and is_datetime64_dtype(dtype) and dtype != self.dtype:
+        elif self.tz is not None and isinstance(dtype, DatetimeTZDtype):
+            # tzaware unit conversion e.g. datetime64[s, UTC]
+            np_dtype = np.dtype(dtype.str)
+            res_values = astype_overflowsafe(self._ndarray, np_dtype, copy=copy)
+            return type(self)._simple_new(res_values, dtype=dtype)
+            # TODO: preserve freq?
+
+        elif (
+            self.tz is None
+            and is_datetime64_dtype(dtype)
+            and dtype != self.dtype
+            and is_unitless(dtype)
+        ):
+            # TODO(2.0): just fall through to dtl.DatetimeLikeArrayMixin.astype
+            warnings.warn(
+                "Passing unit-less datetime64 dtype to .astype is deprecated "
+                "and will raise in a future version. Pass 'datetime64[ns]' instead",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
             # unit conversion e.g. datetime64[s]
             return self._ndarray.astype(dtype)
 
@@ -668,7 +652,6 @@ def astype(self, dtype, copy: bool = True):
     # -----------------------------------------------------------------
     # Rendering Methods
 
-    @dtl.ravel_compat
     def _format_native_types(
         self, *, na_rep="NaT", date_format=None, **kwargs
     ) -> npt.NDArray[np.object_]:
@@ -677,7 +660,7 @@ def _format_native_types(
         fmt = get_format_datetime64_from_values(self, date_format)
 
         return tslib.format_array_from_datetime(
-            self.asi8, tz=self.tz, format=fmt, na_rep=na_rep
+            self.asi8, tz=self.tz, format=fmt, na_rep=na_rep, reso=self._reso
         )
 
     # -----------------------------------------------------------------
@@ -719,80 +702,41 @@ def _assert_tzawareness_compat(self, other) -> None:
     # -----------------------------------------------------------------
     # Arithmetic Methods
 
-    def _sub_datetime_arraylike(self, other):
-        """subtract DatetimeArray/Index or ndarray[datetime64]"""
-        if len(self) != len(other):
-            raise ValueError("cannot add indices of unequal length")
-
-        if isinstance(other, np.ndarray):
-            assert is_datetime64_dtype(other)
-            other = type(self)(other)
-
-        try:
-            self._assert_tzawareness_compat(other)
-        except TypeError as error:
-            new_message = str(error).replace("compare", "subtract")
-            raise type(error)(new_message) from error
-
-        self_i8 = self.asi8
-        other_i8 = other.asi8
-        arr_mask = self._isnan | other._isnan
-        new_values = checked_add_with_arr(self_i8, -other_i8, arr_mask=arr_mask)
-        if self._hasnans or other._hasnans:
-            np.putmask(new_values, arr_mask, iNaT)
-        return new_values.view("timedelta64[ns]")
-
     def _add_offset(self, offset) -> DatetimeArray:
-        if self.ndim == 2:
-            return self.ravel()._add_offset(offset).reshape(self.shape)
 
         assert not isinstance(offset, Tick)
-        try:
-            if self.tz is not None:
-                values = self.tz_localize(None)
-            else:
-                values = self
-            result = offset._apply_array(values).view("M8[ns]")
-            result = DatetimeArray._simple_new(result)
-            result = result.tz_localize(self.tz)
 
+        if self.tz is not None:
+            values = self.tz_localize(None)
+        else:
+            values = self
+
+        try:
+            result = offset._apply_array(values).view(values.dtype)
         except NotImplementedError:
             warnings.warn(
                 "Non-vectorized DateOffset being applied to Series or DatetimeIndex.",
                 PerformanceWarning,
+                stacklevel=find_stack_level(),
             )
             result = self.astype("O") + offset
+            result = type(self)._from_sequence(result)
             if not len(self):
                 # GH#30336 _from_sequence won't be able to infer self.tz
-                return type(self)._from_sequence(result).tz_localize(self.tz)
-
-        return type(self)._from_sequence(result)
-
-    def _sub_datetimelike_scalar(self, other):
-        # subtract a datetime from myself, yielding a ndarray[timedelta64[ns]]
-        assert isinstance(other, (datetime, np.datetime64))
-        assert other is not NaT
-        other = Timestamp(other)
-        # error: Non-overlapping identity check (left operand type: "Timestamp",
-        # right operand type: "NaTType")
-        if other is NaT:  # type: ignore[comparison-overlap]
-            return self - NaT
+                return result.tz_localize(self.tz)
 
-        try:
-            self._assert_tzawareness_compat(other)
-        except TypeError as error:
-            new_message = str(error).replace("compare", "subtract")
-            raise type(error)(new_message) from error
+        else:
+            result = DatetimeArray._simple_new(result, dtype=result.dtype)
+            if self.tz is not None:
+                # FIXME: tz_localize with non-nano
+                result = result.tz_localize(self.tz)
 
-        i8 = self.asi8
-        result = checked_add_with_arr(i8, -other.value, arr_mask=self._isnan)
-        result = self._maybe_mask_results(result)
-        return result.view("timedelta64[ns]")
+        return result
 
     # -----------------------------------------------------------------
     # Timezone Conversion and Localization Methods
 
-    def _local_timestamps(self) -> np.ndarray:
+    def _local_timestamps(self) -> npt.NDArray[np.int64]:
         """
         Convert to an i8 (unix-like nanosecond timestamp) representation
         while keeping the local timezone and not using UTC.
@@ -800,8 +744,9 @@ def _local_timestamps(self) -> np.ndarray:
         were timezone-naive.
         """
         if self.tz is None or timezones.is_utc(self.tz):
+            # Avoid the copy that would be made in tzconversion
             return self.asi8
-        return tzconversion.tz_convert_from_utc(self.asi8, self.tz)
+        return tz_convert_from_utc(self.asi8, self.tz, reso=self._reso)
 
     def tz_convert(self, tz) -> DatetimeArray:
         """
@@ -876,14 +821,13 @@ def tz_convert(self, tz) -> DatetimeArray:
             )
 
         # No conversion since timestamps are all UTC to begin with
-        dtype = tz_to_dtype(tz)
+        dtype = tz_to_dtype(tz, unit=self._unit)
         return self._simple_new(self._ndarray, dtype=dtype, freq=self.freq)
 
     @dtl.ravel_compat
     def tz_localize(self, tz, ambiguous="raise", nonexistent="raise") -> DatetimeArray:
         """
-        Localize tz-naive Datetime Array/Index to tz-aware
-        Datetime Array/Index.
+        Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index.
 
         This method takes a time zone (tz) naive Datetime Array/Index object
         and makes this time zone aware. It does not move the time to another
@@ -1033,7 +977,7 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise") -> DatetimeArr
 
         if self.tz is not None:
             if tz is None:
-                new_dates = tzconversion.tz_convert_from_utc(self.asi8, self.tz)
+                new_dates = tz_convert_from_utc(self.asi8, self.tz)
             else:
                 raise TypeError("Already tz-aware, use tz_convert to convert.")
         else:
@@ -1041,10 +985,14 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise") -> DatetimeArr
             # Convert to UTC
 
             new_dates = tzconversion.tz_localize_to_utc(
-                self.asi8, tz, ambiguous=ambiguous, nonexistent=nonexistent
+                self.asi8,
+                tz,
+                ambiguous=ambiguous,
+                nonexistent=nonexistent,
+                reso=self._reso,
             )
-        new_dates = new_dates.view(DT64NS_DTYPE)
-        dtype = tz_to_dtype(tz)
+        new_dates = new_dates.view(f"M8[{self._unit}]")
+        dtype = tz_to_dtype(tz, unit=self._unit)
 
         freq = None
         if timezones.is_utc(tz) or (len(self) == 1 and not isna(new_dates[0])):
@@ -1061,14 +1009,13 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise") -> DatetimeArr
 
     def to_pydatetime(self) -> npt.NDArray[np.object_]:
         """
-        Return Datetime Array/Index as object ndarray of datetime.datetime
-        objects.
+        Return an ndarray of datetime.datetime objects.
 
         Returns
         -------
         datetimes : ndarray[object]
         """
-        return ints_to_pydatetime(self.asi8, tz=self.tz)
+        return ints_to_pydatetime(self.asi8, tz=self.tz, reso=self._reso)
 
     def normalize(self) -> DatetimeArray:
         """
@@ -1108,10 +1055,15 @@ def normalize(self) -> DatetimeArray:
                        '2014-08-01 00:00:00+05:30'],
                        dtype='datetime64[ns, Asia/Calcutta]', freq=None)
         """
-        new_values = normalize_i8_timestamps(self.asi8, self.tz)
-        return type(self)(new_values)._with_freq("infer").tz_localize(self.tz)
+        new_values = normalize_i8_timestamps(self.asi8, self.tz, reso=self._reso)
+        dt64_values = new_values.view(self._ndarray.dtype)
+
+        dta = type(self)._simple_new(dt64_values, dtype=dt64_values.dtype)
+        dta = dta._with_freq("infer")
+        if self.tz is not None:
+            dta = dta.tz_localize(self.tz)
+        return dta
 
-    @dtl.ravel_compat
     def to_period(self, freq=None) -> PeriodArray:
         """
         Cast to PeriodArray/Index at a particular frequency.
@@ -1163,6 +1115,7 @@ def to_period(self, freq=None) -> PeriodArray:
                 "Converting to PeriodArray/Index representation "
                 "will drop timezone information.",
                 UserWarning,
+                stacklevel=find_stack_level(),
             )
 
         if freq is None:
@@ -1185,9 +1138,9 @@ def to_period(self, freq=None) -> PeriodArray:
 
     def to_perioddelta(self, freq) -> TimedeltaArray:
         """
-        Calculate TimedeltaArray of difference between index
-        values and index converted to PeriodArray at specified
-        freq. Used for vectorized offsets.
+        Calculate deltas between self values and self converted to Periods at a freq.
+
+        Used for vectorized offsets.
 
         Parameters
         ----------
@@ -1208,6 +1161,9 @@ def to_perioddelta(self, freq) -> TimedeltaArray:
         )
         from pandas.core.arrays.timedeltas import TimedeltaArray
 
+        if self._ndarray.dtype != "M8[ns]":
+            raise NotImplementedError("Only supported for nanosecond resolution.")
+
         i8delta = self.asi8 - self.to_period(freq).to_timestamp().asi8
         m8delta = i8delta.view("m8[ns]")
         return TimedeltaArray(m8delta)
@@ -1215,9 +1171,9 @@ def to_perioddelta(self, freq) -> TimedeltaArray:
     # -----------------------------------------------------------------
     # Properties - Vectorized Timestamp Properties/Methods
 
-    def month_name(self, locale=None):
+    def month_name(self, locale=None) -> npt.NDArray[np.object_]:
         """
-        Return the month names of the DateTimeIndex with specified locale.
+        Return the month names with specified locale.
 
         Parameters
         ----------
@@ -1227,11 +1183,23 @@ def month_name(self, locale=None):
 
         Returns
         -------
-        Index
-            Index of month names.
+        Series or Index
+            Series or Index of month names.
 
         Examples
         --------
+        >>> s = pd.Series(pd.date_range(start='2018-01', freq='M', periods=3))
+        >>> s
+        0   2018-01-31
+        1   2018-02-28
+        2   2018-03-31
+        dtype: datetime64[ns]
+        >>> s.dt.month_name()
+        0     January
+        1    February
+        2       March
+        dtype: object
+
         >>> idx = pd.date_range(start='2018-01', freq='M', periods=3)
         >>> idx
         DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
@@ -1241,13 +1209,15 @@ def month_name(self, locale=None):
         """
         values = self._local_timestamps()
 
-        result = fields.get_date_name_field(values, "month_name", locale=locale)
+        result = fields.get_date_name_field(
+            values, "month_name", locale=locale, reso=self._reso
+        )
         result = self._maybe_mask_results(result, fill_value=None)
         return result
 
-    def day_name(self, locale=None):
+    def day_name(self, locale=None) -> npt.NDArray[np.object_]:
         """
-        Return the day names of the DateTimeIndex with specified locale.
+        Return the day names with specified locale.
 
         Parameters
         ----------
@@ -1257,11 +1227,23 @@ def day_name(self, locale=None):
 
         Returns
         -------
-        Index
-            Index of day names.
+        Series or Index
+            Series or Index of day names.
 
         Examples
         --------
+        >>> s = pd.Series(pd.date_range(start='2018-01-01', freq='D', periods=3))
+        >>> s
+        0   2018-01-01
+        1   2018-01-02
+        2   2018-01-03
+        dtype: datetime64[ns]
+        >>> s.dt.day_name()
+        0       Monday
+        1      Tuesday
+        2    Wednesday
+        dtype: object
+
         >>> idx = pd.date_range(start='2018-01-01', freq='D', periods=3)
         >>> idx
         DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'],
@@ -1271,54 +1253,60 @@ def day_name(self, locale=None):
         """
         values = self._local_timestamps()
 
-        result = fields.get_date_name_field(values, "day_name", locale=locale)
+        result = fields.get_date_name_field(
+            values, "day_name", locale=locale, reso=self._reso
+        )
         result = self._maybe_mask_results(result, fill_value=None)
         return result
 
     @property
     def time(self) -> npt.NDArray[np.object_]:
         """
-        Returns numpy array of datetime.time. The time part of the Timestamps.
+        Returns numpy array of :class:`datetime.time` objects.
+
+        The time part of the Timestamps.
         """
         # If the Timestamps have a timezone that is not UTC,
         # convert them into their i8 representation while
         # keeping their timezone and not using UTC
         timestamps = self._local_timestamps()
 
-        return ints_to_pydatetime(timestamps, box="time")
+        return ints_to_pydatetime(timestamps, box="time", reso=self._reso)
 
     @property
     def timetz(self) -> npt.NDArray[np.object_]:
         """
-        Returns numpy array of datetime.time also containing timezone
-        information. The time part of the Timestamps.
+        Returns numpy array of :class:`datetime.time` objects with timezones.
+
+        The time part of the Timestamps.
         """
-        return ints_to_pydatetime(self.asi8, self.tz, box="time")
+        return ints_to_pydatetime(self.asi8, self.tz, box="time", reso=self._reso)
 
     @property
     def date(self) -> npt.NDArray[np.object_]:
         """
-        Returns numpy array of python datetime.date objects (namely, the date
-        part of Timestamps without timezone information).
+        Returns numpy array of python :class:`datetime.date` objects.
+
+        Namely, the date part of Timestamps without time and
+        timezone information.
         """
         # If the Timestamps have a timezone that is not UTC,
         # convert them into their i8 representation while
         # keeping their timezone and not using UTC
         timestamps = self._local_timestamps()
 
-        return ints_to_pydatetime(timestamps, box="date")
+        return ints_to_pydatetime(timestamps, box="date", reso=self._reso)
 
     def isocalendar(self) -> DataFrame:
         """
-        Returns a DataFrame with the year, week, and day calculated according to
-        the ISO 8601 standard.
+        Calculate year, week, and day according to the ISO 8601 standard.
 
         .. versionadded:: 1.1.0
 
         Returns
         -------
         DataFrame
-            with columns year, week and day
+            With columns year, week and day.
 
         See Also
         --------
@@ -1346,11 +1334,11 @@ def isocalendar(self) -> DataFrame:
         from pandas import DataFrame
 
         values = self._local_timestamps()
-        sarray = fields.build_isocalendar_sarray(values)
+        sarray = fields.build_isocalendar_sarray(values, reso=self._reso)
         iso_calendar_df = DataFrame(
             sarray, columns=["year", "week", "day"], dtype="UInt32"
         )
-        if self._hasnans:
+        if self._hasna:
             iso_calendar_df.iloc[self._isnan] = None
         return iso_calendar_df
 
@@ -1891,7 +1879,7 @@ def weekofyear(self):
         """,
     )
 
-    def to_julian_date(self) -> np.ndarray:
+    def to_julian_date(self) -> npt.NDArray[np.float64]:
         """
         Convert Datetime Array to float64 ndarray of Julian Dates.
         0 Julian date is noon January 1, 4713 BC.
@@ -1917,8 +1905,8 @@ def to_julian_date(self) -> np.ndarray:
                 self.hour
                 + self.minute / 60
                 + self.second / 3600
-                + self.microsecond / 3600 / 10 ** 6
-                + self.nanosecond / 3600 / 10 ** 9
+                + self.microsecond / 3600 / 10**6
+                + self.nanosecond / 3600 / 10**9
             )
             / 24
         )
@@ -1944,6 +1932,7 @@ def std(
         ----------
         axis : int optional, default None
             Axis for the function to be applied on.
+            For `Series` this parameter is unused and defaults to `None`.
         ddof : int, default 1
             Degrees of Freedom. The divisor used in calculations is N - ddof,
             where N represents the number of elements.
@@ -1960,10 +1949,13 @@ def std(
         #  without creating a copy by using a view on self._ndarray
         from pandas.core.arrays import TimedeltaArray
 
-        tda = TimedeltaArray(self._ndarray.view("i8"))
-        return tda.std(
-            axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims, skipna=skipna
-        )
+        # Find the td64 dtype with the same resolution as our dt64 dtype
+        dtype_str = self._ndarray.dtype.name.replace("datetime64", "timedelta64")
+        dtype = np.dtype(dtype_str)
+
+        tda = TimedeltaArray._simple_new(self._ndarray.view(dtype), dtype=dtype)
+
+        return tda.std(axis=axis, out=out, ddof=ddof, keepdims=keepdims, skipna=skipna)
 
 
 # -------------------------------------------------------------------
@@ -1988,10 +1980,10 @@ def sequence_to_datetimes(data, require_iso8601: bool = False) -> DatetimeArray:
 def _sequence_to_dt64ns(
     data,
     dtype=None,
-    copy=False,
+    copy: bool = False,
     tz=None,
-    dayfirst=False,
-    yearfirst=False,
+    dayfirst: bool = False,
+    yearfirst: bool = False,
     ambiguous="raise",
     *,
     allow_mixed: bool = False,
@@ -2035,29 +2027,15 @@ def _sequence_to_dt64ns(
     # if dtype has an embedded tz, capture it
     tz = validate_tz_from_dtype(dtype, tz)
 
-    if not hasattr(data, "dtype"):
-        # e.g. list, tuple
-        if np.ndim(data) == 0:
-            # i.e. generator
-            data = list(data)
-        data = np.asarray(data)
-        copy = False
-    elif isinstance(data, ABCMultiIndex):
-        raise TypeError("Cannot create a DatetimeArray from a MultiIndex.")
-    else:
-        data = extract_array(data, extract_numpy=True)
-
-    if isinstance(data, IntegerArray):
-        data = data.to_numpy("int64", na_value=iNaT)
-    elif not isinstance(data, (np.ndarray, ExtensionArray)):
-        # GH#24539 e.g. xarray, dask object
-        data = np.asarray(data)
+    data, copy = dtl.ensure_arraylike_for_datetimelike(
+        data, copy, cls_name="DatetimeArray"
+    )
 
     if isinstance(data, DatetimeArray):
         inferred_freq = data.freq
 
     # By this point we are assured to have either a numpy array or Index
-    data, copy = maybe_convert_dtype(data, copy)
+    data, copy = maybe_convert_dtype(data, copy, tz=tz)
     data_dtype = getattr(data, "dtype", None)
 
     if (
@@ -2088,7 +2066,11 @@ def _sequence_to_dt64ns(
                     # by convention, these are _already_ UTC, e.g
                     return data.view(DT64NS_DTYPE), tz, None
 
-                utc_vals = tzconversion.tz_convert_from_utc(data.view("i8"), tz)
+                if timezones.is_utc(tz):
+                    # Fastpath, avoid copy made in tzconversion
+                    utc_vals = data.view("i8")
+                else:
+                    utc_vals = tz_convert_from_utc(data.view("i8"), tz)
                 data = utc_vals.view(DT64NS_DTYPE)
             elif inferred_tz:
                 tz = inferred_tz
@@ -2106,12 +2088,14 @@ def _sequence_to_dt64ns(
         # tz-naive DatetimeArray or ndarray[datetime64]
         data = getattr(data, "_ndarray", data)
         if data.dtype != DT64NS_DTYPE:
-            data = conversion.ensure_datetime64ns(data)
+            data = astype_overflowsafe(data, dtype=DT64NS_DTYPE)
             copy = False
 
         if tz is not None:
             # Convert tz-naive to UTC
             tz = timezones.maybe_get_tz(tz)
+            # TODO: if tz is UTC, are there situations where we *don't* want a
+            #  copy?  tz_localize_to_utc always makes one.
             data = tzconversion.tz_localize_to_utc(
                 data.view("i8"), tz, ambiguous=ambiguous
             )
@@ -2200,15 +2184,9 @@ def objects_to_datetime64ns(
             allow_mixed=allow_mixed,
         )
         result = result.reshape(data.shape, order=order)
-    except ValueError as err:
-        try:
-            values, tz_parsed = conversion.datetime_to_datetime64(data.ravel("K"))
-            # If tzaware, these values represent unix timestamps, so we
-            #  return them as i8 to distinguish from wall times
-            values = values.reshape(data.shape, order=order)
-            return values.view("i8"), tz_parsed
-        except (ValueError, TypeError):
-            raise err
+    except OverflowError as err:
+        # Exception is raised when a part of date is greater than 32 bit signed int
+        raise OutOfBoundsDatetime("Out of bounds nanosecond timestamp") from err
 
     if tz_parsed is not None:
         # We can take a shortcut since the datetime64 numpy array
@@ -2234,7 +2212,7 @@ def objects_to_datetime64ns(
         raise TypeError(result)
 
 
-def maybe_convert_dtype(data, copy: bool):
+def maybe_convert_dtype(data, copy: bool, tz: tzinfo | None = None):
     """
     Convert data based on dtype conventions, issuing deprecation warnings
     or errors where appropriate.
@@ -2243,6 +2221,7 @@ def maybe_convert_dtype(data, copy: bool):
     ----------
     data : np.ndarray or pd.Index
     copy : bool
+    tz : tzinfo or None, default None
 
     Returns
     -------
@@ -2262,8 +2241,23 @@ def maybe_convert_dtype(data, copy: bool):
         #  as wall-times instead of UTC timestamps.
         data = data.astype(DT64NS_DTYPE)
         copy = False
-        # TODO: deprecate this behavior to instead treat symmetrically
-        #  with integer dtypes.  See discussion in GH#23675
+        if (
+            tz is not None
+            and len(data) > 0
+            and not timezones.is_utc(timezones.maybe_get_tz(tz))
+        ):
+            # GH#23675, GH#45573 deprecate to treat symmetrically with integer dtypes
+            warnings.warn(
+                "The behavior of DatetimeArray._from_sequence with a timezone-aware "
+                "dtype and floating-dtype data is deprecated. In a future version, "
+                "this data will be interpreted as nanosecond UTC timestamps "
+                "instead of wall-times, matching the behavior with integer dtypes. "
+                "To retain the old behavior, explicitly cast to 'datetime64[ns]' "
+                "before passing the data to pandas. To get the future behavior, "
+                "first cast to 'int64'.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
 
     elif is_timedelta64_dtype(data.dtype) or is_bool_dtype(data.dtype):
         # GH#29794 enforcing deprecation introduced in GH#23539
@@ -2275,15 +2269,7 @@ def maybe_convert_dtype(data, copy: bool):
             "Passing PeriodDtype data is invalid. Use `data.to_timestamp()` instead"
         )
 
-    elif is_categorical_dtype(data.dtype):
-        # GH#18664 preserve tz in going DTI->Categorical->DTI
-        # TODO: cases where we need to do another pass through this func,
-        #  e.g. the categories are timedelta64s
-        data = data.categories.take(data.codes, fill_value=NaT)._values
-        copy = False
-
     elif is_extension_array_dtype(data.dtype) and not is_datetime64tz_dtype(data.dtype):
-        # Includes categorical
         # TODO: We have no tests for these
         data = np.array(data, dtype=np.object_)
         copy = False
@@ -2364,6 +2350,16 @@ def _validate_dt64_dtype(dtype):
                 f"Unexpected value for 'dtype': '{dtype}'. "
                 "Must be 'datetime64[ns]' or DatetimeTZDtype'."
             )
+
+        if getattr(dtype, "tz", None):
+            # https://github.com/pandas-dev/pandas/issues/18595
+            # Ensure that we have a standard timezone for pytz objects.
+            # Without this, things like adding an array of timedeltas and
+            # a  tz-aware Timestamp (with a tz specific to its datetime) will
+            # be incorrect(ish?) for the array as a whole
+            dtype = cast(DatetimeTZDtype, dtype)
+            dtype = DatetimeTZDtype(tz=timezones.tz_standardize(dtype.tz))
+
     return dtype
 
 
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index e1f80c5894bb1..0c14fac57d9db 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -1,41 +1,14 @@
 from __future__ import annotations
 
-from typing import overload
-
 import numpy as np
 
-from pandas._libs import (
-    lib,
-    missing as libmissing,
-)
-from pandas._typing import (
-    ArrayLike,
-    AstypeArg,
-    DtypeObj,
-    npt,
-)
-from pandas.util._decorators import cache_readonly
-
-from pandas.core.dtypes.cast import astype_nansafe
-from pandas.core.dtypes.common import (
-    is_bool_dtype,
-    is_datetime64_dtype,
-    is_float_dtype,
-    is_integer_dtype,
-    is_object_dtype,
-    pandas_dtype,
-)
-from pandas.core.dtypes.dtypes import (
-    ExtensionDtype,
-    register_extension_dtype,
-)
+from pandas.core.dtypes.common import is_float_dtype
+from pandas.core.dtypes.dtypes import register_extension_dtype
 
-from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.numeric import (
     NumericArray,
     NumericDtype,
 )
-from pandas.core.tools.numeric import to_numeric
 
 
 class FloatingDtype(NumericDtype):
@@ -48,12 +21,8 @@ class FloatingDtype(NumericDtype):
     The attributes name & type are set when these subclasses are created.
     """
 
-    def __repr__(self) -> str:
-        return f"{self.name}Dtype()"
-
-    @property
-    def _is_numeric(self) -> bool:
-        return True
+    _default_np_dtype = np.dtype(np.float64)
+    _checker = is_float_dtype
 
     @classmethod
     def construct_array_type(cls) -> type[FloatingArray]:
@@ -66,115 +35,20 @@ def construct_array_type(cls) -> type[FloatingArray]:
         """
         return FloatingArray
 
-    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
-        # for now only handle other floating types
-        if not all(isinstance(t, FloatingDtype) for t in dtypes):
-            return None
-        np_dtype = np.find_common_type(
-            # error: Item "ExtensionDtype" of "Union[Any, ExtensionDtype]" has no
-            # attribute "numpy_dtype"
-            [t.numpy_dtype for t in dtypes],  # type: ignore[union-attr]
-            [],
-        )
-        if np.issubdtype(np_dtype, np.floating):
-            return FLOAT_STR_TO_DTYPE[str(np_dtype)]
-        return None
-
-
-def coerce_to_array(
-    values, dtype=None, mask=None, copy: bool = False
-) -> tuple[np.ndarray, np.ndarray]:
-    """
-    Coerce the input values array to numpy arrays with a mask.
+    @classmethod
+    def _str_to_dtype_mapping(cls):
+        return FLOAT_STR_TO_DTYPE
 
-    Parameters
-    ----------
-    values : 1D list-like
-    dtype : float dtype
-    mask : bool 1D array, optional
-    copy : bool, default False
-        if True, copy the input
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        """
+        Safely cast the values to the given dtype.
 
-    Returns
-    -------
-    tuple of (values, mask)
-    """
-    # if values is floating numpy array, preserve its dtype
-    if dtype is None and hasattr(values, "dtype"):
-        if is_float_dtype(values.dtype):
-            dtype = values.dtype
-
-    if dtype is not None:
-        if isinstance(dtype, str) and dtype.startswith("Float"):
-            # Avoid DeprecationWarning from NumPy about np.dtype("Float64")
-            # https://github.com/numpy/numpy/pull/7476
-            dtype = dtype.lower()
-
-        if not issubclass(type(dtype), FloatingDtype):
-            try:
-                dtype = FLOAT_STR_TO_DTYPE[str(np.dtype(dtype))]
-            except KeyError as err:
-                raise ValueError(f"invalid dtype specified {dtype}") from err
-
-    if isinstance(values, FloatingArray):
-        values, mask = values._data, values._mask
-        if dtype is not None:
-            values = values.astype(dtype.numpy_dtype, copy=False)
-
-        if copy:
-            values = values.copy()
-            mask = mask.copy()
-        return values, mask
-
-    values = np.array(values, copy=copy)
-    if is_object_dtype(values.dtype):
-        inferred_type = lib.infer_dtype(values, skipna=True)
-        if inferred_type == "empty":
-            pass
-        elif inferred_type not in [
-            "floating",
-            "integer",
-            "mixed-integer",
-            "integer-na",
-            "mixed-integer-float",
-        ]:
-            raise TypeError(f"{values.dtype} cannot be converted to a FloatingDtype")
-
-    elif is_bool_dtype(values) and is_float_dtype(dtype):
-        values = np.array(values, dtype=float, copy=copy)
-
-    elif not (is_integer_dtype(values) or is_float_dtype(values)):
-        raise TypeError(f"{values.dtype} cannot be converted to a FloatingDtype")
-
-    if values.ndim != 1:
-        raise TypeError("values must be a 1D list-like")
-
-    if mask is None:
-        mask = libmissing.is_numeric_na(values)
-
-    else:
-        assert len(mask) == len(values)
-
-    if not mask.ndim == 1:
-        raise TypeError("mask must be a 1D list-like")
-
-    # infer dtype if needed
-    if dtype is None:
-        dtype = np.dtype("float64")
-    else:
-        dtype = dtype.type
-
-    # if we are float, let's make sure that we can
-    # safely cast
-
-    # we copy as need to coerce here
-    # TODO should this be a safe cast?
-    if mask.any():
-        values = values.copy()
-        values[mask] = np.nan
-    values = values.astype(dtype, copy=False)  # , casting="safe")
-
-    return values, mask
+        "safe" in this context means the casting is lossless.
+        """
+        # This is really only here for compatibility with IntegerDtype
+        # Here for compat with IntegerDtype
+        return values.astype(dtype, copy=copy)
 
 
 class FloatingArray(NumericArray):
@@ -237,106 +111,14 @@ class FloatingArray(NumericArray):
     Length: 3, dtype: Float32
     """
 
+    _dtype_cls = FloatingDtype
+
     # The value used to fill '_data' to avoid upcasting
-    _internal_fill_value = 0.0
+    _internal_fill_value = np.nan
     # Fill values used for any/all
     _truthy_value = 1.0
     _falsey_value = 0.0
 
-    @cache_readonly
-    def dtype(self) -> FloatingDtype:
-        return FLOAT_STR_TO_DTYPE[str(self._data.dtype)]
-
-    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
-        if not (isinstance(values, np.ndarray) and values.dtype.kind == "f"):
-            raise TypeError(
-                "values should be floating numpy array. Use "
-                "the 'pd.array' function instead"
-            )
-        if values.dtype == np.float16:
-            # If we don't raise here, then accessing self.dtype would raise
-            raise TypeError("FloatingArray does not support np.float16 dtype.")
-
-        super().__init__(values, mask, copy=copy)
-
-    @classmethod
-    def _from_sequence(
-        cls, scalars, *, dtype=None, copy: bool = False
-    ) -> FloatingArray:
-        values, mask = coerce_to_array(scalars, dtype=dtype, copy=copy)
-        return FloatingArray(values, mask)
-
-    @classmethod
-    def _from_sequence_of_strings(
-        cls, strings, *, dtype=None, copy: bool = False
-    ) -> FloatingArray:
-        scalars = to_numeric(strings, errors="raise")
-        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
-
-    def _coerce_to_array(self, value) -> tuple[np.ndarray, np.ndarray]:
-        return coerce_to_array(value, dtype=self.dtype)
-
-    @overload
-    def astype(self, dtype: npt.DTypeLike, copy: bool = ...) -> np.ndarray:
-        ...
-
-    @overload
-    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray:
-        ...
-
-    @overload
-    def astype(self, dtype: AstypeArg, copy: bool = ...) -> ArrayLike:
-        ...
-
-    def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
-        """
-        Cast to a NumPy array or ExtensionArray with 'dtype'.
-
-        Parameters
-        ----------
-        dtype : str or dtype
-            Typecode or data-type to which the array is cast.
-        copy : bool, default True
-            Whether to copy the data, even if not necessary. If False,
-            a copy is made only if the old dtype does not match the
-            new dtype.
-
-        Returns
-        -------
-        ndarray or ExtensionArray
-            NumPy ndarray, or BooleanArray, IntegerArray or FloatingArray with
-            'dtype' for its dtype.
-
-        Raises
-        ------
-        TypeError
-            if incompatible type with an FloatingDtype, equivalent of same_kind
-            casting
-        """
-        dtype = pandas_dtype(dtype)
-
-        if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy=copy)
-
-        # coerce
-        if is_float_dtype(dtype):
-            # In astype, we consider dtype=float to also mean na_value=np.nan
-            kwargs = {"na_value": np.nan}
-        elif is_datetime64_dtype(dtype):
-            # error: Dict entry 0 has incompatible type "str": "datetime64"; expected
-            # "str": "float"
-            kwargs = {"na_value": np.datetime64("NaT")}  # type: ignore[dict-item]
-        else:
-            kwargs = {}
-
-        # error: Argument 2 to "to_numpy" of "BaseMaskedArray" has incompatible
-        # type "**Dict[str, float]"; expected "bool"
-        data = self.to_numpy(dtype=dtype, **kwargs)  # type: ignore[arg-type]
-        return astype_nansafe(data, dtype, copy=False)
-
-    def _values_for_argsort(self) -> np.ndarray:
-        return self._data
-
 
 _dtype_docstring = """
 An ExtensionDtype for {dtype} data.
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 443dfa4122389..24e5fa1bef552 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -1,70 +1,28 @@
 from __future__ import annotations
 
-from typing import overload
-
 import numpy as np
 
-from pandas._libs import (
-    lib,
-    missing as libmissing,
-)
-from pandas._typing import (
-    ArrayLike,
-    AstypeArg,
-    Dtype,
-    DtypeObj,
-    npt,
-)
-from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.base import register_extension_dtype
+from pandas.core.dtypes.common import is_integer_dtype
 
-from pandas.core.dtypes.base import (
-    ExtensionDtype,
-    register_extension_dtype,
-)
-from pandas.core.dtypes.common import (
-    is_bool_dtype,
-    is_datetime64_dtype,
-    is_float_dtype,
-    is_integer_dtype,
-    is_object_dtype,
-    is_string_dtype,
-    pandas_dtype,
-)
-
-from pandas.core.arrays import ExtensionArray
-from pandas.core.arrays.masked import BaseMaskedDtype
 from pandas.core.arrays.numeric import (
     NumericArray,
     NumericDtype,
 )
-from pandas.core.tools.numeric import to_numeric
 
 
-class _IntegerDtype(NumericDtype):
+class IntegerDtype(NumericDtype):
     """
     An ExtensionDtype to hold a single size & kind of integer dtype.
 
     These specific implementations are subclasses of the non-public
-    _IntegerDtype. For example we have Int8Dtype to represent signed int 8s.
+    IntegerDtype. For example we have Int8Dtype to represent signed int 8s.
 
     The attributes name & type are set when these subclasses are created.
     """
 
-    def __repr__(self) -> str:
-        sign = "U" if self.is_unsigned_integer else ""
-        return f"{sign}Int{8 * self.itemsize}Dtype()"
-
-    @cache_readonly
-    def is_signed_integer(self) -> bool:
-        return self.kind == "i"
-
-    @cache_readonly
-    def is_unsigned_integer(self) -> bool:
-        return self.kind == "u"
-
-    @property
-    def _is_numeric(self) -> bool:
-        return True
+    _default_np_dtype = np.dtype(np.int64)
+    _checker = is_integer_dtype
 
     @classmethod
     def construct_array_type(cls) -> type[IntegerArray]:
@@ -77,159 +35,28 @@ def construct_array_type(cls) -> type[IntegerArray]:
         """
         return IntegerArray
 
-    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
-        # we only handle nullable EA dtypes and numeric numpy dtypes
-        if not all(
-            isinstance(t, BaseMaskedDtype)
-            or (
-                isinstance(t, np.dtype)
-                and (np.issubdtype(t, np.number) or np.issubdtype(t, np.bool_))
-            )
-            for t in dtypes
-        ):
-            return None
-        np_dtype = np.find_common_type(
-            # error: List comprehension has incompatible type List[Union[Any,
-            # dtype, ExtensionDtype]]; expected List[Union[dtype, None, type,
-            # _SupportsDtype, str, Tuple[Any, Union[int, Sequence[int]]],
-            # List[Any], _DtypeDict, Tuple[Any, Any]]]
-            [
-                t.numpy_dtype  # type: ignore[misc]
-                if isinstance(t, BaseMaskedDtype)
-                else t
-                for t in dtypes
-            ],
-            [],
-        )
-        if np.issubdtype(np_dtype, np.integer):
-            return INT_STR_TO_DTYPE[str(np_dtype)]
-        elif np.issubdtype(np_dtype, np.floating):
-            from pandas.core.arrays.floating import FLOAT_STR_TO_DTYPE
-
-            return FLOAT_STR_TO_DTYPE[str(np_dtype)]
-        return None
-
-
-def safe_cast(values, dtype, copy: bool):
-    """
-    Safely cast the values to the dtype if they
-    are equivalent, meaning floats must be equivalent to the
-    ints.
-    """
-    try:
-        return values.astype(dtype, casting="safe", copy=copy)
-    except TypeError as err:
-        casted = values.astype(dtype, copy=copy)
-        if (casted == values).all():
-            return casted
-
-        raise TypeError(
-            f"cannot safely cast non-equivalent {values.dtype} to {np.dtype(dtype)}"
-        ) from err
-
+    @classmethod
+    def _str_to_dtype_mapping(cls):
+        return INT_STR_TO_DTYPE
 
-def coerce_to_array(
-    values, dtype, mask=None, copy: bool = False
-) -> tuple[np.ndarray, np.ndarray]:
-    """
-    Coerce the input values array to numpy arrays with a mask.
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        """
+        Safely cast the values to the given dtype.
 
-    Parameters
-    ----------
-    values : 1D list-like
-    dtype : integer dtype
-    mask : bool 1D array, optional
-    copy : bool, default False
-        if True, copy the input
+        "safe" in this context means the casting is lossless. e.g. if 'values'
+        has a floating dtype, each value must be an integer.
+        """
+        try:
+            return values.astype(dtype, casting="safe", copy=copy)
+        except TypeError as err:
+            casted = values.astype(dtype, copy=copy)
+            if (casted == values).all():
+                return casted
 
-    Returns
-    -------
-    tuple of (values, mask)
-    """
-    # if values is integer numpy array, preserve its dtype
-    if dtype is None and hasattr(values, "dtype"):
-        if is_integer_dtype(values.dtype):
-            dtype = values.dtype
-
-    if dtype is not None:
-        if isinstance(dtype, str) and (
-            dtype.startswith("Int") or dtype.startswith("UInt")
-        ):
-            # Avoid DeprecationWarning from NumPy about np.dtype("Int64")
-            # https://github.com/numpy/numpy/pull/7476
-            dtype = dtype.lower()
-
-        if not issubclass(type(dtype), _IntegerDtype):
-            try:
-                dtype = INT_STR_TO_DTYPE[str(np.dtype(dtype))]
-            except KeyError as err:
-                raise ValueError(f"invalid dtype specified {dtype}") from err
-
-    if isinstance(values, IntegerArray):
-        values, mask = values._data, values._mask
-        if dtype is not None:
-            values = values.astype(dtype.numpy_dtype, copy=False)
-
-        if copy:
-            values = values.copy()
-            mask = mask.copy()
-        return values, mask
-
-    values = np.array(values, copy=copy)
-    inferred_type = None
-    if is_object_dtype(values.dtype) or is_string_dtype(values.dtype):
-        inferred_type = lib.infer_dtype(values, skipna=True)
-        if inferred_type == "empty":
-            pass
-        elif inferred_type not in [
-            "floating",
-            "integer",
-            "mixed-integer",
-            "integer-na",
-            "mixed-integer-float",
-            "string",
-            "unicode",
-        ]:
-            raise TypeError(f"{values.dtype} cannot be converted to an IntegerDtype")
-
-    elif is_bool_dtype(values) and is_integer_dtype(dtype):
-        values = np.array(values, dtype=int, copy=copy)
-
-    elif not (is_integer_dtype(values) or is_float_dtype(values)):
-        raise TypeError(f"{values.dtype} cannot be converted to an IntegerDtype")
-
-    if values.ndim != 1:
-        raise TypeError("values must be a 1D list-like")
-
-    if mask is None:
-        mask = libmissing.is_numeric_na(values)
-    else:
-        assert len(mask) == len(values)
-
-    if mask.ndim != 1:
-        raise TypeError("mask must be a 1D list-like")
-
-    # infer dtype if needed
-    if dtype is None:
-        dtype = np.dtype("int64")
-    else:
-        dtype = dtype.type
-
-    # if we are float, let's make sure that we can
-    # safely cast
-
-    # we copy as need to coerce here
-    if mask.any():
-        values = values.copy()
-        values[mask] = 1
-    if inferred_type in ("string", "unicode"):
-        # casts from str are always safe since they raise
-        # a ValueError if the str cannot be parsed into an int
-        values = values.astype(dtype, copy=copy)
-    else:
-        values = safe_cast(values, dtype, copy=False)
-
-    return values, mask
+            raise TypeError(
+                f"cannot safely cast non-equivalent {values.dtype} to {np.dtype(dtype)}"
+            ) from err
 
 
 class IntegerArray(NumericArray):
@@ -300,114 +127,14 @@ class IntegerArray(NumericArray):
     Length: 3, dtype: UInt16
     """
 
+    _dtype_cls = IntegerDtype
+
     # The value used to fill '_data' to avoid upcasting
     _internal_fill_value = 1
     # Fill values used for any/all
     _truthy_value = 1
     _falsey_value = 0
 
-    @cache_readonly
-    def dtype(self) -> _IntegerDtype:
-        return INT_STR_TO_DTYPE[str(self._data.dtype)]
-
-    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
-        if not (isinstance(values, np.ndarray) and values.dtype.kind in ["i", "u"]):
-            raise TypeError(
-                "values should be integer numpy array. Use "
-                "the 'pd.array' function instead"
-            )
-        super().__init__(values, mask, copy=copy)
-
-    @classmethod
-    def _from_sequence(
-        cls, scalars, *, dtype: Dtype | None = None, copy: bool = False
-    ) -> IntegerArray:
-        values, mask = coerce_to_array(scalars, dtype=dtype, copy=copy)
-        return IntegerArray(values, mask)
-
-    @classmethod
-    def _from_sequence_of_strings(
-        cls, strings, *, dtype: Dtype | None = None, copy: bool = False
-    ) -> IntegerArray:
-        scalars = to_numeric(strings, errors="raise")
-        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
-
-    def _coerce_to_array(self, value) -> tuple[np.ndarray, np.ndarray]:
-        return coerce_to_array(value, dtype=self.dtype)
-
-    @overload
-    def astype(self, dtype: npt.DTypeLike, copy: bool = ...) -> np.ndarray:
-        ...
-
-    @overload
-    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray:
-        ...
-
-    @overload
-    def astype(self, dtype: AstypeArg, copy: bool = ...) -> ArrayLike:
-        ...
-
-    def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
-        """
-        Cast to a NumPy array or ExtensionArray with 'dtype'.
-
-        Parameters
-        ----------
-        dtype : str or dtype
-            Typecode or data-type to which the array is cast.
-        copy : bool, default True
-            Whether to copy the data, even if not necessary. If False,
-            a copy is made only if the old dtype does not match the
-            new dtype.
-
-        Returns
-        -------
-        ndarray or ExtensionArray
-            NumPy ndarray, BooleanArray or IntegerArray with 'dtype' for its dtype.
-
-        Raises
-        ------
-        TypeError
-            if incompatible type with an IntegerDtype, equivalent of same_kind
-            casting
-        """
-        dtype = pandas_dtype(dtype)
-
-        if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy=copy)
-
-        na_value: float | np.datetime64 | lib.NoDefault
-
-        # coerce
-        if is_float_dtype(dtype):
-            # In astype, we consider dtype=float to also mean na_value=np.nan
-            na_value = np.nan
-        elif is_datetime64_dtype(dtype):
-            na_value = np.datetime64("NaT")
-        else:
-            na_value = lib.no_default
-
-        return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
-
-    def _values_for_argsort(self) -> np.ndarray:
-        """
-        Return values for sorting.
-
-        Returns
-        -------
-        ndarray
-            The transformed values should maintain the ordering between values
-            within the array.
-
-        See Also
-        --------
-        ExtensionArray.argsort : Return the indices that would sort this array.
-        """
-        data = self._data.copy()
-        if self._mask.any():
-            data[self._mask] = data.min() - 1
-        return data
-
 
 _dtype_docstring = """
 An ExtensionDtype for {dtype} integer data.
@@ -430,62 +157,62 @@ def _values_for_argsort(self) -> np.ndarray:
 
 
 @register_extension_dtype
-class Int8Dtype(_IntegerDtype):
+class Int8Dtype(IntegerDtype):
     type = np.int8
     name = "Int8"
     __doc__ = _dtype_docstring.format(dtype="int8")
 
 
 @register_extension_dtype
-class Int16Dtype(_IntegerDtype):
+class Int16Dtype(IntegerDtype):
     type = np.int16
     name = "Int16"
     __doc__ = _dtype_docstring.format(dtype="int16")
 
 
 @register_extension_dtype
-class Int32Dtype(_IntegerDtype):
+class Int32Dtype(IntegerDtype):
     type = np.int32
     name = "Int32"
     __doc__ = _dtype_docstring.format(dtype="int32")
 
 
 @register_extension_dtype
-class Int64Dtype(_IntegerDtype):
+class Int64Dtype(IntegerDtype):
     type = np.int64
     name = "Int64"
     __doc__ = _dtype_docstring.format(dtype="int64")
 
 
 @register_extension_dtype
-class UInt8Dtype(_IntegerDtype):
+class UInt8Dtype(IntegerDtype):
     type = np.uint8
     name = "UInt8"
     __doc__ = _dtype_docstring.format(dtype="uint8")
 
 
 @register_extension_dtype
-class UInt16Dtype(_IntegerDtype):
+class UInt16Dtype(IntegerDtype):
     type = np.uint16
     name = "UInt16"
     __doc__ = _dtype_docstring.format(dtype="uint16")
 
 
 @register_extension_dtype
-class UInt32Dtype(_IntegerDtype):
+class UInt32Dtype(IntegerDtype):
     type = np.uint32
     name = "UInt32"
     __doc__ = _dtype_docstring.format(dtype="uint32")
 
 
 @register_extension_dtype
-class UInt64Dtype(_IntegerDtype):
+class UInt64Dtype(IntegerDtype):
     type = np.uint64
     name = "UInt64"
     __doc__ = _dtype_docstring.format(dtype="uint64")
 
 
-INT_STR_TO_DTYPE: dict[str, _IntegerDtype] = {
+INT_STR_TO_DTYPE: dict[str, IntegerDtype] = {
     "int8": Int8Dtype(),
     "int16": Int16Dtype(),
     "int32": Int32Dtype(),
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index ea6673fdaf0cf..ea5c6d52f29ba 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -7,6 +7,8 @@
 )
 import textwrap
 from typing import (
+    TYPE_CHECKING,
+    Literal,
     Sequence,
     TypeVar,
     Union,
@@ -18,10 +20,7 @@
 
 from pandas._config import get_option
 
-from pandas._libs import (
-    NaT,
-    lib,
-)
+from pandas._libs import lib
 from pandas._libs.interval import (
     VALID_CLOSED,
     Interval,
@@ -32,6 +31,7 @@
 from pandas._typing import (
     ArrayLike,
     Dtype,
+    IntervalClosedType,
     NpDtype,
     PositionalIndexer,
     ScalarIndexer,
@@ -39,12 +39,15 @@
     npt,
 )
 from pandas.compat.numpy import function as nv
-from pandas.util._decorators import Appender
+from pandas.errors import IntCastingNaNError
+from pandas.util._decorators import (
+    Appender,
+    deprecate_nonkeyword_arguments,
+)
 
+from pandas.core.dtypes.cast import LossySetitemError
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
-    is_datetime64_dtype,
-    is_datetime64tz_dtype,
     is_dtype_equal,
     is_float_dtype,
     is_integer_dtype,
@@ -53,7 +56,6 @@
     is_object_dtype,
     is_scalar,
     is_string_dtype,
-    is_timedelta64_dtype,
     needs_i8_conversion,
     pandas_dtype,
 )
@@ -93,6 +95,13 @@
     unpack_zerodim_and_defer,
 )
 
+if TYPE_CHECKING:
+    from pandas import (
+        Index,
+        Series,
+    )
+
+
 IntervalArrayT = TypeVar("IntervalArrayT", bound="IntervalArray")
 IntervalOrNA = Union[Interval, float]
 
@@ -197,10 +206,18 @@
     }
 )
 class IntervalArray(IntervalMixin, ExtensionArray):
-    ndim = 1
     can_hold_na = True
     _na_value = _fill_value = np.nan
 
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
+
+    # To make mypy recognize the fields
+    _left: np.ndarray
+    _right: np.ndarray
+    _dtype: IntervalDtype
+
     # ---------------------------------------------------------------------
     # Constructors
 
@@ -253,7 +270,7 @@ def _simple_new(
         cls: type[IntervalArrayT],
         left,
         right,
-        closed=None,
+        closed: IntervalClosedType | None = None,
         copy: bool = False,
         dtype: Dtype | None = None,
         verify_integrity: bool = True,
@@ -366,7 +383,8 @@ def _from_factorized(
             Left and right bounds for each interval.
         closed : {'left', 'right', 'both', 'neither'}, default 'right'
             Whether the intervals are closed on the left-side, right-side, both
-            or neither.
+            or neither.\
+        %(name)s
         copy : bool, default False
             Copy the data.
         dtype : dtype or None, default None
@@ -391,6 +409,7 @@ def _from_factorized(
         _interval_shared_docs["from_breaks"]
         % {
             "klass": "IntervalArray",
+            "name": "",
             "examples": textwrap.dedent(
                 """\
         Examples
@@ -406,7 +425,7 @@ def _from_factorized(
     def from_breaks(
         cls: type[IntervalArrayT],
         breaks,
-        closed="right",
+        closed: IntervalClosedType | None = "right",
         copy: bool = False,
         dtype: Dtype | None = None,
     ) -> IntervalArrayT:
@@ -426,7 +445,8 @@ def from_breaks(
             Right bounds for each interval.
         closed : {'left', 'right', 'both', 'neither'}, default 'right'
             Whether the intervals are closed on the left-side, right-side, both
-            or neither.
+            or neither.\
+        %(name)s
         copy : bool, default False
             Copy the data.
         dtype : dtype, optional
@@ -468,6 +488,7 @@ def from_breaks(
         _interval_shared_docs["from_arrays"]
         % {
             "klass": "IntervalArray",
+            "name": "",
             "examples": textwrap.dedent(
                 """\
         >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3])
@@ -482,7 +503,7 @@ def from_arrays(
         cls: type[IntervalArrayT],
         left,
         right,
-        closed="right",
+        closed: IntervalClosedType | None = "right",
         copy: bool = False,
         dtype: Dtype | None = None,
     ) -> IntervalArrayT:
@@ -503,7 +524,8 @@ def from_arrays(
             Array of tuples.
         closed : {'left', 'right', 'both', 'neither'}, default 'right'
             Whether the intervals are closed on the left-side, right-side, both
-            or neither.
+            or neither.\
+        %(name)s
         copy : bool, default False
             By-default copy the data, this is compat only and ignored.
         dtype : dtype or None, default None
@@ -530,6 +552,7 @@ def from_arrays(
         _interval_shared_docs["from_tuples"]
         % {
             "klass": "IntervalArray",
+            "name": "",
             "examples": textwrap.dedent(
                 """\
         Examples
@@ -661,16 +684,12 @@ def __getitem__(
             if is_scalar(left) and isna(left):
                 return self._fill_value
             return Interval(left, right, self.closed)
-        # error: Argument 1 to "ndim" has incompatible type "Union[ndarray,
-        # ExtensionArray]"; expected "Union[Union[int, float, complex, str, bytes,
-        # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
-        # Sequence[Sequence[Any]], _SupportsArray]"
-        if np.ndim(left) > 1:  # type: ignore[arg-type]
+        if np.ndim(left) > 1:
             # GH#30588 multi-dimensional indexer disallowed
             raise ValueError("multi-dimensional indexing not allowed")
         return self._shallow_copy(left, right)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         value_left, value_right = self._validate_setitem_value(value)
         key = check_array_indexer(self, key)
 
@@ -780,6 +799,7 @@ def __lt__(self, other):
     def __le__(self, other):
         return self._cmp_method(other, operator.le)
 
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def argsort(
         self,
         ascending: bool = True,
@@ -798,7 +818,7 @@ def argsort(
             ascending=ascending, kind=kind, na_position=na_position, **kwargs
         )
 
-    def min(self, *, axis: int | None = None, skipna: bool = True):
+    def min(self, *, axis: int | None = None, skipna: bool = True) -> IntervalOrNA:
         nv.validate_minmax_axis(axis, self.ndim)
 
         if not len(self):
@@ -815,7 +835,7 @@ def min(self, *, axis: int | None = None, skipna: bool = True):
         indexer = obj.argsort()[0]
         return obj[indexer]
 
-    def max(self, *, axis: int | None = None, skipna: bool = True):
+    def max(self, *, axis: int | None = None, skipna: bool = True) -> IntervalOrNA:
         nv.validate_minmax_axis(axis, self.ndim)
 
         if not len(self):
@@ -906,7 +926,12 @@ def astype(self, dtype, copy: bool = True):
                 #  np.nan entries to int subtypes
                 new_left = Index(self._left, copy=False).astype(dtype.subtype)
                 new_right = Index(self._right, copy=False).astype(dtype.subtype)
-            except TypeError as err:
+            except IntCastingNaNError:
+                # e.g test_subtype_integer
+                raise
+            except (TypeError, ValueError) as err:
+                # e.g. test_subtype_integer_errors f8->u8 can be lossy
+                #  and raises ValueError
                 msg = (
                     f"Cannot convert {self.dtype} to {dtype}; subtypes are incompatible"
                 )
@@ -944,10 +969,10 @@ def _concat_same_type(
         -------
         IntervalArray
         """
-        closed = {interval.closed for interval in to_concat}
-        if len(closed) != 1:
+        closed_set = {interval.closed for interval in to_concat}
+        if len(closed_set) != 1:
             raise ValueError("Intervals must all be closed on the same side.")
-        closed = closed.pop()
+        closed = closed_set.pop()
 
         left = np.concatenate([interval.left for interval in to_concat])
         right = np.concatenate([interval.right for interval in to_concat])
@@ -1081,7 +1106,7 @@ def _validate_listlike(self, value):
 
         try:
             self.left._validate_fill_value(value_left)
-        except (ValueError, TypeError) as err:
+        except (LossySetitemError, TypeError) as err:
             msg = (
                 "'value' should be a compatible interval type, "
                 f"got {type(value)} instead."
@@ -1097,7 +1122,7 @@ def _validate_scalar(self, value):
             # TODO: check subdtype match like _validate_setitem_value?
         elif is_valid_na_for_dtype(value, self.left.dtype):
             # GH#18295
-            left = right = value
+            left = right = self.left._na_value
         else:
             raise TypeError(
                 "can only insert Interval objects and NA into an IntervalArray"
@@ -1105,22 +1130,15 @@ def _validate_scalar(self, value):
         return left, right
 
     def _validate_setitem_value(self, value):
-        needs_float_conversion = False
 
         if is_valid_na_for_dtype(value, self.left.dtype):
             # na value: need special casing to set directly on numpy arrays
+            value = self.left._na_value
             if is_integer_dtype(self.dtype.subtype):
                 # can't set NaN on a numpy integer array
-                needs_float_conversion = True
-            elif is_datetime64_dtype(self.dtype.subtype):
-                # need proper NaT to set directly on the numpy array
-                value = np.datetime64("NaT")
-            elif is_datetime64tz_dtype(self.dtype.subtype):
-                # need proper NaT to set directly on the DatetimeArray array
-                value = NaT
-            elif is_timedelta64_dtype(self.dtype.subtype):
-                # need proper NaT to set directly on the numpy array
-                value = np.timedelta64("NaT")
+                # GH#45484 TypeError, not ValueError, matches what we get with
+                #  non-NA un-holdable value.
+                raise TypeError("Cannot set float NaN to integer-backed IntervalArray")
             value_left, value_right = value, value
 
         elif isinstance(value, Interval):
@@ -1133,11 +1151,9 @@ def _validate_setitem_value(self, value):
         else:
             return self._validate_listlike(value)
 
-        if needs_float_conversion:
-            raise ValueError("Cannot set float NaN to integer-backed IntervalArray")
         return value_left, value_right
 
-    def value_counts(self, dropna: bool = True):
+    def value_counts(self, dropna: bool = True) -> Series:
         """
         Returns a Series containing counts of each interval.
 
@@ -1214,8 +1230,7 @@ def _format_space(self) -> str:
     @property
     def left(self):
         """
-        Return the left endpoints of each Interval in the IntervalArray as
-        an Index.
+        Return the left endpoints of each Interval in the IntervalArray as an Index.
         """
         from pandas import Index
 
@@ -1224,23 +1239,21 @@ def left(self):
     @property
     def right(self):
         """
-        Return the right endpoints of each Interval in the IntervalArray as
-        an Index.
+        Return the right endpoints of each Interval in the IntervalArray as an Index.
         """
         from pandas import Index
 
         return Index(self._right, copy=False)
 
     @property
-    def length(self):
+    def length(self) -> Index:
         """
-        Return an Index with entries denoting the length of each Interval in
-        the IntervalArray.
+        Return an Index with entries denoting the length of each Interval.
         """
         return self.right - self.left
 
     @property
-    def mid(self):
+    def mid(self) -> Index:
         """
         Return the midpoint of each Interval in the IntervalArray as an Index.
         """
@@ -1325,17 +1338,17 @@ def overlaps(self, other):
     # ---------------------------------------------------------------------
 
     @property
-    def closed(self):
+    def closed(self) -> IntervalClosedType:
         """
-        Whether the intervals are closed on the left-side, right-side, both or
-        neither.
+        String describing the inclusive side the intervals.
+
+        Either ``left``, ``right``, ``both`` or ``neither``.
         """
         return self.dtype.closed
 
     _interval_shared_docs["set_closed"] = textwrap.dedent(
         """
-        Return an %(klass)s identical to the current one, but closed on the
-        specified side.
+        Return an identical %(klass)s closed on the specified side.
 
         Parameters
         ----------
@@ -1372,7 +1385,7 @@ def closed(self):
             ),
         }
     )
-    def set_closed(self: IntervalArrayT, closed) -> IntervalArrayT:
+    def set_closed(self: IntervalArrayT, closed: IntervalClosedType) -> IntervalArrayT:
         if closed not in VALID_CLOSED:
             msg = f"invalid option for 'closed': {closed}"
             raise ValueError(msg)
@@ -1384,9 +1397,10 @@ def set_closed(self: IntervalArrayT, closed) -> IntervalArrayT:
     _interval_shared_docs[
         "is_non_overlapping_monotonic"
     ] = """
-        Return True if the %(klass)s is non-overlapping (no Intervals share
-        points) and is either monotonic increasing or monotonic decreasing,
-        else False.
+        Return a boolean whether the %(klass)s is non-overlapping and monotonic.
+
+        Non-overlapping means (no Intervals share points), and monotonic means
+        either monotonic increasing or monotonic decreasing.
         """
 
     # https://github.com/python/mypy/issues/1362
@@ -1442,7 +1456,7 @@ def __arrow_array__(self, type=None):
         """
         import pyarrow
 
-        from pandas.core.arrays._arrow_utils import ArrowIntervalType
+        from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 
         try:
             subtype = pyarrow.from_numpy_dtype(self.dtype.subtype)
@@ -1624,7 +1638,7 @@ def contains(self, other):
             other < self._right if self.open_right else other <= self._right
         )
 
-    def isin(self, values) -> np.ndarray:
+    def isin(self, values) -> npt.NDArray[np.bool_]:
         if not hasattr(values, "dtype"):
             values = np.array(values)
         values = extract_array(values, extract_numpy=True)
@@ -1639,7 +1653,14 @@ def isin(self, values) -> np.ndarray:
                 #  complex128 ndarray is much more performant.
                 left = self._combined.view("complex128")
                 right = values._combined.view("complex128")
-                return np.in1d(left, right)
+                # error: Argument 1 to "in1d" has incompatible type
+                # "Union[ExtensionArray, ndarray[Any, Any],
+                # ndarray[Any, dtype[Any]]]"; expected
+                # "Union[_SupportsArray[dtype[Any]],
+                # _NestedSequence[_SupportsArray[dtype[Any]]], bool,
+                # int, float, complex, str, bytes, _NestedSequence[
+                # Union[bool, int, float, complex, str, bytes]]]"
+                return np.in1d(left, right)  # type: ignore[arg-type]
 
             elif needs_i8_conversion(self.left.dtype) ^ needs_i8_conversion(
                 values.left.dtype
@@ -1667,8 +1688,14 @@ def _from_combined(self, combined: np.ndarray) -> IntervalArray:
 
         dtype = self._left.dtype
         if needs_i8_conversion(dtype):
-            new_left = type(self._left)._from_sequence(nc[:, 0], dtype=dtype)
-            new_right = type(self._right)._from_sequence(nc[:, 1], dtype=dtype)
+            # error: "Type[ndarray[Any, Any]]" has no attribute "_from_sequence"
+            new_left = type(self._left)._from_sequence(  # type: ignore[attr-defined]
+                nc[:, 0], dtype=dtype
+            )
+            # error: "Type[ndarray[Any, Any]]" has no attribute "_from_sequence"
+            new_right = type(self._right)._from_sequence(  # type: ignore[attr-defined]
+                nc[:, 1], dtype=dtype
+            )
         else:
             new_left = nc[:, 0].view(dtype)
             new_right = nc[:, 1].view(dtype)
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index 065e10f3c49ba..5cdd632d39b3c 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -3,6 +3,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Literal,
     Sequence,
     TypeVar,
     overload,
@@ -12,13 +13,13 @@
 import numpy as np
 
 from pandas._libs import (
-    iNaT,
     lib,
     missing as libmissing,
 )
 from pandas._typing import (
     ArrayLike,
     AstypeArg,
+    DtypeObj,
     NpDtype,
     PositionalIndexer,
     Scalar,
@@ -26,38 +27,37 @@
     SequenceIndexer,
     Shape,
     npt,
-    type_t,
 )
 from pandas.errors import AbstractMethodError
-from pandas.util._decorators import (
-    cache_readonly,
-    doc,
-)
+from pandas.util._decorators import doc
 from pandas.util._validators import validate_fillna_kwargs
 
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.base import ExtensionDtype
 from pandas.core.dtypes.common import (
     is_bool,
     is_bool_dtype,
+    is_datetime64_dtype,
     is_dtype_equal,
-    is_float,
     is_float_dtype,
     is_integer_dtype,
     is_list_like,
-    is_numeric_dtype,
     is_object_dtype,
     is_scalar,
     is_string_dtype,
     pandas_dtype,
 )
+from pandas.core.dtypes.dtypes import BaseMaskedDtype
 from pandas.core.dtypes.inference import is_array_like
 from pandas.core.dtypes.missing import (
     array_equivalent,
+    is_valid_na_for_dtype,
     isna,
     notna,
 )
 
 from pandas.core import (
+    algorithms as algos,
     arraylike,
     missing,
     nanops,
@@ -72,55 +72,23 @@
 from pandas.core.array_algos.quantile import quantile_with_mask
 from pandas.core.arraylike import OpsMixin
 from pandas.core.arrays import ExtensionArray
+from pandas.core.construction import ensure_wrapped_if_datetimelike
 from pandas.core.indexers import check_array_indexer
 from pandas.core.ops import invalid_comparison
 
 if TYPE_CHECKING:
     from pandas import Series
     from pandas.core.arrays import BooleanArray
+    from pandas._typing import (
+        NumpySorter,
+        NumpyValueArrayLike,
+    )
 
 from pandas.compat.numpy import function as nv
 
 BaseMaskedArrayT = TypeVar("BaseMaskedArrayT", bound="BaseMaskedArray")
 
 
-class BaseMaskedDtype(ExtensionDtype):
-    """
-    Base class for dtypes for BasedMaskedArray subclasses.
-    """
-
-    name: str
-    base = None
-    type: type
-
-    na_value = libmissing.NA
-
-    @cache_readonly
-    def numpy_dtype(self) -> np.dtype:
-        """Return an instance of our numpy dtype"""
-        return np.dtype(self.type)
-
-    @cache_readonly
-    def kind(self) -> str:
-        return self.numpy_dtype.kind
-
-    @cache_readonly
-    def itemsize(self) -> int:
-        """Return the number of bytes in this dtype"""
-        return self.numpy_dtype.itemsize
-
-    @classmethod
-    def construct_array_type(cls) -> type_t[BaseMaskedArray]:
-        """
-        Return the array type associated with this dtype.
-
-        Returns
-        -------
-        type
-        """
-        raise NotImplementedError
-
-
 class BaseMaskedArray(OpsMixin, ExtensionArray):
     """
     Base class for masked arrays (which use _data and _mask to store the data).
@@ -132,13 +100,15 @@ class BaseMaskedArray(OpsMixin, ExtensionArray):
     _internal_fill_value: Scalar
     # our underlying data and mask are each ndarrays
     _data: np.ndarray
-    _mask: np.ndarray
+    _mask: npt.NDArray[np.bool_]
 
     # Fill values used for any/all
     _truthy_value = Scalar  # bool(_truthy_value) = True
     _falsey_value = Scalar  # bool(_falsey_value) = False
 
-    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
+    def __init__(
+        self, values: np.ndarray, mask: npt.NDArray[np.bool_], copy: bool = False
+    ) -> None:
         # values is supposed to already be validated in the subclass
         if not (isinstance(mask, np.ndarray) and mask.dtype == np.bool_):
             raise TypeError(
@@ -155,6 +125,13 @@ def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
         self._data = values
         self._mask = mask
 
+    @classmethod
+    def _from_sequence(
+        cls: type[BaseMaskedArrayT], scalars, *, dtype=None, copy: bool = False
+    ) -> BaseMaskedArrayT:
+        values, mask = cls._coerce_to_array(scalars, dtype=dtype, copy=copy)
+        return cls(values, mask)
+
     @property
     def dtype(self) -> BaseMaskedDtype:
         raise AbstractMethodError(self)
@@ -200,12 +177,10 @@ def fillna(
         if mask.any():
             if method is not None:
                 func = missing.get_fill_func(method, ndim=self.ndim)
-                new_values, new_mask = func(
-                    self._data.copy().T,
-                    limit=limit,
-                    mask=mask.copy().T,
-                )
-                return type(self)(new_values.T, new_mask.view(np.bool_).T)
+                npvalues = self._data.copy().T
+                new_mask = mask.copy().T
+                func(npvalues, limit=limit, mask=new_mask)
+                return type(self)(npvalues.T, new_mask.T)
             else:
                 # fill with value
                 new_values = self.copy()
@@ -214,20 +189,53 @@ def fillna(
             new_values = self.copy()
         return new_values
 
-    def _coerce_to_array(self, values) -> tuple[np.ndarray, np.ndarray]:
-        raise AbstractMethodError(self)
+    @classmethod
+    def _coerce_to_array(
+        cls, values, *, dtype: DtypeObj, copy: bool = False
+    ) -> tuple[np.ndarray, np.ndarray]:
+        raise AbstractMethodError(cls)
 
-    def __setitem__(self, key, value) -> None:
-        _is_scalar = is_scalar(value)
-        if _is_scalar:
-            value = [value]
-        value, mask = self._coerce_to_array(value)
+    def _validate_setitem_value(self, value):
+        """
+        Check if we have a scalar that we can cast losslessly.
+
+        Raises
+        ------
+        TypeError
+        """
+        kind = self.dtype.kind
+        # TODO: get this all from np_can_hold_element?
+        if kind == "b":
+            if lib.is_bool(value):
+                return value
+
+        elif kind == "f":
+            if lib.is_integer(value) or lib.is_float(value):
+                return value
 
-        if _is_scalar:
-            value = value[0]
-            mask = mask[0]
+        else:
+            if lib.is_integer(value) or (lib.is_float(value) and value.is_integer()):
+                return value
+            # TODO: unsigned checks
+
+        # Note: without the "str" here, the f-string rendering raises in
+        #  py38 builds.
+        raise TypeError(f"Invalid value '{str(value)}' for dtype {self.dtype}")
 
+    def __setitem__(self, key, value) -> None:
         key = check_array_indexer(self, key)
+
+        if is_scalar(value):
+            if is_valid_na_for_dtype(value, self.dtype):
+                self._mask[key] = True
+            else:
+                value = self._validate_setitem_value(value)
+                self._data[key] = value
+                self._mask[key] = False
+            return
+
+        value, mask = self._coerce_to_array(value, dtype=self.dtype)
+
         self._data[key] = value
         self._mask[key] = mask
 
@@ -278,14 +286,58 @@ def ravel(self: BaseMaskedArrayT, *args, **kwargs) -> BaseMaskedArrayT:
     def T(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
         return type(self)(self._data.T, self._mask.T)
 
+    def round(self, decimals: int = 0, *args, **kwargs):
+        """
+        Round each value in the array a to the given number of decimals.
+
+        Parameters
+        ----------
+        decimals : int, default 0
+            Number of decimal places to round to. If decimals is negative,
+            it specifies the number of positions to the left of the decimal point.
+        *args, **kwargs
+            Additional arguments and keywords have no effect but might be
+            accepted for compatibility with NumPy.
+
+        Returns
+        -------
+        NumericArray
+            Rounded values of the NumericArray.
+
+        See Also
+        --------
+        numpy.around : Round values of an np.array.
+        DataFrame.round : Round values of a DataFrame.
+        Series.round : Round values of a Series.
+        """
+        nv.validate_round(args, kwargs)
+        values = np.round(self._data, decimals=decimals, **kwargs)
+
+        # Usually we'll get same type as self, but ndarray[bool] casts to float
+        return self._maybe_mask_result(values, self._mask.copy())
+
+    # ------------------------------------------------------------------
+    # Unary Methods
+
     def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
         return type(self)(~self._data, self._mask.copy())
 
+    def __neg__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        return type(self)(-self._data, self._mask.copy())
+
+    def __pos__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        return self.copy()
+
+    def __abs__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        return type(self)(abs(self._data), self._mask.copy())
+
+    # ------------------------------------------------------------------
+
     def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value: Scalar = lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Convert to a NumPy Array.
@@ -403,7 +455,30 @@ def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
             eacls = dtype.construct_array_type()
             return eacls._from_sequence(self, dtype=dtype, copy=copy)
 
-        raise NotImplementedError("subclass must implement astype to np.dtype")
+        na_value: float | np.datetime64 | lib.NoDefault
+
+        # coerce
+        if is_float_dtype(dtype):
+            # In astype, we consider dtype=float to also mean na_value=np.nan
+            na_value = np.nan
+        elif is_datetime64_dtype(dtype):
+            na_value = np.datetime64("NaT")
+        else:
+            na_value = lib.no_default
+
+        # to_numpy will also raise, but we get somewhat nicer exception messages here
+        if is_integer_dtype(dtype) and self._hasna:
+            raise ValueError("cannot convert NA to integer")
+        if is_bool_dtype(dtype) and self._hasna:
+            # careful: astype_nansafe converts np.nan to True
+            raise ValueError("cannot convert float NaN to bool")
+
+        data = self.to_numpy(dtype=dtype, na_value=na_value, copy=copy)
+        if self.dtype.kind == "f":
+            # TODO: make this consistent between IntegerArray/FloatingArray,
+            #  see test_astype_str
+            return astype_nansafe(data, dtype, copy=False)
+        return data
 
     __array_priority__ = 1000  # higher than ndarray so ops dispatch to us
 
@@ -510,6 +585,104 @@ def _hasna(self) -> bool:
         # error: Incompatible return value type (got "bool_", expected "bool")
         return self._mask.any()  # type: ignore[return-value]
 
+    def _propagate_mask(
+        self, mask: npt.NDArray[np.bool_] | None, other
+    ) -> npt.NDArray[np.bool_]:
+        if mask is None:
+            mask = self._mask.copy()  # TODO: need test for BooleanArray needing a copy
+            if other is libmissing.NA:
+                # GH#45421 don't alter inplace
+                mask = mask | True
+        else:
+            mask = self._mask | mask
+        return mask
+
+    def _arith_method(self, other, op):
+        op_name = op.__name__
+        omask = None
+
+        if isinstance(other, BaseMaskedArray):
+            other, omask = other._data, other._mask
+
+        elif is_list_like(other):
+            if not isinstance(other, ExtensionArray):
+                other = np.asarray(other)
+            if other.ndim > 1:
+                raise NotImplementedError("can only perform ops with 1-d structures")
+
+        # We wrap the non-masked arithmetic logic used for numpy dtypes
+        #  in Series/Index arithmetic ops.
+        other = ops.maybe_prepare_scalar_for_op(other, (len(self),))
+        pd_op = ops.get_array_op(op)
+        other = ensure_wrapped_if_datetimelike(other)
+
+        if op_name in {"pow", "rpow"} and isinstance(other, np.bool_):
+            # Avoid DeprecationWarning: In future, it will be an error
+            #  for 'np.bool_' scalars to be interpreted as an index
+            #  e.g. test_array_scalar_like_equivalence
+            other = bool(other)
+
+        mask = self._propagate_mask(omask, other)
+
+        if other is libmissing.NA:
+            result = np.ones_like(self._data)
+            if self.dtype.kind == "b":
+                if op_name in {
+                    "floordiv",
+                    "rfloordiv",
+                    "pow",
+                    "rpow",
+                    "truediv",
+                    "rtruediv",
+                }:
+                    # GH#41165 Try to match non-masked Series behavior
+                    #  This is still imperfect GH#46043
+                    raise NotImplementedError(
+                        f"operator '{op_name}' not implemented for bool dtypes"
+                    )
+                elif op_name in {"mod", "rmod"}:
+                    dtype = "int8"
+                else:
+                    dtype = "bool"
+                result = result.astype(dtype)
+            elif "truediv" in op_name and self.dtype.kind != "f":
+                # The actual data here doesn't matter since the mask
+                #  will be all-True, but since this is division, we want
+                #  to end up with floating dtype.
+                result = result.astype(np.float64)
+        else:
+            # Make sure we do this before the "pow" mask checks
+            #  to get an expected exception message on shape mismatch.
+            if self.dtype.kind in ["i", "u"] and op_name in ["floordiv", "mod"]:
+                # TODO(GH#30188) ATM we don't match the behavior of non-masked
+                #  types with respect to floordiv-by-zero
+                pd_op = op
+
+            with np.errstate(all="ignore"):
+                result = pd_op(self._data, other)
+
+        if op_name == "pow":
+            # 1 ** x is 1.
+            mask = np.where((self._data == 1) & ~self._mask, False, mask)
+            # x ** 0 is 1.
+            if omask is not None:
+                mask = np.where((other == 0) & ~omask, False, mask)
+            elif other is not libmissing.NA:
+                mask = np.where(other == 0, False, mask)
+
+        elif op_name == "rpow":
+            # 1 ** x is 1.
+            if omask is not None:
+                mask = np.where((other == 1) & ~omask, False, mask)
+            elif other is not libmissing.NA:
+                mask = np.where(other == 1, False, mask)
+            # x ** 0 is 1.
+            mask = np.where((self._data == 0) & ~self._mask, False, mask)
+
+        return self._maybe_mask_result(result, mask)
+
+    _logical_method = _arith_method
+
     def _cmp_method(self, other, op) -> BooleanArray:
         from pandas.core.arrays import BooleanArray
 
@@ -547,36 +720,30 @@ def _cmp_method(self, other, op) -> BooleanArray:
                 if result is NotImplemented:
                     result = invalid_comparison(self._data, other, op)
 
-        # nans propagate
-        if mask is None:
-            mask = self._mask.copy()
-        else:
-            mask = self._mask | mask
-
+        mask = self._propagate_mask(mask, other)
         return BooleanArray(result, mask, copy=False)
 
-    def _maybe_mask_result(self, result, mask, other, op_name: str):
+    def _maybe_mask_result(self, result, mask):
         """
         Parameters
         ----------
-        result : array-like
+        result : array-like or tuple[array-like]
         mask : array-like bool
-        other : scalar or array-like
-        op_name : str
         """
-        # if we have a float operand we are by-definition
-        # a float result
-        # or our op is a divide
-        if (
-            (is_float_dtype(other) or is_float(other))
-            or (op_name in ["rtruediv", "truediv"])
-            or (is_float_dtype(self.dtype) and is_numeric_dtype(result.dtype))
-        ):
+        if isinstance(result, tuple):
+            # i.e. divmod
+            div, mod = result
+            return (
+                self._maybe_mask_result(div, mask),
+                self._maybe_mask_result(mod, mask),
+            )
+
+        if is_float_dtype(result.dtype):
             from pandas.core.arrays import FloatingArray
 
             return FloatingArray(result, mask, copy=False)
 
-        elif is_bool_dtype(result):
+        elif is_bool_dtype(result.dtype):
             from pandas.core.arrays import BooleanArray
 
             return BooleanArray(result, mask, copy=False)
@@ -585,10 +752,13 @@ def _maybe_mask_result(self, result, mask, other, op_name: str):
             # e.g. test_numeric_arr_mul_tdscalar_numexpr_path
             from pandas.core.arrays import TimedeltaArray
 
-            result[mask] = iNaT
-            return TimedeltaArray._simple_new(result)
+            if not isinstance(result, TimedeltaArray):
+                result = TimedeltaArray._simple_new(result)
 
-        elif is_integer_dtype(result):
+            result[mask] = result.dtype.type("NaT")
+            return result
+
+        elif is_integer_dtype(result.dtype):
             from pandas.core.arrays import IntegerArray
 
             return IntegerArray(result, mask, copy=False)
@@ -681,18 +851,80 @@ def copy(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
         mask = mask.copy()
         return type(self)(data, mask, copy=False)
 
+    def unique(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        """
+        Compute the BaseMaskedArray of unique values.
+
+        Returns
+        -------
+        uniques : BaseMaskedArray
+        """
+        uniques, mask = algos.unique_with_mask(self._data, self._mask)
+        return type(self)(uniques, mask, copy=False)
+
+    @doc(ExtensionArray.searchsorted)
+    def searchsorted(
+        self,
+        value: NumpyValueArrayLike | ExtensionArray,
+        side: Literal["left", "right"] = "left",
+        sorter: NumpySorter = None,
+    ) -> npt.NDArray[np.intp] | np.intp:
+        if self._hasna:
+            raise ValueError(
+                "searchsorted requires array to be sorted, which is impossible "
+                "with NAs present."
+            )
+        if isinstance(value, ExtensionArray):
+            value = value.astype(object)
+        # Base class searchsorted would cast to object, which is *much* slower.
+        return self._data.searchsorted(value, side=side, sorter=sorter)
+
     @doc(ExtensionArray.factorize)
-    def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
+    def factorize(
+        self,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
+    ) -> tuple[np.ndarray, ExtensionArray]:
+        resolved_na_sentinel = algos.resolve_na_sentinel(na_sentinel, use_na_sentinel)
         arr = self._data
         mask = self._mask
 
-        codes, uniques = factorize_array(arr, na_sentinel=na_sentinel, mask=mask)
+        # Pass non-None na_sentinel; recode and add NA to uniques if necessary below
+        na_sentinel_arg = -1 if resolved_na_sentinel is None else resolved_na_sentinel
+        codes, uniques = factorize_array(arr, na_sentinel=na_sentinel_arg, mask=mask)
+
+        # check that factorize_array correctly preserves dtype.
+        assert uniques.dtype == self.dtype.numpy_dtype, (uniques.dtype, self.dtype)
+
+        has_na = mask.any()
+        if resolved_na_sentinel is not None or not has_na:
+            size = len(uniques)
+        else:
+            # Make room for an NA value
+            size = len(uniques) + 1
+        uniques_mask = np.zeros(size, dtype=bool)
+        if resolved_na_sentinel is None and has_na:
+            na_index = mask.argmax()
+            # Insert na with the proper code
+            if na_index == 0:
+                na_code = np.intp(0)
+            else:
+                # mypy error: Slice index must be an integer or None
+                # https://github.com/python/mypy/issues/2410
+                na_code = codes[:na_index].max() + 1  # type: ignore[misc]
+            codes[codes >= na_code] += 1
+            codes[codes == -1] = na_code
+            # dummy value for uniques; not used since uniques_mask will be True
+            uniques = np.insert(uniques, na_code, 0)
+            uniques_mask[na_code] = True
+        uniques_ea = type(self)(uniques, uniques_mask)
 
-        # the hashtables don't handle all different types of bits
-        uniques = uniques.astype(self.dtype.numpy_dtype, copy=False)
-        uniques_ea = type(self)(uniques, np.zeros(len(uniques), dtype=bool))
         return codes, uniques_ea
 
+    @doc(ExtensionArray._values_for_argsort)
+    def _values_for_argsort(self) -> np.ndarray:
+        return self._data
+
     def value_counts(self, dropna: bool = True) -> Series:
         """
         Returns a Series containing counts of each unique value.
@@ -716,6 +948,15 @@ def value_counts(self, dropna: bool = True) -> Series:
         )
         from pandas.arrays import IntegerArray
 
+        if dropna:
+            keys, counts = algos.value_counts_arraylike(
+                self._data, dropna=True, mask=self._mask
+            )
+            res = Series(counts, index=keys)
+            res.index = res.index.astype(self.dtype)
+            res = res.astype("Int64")
+            return res
+
         # compute counts on the data with no nans
         data = self._data[~self._mask]
         value_counts = Index(data).value_counts()
@@ -735,9 +976,9 @@ def value_counts(self, dropna: bool = True) -> Series:
         index = index.astype(self.dtype)
 
         mask = np.zeros(len(counts), dtype="bool")
-        counts = IntegerArray(counts, mask)
+        counts_array = IntegerArray(counts, mask)
 
-        return Series(counts, index=index)
+        return Series(counts_array, index=index)
 
     @doc(ExtensionArray.equals)
     def equals(self, other) -> bool:
@@ -756,8 +997,8 @@ def equals(self, other) -> bool:
         return array_equivalent(left, right, dtype_equal=True)
 
     def _quantile(
-        self: BaseMaskedArrayT, qs: npt.NDArray[np.float64], interpolation: str
-    ) -> BaseMaskedArrayT:
+        self, qs: npt.NDArray[np.float64], interpolation: str
+    ) -> BaseMaskedArray:
         """
         Dispatch to quantile_with_mask, needed because we do not have
         _from_factorized.
@@ -766,26 +1007,38 @@ def _quantile(
         -----
         We assume that all impacted cases are 1D-only.
         """
-        mask = np.atleast_2d(np.asarray(self.isna()))
-        npvalues = np.atleast_2d(np.asarray(self))
-
         res = quantile_with_mask(
-            npvalues,
-            mask=mask,
-            fill_value=self.dtype.na_value,
+            self._data,
+            mask=self._mask,
+            # TODO(GH#40932): na_value_for_dtype(self.dtype.numpy_dtype)
+            #  instead of np.nan
+            fill_value=np.nan,
             qs=qs,
             interpolation=interpolation,
         )
-        assert res.ndim == 2
-        assert res.shape[0] == 1
-        res = res[0]
-        try:
-            out = type(self)._from_sequence(res, dtype=self.dtype)
-        except TypeError:
-            # GH#42626: not able to safely cast Int64
-            # for floating point output
-            out = np.asarray(res, dtype=np.float64)
-        return out
+
+        if self._hasna:
+            # Our result mask is all-False unless we are all-NA, in which
+            #  case it is all-True.
+            if self.ndim == 2:
+                # I think this should be out_mask=self.isna().all(axis=1)
+                #  but am holding off until we have tests
+                raise NotImplementedError
+            elif self.isna().all():
+                out_mask = np.ones(res.shape, dtype=bool)
+
+                if is_integer_dtype(self.dtype):
+                    # We try to maintain int dtype if possible for not all-na case
+                    # as well
+                    res = np.zeros(res.shape, dtype=self.dtype.numpy_dtype)
+            else:
+                out_mask = np.zeros(res.shape, dtype=bool)
+        else:
+            out_mask = np.zeros(res.shape, dtype=bool)
+        return self._maybe_mask_result(res, mask=out_mask)
+
+    # ------------------------------------------------------------------
+    # Reductions
 
     def _reduce(self, name: str, *, skipna: bool = True, **kwargs):
         if name in {"any", "all", "min", "max", "sum", "prod"}:
@@ -822,7 +1075,7 @@ def _wrap_reduction_result(self, name: str, result, skipna, **kwargs):
             else:
                 mask = self._mask.any(axis=axis)
 
-            return self._maybe_mask_result(result, mask, other=None, op_name=name)
+            return self._maybe_mask_result(result, mask)
         return result
 
     def sum(self, *, skipna=True, min_count=0, axis: int | None = 0, **kwargs):
@@ -943,7 +1196,12 @@ def any(self, *, skipna: bool = True, **kwargs):
         nv.validate_any((), kwargs)
 
         values = self._data.copy()
-        np.putmask(values, self._mask, self._falsey_value)
+        # error: Argument 3 to "putmask" has incompatible type "object";
+        # expected "Union[_SupportsArray[dtype[Any]],
+        # _NestedSequence[_SupportsArray[dtype[Any]]],
+        # bool, int, float, complex, str, bytes,
+        # _NestedSequence[Union[bool, int, float, complex, str, bytes]]]"
+        np.putmask(values, self._mask, self._falsey_value)  # type: ignore[arg-type]
         result = values.any()
         if skipna:
             return result
@@ -1019,7 +1277,12 @@ def all(self, *, skipna: bool = True, **kwargs):
         nv.validate_all((), kwargs)
 
         values = self._data.copy()
-        np.putmask(values, self._mask, self._truthy_value)
+        # error: Argument 3 to "putmask" has incompatible type "object";
+        # expected "Union[_SupportsArray[dtype[Any]],
+        # _NestedSequence[_SupportsArray[dtype[Any]]],
+        # bool, int, float, complex, str, bytes,
+        # _NestedSequence[Union[bool, int, float, complex, str, bytes]]]"
+        np.putmask(values, self._mask, self._truthy_value)  # type: ignore[arg-type]
         result = values.all()
 
         if skipna:
diff --git a/pandas/core/arrays/numeric.py b/pandas/core/arrays/numeric.py
index 2ab95b4421814..b32cbdcba1853 100644
--- a/pandas/core/arrays/numeric.py
+++ b/pandas/core/arrays/numeric.py
@@ -1,26 +1,34 @@
 from __future__ import annotations
 
-import datetime
 import numbers
 from typing import (
     TYPE_CHECKING,
+    Any,
+    Callable,
+    Mapping,
     TypeVar,
 )
 
 import numpy as np
 
 from pandas._libs import (
-    Timedelta,
+    lib,
     missing as libmissing,
 )
-from pandas.compat.numpy import function as nv
+from pandas._typing import (
+    Dtype,
+    DtypeObj,
+    npt,
+)
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly
 
 from pandas.core.dtypes.common import (
-    is_float,
+    is_bool_dtype,
     is_float_dtype,
-    is_integer,
     is_integer_dtype,
-    is_list_like,
+    is_object_dtype,
+    is_string_dtype,
     pandas_dtype,
 )
 
@@ -32,10 +40,29 @@
 if TYPE_CHECKING:
     import pyarrow
 
+
 T = TypeVar("T", bound="NumericArray")
 
 
 class NumericDtype(BaseMaskedDtype):
+    _default_np_dtype: np.dtype
+    _checker: Callable[[Any], bool]  # is_foo_dtype
+
+    def __repr__(self) -> str:
+        return f"{self.name}Dtype()"
+
+    @cache_readonly
+    def is_signed_integer(self) -> bool:
+        return self.kind == "i"
+
+    @cache_readonly
+    def is_unsigned_integer(self) -> bool:
+        return self.kind == "u"
+
+    @property
+    def _is_numeric(self) -> bool:
+        return True
+
     def __from_arrow__(
         self, array: pyarrow.Array | pyarrow.ChunkedArray
     ) -> BaseMaskedArray:
@@ -44,7 +71,9 @@ def __from_arrow__(
         """
         import pyarrow
 
-        from pandas.core.arrays._arrow_utils import pyarrow_array_to_numpy_and_mask
+        from pandas.core.arrays.arrow._arrow_utils import (
+            pyarrow_array_to_numpy_and_mask,
+        )
 
         array_class = self.construct_array_type()
 
@@ -70,7 +99,7 @@ def __from_arrow__(
 
         results = []
         for arr in chunks:
-            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype=self.type)
+            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype=self.numpy_dtype)
             num_arr = array_class(data.copy(), ~mask, copy=False)
             results.append(num_arr)
 
@@ -84,119 +113,160 @@ def __from_arrow__(
         else:
             return array_class._concat_same_type(results)
 
+    @classmethod
+    def _str_to_dtype_mapping(cls) -> Mapping[str, NumericDtype]:
+        raise AbstractMethodError(cls)
 
-class NumericArray(BaseMaskedArray):
-    """
-    Base class for IntegerArray and FloatingArray.
-    """
+    @classmethod
+    def _standardize_dtype(cls, dtype: NumericDtype | str | np.dtype) -> NumericDtype:
+        """
+        Convert a string representation or a numpy dtype to NumericDtype.
+        """
+        if isinstance(dtype, str) and (dtype.startswith(("Int", "UInt", "Float"))):
+            # Avoid DeprecationWarning from NumPy about np.dtype("Int64")
+            # https://github.com/numpy/numpy/pull/7476
+            dtype = dtype.lower()
+
+        if not isinstance(dtype, NumericDtype):
+            mapping = cls._str_to_dtype_mapping()
+            try:
+                dtype = mapping[str(np.dtype(dtype))]
+            except KeyError as err:
+                raise ValueError(f"invalid dtype specified {dtype}") from err
+        return dtype
+
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        """
+        Safely cast the values to the given dtype.
 
-    def _arith_method(self, other, op):
-        op_name = op.__name__
-        omask = None
+        "safe" in this context means the casting is lossless.
+        """
+        raise AbstractMethodError(cls)
 
-        if getattr(other, "ndim", 0) > 1:
-            raise NotImplementedError("can only perform ops with 1-d structures")
 
-        if isinstance(other, NumericArray):
-            other, omask = other._data, other._mask
+def _coerce_to_data_and_mask(values, mask, dtype, copy, dtype_cls, default_dtype):
+    checker = dtype_cls._checker
 
-        elif is_list_like(other):
-            other = np.asarray(other)
-            if other.ndim > 1:
-                raise NotImplementedError("can only perform ops with 1-d structures")
-            if len(self) != len(other):
-                raise ValueError("Lengths must match")
-            if not (is_float_dtype(other) or is_integer_dtype(other)):
-                raise TypeError("can only perform ops with numeric values")
+    inferred_type = None
 
-        elif isinstance(other, (datetime.timedelta, np.timedelta64)):
-            other = Timedelta(other)
+    if dtype is None and hasattr(values, "dtype"):
+        if checker(values.dtype):
+            dtype = values.dtype
 
-        else:
-            if not (is_float(other) or is_integer(other) or other is libmissing.NA):
-                raise TypeError("can only perform ops with numeric values")
+    if dtype is not None:
+        dtype = dtype_cls._standardize_dtype(dtype)
 
-        if omask is None:
-            mask = self._mask.copy()
-            if other is libmissing.NA:
-                mask |= True
-        else:
-            mask = self._mask | omask
-
-        if op_name == "pow":
-            # 1 ** x is 1.
-            mask = np.where((self._data == 1) & ~self._mask, False, mask)
-            # x ** 0 is 1.
-            if omask is not None:
-                mask = np.where((other == 0) & ~omask, False, mask)
-            elif other is not libmissing.NA:
-                mask = np.where(other == 0, False, mask)
-
-        elif op_name == "rpow":
-            # 1 ** x is 1.
-            if omask is not None:
-                mask = np.where((other == 1) & ~omask, False, mask)
-            elif other is not libmissing.NA:
-                mask = np.where(other == 1, False, mask)
-            # x ** 0 is 1.
-            mask = np.where((self._data == 0) & ~self._mask, False, mask)
-
-        if other is libmissing.NA:
-            result = np.ones_like(self._data)
-            if "truediv" in op_name and self.dtype.kind != "f":
-                # The actual data here doesn't matter since the mask
-                #  will be all-True, but since this is division, we want
-                #  to end up with floating dtype.
-                result = result.astype(np.float64)
-        else:
-            with np.errstate(all="ignore"):
-                result = op(self._data, other)
-
-        # divmod returns a tuple
-        if op_name == "divmod":
-            div, mod = result
-            return (
-                self._maybe_mask_result(div, mask, other, "floordiv"),
-                self._maybe_mask_result(mod, mask, other, "mod"),
-            )
+    cls = dtype_cls.construct_array_type()
+    if isinstance(values, cls):
+        values, mask = values._data, values._mask
+        if dtype is not None:
+            values = values.astype(dtype.numpy_dtype, copy=False)
 
-        return self._maybe_mask_result(result, mask, other, op_name)
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+        return values, mask, dtype, inferred_type
 
-    _HANDLED_TYPES = (np.ndarray, numbers.Number)
+    values = np.array(values, copy=copy)
+    inferred_type = None
+    if is_object_dtype(values.dtype) or is_string_dtype(values.dtype):
+        inferred_type = lib.infer_dtype(values, skipna=True)
+        if inferred_type == "empty":
+            pass
+        elif inferred_type == "boolean":
+            name = dtype_cls.__name__.strip("_")
+            raise TypeError(f"{values.dtype} cannot be converted to {name}")
 
-    def __neg__(self):
-        return type(self)(-self._data, self._mask.copy())
+    elif is_bool_dtype(values) and checker(dtype):
+        values = np.array(values, dtype=default_dtype, copy=copy)
 
-    def __pos__(self):
-        return self.copy()
+    elif not (is_integer_dtype(values) or is_float_dtype(values)):
+        name = dtype_cls.__name__.strip("_")
+        raise TypeError(f"{values.dtype} cannot be converted to {name}")
 
-    def __abs__(self):
-        return type(self)(abs(self._data), self._mask.copy())
+    if values.ndim != 1:
+        raise TypeError("values must be a 1D list-like")
 
-    def round(self: T, decimals: int = 0, *args, **kwargs) -> T:
-        """
-        Round each value in the array a to the given number of decimals.
-
-        Parameters
-        ----------
-        decimals : int, default 0
-            Number of decimal places to round to. If decimals is negative,
-            it specifies the number of positions to the left of the decimal point.
-        *args, **kwargs
-            Additional arguments and keywords have no effect but might be
-            accepted for compatibility with NumPy.
-
-        Returns
-        -------
-        NumericArray
-            Rounded values of the NumericArray.
-
-        See Also
-        --------
-        numpy.around : Round values of an np.array.
-        DataFrame.round : Round values of a DataFrame.
-        Series.round : Round values of a Series.
-        """
-        nv.validate_round(args, kwargs)
-        values = np.round(self._data, decimals=decimals, **kwargs)
-        return type(self)(values, self._mask.copy())
+    if mask is None:
+        mask = libmissing.is_numeric_na(values)
+    else:
+        assert len(mask) == len(values)
+
+    if mask.ndim != 1:
+        raise TypeError("mask must be a 1D list-like")
+
+    # infer dtype if needed
+    if dtype is None:
+        dtype = default_dtype
+    else:
+        dtype = dtype.type
+
+    # we copy as need to coerce here
+    if mask.any():
+        values = values.copy()
+        values[mask] = cls._internal_fill_value
+    if inferred_type in ("string", "unicode"):
+        # casts from str are always safe since they raise
+        # a ValueError if the str cannot be parsed into a float
+        values = values.astype(dtype, copy=copy)
+    else:
+        values = dtype_cls._safe_cast(values, dtype, copy=False)
+
+    return values, mask, dtype, inferred_type
+
+
+class NumericArray(BaseMaskedArray):
+    """
+    Base class for IntegerArray and FloatingArray.
+    """
+
+    _dtype_cls: type[NumericDtype]
+
+    def __init__(
+        self, values: np.ndarray, mask: npt.NDArray[np.bool_], copy: bool = False
+    ) -> None:
+        checker = self._dtype_cls._checker
+        if not (isinstance(values, np.ndarray) and checker(values.dtype)):
+            descr = (
+                "floating"
+                if self._dtype_cls.kind == "f"  # type: ignore[comparison-overlap]
+                else "integer"
+            )
+            raise TypeError(
+                f"values should be {descr} numpy array. Use "
+                "the 'pd.array' function instead"
+            )
+        if values.dtype == np.float16:
+            # If we don't raise here, then accessing self.dtype would raise
+            raise TypeError("FloatingArray does not support np.float16 dtype.")
+
+        super().__init__(values, mask, copy=copy)
+
+    @cache_readonly
+    def dtype(self) -> NumericDtype:
+        mapping = self._dtype_cls._str_to_dtype_mapping()
+        return mapping[str(self._data.dtype)]
+
+    @classmethod
+    def _coerce_to_array(
+        cls, value, *, dtype: DtypeObj, copy: bool = False
+    ) -> tuple[np.ndarray, np.ndarray]:
+        dtype_cls = cls._dtype_cls
+        default_dtype = dtype_cls._default_np_dtype
+        mask = None
+        values, mask, _, _ = _coerce_to_data_and_mask(
+            value, mask, dtype, copy, dtype_cls, default_dtype
+        )
+        return values, mask
+
+    @classmethod
+    def _from_sequence_of_strings(
+        cls: type[T], strings, *, dtype: Dtype | None = None, copy: bool = False
+    ) -> T:
+        from pandas.core.tools.numeric import to_numeric
+
+        scalars = to_numeric(strings, errors="raise")
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
+
+    _HANDLED_TYPES = (np.ndarray, numbers.Number)
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index ddb36f5ef01d0..36c67d2fe1225 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -61,11 +61,12 @@ class PandasArray(
     __array_priority__ = 1000
     _ndarray: np.ndarray
     _dtype: PandasDtype
+    _internal_fill_value = np.nan
 
     # ------------------------------------------------------------------------
     # Constructors
 
-    def __init__(self, values: np.ndarray | PandasArray, copy: bool = False):
+    def __init__(self, values: np.ndarray | PandasArray, copy: bool = False) -> None:
         if isinstance(values, type(self)):
             values = values._ndarray
         if not isinstance(values, np.ndarray):
@@ -108,10 +109,6 @@ def _from_sequence(
             result = result.copy()
         return cls(result)
 
-    @classmethod
-    def _from_factorized(cls, values, original) -> PandasArray:
-        return cls(values)
-
     def _from_backing_data(self, arr: np.ndarray) -> PandasArray:
         return type(self)(arr)
 
@@ -141,6 +138,12 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
         if result is not NotImplemented:
             return result
 
+        if "out" in kwargs:
+            # e.g. test_ufunc_unary
+            return arraylike.dispatch_ufunc_with_out(
+                self, ufunc, method, *inputs, **kwargs
+            )
+
         if method == "reduce":
             result = arraylike.dispatch_reduction_ufunc(
                 self, ufunc, method, *inputs, **kwargs
@@ -186,8 +189,12 @@ def _validate_scalar(self, fill_value):
             fill_value = self.dtype.na_value
         return fill_value
 
-    def _values_for_factorize(self) -> tuple[np.ndarray, int]:
-        return self._ndarray, -1
+    def _values_for_factorize(self) -> tuple[np.ndarray, float | None]:
+        if self.dtype.kind in ["i", "u", "b"]:
+            fv = None
+        else:
+            fv = np.nan
+        return self._ndarray, fv
 
     # ------------------------------------------------------------------------
     # Reductions
@@ -361,7 +368,7 @@ def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         result = np.asarray(self._ndarray, dtype=dtype)
 
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 487b51735bd4e..e6ea7b0879100 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -8,19 +8,25 @@
     Callable,
     Literal,
     Sequence,
+    TypeVar,
+    overload,
 )
 
 import numpy as np
 
-from pandas._libs import algos as libalgos
+from pandas._libs import (
+    algos as libalgos,
+    lib,
+)
 from pandas._libs.arrays import NDArrayBacked
 from pandas._libs.tslibs import (
     BaseOffset,
     NaT,
     NaTType,
     Timedelta,
-    delta_to_nanoseconds,
+    astype_overflowsafe,
     dt64arr_to_periodarr as c_dt64arr_to_periodarr,
+    get_unit_from_dtype,
     iNaT,
     parsing,
     period as libperiod,
@@ -51,7 +57,6 @@
 )
 
 from pandas.core.dtypes.common import (
-    TD64NS_DTYPE,
     ensure_object,
     is_datetime64_any_dtype,
     is_datetime64_dtype,
@@ -68,14 +73,10 @@
     ABCSeries,
     ABCTimedeltaArray,
 )
-from pandas.core.dtypes.missing import (
-    isna,
-    notna,
-)
+from pandas.core.dtypes.missing import isna
 
 import pandas.core.algorithms as algos
 from pandas.core.arrays import datetimelike as dtl
-from pandas.core.arrays.base import ExtensionArray
 import pandas.core.common as com
 
 if TYPE_CHECKING:
@@ -85,7 +86,14 @@
         NumpyValueArrayLike,
     )
 
-    from pandas.core.arrays import DatetimeArray
+    from pandas.core.arrays import (
+        DatetimeArray,
+        TimedeltaArray,
+    )
+    from pandas.core.arrays.base import ExtensionArray
+
+
+BaseOffsetT = TypeVar("BaseOffsetT", bound=BaseOffset)
 
 
 _shared_doc_kwargs = {
@@ -104,7 +112,7 @@ def f(self):
     return property(f)
 
 
-class PeriodArray(dtl.DatelikeOps):
+class PeriodArray(dtl.DatelikeOps, libperiod.PeriodMixin):
     """
     Pandas ExtensionArray for storing Period data.
 
@@ -162,11 +170,15 @@ class PeriodArray(dtl.DatelikeOps):
     # array priority higher than numpy scalars
     __array_priority__ = 1000
     _typ = "periodarray"  # ABCPeriodArray
-    _scalar_type = Period
+    _internal_fill_value = np.int64(iNaT)
     _recognized_scalars = (Period,)
     _is_recognized_dtype = is_period_dtype
     _infer_matches = ("period",)
 
+    @property
+    def _scalar_type(self) -> type[Period]:
+        return Period
+
     # Names others delegate to us
     _other_ops: list[str] = []
     _bool_ops: list[str] = ["is_leap_year"]
@@ -200,7 +212,7 @@ class PeriodArray(dtl.DatelikeOps):
 
     def __init__(
         self, values, dtype: Dtype | None = None, freq=None, copy: bool = False
-    ):
+    ) -> None:
         freq = validate_dtype_freq(dtype, freq)
 
         if freq is not None:
@@ -365,7 +377,7 @@ def __arrow_array__(self, type=None):
         """
         import pyarrow
 
-        from pandas.core.arrays._arrow_utils import ArrowPeriodType
+        from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
         if type is not None:
             if pyarrow.types.is_integer(type):
@@ -499,7 +511,7 @@ def to_timestamp(self, freq=None, how: str = "start") -> DatetimeArray:
                 return (self + self.freq).to_timestamp(how="start") - adjust
 
         if freq is None:
-            freq = self._get_to_timestamp_base()
+            freq = self._dtype._get_to_timestamp_base()
             base = freq
         else:
             freq = Period._maybe_convert_freq(freq)
@@ -547,10 +559,7 @@ def _time_shift(self, periods: int, freq=None) -> PeriodArray:
                 "`freq` argument is not supported for "
                 f"{type(self).__name__}._time_shift"
             )
-        values = self.asi8 + periods * self.freq.n
-        if self._hasnans:
-            values[self._isnan] = iNaT
-        return type(self)(values, freq=self.freq)
+        return self + periods
 
     def _box_func(self, x) -> Period | NaTType:
         return Period._from_ordinal(ordinal=x, freq=self.freq)
@@ -605,7 +614,7 @@ def asfreq(self, freq=None, how: str = "E") -> PeriodArray:
 
         freq = Period._maybe_convert_freq(freq)
 
-        base1 = self.freq._period_dtype_code
+        base1 = self._dtype._dtype_code
         base2 = freq._period_dtype_code
 
         asi8 = self.asi8
@@ -618,7 +627,7 @@ def asfreq(self, freq=None, how: str = "E") -> PeriodArray:
 
         new_data = period_asfreq_arr(ordinal, base1, base2, end)
 
-        if self._hasnans:
+        if self._hasna:
             new_data[self._isnan] = iNaT
 
         return type(self)(new_data, freq=freq)
@@ -634,24 +643,27 @@ def _formatter(self, boxed: bool = False):
     @dtl.ravel_compat
     def _format_native_types(
         self, *, na_rep="NaT", date_format=None, **kwargs
-    ) -> np.ndarray:
+    ) -> npt.NDArray[np.object_]:
         """
         actually format my specific types
         """
         values = self.astype(object)
 
+        # Create the formatter function
         if date_format:
-            formatter = lambda dt: dt.strftime(date_format)
+            formatter = lambda per: per.strftime(date_format)
         else:
-            formatter = lambda dt: str(dt)
+            # Uses `_Period.str` which in turn uses `format_period`
+            formatter = lambda per: str(per)
 
-        if self._hasnans:
+        # Apply the formatter to all values in the array, possibly with a mask
+        if self._hasna:
             mask = self._isnan
             values[mask] = na_rep
             imask = ~mask
-            values[imask] = np.array([formatter(dt) for dt in values[imask]])
+            values[imask] = np.array([formatter(per) for per in values[imask]])
         else:
-            values = np.array([formatter(dt) for dt in values])
+            values = np.array([formatter(per) for per in values])
         return values
 
     # ------------------------------------------------------------------
@@ -697,55 +709,22 @@ def fillna(self, value=None, method=None, limit=None) -> PeriodArray:
             return result.view(self.dtype)  # type: ignore[return-value]
         return super().fillna(value=value, method=method, limit=limit)
 
+    def _quantile(
+        self: PeriodArray,
+        qs: npt.NDArray[np.float64],
+        interpolation: str,
+    ) -> PeriodArray:
+        # dispatch to DatetimeArray implementation
+        dtres = self.view("M8[ns]")._quantile(qs, interpolation)
+        # error: Incompatible return value type (got "Union[ExtensionArray,
+        # ndarray[Any, Any]]", expected "PeriodArray")
+        return dtres.view(self.dtype)  # type: ignore[return-value]
+
     # ------------------------------------------------------------------
     # Arithmetic Methods
 
-    def _sub_datelike(self, other):
-        assert other is not NaT
-        return NotImplemented
-
-    def _sub_period(self, other):
-        # If the operation is well-defined, we return an object-Index
-        # of DateOffsets.  Null entries are filled with pd.NaT
-        self._check_compatible_with(other)
-        asi8 = self.asi8
-        new_data = asi8 - other.ordinal
-        new_data = np.array([self.freq * x for x in new_data])
-
-        if self._hasnans:
-            new_data[self._isnan] = NaT
-
-        return new_data
-
-    def _sub_period_array(self, other):
-        """
-        Subtract a Period Array/Index from self.  This is only valid if self
-        is itself a Period Array/Index, raises otherwise.  Both objects must
-        have the same frequency.
-
-        Parameters
-        ----------
-        other : PeriodIndex or PeriodArray
-
-        Returns
-        -------
-        result : np.ndarray[object]
-            Array of DateOffset objects; nulls represented by NaT.
-        """
-        self._require_matching_freq(other)
-
-        new_values = algos.checked_add_with_arr(
-            self.asi8, -other.asi8, arr_mask=self._isnan, b_mask=other._isnan
-        )
-
-        new_values = np.array([self.freq.base * x for x in new_values])
-        if self._hasnans or other._hasnans:
-            mask = self._isnan | other._isnan
-            new_values[mask] = NaT
-        return new_values
-
-    def _addsub_int_array(
-        self, other: np.ndarray, op: Callable[[Any, Any], Any]
+    def _addsub_int_array_or_scalar(
+        self, other: np.ndarray | int, op: Callable[[Any, Any], Any]
     ) -> PeriodArray:
         """
         Add or subtract array of integers; equivalent to applying
@@ -753,7 +732,7 @@ def _addsub_int_array(
 
         Parameters
         ----------
-        other : np.ndarray[integer-dtype]
+        other : np.ndarray[int64] or int
         op : {operator.add, operator.sub}
 
         Returns
@@ -764,21 +743,15 @@ def _addsub_int_array(
         if op is operator.sub:
             other = -other
         res_values = algos.checked_add_with_arr(self.asi8, other, arr_mask=self._isnan)
-        res_values = res_values.view("i8")
-        np.putmask(res_values, self._isnan, iNaT)
         return type(self)(res_values, freq=self.freq)
 
     def _add_offset(self, other: BaseOffset):
         assert not isinstance(other, Tick)
 
         self._require_matching_freq(other, base=True)
+        return self._addsub_int_array_or_scalar(other.n, operator.add)
 
-        # Note: when calling parent class's _add_timedeltalike_scalar,
-        #  it will call delta_to_nanoseconds(delta).  Because delta here
-        #  is an integer, delta_to_nanoseconds will return it unchanged.
-        result = super()._add_timedeltalike_scalar(other.n)
-        return type(self)(result, freq=self.freq)
-
+    # TODO: can we de-duplicate with Period._add_timedeltalike_scalar?
     def _add_timedeltalike_scalar(self, other):
         """
         Parameters
@@ -793,17 +766,16 @@ def _add_timedeltalike_scalar(self, other):
             # We cannot add timedelta-like to non-tick PeriodArray
             raise raise_on_incompatible(self, other)
 
-        if notna(other):
-            # special handling for np.timedelta64("NaT"), avoid calling
-            #  _check_timedeltalike_freq_compat as that would raise TypeError
-            other = self._check_timedeltalike_freq_compat(other)
+        if isna(other):
+            # i.e. np.timedelta64("NaT")
+            return super()._add_timedeltalike_scalar(other)
 
-        # Note: when calling parent class's _add_timedeltalike_scalar,
-        #  it will call delta_to_nanoseconds(delta).  Because delta here
-        #  is an integer, delta_to_nanoseconds will return it unchanged.
-        return super()._add_timedeltalike_scalar(other)
+        td = np.asarray(Timedelta(other).asm8)
+        return self._add_timedelta_arraylike(td)
 
-    def _add_timedelta_arraylike(self, other):
+    def _add_timedelta_arraylike(
+        self, other: TimedeltaArray | npt.NDArray[np.timedelta64]
+    ) -> PeriodArray:
         """
         Parameters
         ----------
@@ -811,22 +783,36 @@ def _add_timedelta_arraylike(self, other):
 
         Returns
         -------
-        result : ndarray[int64]
+        PeriodArray
         """
-        if not isinstance(self.freq, Tick):
+        freq = self.freq
+        if not isinstance(freq, Tick):
             # We cannot add timedelta-like to non-tick PeriodArray
             raise TypeError(
                 f"Cannot add or subtract timedelta64[ns] dtype from {self.dtype}"
             )
 
-        if not np.all(isna(other)):
-            delta = self._check_timedeltalike_freq_compat(other)
-        else:
-            # all-NaT TimedeltaIndex is equivalent to a single scalar td64 NaT
-            return self + np.timedelta64("NaT")
+        dtype = np.dtype(f"m8[{freq._td64_unit}]")
 
-        ordinals = self._addsub_int_array(delta, operator.add).asi8
-        return type(self)(ordinals, dtype=self.dtype)
+        try:
+            delta = astype_overflowsafe(
+                np.asarray(other), dtype=dtype, copy=False, round_ok=False
+            )
+        except ValueError as err:
+            # e.g. if we have minutes freq and try to add 30s
+            # "Cannot losslessly convert units"
+            raise IncompatibleFrequency(
+                "Cannot add/subtract timedelta-like from PeriodArray that is "
+                "not an integer multiple of the PeriodArray's freq."
+            ) from err
+
+        b_mask = np.isnat(delta)
+
+        res_values = algos.checked_add_with_arr(
+            self.asi8, delta.view("i8"), arr_mask=self._isnan, b_mask=b_mask
+        )
+        np.putmask(res_values, self._isnan | b_mask, iNaT)
+        return type(self)(res_values, freq=self.freq)
 
     def _check_timedeltalike_freq_compat(self, other):
         """
@@ -849,82 +835,21 @@ def _check_timedeltalike_freq_compat(self, other):
         IncompatibleFrequency
         """
         assert isinstance(self.freq, Tick)  # checked by calling function
-        base_nanos = self.freq.base.nanos
-
-        if isinstance(other, (timedelta, np.timedelta64, Tick)):
-            nanos = delta_to_nanoseconds(other)
-
-        elif isinstance(other, np.ndarray):
-            # numpy timedelta64 array; all entries must be compatible
-            assert other.dtype.kind == "m"
-            if other.dtype != TD64NS_DTYPE:
-                # i.e. non-nano unit
-                # TODO: disallow unit-less timedelta64
-                other = other.astype(TD64NS_DTYPE)
-            nanos = other.view("i8")
-        else:
-            # TimedeltaArray/Index
-            nanos = other.asi8
-
-        if np.all(nanos % base_nanos == 0):
-            # nanos being added is an integer multiple of the
-            #  base-frequency to self.freq
-            delta = nanos // base_nanos
-            # delta is the integer (or integer-array) number of periods
-            # by which will be added to self.
-            return delta
-
-        raise raise_on_incompatible(self, other)
-
-    # ------------------------------------------------------------------
-    # TODO: See if we can re-share this with Period
-
-    def _get_to_timestamp_base(self) -> int:
-        """
-        Return frequency code group used for base of to_timestamp against
-        frequency code.
-
-        Return day freq code against longer freq than day.
-        Return second freq code against hour between second.
 
-        Returns
-        -------
-        int
-        """
-        base = self._dtype._dtype_code
-        if base < FreqGroup.FR_BUS.value:
-            return FreqGroup.FR_DAY.value
-        elif FreqGroup.FR_HR.value <= base <= FreqGroup.FR_SEC.value:
-            return FreqGroup.FR_SEC.value
-        return base
-
-    @property
-    def start_time(self) -> DatetimeArray:
-        return self.to_timestamp(how="start")
-
-    @property
-    def end_time(self) -> DatetimeArray:
-        return self.to_timestamp(how="end")
+        dtype = np.dtype(f"m8[{self.freq._td64_unit}]")
 
-    def _require_matching_freq(self, other, base: bool = False) -> None:
-        # See also arrays.period.raise_on_incompatible
-        if isinstance(other, BaseOffset):
-            other_freq = other
+        if isinstance(other, (timedelta, np.timedelta64, Tick)):
+            td = np.asarray(Timedelta(other).asm8)
         else:
-            other_freq = other.freq
+            td = np.asarray(other)
 
-        if base:
-            condition = self.freq.base != other_freq.base
-        else:
-            condition = self.freq != other_freq
+        try:
+            delta = astype_overflowsafe(td, dtype=dtype, copy=False, round_ok=False)
+        except ValueError as err:
+            raise raise_on_incompatible(self, other) from err
 
-        if condition:
-            msg = DIFFERENT_FREQ.format(
-                cls=type(self).__name__,
-                own_freq=self.freqstr,
-                other_freq=other_freq.freqstr,
-            )
-            raise IncompatibleFrequency(msg)
+        delta = delta.view("i8")
+        return lib.item_from_zerodim(delta)
 
 
 def raise_on_incompatible(left, right):
@@ -1042,7 +967,9 @@ def period_array(
 
     if is_integer_dtype(arrdata.dtype):
         arr = arrdata.astype(np.int64, copy=False)
-        ordinals = libperiod.from_ordinals(arr, freq)
+        # error: Argument 2 to "from_ordinals" has incompatible type "Union[str,
+        # Tick, None]"; expected "Union[timedelta, BaseOffset, str]"
+        ordinals = libperiod.from_ordinals(arr, freq)  # type: ignore[arg-type]
         return PeriodArray(ordinals, dtype=dtype)
 
     data = ensure_object(arrdata)
@@ -1050,7 +977,19 @@ def period_array(
     return PeriodArray._from_sequence(data, dtype=dtype)
 
 
-def validate_dtype_freq(dtype, freq):
+@overload
+def validate_dtype_freq(dtype, freq: BaseOffsetT) -> BaseOffsetT:
+    ...
+
+
+@overload
+def validate_dtype_freq(dtype, freq: timedelta | str | None) -> BaseOffset:
+    ...
+
+
+def validate_dtype_freq(
+    dtype, freq: BaseOffsetT | timedelta | str | None
+) -> BaseOffsetT:
     """
     If both a dtype and a freq are available, ensure they match.  If only
     dtype is available, extract the implied freq.
@@ -1070,7 +1009,10 @@ def validate_dtype_freq(dtype, freq):
     IncompatibleFrequency : mismatch between dtype and freq
     """
     if freq is not None:
-        freq = to_offset(freq)
+        # error: Incompatible types in assignment (expression has type
+        # "BaseOffset", variable has type "Union[BaseOffsetT, timedelta,
+        # str, None]")
+        freq = to_offset(freq)  # type: ignore[assignment]
 
     if dtype is not None:
         dtype = pandas_dtype(dtype)
@@ -1080,10 +1022,14 @@ def validate_dtype_freq(dtype, freq):
             freq = dtype.freq
         elif freq != dtype.freq:
             raise IncompatibleFrequency("specified freq and dtype are different")
-    return freq
+    # error: Incompatible return value type (got "Union[BaseOffset, Any, None]",
+    # expected "BaseOffset")
+    return freq  # type: ignore[return-value]
 
 
-def dt64arr_to_periodarr(data, freq, tz=None):
+def dt64arr_to_periodarr(
+    data, freq, tz=None
+) -> tuple[npt.NDArray[np.int64], BaseOffset]:
     """
     Convert an datetime-like array to values Period ordinals.
 
@@ -1103,7 +1049,7 @@ def dt64arr_to_periodarr(data, freq, tz=None):
         used.
 
     """
-    if data.dtype != np.dtype("M8[ns]"):
+    if not isinstance(data.dtype, np.dtype) or data.dtype.kind != "M":
         raise ValueError(f"Wrong dtype: {data.dtype}")
 
     if freq is None:
@@ -1115,9 +1061,10 @@ def dt64arr_to_periodarr(data, freq, tz=None):
     elif isinstance(data, (ABCIndex, ABCSeries)):
         data = data._values
 
+    reso = get_unit_from_dtype(data.dtype)
     freq = Period._maybe_convert_freq(freq)
     base = freq._period_dtype_code
-    return c_dt64arr_to_periodarr(data.view("i8"), base, tz), freq
+    return c_dt64arr_to_periodarr(data.view("i8"), base, tz, reso=reso), freq
 
 
 def _get_ordinal_range(start, end, periods, freq, mult=1):
diff --git a/pandas/core/arrays/sparse/__init__.py b/pandas/core/arrays/sparse/__init__.py
index 18294ead0329d..56dbc6df54fc9 100644
--- a/pandas/core/arrays/sparse/__init__.py
+++ b/pandas/core/arrays/sparse/__init__.py
@@ -1,5 +1,3 @@
-# flake8: noqa: F401
-
 from pandas.core.arrays.sparse.accessor import (
     SparseAccessor,
     SparseFrameAccessor,
@@ -11,3 +9,13 @@
     make_sparse_index,
 )
 from pandas.core.arrays.sparse.dtype import SparseDtype
+
+__all__ = [
+    "BlockIndex",
+    "IntIndex",
+    "make_sparse_index",
+    "SparseAccessor",
+    "SparseArray",
+    "SparseDtype",
+    "SparseFrameAccessor",
+]
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index 8e61460e3fe0b..f1e4412ff8cd8 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -1,4 +1,7 @@
 """Sparse accessor"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -13,11 +16,17 @@
 from pandas.core.arrays.sparse.array import SparseArray
 from pandas.core.arrays.sparse.dtype import SparseDtype
 
+if TYPE_CHECKING:
+    from pandas import (
+        DataFrame,
+        Series,
+    )
+
 
 class BaseAccessor:
     _validation_msg = "Can only use the '.sparse' accessor with Sparse data."
 
-    def __init__(self, data=None):
+    def __init__(self, data=None) -> None:
         self._parent = data
         self._validate(data)
 
@@ -49,7 +58,7 @@ def _delegate_method(self, name, *args, **kwargs):
             raise ValueError
 
     @classmethod
-    def from_coo(cls, A, dense_index=False):
+    def from_coo(cls, A, dense_index=False) -> Series:
         """
         Create a Series with sparse values from a scipy.sparse.coo_matrix.
 
@@ -180,7 +189,7 @@ def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels=False):
         )
         return A, rows, columns
 
-    def to_dense(self):
+    def to_dense(self) -> Series:
         """
         Convert a Series from sparse values to dense.
 
@@ -228,7 +237,7 @@ def _validate(self, data):
             raise AttributeError(self._validation_msg)
 
     @classmethod
-    def from_spmatrix(cls, data, index=None, columns=None):
+    def from_spmatrix(cls, data, index=None, columns=None) -> DataFrame:
         """
         Create a new DataFrame from a scipy sparse matrix.
 
@@ -284,7 +293,7 @@ def from_spmatrix(cls, data, index=None, columns=None):
             arrays, columns=columns, index=index, verify_integrity=False
         )
 
-    def to_dense(self):
+    def to_dense(self) -> DataFrame:
         """
         Convert a DataFrame with sparse values to dense.
 
@@ -339,7 +348,7 @@ def to_coo(self):
             dtype = dtype.subtype
 
         cols, rows, data = [], [], []
-        for col, (_, ser) in enumerate(self._parent.iteritems()):
+        for col, (_, ser) in enumerate(self._parent.items()):
             sp_arr = ser.array
             if sp_arr.fill_value != 0:
                 raise ValueError("fill value must be 0 when converting to COO matrix")
@@ -360,7 +369,8 @@ def density(self) -> float:
         Ratio of non-sparse points to total (dense) data points.
         """
         tmp = np.mean([column.array.density for _, column in self._parent.items()])
-        return tmp
+        # error: Expression of type "floating" cannot be assigned to return type "float"
+        return tmp  # pyright: ignore[reportGeneralTypeIssues]
 
     @staticmethod
     def _prep_index(data, index, columns):
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index c861abfc7920d..62ae6163a073e 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -42,10 +42,13 @@
 from pandas.compat.numpy import function as nv
 from pandas.errors import PerformanceWarning
 from pandas.util._exceptions import find_stack_level
-from pandas.util._validators import validate_insert_loc
+from pandas.util._validators import (
+    validate_bool_kwarg,
+    validate_insert_loc,
+)
 
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.cast import (
-    astype_nansafe,
     construct_1d_arraylike_from_scalar,
     find_common_type,
     maybe_box_datetimelike,
@@ -75,6 +78,7 @@
 
 from pandas.core import arraylike
 import pandas.core.algorithms as algos
+from pandas.core.array_algos.quantile import quantile_with_mask
 from pandas.core.arraylike import OpsMixin
 from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.sparse.dtype import SparseDtype
@@ -298,7 +302,7 @@ class SparseArray(OpsMixin, PandasObject, ExtensionArray):
             repeats of the scalar value instead.
 
     fill_value : scalar, optional
-        Elements in `data` that are `fill_value` are not stored in the
+        Elements in data that are ``fill_value`` are not stored in the
         SparseArray. For memory savings, this should be the most common value
         in `data`. By default, `fill_value` depends on the dtype of `data`:
 
@@ -361,6 +365,8 @@ class SparseArray(OpsMixin, PandasObject, ExtensionArray):
     _subtyp = "sparse_array"  # register ABCSparseArray
     _hidden_attrs = PandasObject._hidden_attrs | frozenset(["get_values"])
     _sparse_index: SparseIndex
+    _sparse_values: np.ndarray
+    _dtype: SparseDtype
 
     def __init__(
         self,
@@ -371,7 +377,7 @@ def __init__(
         kind: SparseIndexKind = "integer",
         dtype: Dtype | None = None,
         copy: bool = False,
-    ):
+    ) -> None:
 
         if fill_value is None and isinstance(dtype, SparseDtype):
             fill_value = dtype.fill_value
@@ -722,7 +728,7 @@ def isna(self):
         dtype = SparseDtype(bool, self._null_fill_value)
         if self._null_fill_value:
             return type(self)._simple_new(isna(self.sp_values), self.sp_index, dtype)
-        mask = np.full(len(self), False, dtype=np.bool8)
+        mask = np.full(len(self), False, dtype=np.bool_)
         mask[self.sp_index.indices] = isna(self.sp_values)
         return type(self)(mask, fill_value=False, dtype=dtype)
 
@@ -771,7 +777,11 @@ def fillna(
 
         elif method is not None:
             msg = "fillna with 'method' requires high memory usage."
-            warnings.warn(msg, PerformanceWarning)
+            warnings.warn(
+                msg,
+                PerformanceWarning,
+                stacklevel=find_stack_level(),
+            )
             new_values = np.asarray(self)
             # interpolate_2d modifies new_values inplace
             interpolate_2d(new_values, method=method, limit=limit)
@@ -818,7 +828,7 @@ def shift(self: SparseArrayT, periods: int = 1, fill_value=None) -> SparseArrayT
 
     def _first_fill_value_loc(self):
         """
-        Get the location of the first missing value.
+        Get the location of the first fill value.
 
         Returns
         -------
@@ -831,27 +841,47 @@ def _first_fill_value_loc(self):
         if not len(indices) or indices[0] > 0:
             return 0
 
-        diff = indices[1:] - indices[:-1]
-        return np.searchsorted(diff, 2) + 1
+        # a number larger than 1 should be appended to
+        # the last in case of fill value only appears
+        # in the tail of array
+        diff = np.r_[np.diff(indices), 2]
+        return indices[(diff > 1).argmax()] + 1
 
     def unique(self: SparseArrayT) -> SparseArrayT:
-        uniques = list(algos.unique(self.sp_values))
-        fill_loc = self._first_fill_value_loc()
-        if fill_loc >= 0:
-            uniques.insert(fill_loc, self.fill_value)
+        uniques = algos.unique(self.sp_values)
+        if len(self.sp_values) != len(self):
+            fill_loc = self._first_fill_value_loc()
+            # Inorder to align the behavior of pd.unique or
+            # pd.Series.unique, we should keep the original
+            # order, here we use unique again to find the
+            # insertion place. Since the length of sp_values
+            # is not large, maybe minor performance hurt
+            # is worthwhile to the correctness.
+            insert_loc = len(algos.unique(self.sp_values[:fill_loc]))
+            uniques = np.insert(uniques, insert_loc, self.fill_value)
         return type(self)._from_sequence(uniques, dtype=self.dtype)
 
     def _values_for_factorize(self):
         # Still override this for hash_pandas_object
         return np.asarray(self), self.fill_value
 
-    def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, SparseArray]:
+    def factorize(
+        self,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
+    ) -> tuple[np.ndarray, SparseArray]:
         # Currently, ExtensionArray.factorize -> Tuple[ndarray, EA]
         # The sparsity on this is backwards from what Sparse would want. Want
         # ExtensionArray.factorize -> Tuple[EA, EA]
         # Given that we have to return a dense array of codes, why bother
         # implementing an efficient factorize?
-        codes, uniques = algos.factorize(np.asarray(self), na_sentinel=na_sentinel)
+        codes, uniques = algos.factorize(
+            np.asarray(self), na_sentinel=na_sentinel, use_na_sentinel=use_na_sentinel
+        )
+        if na_sentinel is lib.no_default:
+            na_sentinel = -1
+        if use_na_sentinel is lib.no_default or use_na_sentinel:
+            codes[codes == -1] = na_sentinel
         uniques_sp = SparseArray(uniques, dtype=self.dtype)
         return codes, uniques_sp
 
@@ -880,18 +910,43 @@ def value_counts(self, dropna: bool = True) -> Series:
             if mask.any():
                 counts[mask] += fcounts
             else:
-                keys = np.insert(keys, 0, self.fill_value)
+                # error: Argument 1 to "insert" has incompatible type "Union[
+                # ExtensionArray,ndarray[Any, Any]]"; expected "Union[
+                # _SupportsArray[dtype[Any]], Sequence[_SupportsArray[dtype
+                # [Any]]], Sequence[Sequence[_SupportsArray[dtype[Any]]]],
+                # Sequence[Sequence[Sequence[_SupportsArray[dtype[Any]]]]], Sequence
+                # [Sequence[Sequence[Sequence[_SupportsArray[dtype[Any]]]]]]]"
+                keys = np.insert(keys, 0, self.fill_value)  # type: ignore[arg-type]
                 counts = np.insert(counts, 0, fcounts)
 
         if not isinstance(keys, ABCIndex):
-            keys = Index(keys)
-        return Series(counts, index=keys)
+            index = Index(keys)
+        else:
+            index = keys
+        return Series(counts, index=index)
 
     def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str):
+
+        if self._null_fill_value or self.sp_index.ngaps == 0:
+            # We can avoid densifying
+            npvalues = self.sp_values
+            mask = np.zeros(npvalues.shape, dtype=bool)
+        else:
+            npvalues = self.to_numpy()
+            mask = self.isna()
+
+        fill_value = na_value_for_dtype(npvalues.dtype, compat=False)
+        res_values = quantile_with_mask(
+            npvalues,
+            mask,
+            fill_value,
+            qs,
+            interpolation,
+        )
+
         # Special case: the returned array isn't _really_ sparse, so we don't
         #  wrap it in a SparseArray
-        result = super()._quantile(qs, interpolation)
-        return np.asarray(result)
+        return res_values
 
     # --------
     # Indexing
@@ -924,7 +979,16 @@ def __getitem__(
         if is_integer(key):
             return self._get_val_at(key)
         elif isinstance(key, tuple):
-            data_slice = self.to_dense()[key]
+            # error: Invalid index type "Tuple[Union[int, ellipsis], ...]"
+            # for "ndarray[Any, Any]"; expected type
+            # "Union[SupportsIndex, _SupportsArray[dtype[Union[bool_,
+            # integer[Any]]]], _NestedSequence[_SupportsArray[dtype[
+            # Union[bool_, integer[Any]]]]], _NestedSequence[Union[
+            # bool, int]], Tuple[Union[SupportsIndex, _SupportsArray[
+            # dtype[Union[bool_, integer[Any]]]], _NestedSequence[
+            # _SupportsArray[dtype[Union[bool_, integer[Any]]]]],
+            # _NestedSequence[Union[bool, int]]], ...]]"
+            data_slice = self.to_dense()[key]  # type: ignore[index]
         elif isinstance(key, slice):
 
             # Avoid densifying when handling contiguous slices
@@ -979,7 +1043,7 @@ def __getitem__(
                     if not key.fill_value:
                         return self.take(key.sp_index.indices)
                     n = len(self)
-                    mask = np.full(n, True, dtype=np.bool8)
+                    mask = np.full(n, True, dtype=np.bool_)
                     mask[key.sp_index.indices] = False
                     return self.take(np.arange(n)[mask])
                 else:
@@ -1164,7 +1228,10 @@ def _concat_same_type(
 
             data = np.concatenate(values)
             indices_arr = np.concatenate(indices)
-            sp_index = IntIndex(length, indices_arr)
+            # error: Argument 2 to "IntIndex" has incompatible type
+            # "ndarray[Any, dtype[signedinteger[_32Bit]]]";
+            # expected "Sequence[int]"
+            sp_index = IntIndex(length, indices_arr)  # type: ignore[arg-type]
 
         else:
             # when concatenating block indices, we don't claim that you'll
@@ -1223,7 +1290,7 @@ def astype(self, dtype: AstypeArg | None = None, copy: bool = True):
         IntIndex
         Indices: array([2, 3], dtype=int32)
 
-        >>> arr.astype(np.dtype('int32'))
+        >>> arr.astype(SparseDtype(np.dtype('int32')))
         [0, 0, 1, 2]
         Fill: 0
         IntIndex
@@ -1232,19 +1299,19 @@ def astype(self, dtype: AstypeArg | None = None, copy: bool = True):
         Using a NumPy dtype with a different kind (e.g. float) will coerce
         just ``self.sp_values``.
 
-        >>> arr.astype(np.dtype('float64'))
+        >>> arr.astype(SparseDtype(np.dtype('float64')))
         ... # doctest: +NORMALIZE_WHITESPACE
-        [0.0, 0.0, 1.0, 2.0]
-        Fill: 0.0
+        [nan, nan, 1.0, 2.0]
+        Fill: nan
         IntIndex
         Indices: array([2, 3], dtype=int32)
 
-        Use a SparseDtype if you wish to be change the fill value as well.
+        Using a SparseDtype, you can also change the fill value as well.
 
-        >>> arr.astype(SparseDtype("float64", fill_value=np.nan))
+        >>> arr.astype(SparseDtype("float64", fill_value=0.0))
         ... # doctest: +NORMALIZE_WHITESPACE
-        [nan, nan, 1.0, 2.0]
-        Fill: nan
+        [0.0, 0.0, 1.0, 2.0]
+        Fill: 0.0
         IntIndex
         Indices: array([2, 3], dtype=int32)
         """
@@ -1253,6 +1320,19 @@ def astype(self, dtype: AstypeArg | None = None, copy: bool = True):
                 return self
             else:
                 return self.copy()
+
+        future_dtype = pandas_dtype(dtype)
+        if not isinstance(future_dtype, SparseDtype):
+            # GH#34457
+            warnings.warn(
+                "The behavior of .astype from SparseDtype to a non-sparse dtype "
+                "is deprecated. In a future version, this will return a non-sparse "
+                "array with the requested dtype. To retain the old behavior, use "
+                "`obj.astype(SparseDtype(dtype))`",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
         dtype = self.dtype.update_dtype(dtype)
         subtype = pandas_dtype(dtype._subtype_with_str)
         sp_values = astype_nansafe(self.sp_values, subtype, copy=copy)
@@ -1265,7 +1345,7 @@ def astype(self, dtype: AstypeArg | None = None, copy: bool = True):
 
     def map(self: SparseArrayT, mapper) -> SparseArrayT:
         """
-        Map categories using input correspondence (dict, Series, or function).
+        Map categories using an input mapping or function.
 
         Parameters
         ----------
@@ -1325,19 +1405,18 @@ def to_dense(self) -> np.ndarray:
         """
         return np.asarray(self, dtype=self.sp_values.dtype)
 
-    _internal_get_values = to_dense
-
     def _where(self, mask, value):
         # NB: may not preserve dtype, e.g. result may be Sparse[float64]
         #  while self is Sparse[int64]
         naive_implementation = np.where(mask, self, value)
-        result = type(self)._from_sequence(naive_implementation)
+        dtype = SparseDtype(naive_implementation.dtype, fill_value=self.fill_value)
+        result = type(self)._from_sequence(naive_implementation, dtype=dtype)
         return result
 
     # ------------------------------------------------------------------------
     # IO
     # ------------------------------------------------------------------------
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         """Necessary for making this object picklable"""
         if isinstance(state, tuple):
             # Compat for pandas < 0.24.0
@@ -1351,7 +1430,7 @@ def __setstate__(self, state):
         else:
             self.__dict__.update(state)
 
-    def nonzero(self):
+    def nonzero(self) -> tuple[npt.NDArray[np.int32]]:
         if self.fill_value == 0:
             return (self.sp_index.indices,)
         else:
@@ -1577,6 +1656,45 @@ def _min_max(self, kind: Literal["min", "max"], skipna: bool) -> Scalar:
         else:
             return na_value_for_dtype(self.dtype.subtype, compat=False)
 
+    def _argmin_argmax(self, kind: Literal["argmin", "argmax"]) -> int:
+
+        values = self._sparse_values
+        index = self._sparse_index.indices
+        mask = np.asarray(isna(values))
+        func = np.argmax if kind == "argmax" else np.argmin
+
+        idx = np.arange(values.shape[0])
+        non_nans = values[~mask]
+        non_nan_idx = idx[~mask]
+
+        _candidate = non_nan_idx[func(non_nans)]
+        candidate = index[_candidate]
+
+        if isna(self.fill_value):
+            return candidate
+        if kind == "argmin" and self[candidate] < self.fill_value:
+            return candidate
+        if kind == "argmax" and self[candidate] > self.fill_value:
+            return candidate
+        _loc = self._first_fill_value_loc()
+        if _loc == -1:
+            # fill_value doesn't exist
+            return candidate
+        else:
+            return _loc
+
+    def argmax(self, skipna: bool = True) -> int:
+        validate_bool_kwarg(skipna, "skipna")
+        if not skipna and self._hasna:
+            raise NotImplementedError
+        return self._argmin_argmax("argmax")
+
+    def argmin(self, skipna: bool = True) -> int:
+        validate_bool_kwarg(skipna, "skipna")
+        if not skipna and self._hasna:
+            raise NotImplementedError
+        return self._argmin_argmax("argmin")
+
     # ------------------------------------------------------------------------
     # Ufuncs
     # ------------------------------------------------------------------------
@@ -1704,13 +1822,14 @@ def _cmp_method(self, other, op) -> SparseArray:
             op_name = op.__name__.strip("_")
             return _sparse_array_op(self, other, op, op_name)
         else:
+            # scalar
             with np.errstate(all="ignore"):
                 fill_value = op(self.fill_value, other)
-                result = op(self.sp_values, other)
+                result = np.full(len(self), fill_value, dtype=np.bool_)
+                result[self.sp_index.indices] = op(self.sp_values, other)
 
             return type(self)(
                 result,
-                sparse_index=self.sp_index,
                 fill_value=fill_value,
                 dtype=np.bool_,
             )
diff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py
index f1da2421c4106..eaed6257736ba 100644
--- a/pandas/core/arrays/sparse/dtype.py
+++ b/pandas/core/arrays/sparse/dtype.py
@@ -18,11 +18,11 @@
 from pandas.errors import PerformanceWarning
 from pandas.util._exceptions import find_stack_level
 
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.base import (
     ExtensionDtype,
     register_extension_dtype,
 )
-from pandas.core.dtypes.cast import astype_nansafe
 from pandas.core.dtypes.common import (
     is_bool_dtype,
     is_object_dtype,
@@ -81,7 +81,7 @@ class SparseDtype(ExtensionDtype):
     # hash(nan) is (sometimes?) 0.
     _metadata = ("_dtype", "_fill_value", "_is_na_fill_value")
 
-    def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None):
+    def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None) -> None:
 
         if isinstance(dtype, type(self)):
             if fill_value is None:
@@ -99,7 +99,7 @@ def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None):
         self._fill_value = fill_value
         self._check_fill_value()
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         # Python3 doesn't inherit __hash__ when a base class overrides
         # __eq__, so we explicitly do it here.
         return super().__hash__()
@@ -179,7 +179,7 @@ def _is_boolean(self) -> bool:
         return is_bool_dtype(self.subtype)
 
     @property
-    def kind(self):
+    def kind(self) -> str:
         """
         The sparse kind. Either 'integer', or 'block'.
         """
@@ -194,7 +194,7 @@ def subtype(self):
         return self._dtype
 
     @property
-    def name(self):
+    def name(self) -> str:
         return f"Sparse[{self.subtype.name}, {repr(self.fill_value)}]"
 
     def __repr__(self) -> str:
@@ -354,7 +354,9 @@ def update_dtype(self, dtype) -> SparseDtype:
             if not isinstance(dtype, np.dtype):
                 raise TypeError("sparse arrays of extension dtypes not supported")
 
-            fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
+            fvarr = astype_nansafe(np.array(self.fill_value), dtype)
+            # NB: not fv_0d.item(), as that casts dt64->int
+            fill_value = fvarr[0]
             dtype = cls(dtype, fill_value=fill_value)
 
         return dtype
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 919b882f22ecb..0e2df9f7cf728 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-from typing import (
-    TYPE_CHECKING,
-    Any,
-)
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -17,6 +14,7 @@
 from pandas._typing import (
     Dtype,
     Scalar,
+    npt,
     type_t,
 )
 from pandas.compat import pa_version_under1p01
@@ -24,6 +22,7 @@
 
 from pandas.core.dtypes.base import (
     ExtensionDtype,
+    StorageExtensionDtype,
     register_extension_dtype,
 )
 from pandas.core.dtypes.common import (
@@ -39,13 +38,13 @@
 from pandas.core import ops
 from pandas.core.array_algos import masked_reductions
 from pandas.core.arrays import (
+    ExtensionArray,
     FloatingArray,
     IntegerArray,
-    PandasArray,
 )
-from pandas.core.arrays.base import ExtensionArray
 from pandas.core.arrays.floating import FloatingDtype
-from pandas.core.arrays.integer import _IntegerDtype
+from pandas.core.arrays.integer import IntegerDtype
+from pandas.core.arrays.numpy_ import PandasArray
 from pandas.core.construction import extract_array
 from pandas.core.indexers import check_array_indexer
 from pandas.core.missing import isna
@@ -53,9 +52,11 @@
 if TYPE_CHECKING:
     import pyarrow
 
+    from pandas import Series
+
 
 @register_extension_dtype
-class StringDtype(ExtensionDtype):
+class StringDtype(StorageExtensionDtype):
     """
     Extension dtype for string data.
 
@@ -66,9 +67,6 @@ class StringDtype(ExtensionDtype):
        StringDtype is considered experimental. The implementation and
        parts of the API may change without warning.
 
-       In particular, StringDtype.na_value may change to no longer be
-       ``numpy.nan``.
-
     Parameters
     ----------
     storage : {"python", "pyarrow"}, optional
@@ -93,11 +91,14 @@ class StringDtype(ExtensionDtype):
 
     name = "string"
 
-    #: StringDtype.na_value uses pandas.NA
-    na_value = libmissing.NA
+    #: StringDtype().na_value uses pandas.NA
+    @property
+    def na_value(self) -> libmissing.NAType:
+        return libmissing.NA
+
     _metadata = ("storage",)
 
-    def __init__(self, storage=None):
+    def __init__(self, storage=None) -> None:
         if storage is None:
             storage = get_option("mode.string_storage")
         if storage not in {"python", "pyarrow"}:
@@ -141,7 +142,6 @@ def construct_from_string(cls, string):
         -----
         TypeError
             If the string is not a valid option.
-
         """
         if not isinstance(string, str):
             raise TypeError(
@@ -156,15 +156,6 @@ def construct_from_string(cls, string):
         else:
             raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
 
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, str) and other == "string":
-            return True
-        return super().__eq__(other)
-
-    def __hash__(self) -> int:
-        # custom __eq__ so have to override __hash__
-        return super().__hash__()
-
     # https://github.com/pandas-dev/pandas/issues/36126
     # error: Signature of "construct_array_type" incompatible with supertype
     # "ExtensionDtype"
@@ -185,12 +176,6 @@ def construct_array_type(  # type: ignore[override]
         else:
             return ArrowStringArray
 
-    def __repr__(self):
-        return f"string[{self.storage}]"
-
-    def __str__(self):
-        return self.name
-
     def __from_arrow__(
         self, array: pyarrow.Array | pyarrow.ChunkedArray
     ) -> BaseStringArray:
@@ -224,6 +209,10 @@ def __from_arrow__(
 
 
 class BaseStringArray(ExtensionArray):
+    """
+    Mixin class for StringArray, ArrowStringArray.
+    """
+
     pass
 
 
@@ -246,11 +235,18 @@ class StringArray(BaseStringArray, PandasArray):
         .. warning::
 
            Currently, this expects an object-dtype ndarray
-           where the elements are Python strings or :attr:`pandas.NA`.
+           where the elements are Python strings
+           or nan-likes (``None``, ``np.nan``, ``NA``).
            This may change without warning in the future. Use
            :meth:`pandas.array` with ``dtype="string"`` for a stable way of
            creating a `StringArray` from any sequence.
 
+        .. versionchanged:: 1.5.0
+
+           StringArray now accepts array-likes containing
+           nan-likes(``None``, ``np.nan``) for the ``values`` parameter
+           in addition to strings and :attr:`pandas.NA`
+
     copy : bool, default False
         Whether to copy the array of data.
 
@@ -306,15 +302,13 @@ class StringArray(BaseStringArray, PandasArray):
     # undo the PandasArray hack
     _typ = "extension"
 
-    def __init__(self, values, copy=False):
+    def __init__(self, values, copy=False) -> None:
         values = extract_array(values)
 
         super().__init__(values, copy=copy)
-        # error: Incompatible types in assignment (expression has type "StringDtype",
-        # variable has type "PandasDtype")
-        NDArrayBacked.__init__(self, self._ndarray, StringDtype(storage="python"))
         if not isinstance(values, type(self)):
             self._validate()
+        NDArrayBacked.__init__(self, self._ndarray, StringDtype(storage="python"))
 
     def _validate(self):
         """Validate that we only store NA or strings."""
@@ -325,6 +319,12 @@ def _validate(self):
                 "StringArray requires a sequence of strings or pandas.NA. Got "
                 f"'{self._ndarray.dtype}' dtype instead."
             )
+        # Check to see if need to convert Na values to pd.NA
+        if self._ndarray.ndim > 2:
+            # Ravel if ndims > 2 b/c no cythonized version available
+            lib.convert_nans_to_NA(self._ndarray.ravel("K"))
+        else:
+            lib.convert_nans_to_NA(self._ndarray)
 
     @classmethod
     def _from_sequence(cls, scalars, *, dtype: Dtype | None = None, copy=False):
@@ -339,13 +339,11 @@ def _from_sequence(cls, scalars, *, dtype: Dtype | None = None, copy=False):
             na_values = scalars._mask
             result = scalars._data
             result = lib.ensure_string_array(result, copy=copy, convert_na_value=False)
-            result[na_values] = StringDtype.na_value
+            result[na_values] = libmissing.NA
 
         else:
-            # convert non-na-likes to str, and nan-likes to StringDtype.na_value
-            result = lib.ensure_string_array(
-                scalars, na_value=StringDtype.na_value, copy=copy
-            )
+            # convert non-na-likes to str, and nan-likes to StringDtype().na_value
+            result = lib.ensure_string_array(scalars, na_value=libmissing.NA, copy=copy)
 
         # Manually creating new array avoids the validation step in the __init__, so is
         # faster. Refactor need for validation?
@@ -382,8 +380,8 @@ def __arrow_array__(self, type=None):
     def _values_for_factorize(self):
         arr = self._ndarray.copy()
         mask = self.isna()
-        arr[mask] = -1
-        return arr, -1
+        arr[mask] = None
+        return arr, None
 
     def __setitem__(self, key, value):
         value = extract_array(value, extract_numpy=True)
@@ -400,7 +398,7 @@ def __setitem__(self, key, value):
         # validate new items
         if scalar_value:
             if isna(value):
-                value = StringDtype.na_value
+                value = libmissing.NA
             elif not isinstance(value, str):
                 raise ValueError(
                     f"Cannot set non-string value '{value}' into a StringArray."
@@ -411,8 +409,16 @@ def __setitem__(self, key, value):
             if len(value) and not lib.is_string_array(value, skipna=True):
                 raise ValueError("Must provide strings.")
 
+            value[isna(value)] = libmissing.NA
+
         super().__setitem__(key, value)
 
+    def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
+        # the super() method NDArrayBackedExtensionArray._putmask uses
+        # np.putmask which doesn't properly handle None/pd.NA, so using the
+        # base class implementation that uses __setitem__
+        ExtensionArray._putmask(self, mask, value)
+
     def astype(self, dtype, copy: bool = True):
         dtype = pandas_dtype(dtype)
 
@@ -421,7 +427,7 @@ def astype(self, dtype, copy: bool = True):
                 return self.copy()
             return self
 
-        elif isinstance(dtype, _IntegerDtype):
+        elif isinstance(dtype, IntegerDtype):
             arr = self._ndarray.copy()
             mask = self.isna()
             arr[mask] = 0
@@ -467,7 +473,7 @@ def max(self, axis=None, skipna: bool = True, **kwargs) -> Scalar:
         )
         return self._wrap_reduction_result(axis, result)
 
-    def value_counts(self, dropna: bool = True):
+    def value_counts(self, dropna: bool = True) -> Series:
         from pandas import value_counts
 
         result = value_counts(self._ndarray, dropna=dropna).astype("Int64")
@@ -501,7 +507,7 @@ def _cmp_method(self, other, op):
 
         if op.__name__ in ops.ARITHMETIC_BINOPS:
             result = np.empty_like(self._ndarray, dtype="object")
-            result[mask] = StringDtype.na_value
+            result[mask] = libmissing.NA
             result[valid] = op(self._ndarray[valid], other)
             return StringArray(result)
         else:
@@ -516,7 +522,7 @@ def _cmp_method(self, other, op):
     # String methods interface
     # error: Incompatible types in assignment (expression has type "NAType",
     # base class "PandasArray" defined the type as "float")
-    _str_na_value = StringDtype.na_value  # type: ignore[assignment]
+    _str_na_value = libmissing.NA  # type: ignore[assignment]
 
     def _str_map(
         self, f, na_value=None, dtype: Dtype | None = None, convert: bool = True
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index 3503b54dd478a..ed71e263ae51c 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -2,13 +2,7 @@
 
 from collections.abc import Callable  # noqa: PDF001
 import re
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Union,
-    cast,
-    overload,
-)
+from typing import Union
 
 import numpy as np
 
@@ -19,11 +13,7 @@
 from pandas._typing import (
     Dtype,
     NpDtype,
-    PositionalIndexer,
     Scalar,
-    ScalarIndexer,
-    SequenceIndexer,
-    TakeIndexer,
     npt,
 )
 from pandas.compat import (
@@ -32,13 +22,10 @@
     pa_version_under3p0,
     pa_version_under4p0,
 )
-from pandas.util._decorators import doc
 
 from pandas.core.dtypes.common import (
-    is_array_like,
     is_bool_dtype,
     is_dtype_equal,
-    is_integer,
     is_integer_dtype,
     is_object_dtype,
     is_scalar,
@@ -47,8 +34,7 @@
 )
 from pandas.core.dtypes.missing import isna
 
-from pandas.core.arraylike import OpsMixin
-from pandas.core.arrays.base import ExtensionArray
+from pandas.core.arrays.arrow import ArrowExtensionArray
 from pandas.core.arrays.boolean import BooleanDtype
 from pandas.core.arrays.integer import Int64Dtype
 from pandas.core.arrays.numeric import NumericDtype
@@ -56,36 +42,20 @@
     BaseStringArray,
     StringDtype,
 )
-from pandas.core.indexers import (
-    check_array_indexer,
-    unpack_tuple_and_ellipses,
-    validate_indices,
-)
 from pandas.core.strings.object_array import ObjectStringArrayMixin
 
 if not pa_version_under1p01:
     import pyarrow as pa
     import pyarrow.compute as pc
 
-    ARROW_CMP_FUNCS = {
-        "eq": pc.equal,
-        "ne": pc.not_equal,
-        "lt": pc.less,
-        "gt": pc.greater,
-        "le": pc.less_equal,
-        "ge": pc.greater_equal,
-    }
-
-
-if TYPE_CHECKING:
-    from pandas import Series
+    from pandas.core.arrays.arrow._arrow_utils import fallback_performancewarning
 
 ArrowStringScalarOrNAT = Union[str, libmissing.NAType]
 
 
 def _chk_pyarrow_available() -> None:
     if pa_version_under1p01:
-        msg = "pyarrow>=1.0.0 is required for PyArrow backed StringArray."
+        msg = "pyarrow>=1.0.0 is required for PyArrow backed ArrowExtensionArray."
         raise ImportError(msg)
 
 
@@ -94,7 +64,7 @@ def _chk_pyarrow_available() -> None:
 # fallback for the ones that pyarrow doesn't yet support
 
 
-class ArrowStringArray(OpsMixin, BaseStringArray, ObjectStringArrayMixin):
+class ArrowStringArray(ArrowExtensionArray, BaseStringArray, ObjectStringArrayMixin):
     """
     Extension array for string data in a ``pyarrow.ChunkedArray``.
 
@@ -138,14 +108,13 @@ class ArrowStringArray(OpsMixin, BaseStringArray, ObjectStringArrayMixin):
     Length: 4, dtype: string
     """
 
-    def __init__(self, values):
+    # error: Incompatible types in assignment (expression has type "StringDtype",
+    # base class "ArrowExtensionArray" defined the type as "ArrowDtype")
+    _dtype: StringDtype  # type: ignore[assignment]
+
+    def __init__(self, values) -> None:
+        super().__init__(values)
         self._dtype = StringDtype(storage="pyarrow")
-        if isinstance(values, pa.Array):
-            self._data = pa.chunked_array([values])
-        elif isinstance(values, pa.ChunkedArray):
-            self._data = values
-        else:
-            raise ValueError(f"Unsupported type '{type(values)}' for ArrowStringArray")
 
         if not pa.types.is_string(self._data.type):
             raise ValueError(
@@ -181,7 +150,7 @@ def _from_sequence_of_strings(
         return cls._from_sequence(strings, dtype=dtype, copy=copy)
 
     @property
-    def dtype(self) -> StringDtype:
+    def dtype(self) -> StringDtype:  # type: ignore[override]
         """
         An instance of 'string[pyarrow]'.
         """
@@ -191,10 +160,6 @@ def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
         """Correctly construct numpy arrays when passed to `np.asarray()`."""
         return self.to_numpy(dtype=dtype)
 
-    def __arrow_array__(self, type=None):
-        """Convert myself to a pyarrow Array or ChunkedArray."""
-        return self._data
-
     def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
@@ -216,354 +181,29 @@ def to_numpy(
             result[mask] = na_value
         return result
 
-    def __len__(self) -> int:
-        """
-        Length of this array.
-
-        Returns
-        -------
-        length : int
-        """
-        return len(self._data)
-
-    @doc(ExtensionArray.factorize)
-    def factorize(self, na_sentinel: int = -1) -> tuple[np.ndarray, ExtensionArray]:
-        encoded = self._data.dictionary_encode()
-        indices = pa.chunked_array(
-            [c.indices for c in encoded.chunks], type=encoded.type.index_type
-        ).to_pandas()
-        if indices.dtype.kind == "f":
-            indices[np.isnan(indices)] = na_sentinel
-        indices = indices.astype(np.int64, copy=False)
-
-        if encoded.num_chunks:
-            uniques = type(self)(encoded.chunk(0).dictionary)
-        else:
-            uniques = type(self)(pa.array([], type=encoded.type.value_type))
-
-        return indices.values, uniques
-
-    @classmethod
-    def _concat_same_type(cls, to_concat) -> ArrowStringArray:
-        """
-        Concatenate multiple ArrowStringArray.
-
-        Parameters
-        ----------
-        to_concat : sequence of ArrowStringArray
-
-        Returns
-        -------
-        ArrowStringArray
-        """
-        return cls(
-            pa.chunked_array(
-                [array for ea in to_concat for array in ea._data.iterchunks()]
-            )
-        )
-
-    @overload
-    def __getitem__(self, item: ScalarIndexer) -> ArrowStringScalarOrNAT:
-        ...
-
-    @overload
-    def __getitem__(self: ArrowStringArray, item: SequenceIndexer) -> ArrowStringArray:
-        ...
-
-    def __getitem__(
-        self: ArrowStringArray, item: PositionalIndexer
-    ) -> ArrowStringArray | ArrowStringScalarOrNAT:
-        """Select a subset of self.
-
-        Parameters
-        ----------
-        item : int, slice, or ndarray
-            * int: The position in 'self' to get.
-            * slice: A slice object, where 'start', 'stop', and 'step' are
-              integers or None
-            * ndarray: A 1-d boolean NumPy ndarray the same length as 'self'
-
-        Returns
-        -------
-        item : scalar or ExtensionArray
-
-        Notes
-        -----
-        For scalar ``item``, return a scalar value suitable for the array's
-        type. This should be an instance of ``self.dtype.type``.
-        For slice ``key``, return an instance of ``ExtensionArray``, even
-        if the slice is length 0 or 1.
-        For a boolean mask, return an instance of ``ExtensionArray``, filtered
-        to the values where ``item`` is True.
-        """
-        item = check_array_indexer(self, item)
-
-        if isinstance(item, np.ndarray):
-            if not len(item):
-                return type(self)(pa.chunked_array([], type=pa.string()))
-            elif is_integer_dtype(item.dtype):
-                return self.take(item)
-            elif is_bool_dtype(item.dtype):
-                return type(self)(self._data.filter(item))
-            else:
-                raise IndexError(
-                    "Only integers, slices and integer or "
-                    "boolean arrays are valid indices."
-                )
-        elif isinstance(item, tuple):
-            item = unpack_tuple_and_ellipses(item)
-
-        # error: Non-overlapping identity check (left operand type:
-        # "Union[Union[int, integer[Any]], Union[slice, List[int],
-        # ndarray[Any, Any]]]", right operand type: "ellipsis")
-        if item is Ellipsis:  # type: ignore[comparison-overlap]
-            # TODO: should be handled by pyarrow?
-            item = slice(None)
-
-        if is_scalar(item) and not is_integer(item):
-            # e.g. "foo" or 2.5
-            # exception message copied from numpy
-            raise IndexError(
-                r"only integers, slices (`:`), ellipsis (`...`), numpy.newaxis "
-                r"(`None`) and integer or boolean arrays are valid indices"
-            )
-        # We are not an array indexer, so maybe e.g. a slice or integer
-        # indexer. We dispatch to pyarrow.
-        value = self._data[item]
-        if isinstance(value, pa.ChunkedArray):
-            return type(self)(value)
-        else:
-            return self._as_pandas_scalar(value)
-
-    def _as_pandas_scalar(self, arrow_scalar: pa.Scalar):
-        scalar = arrow_scalar.as_py()
-        if scalar is None:
-            return self._dtype.na_value
-        else:
-            return scalar
-
-    @property
-    def nbytes(self) -> int:
-        """
-        The number of bytes needed to store this object in memory.
-        """
-        return self._data.nbytes
-
-    def isna(self) -> np.ndarray:
-        """
-        Boolean NumPy array indicating if each value is missing.
-
-        This should return a 1-D array the same length as 'self'.
-        """
-        # TODO: Implement .to_numpy for ChunkedArray
-        return self._data.is_null().to_pandas().values
-
-    def copy(self) -> ArrowStringArray:
-        """
-        Return a shallow copy of the array.
-
-        Underlying ChunkedArray is immutable, so a deep copy is unnecessary.
-
-        Returns
-        -------
-        ArrowStringArray
-        """
-        return type(self)(self._data)
-
-    def _cmp_method(self, other, op):
-        from pandas.arrays import BooleanArray
-
-        pc_func = ARROW_CMP_FUNCS[op.__name__]
-        if isinstance(other, ArrowStringArray):
-            result = pc_func(self._data, other._data)
-        elif isinstance(other, (np.ndarray, list)):
-            result = pc_func(self._data, other)
-        elif is_scalar(other):
-            try:
-                result = pc_func(self._data, pa.scalar(other))
-            except (pa.lib.ArrowNotImplementedError, pa.lib.ArrowInvalid):
-                mask = isna(self) | isna(other)
-                valid = ~mask
-                result = np.zeros(len(self), dtype="bool")
-                result[valid] = op(np.array(self)[valid], other)
-                return BooleanArray(result, mask)
-        else:
-            return NotImplemented
-
-        # TODO(ARROW-9429): Add a .to_numpy() to ChunkedArray
-        return BooleanArray._from_sequence(result.to_pandas().values)
-
-    def insert(self, loc: int, item):
+    def insert(self, loc: int, item) -> ArrowStringArray:
         if not isinstance(item, str) and item is not libmissing.NA:
             raise TypeError("Scalar must be NA or str")
         return super().insert(loc, item)
 
-    def __setitem__(self, key: int | slice | np.ndarray, value: Any) -> None:
-        """Set one or more values inplace.
-
-        Parameters
-        ----------
-        key : int, ndarray, or slice
-            When called from, e.g. ``Series.__setitem__``, ``key`` will be
-            one of
-
-            * scalar int
-            * ndarray of integers.
-            * boolean ndarray
-            * slice object
-
-        value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
-            value or values to be set of ``key``.
-
-        Returns
-        -------
-        None
-        """
-        key = check_array_indexer(self, key)
-
-        if is_integer(key):
-            key = cast(int, key)
-
-            if not is_scalar(value):
-                raise ValueError("Must pass scalars with scalar indexer")
-            elif isna(value):
+    def _maybe_convert_setitem_value(self, value):
+        """Maybe convert value to be pyarrow compatible."""
+        if is_scalar(value):
+            if isna(value):
                 value = None
             elif not isinstance(value, str):
                 raise ValueError("Scalar must be NA or str")
-
-            # Slice data and insert in-between
-            new_data = [
-                *self._data[0:key].chunks,
-                pa.array([value], type=pa.string()),
-                *self._data[(key + 1) :].chunks,
-            ]
-            self._data = pa.chunked_array(new_data)
-        else:
-            # Convert to integer indices and iteratively assign.
-            # TODO: Make a faster variant of this in Arrow upstream.
-            #       This is probably extremely slow.
-
-            # Convert all possible input key types to an array of integers
-            if isinstance(key, slice):
-                key_array = np.array(range(len(self))[key])
-            elif is_bool_dtype(key):
-                # TODO(ARROW-9430): Directly support setitem(booleans)
-                key_array = np.argwhere(key).flatten()
-            else:
-                # TODO(ARROW-9431): Directly support setitem(integers)
-                key_array = np.asanyarray(key)
-
-            if is_scalar(value):
-                value = np.broadcast_to(value, len(key_array))
-            else:
-                value = np.asarray(value)
-
-            if len(key_array) != len(value):
-                raise ValueError("Length of indexer and values mismatch")
-
-            for k, v in zip(key_array, value):
-                self[k] = v
-
-    def take(
-        self,
-        indices: TakeIndexer,
-        allow_fill: bool = False,
-        fill_value: Any = None,
-    ):
-        """
-        Take elements from an array.
-
-        Parameters
-        ----------
-        indices : sequence of int or one-dimensional np.ndarray of int
-            Indices to be taken.
-        allow_fill : bool, default False
-            How to handle negative values in `indices`.
-
-            * False: negative values in `indices` indicate positional indices
-              from the right (the default). This is similar to
-              :func:`numpy.take`.
-
-            * True: negative values in `indices` indicate
-              missing values. These values are set to `fill_value`. Any other
-              other negative values raise a ``ValueError``.
-
-        fill_value : any, optional
-            Fill value to use for NA-indices when `allow_fill` is True.
-            This may be ``None``, in which case the default NA value for
-            the type, ``self.dtype.na_value``, is used.
-
-            For many ExtensionArrays, there will be two representations of
-            `fill_value`: a user-facing "boxed" scalar, and a low-level
-            physical NA value. `fill_value` should be the user-facing version,
-            and the implementation should handle translating that to the
-            physical version for processing the take if necessary.
-
-        Returns
-        -------
-        ExtensionArray
-
-        Raises
-        ------
-        IndexError
-            When the indices are out of bounds for the array.
-        ValueError
-            When `indices` contains negative values other than ``-1``
-            and `allow_fill` is True.
-
-        See Also
-        --------
-        numpy.take
-        api.extensions.take
-
-        Notes
-        -----
-        ExtensionArray.take is called by ``Series.__getitem__``, ``.loc``,
-        ``iloc``, when `indices` is a sequence of values. Additionally,
-        it's called by :meth:`Series.reindex`, or any other method
-        that causes realignment, with a `fill_value`.
-        """
-        # TODO: Remove once we got rid of the (indices < 0) check
-        if not is_array_like(indices):
-            indices_array = np.asanyarray(indices)
         else:
-            # error: Incompatible types in assignment (expression has type
-            # "Sequence[int]", variable has type "ndarray")
-            indices_array = indices  # type: ignore[assignment]
-
-        if len(self._data) == 0 and (indices_array >= 0).any():
-            raise IndexError("cannot do a non-empty take")
-        if indices_array.size > 0 and indices_array.max() >= len(self._data):
-            raise IndexError("out of bounds value in 'indices'.")
-
-        if allow_fill:
-            fill_mask = indices_array < 0
-            if fill_mask.any():
-                validate_indices(indices_array, len(self._data))
-                # TODO(ARROW-9433): Treat negative indices as NULL
-                indices_array = pa.array(indices_array, mask=fill_mask)
-                result = self._data.take(indices_array)
-                if isna(fill_value):
-                    return type(self)(result)
-                # TODO: ArrowNotImplementedError: Function fill_null has no
-                # kernel matching input types (array[string], scalar[string])
-                result = type(self)(result)
-                result[fill_mask] = fill_value
-                return result
-                # return type(self)(pc.fill_null(result, pa.scalar(fill_value)))
-            else:
-                # Nothing to fill
-                return type(self)(self._data.take(indices))
-        else:  # allow_fill=False
-            # TODO(ARROW-9432): Treat negative indices as indices from the right.
-            if (indices_array < 0).any():
-                # Don't modify in-place
-                indices_array = np.copy(indices_array)
-                indices_array[indices_array < 0] += len(self._data)
-            return type(self)(self._data.take(indices_array))
-
-    def isin(self, values):
+            value = np.array(value, dtype=object, copy=True)
+            value[isna(value)] = None
+            for v in value:
+                if not (v is None or isinstance(v, str)):
+                    raise ValueError("Scalar must be NA or str")
+        return value
+
+    def isin(self, values) -> npt.NDArray[np.bool_]:
         if pa_version_under2p0:
+            fallback_performancewarning(version="2")
             return super().isin(values)
 
         value_set = [
@@ -588,44 +228,6 @@ def isin(self, values):
         # to False
         return np.array(result, dtype=np.bool_)
 
-    def value_counts(self, dropna: bool = True) -> Series:
-        """
-        Return a Series containing counts of each unique value.
-
-        Parameters
-        ----------
-        dropna : bool, default True
-            Don't include counts of missing values.
-
-        Returns
-        -------
-        counts : Series
-
-        See Also
-        --------
-        Series.value_counts
-        """
-        from pandas import (
-            Index,
-            Series,
-        )
-
-        vc = self._data.value_counts()
-
-        values = vc.field(0)
-        counts = vc.field(1)
-        if dropna and self._data.null_count > 0:
-            mask = values.is_valid()
-            values = values.filter(mask)
-            counts = counts.filter(mask)
-
-        # No missing values so we can adhere to the interface and return a numpy array.
-        counts = np.array(counts)
-
-        index = Index(type(self)(values))
-
-        return Series(counts, index=index).astype("Int64")
-
     def astype(self, dtype, copy: bool = True):
         dtype = pandas_dtype(dtype)
 
@@ -643,8 +245,9 @@ def astype(self, dtype, copy: bool = True):
     # ------------------------------------------------------------------------
     # String methods interface
 
-    # error: Cannot determine type of 'na_value'
-    _str_na_value = StringDtype.na_value  # type: ignore[has-type]
+    # error: Incompatible types in assignment (expression has type "NAType",
+    # base class "ObjectStringArrayMixin" defined the type as "float")
+    _str_na_value = libmissing.NA  # type: ignore[assignment]
 
     def _str_map(
         self, f, na_value=None, dtype: Dtype | None = None, convert: bool = True
@@ -708,10 +311,12 @@ def _str_map(
 
     def _str_contains(self, pat, case=True, flags=0, na=np.nan, regex: bool = True):
         if flags:
+            fallback_performancewarning()
             return super()._str_contains(pat, case, flags, na, regex)
 
         if regex:
             if pa_version_under4p0 or case is False:
+                fallback_performancewarning(version="4")
                 return super()._str_contains(pat, case, flags, na, regex)
             else:
                 result = pc.match_substring_regex(self._data, pat)
@@ -727,6 +332,7 @@ def _str_contains(self, pat, case=True, flags=0, na=np.nan, regex: bool = True):
 
     def _str_startswith(self, pat: str, na=None):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_startswith(pat, na)
 
         pat = "^" + re.escape(pat)
@@ -734,6 +340,7 @@ def _str_startswith(self, pat: str, na=None):
 
     def _str_endswith(self, pat: str, na=None):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_endswith(pat, na)
 
         pat = re.escape(pat) + "$"
@@ -755,6 +362,7 @@ def _str_replace(
             or not case
             or flags
         ):
+            fallback_performancewarning(version="4")
             return super()._str_replace(pat, repl, n, case, flags, regex)
 
         func = pc.replace_substring_regex if regex else pc.replace_substring
@@ -762,17 +370,21 @@ def _str_replace(
         return type(self)(result)
 
     def _str_match(
-        self, pat: str, case: bool = True, flags: int = 0, na: Scalar = None
+        self, pat: str, case: bool = True, flags: int = 0, na: Scalar | None = None
     ):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_match(pat, case, flags, na)
 
         if not pat.startswith("^"):
             pat = "^" + pat
         return self._str_contains(pat, case, flags, na, regex=True)
 
-    def _str_fullmatch(self, pat, case: bool = True, flags: int = 0, na: Scalar = None):
+    def _str_fullmatch(
+        self, pat, case: bool = True, flags: int = 0, na: Scalar | None = None
+    ):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_fullmatch(pat, case, flags, na)
 
         if not pat.endswith("$") or pat.endswith("//$"):
@@ -805,6 +417,7 @@ def _str_isnumeric(self):
 
     def _str_isspace(self):
         if pa_version_under2p0:
+            fallback_performancewarning(version="2")
             return super()._str_isspace()
 
         result = pc.utf8_is_space(self._data)
@@ -820,6 +433,7 @@ def _str_isupper(self):
 
     def _str_len(self):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_len()
 
         result = pc.utf8_length(self._data)
@@ -833,6 +447,7 @@ def _str_upper(self):
 
     def _str_strip(self, to_strip=None):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_strip(to_strip)
 
         if to_strip is None:
@@ -843,6 +458,7 @@ def _str_strip(self, to_strip=None):
 
     def _str_lstrip(self, to_strip=None):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_lstrip(to_strip)
 
         if to_strip is None:
@@ -853,6 +469,7 @@ def _str_lstrip(self, to_strip=None):
 
     def _str_rstrip(self, to_strip=None):
         if pa_version_under4p0:
+            fallback_performancewarning(version="4")
             return super()._str_rstrip(to_strip)
 
         if to_strip is None:
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 79387cc2584da..4011f29855949 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
 
 import numpy as np
 
@@ -9,22 +12,18 @@
     lib,
     tslibs,
 )
-from pandas._libs.arrays import NDArrayBacked
 from pandas._libs.tslibs import (
     BaseOffset,
     NaT,
     NaTType,
-    Period,
     Tick,
     Timedelta,
-    Timestamp,
+    astype_overflowsafe,
     iNaT,
+    periods_per_second,
     to_offset,
 )
-from pandas._libs.tslibs.conversion import (
-    ensure_timedelta64ns,
-    precision_from_unit,
-)
+from pandas._libs.tslibs.conversion import precision_from_unit
 from pandas._libs.tslibs.fields import get_timedelta_field
 from pandas._libs.tslibs.timedeltas import (
     array_to_timedelta64,
@@ -34,13 +33,13 @@
 from pandas._typing import (
     DtypeObj,
     NpDtype,
+    npt,
 )
 from pandas.compat.numpy import function as nv
 from pandas.util._validators import validate_endpoints
 
-from pandas.core.dtypes.cast import astype_td64_unit_conversion
+from pandas.core.dtypes.astype import astype_td64_unit_conversion
 from pandas.core.dtypes.common import (
-    DT64NS_DTYPE,
     TD64NS_DTYPE,
     is_dtype_equal,
     is_float_dtype,
@@ -51,38 +50,23 @@
     is_timedelta64_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.dtypes import DatetimeTZDtype
-from pandas.core.dtypes.generic import (
-    ABCCategorical,
-    ABCMultiIndex,
-)
 from pandas.core.dtypes.missing import isna
 
 from pandas.core import nanops
-from pandas.core.algorithms import checked_add_with_arr
-from pandas.core.arrays import (
-    ExtensionArray,
-    IntegerArray,
-    datetimelike as dtl,
-)
+from pandas.core.arrays import datetimelike as dtl
 from pandas.core.arrays._ranges import generate_regular_range
 import pandas.core.common as com
-from pandas.core.construction import extract_array
 from pandas.core.ops.common import unpack_zerodim_and_defer
 
 if TYPE_CHECKING:
     from pandas import DataFrame
-    from pandas.core.arrays import (
-        DatetimeArray,
-        PeriodArray,
-    )
 
 
 def _field_accessor(name: str, alias: str, docstring: str):
     def f(self) -> np.ndarray:
         values = self.asi8
-        result = get_timedelta_field(values, alias)
-        if self._hasnans:
+        result = get_timedelta_field(values, alias, reso=self._reso)
+        if self._hasna:
             result = self._maybe_mask_results(
                 result, fill_value=None, convert="float64"
             )
@@ -126,11 +110,15 @@ class TimedeltaArray(dtl.TimelikeOps):
     """
 
     _typ = "timedeltaarray"
-    _scalar_type = Timedelta
+    _internal_fill_value = np.timedelta64("NaT", "ns")
     _recognized_scalars = (timedelta, np.timedelta64, Tick)
     _is_recognized_dtype = is_timedelta64_dtype
     _infer_matches = ("timedelta", "timedelta64")
 
+    @property
+    def _scalar_type(self) -> type[Timedelta]:
+        return Timedelta
+
     __array_priority__ = 1000
     # define my properties & methods for delegation
     _other_ops: list[str] = []
@@ -149,8 +137,11 @@ class TimedeltaArray(dtl.TimelikeOps):
     # Note: ndim must be defined to ensure NaT.__richcmp__(TimedeltaArray)
     #  operates pointwise.
 
-    def _box_func(self, x) -> Timedelta | NaTType:
-        return Timedelta(x, unit="ns")
+    def _box_func(self, x: np.timedelta64) -> Timedelta | NaTType:
+        y = x.view("i8")
+        if y == NaT.value:
+            return NaT
+        return Timedelta._from_value_and_reso(y, reso=self._reso)
 
     @property
     # error: Return type "dtype" of "dtype" incompatible with return type
@@ -169,81 +160,33 @@ def dtype(self) -> np.dtype:  # type: ignore[override]
         -------
         numpy.dtype
         """
-        return TD64NS_DTYPE
+        return self._ndarray.dtype
 
     # ----------------------------------------------------------------
     # Constructors
 
     _freq = None
+    _default_dtype = TD64NS_DTYPE  # used in TimeLikeOps.__init__
 
-    def __init__(
-        self, values, dtype=TD64NS_DTYPE, freq=lib.no_default, copy: bool = False
-    ):
-        values = extract_array(values, extract_numpy=True)
-        if isinstance(values, IntegerArray):
-            values = values.to_numpy("int64", na_value=tslibs.iNaT)
-
-        inferred_freq = getattr(values, "_freq", None)
-        explicit_none = freq is None
-        freq = freq if freq is not lib.no_default else None
-
-        if isinstance(values, type(self)):
-            if explicit_none:
-                # dont inherit from values
-                pass
-            elif freq is None:
-                freq = values.freq
-            elif freq and values.freq:
-                freq = to_offset(freq)
-                freq, _ = dtl.validate_inferred_freq(freq, values.freq, False)
-            values = values._ndarray
-
-        if not isinstance(values, np.ndarray):
-            msg = (
-                f"Unexpected type '{type(values).__name__}'. 'values' must be a "
-                "TimedeltaArray, ndarray, or Series or Index containing one of those."
-            )
-            raise ValueError(msg)
-        if values.ndim not in [1, 2]:
-            raise ValueError("Only 1-dimensional input arrays are supported.")
-
-        if values.dtype == "i8":
-            # for compat with datetime/timedelta/period shared methods,
-            #  we can sometimes get here with int64 values.  These represent
-            #  nanosecond UTC (or tz-naive) unix timestamps
-            values = values.view(TD64NS_DTYPE)
-
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        # used in TimeLikeOps.__init__
         _validate_td64_dtype(values.dtype)
         dtype = _validate_td64_dtype(dtype)
-
-        if freq == "infer":
-            msg = (
-                "Frequency inference not allowed in TimedeltaArray.__init__. "
-                "Use 'pd.array()' instead."
-            )
-            raise ValueError(msg)
-
-        if copy:
-            values = values.copy()
-        if freq:
-            freq = to_offset(freq)
-
-        NDArrayBacked.__init__(self, values=values, dtype=dtype)
-        self._freq = freq
-
-        if inferred_freq is None and freq is not None:
-            type(self)._validate_frequency(self, freq)
+        return dtype
 
     # error: Signature of "_simple_new" incompatible with supertype "NDArrayBacked"
     @classmethod
     def _simple_new(  # type: ignore[override]
         cls, values: np.ndarray, freq: BaseOffset | None = None, dtype=TD64NS_DTYPE
     ) -> TimedeltaArray:
-        assert dtype == TD64NS_DTYPE, dtype
+        # Require td64 dtype, not unit-less, matching values.dtype
+        assert isinstance(dtype, np.dtype) and dtype.kind == "m"
+        assert not tslibs.is_unitless(dtype)
         assert isinstance(values, np.ndarray), type(values)
-        assert values.dtype == TD64NS_DTYPE
+        assert dtype == values.dtype
 
-        result = super()._simple_new(values=values, dtype=TD64NS_DTYPE)
+        result = super()._simple_new(values=values, dtype=dtype)
         result._freq = freq
         return result
 
@@ -257,7 +200,7 @@ def _from_sequence(
         data, inferred_freq = sequence_to_td64ns(data, copy=copy, unit=None)
         freq, _ = dtl.validate_inferred_freq(None, inferred_freq, False)
 
-        return cls._simple_new(data, freq=freq)
+        return cls._simple_new(data, dtype=data.dtype, freq=freq)
 
     @classmethod
     def _from_sequence_not_strict(
@@ -271,6 +214,8 @@ def _from_sequence_not_strict(
         if dtype:
             _validate_td64_dtype(dtype)
 
+        assert unit not in ["Y", "y", "M"]  # caller is responsible for checking
+
         explicit_none = freq is None
         freq = freq if freq is not lib.no_default else None
 
@@ -281,7 +226,7 @@ def _from_sequence_not_strict(
         if explicit_none:
             freq = None
 
-        result = cls._simple_new(data, freq=freq)
+        result = cls._simple_new(data, dtype=data.dtype, freq=freq)
 
         if inferred_freq is None and freq is not None:
             # this condition precludes `freq_infer`
@@ -325,7 +270,8 @@ def _generate_range(cls, start, end, periods, freq, closed=None):
         if not right_closed:
             index = index[:-1]
 
-        return cls._simple_new(index.view("m8[ns]"), freq=freq)
+        td64values = index.view("m8[ns]")
+        return cls._simple_new(td64values, dtype=td64values.dtype, freq=freq)
 
     # ----------------------------------------------------------------
     # DatetimeLike Interface
@@ -364,7 +310,7 @@ def __iter__(self):
                 yield self[i]
         else:
             # convert in chunks of 10k for efficiency
-            data = self.asi8
+            data = self._ndarray
             length = len(self)
             chunksize = 10000
             chunks = (length // chunksize) + 1
@@ -424,14 +370,16 @@ def _formatter(self, boxed: bool = False):
 
         return get_format_timedelta64(self, box=True)
 
-    @dtl.ravel_compat
     def _format_native_types(
         self, *, na_rep="NaT", date_format=None, **kwargs
-    ) -> np.ndarray:
+    ) -> npt.NDArray[np.object_]:
         from pandas.io.formats.format import get_format_timedelta64
 
+        # Relies on TimeDelta._repr_base
         formatter = get_format_timedelta64(self._ndarray, na_rep)
-        return np.array([formatter(x) for x in self._ndarray])
+        # equiv: np.array([formatter(x) for x in self._ndarray])
+        #  but independent of dimension
+        return np.frompyfunc(formatter, 1, 1)(self._ndarray)
 
     # ----------------------------------------------------------------
     # Arithmetic Methods
@@ -442,60 +390,6 @@ def _add_offset(self, other):
             f"cannot add the type {type(other).__name__} to a {type(self).__name__}"
         )
 
-    def _add_period(self, other: Period) -> PeriodArray:
-        """
-        Add a Period object.
-        """
-        # We will wrap in a PeriodArray and defer to the reversed operation
-        from pandas.core.arrays.period import PeriodArray
-
-        i8vals = np.broadcast_to(other.ordinal, self.shape)
-        oth = PeriodArray(i8vals, freq=other.freq)
-        return oth + self
-
-    def _add_datetime_arraylike(self, other):
-        """
-        Add DatetimeArray/Index or ndarray[datetime64] to TimedeltaArray.
-        """
-        if isinstance(other, np.ndarray):
-            # At this point we have already checked that dtype is datetime64
-            from pandas.core.arrays import DatetimeArray
-
-            other = DatetimeArray(other)
-
-        # defer to implementation in DatetimeArray
-        return other + self
-
-    def _add_datetimelike_scalar(self, other) -> DatetimeArray:
-        # adding a timedeltaindex to a datetimelike
-        from pandas.core.arrays import DatetimeArray
-
-        assert other is not NaT
-        other = Timestamp(other)
-        if other is NaT:
-            # In this case we specifically interpret NaT as a datetime, not
-            # the timedelta interpretation we would get by returning self + NaT
-            result = self.asi8.view("m8[ms]") + NaT.to_datetime64()
-            return DatetimeArray(result)
-
-        i8 = self.asi8
-        result = checked_add_with_arr(i8, other.value, arr_mask=self._isnan)
-        result = self._maybe_mask_results(result)
-        dtype = DatetimeTZDtype(tz=other.tz) if other.tz else DT64NS_DTYPE
-        return DatetimeArray(result, dtype=dtype, freq=self.freq)
-
-    def _addsub_object_array(self, other, op):
-        # Add or subtract Array-like of objects
-        try:
-            # TimedeltaIndex can only operate with a subset of DateOffset
-            # subclasses.  Incompatible classes will raise AttributeError,
-            # which we re-raise as TypeError
-            return super()._addsub_object_array(other, op)
-        except AttributeError as err:
-            raise TypeError(
-                f"Cannot add/subtract non-tick DateOffset to {type(self).__name__}"
-            ) from err
-
     @unpack_zerodim_and_defer("__mul__")
     def __mul__(self, other) -> TimedeltaArray:
         if is_scalar(other):
@@ -504,7 +398,7 @@ def __mul__(self, other) -> TimedeltaArray:
             freq = None
             if self.freq is not None and not isna(other):
                 freq = self.freq * other
-            return type(self)(result, freq=freq)
+            return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
 
         if not hasattr(other, "dtype"):
             # list, tuple
@@ -518,13 +412,14 @@ def __mul__(self, other) -> TimedeltaArray:
             # this multiplication will succeed only if all elements of other
             #  are int or float scalars, so we will end up with
             #  timedelta64[ns]-dtyped result
-            result = [self[n] * other[n] for n in range(len(self))]
+            arr = self._ndarray
+            result = [arr[n] * other[n] for n in range(len(self))]
             result = np.array(result)
-            return type(self)(result)
+            return type(self)._simple_new(result, dtype=result.dtype)
 
         # numpy will accept float or int dtype, raise TypeError for others
         result = self._ndarray * other
-        return type(self)(result)
+        return type(self)._simple_new(result, dtype=result.dtype)
 
     __rmul__ = __mul__
 
@@ -534,7 +429,9 @@ def __truediv__(self, other):
 
         if isinstance(other, self._recognized_scalars):
             other = Timedelta(other)
-            if other is NaT:
+            # mypy assumes that __new__ returns an instance of the class
+            # github.com/python/mypy/issues/1020
+            if cast("Timedelta | NaTType", other) is NaT:
                 # specifically timedelta64-NaT
                 result = np.empty(self.shape, dtype=np.float64)
                 result.fill(np.nan)
@@ -550,7 +447,8 @@ def __truediv__(self, other):
             if self.freq is not None:
                 # Tick division is not implemented, so operate on Timedelta
                 freq = self.freq.delta / other
-            return type(self)(result, freq=freq)
+                freq = to_offset(freq)
+            return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
 
         if not hasattr(other, "dtype"):
             # e.g. list, tuple
@@ -566,10 +464,11 @@ def __truediv__(self, other):
         elif is_object_dtype(other.dtype):
             # We operate on raveled arrays to avoid problems in inference
             #  on NaT
+            # TODO: tests with non-nano
             srav = self.ravel()
             orav = other.ravel()
-            result = [srav[n] / orav[n] for n in range(len(srav))]
-            result = np.array(result).reshape(self.shape)
+            result_list = [srav[n] / orav[n] for n in range(len(srav))]
+            result = np.array(result_list).reshape(self.shape)
 
             # We need to do dtype inference in order to keep DataFrame ops
             #  behavior consistent with Series behavior
@@ -583,20 +482,25 @@ def __truediv__(self, other):
                 # GH#39750 this occurs when result is all-NaT, in which case
                 #  we want to interpret these NaTs as td64.
                 #  We construct an all-td64NaT result.
-                result = self * np.nan
+                # error: Incompatible types in assignment (expression has type
+                # "TimedeltaArray", variable has type "ndarray[Any,
+                # dtype[floating[_64Bit]]]")
+                result = self * np.nan  # type: ignore[assignment]
 
             return result
 
         else:
             result = self._ndarray / other
-            return type(self)(result)
+            return type(self)._simple_new(result, dtype=result.dtype)
 
     @unpack_zerodim_and_defer("__rtruediv__")
     def __rtruediv__(self, other):
         # X / timedelta is defined only for timedelta-like X
         if isinstance(other, self._recognized_scalars):
             other = Timedelta(other)
-            if other is NaT:
+            # mypy assumes that __new__ returns an instance of the class
+            # github.com/python/mypy/issues/1020
+            if cast("Timedelta | NaTType", other) is NaT:
                 # specifically timedelta64-NaT
                 result = np.empty(self.shape, dtype=np.float64)
                 result.fill(np.nan)
@@ -625,8 +529,8 @@ def __rtruediv__(self, other):
             # Note: unlike in __truediv__, we do not _need_ to do type
             #  inference on the result.  It does not raise, a numeric array
             #  is returned.  GH#23829
-            result = [other[n] / self[n] for n in range(len(self))]
-            return np.array(result)
+            result_list = [other[n] / self[n] for n in range(len(self))]
+            return np.array(result_list)
 
         else:
             raise TypeError(
@@ -639,15 +543,16 @@ def __floordiv__(self, other):
         if is_scalar(other):
             if isinstance(other, self._recognized_scalars):
                 other = Timedelta(other)
-                if other is NaT:
+                # mypy assumes that __new__ returns an instance of the class
+                # github.com/python/mypy/issues/1020
+                if cast("Timedelta | NaTType", other) is NaT:
                     # treat this specifically as timedelta-NaT
                     result = np.empty(self.shape, dtype=np.float64)
                     result.fill(np.nan)
                     return result
 
                 # dispatch to Timedelta implementation
-                result = other.__rfloordiv__(self._ndarray)
-                return result
+                return other.__rfloordiv__(self._ndarray)
 
             # at this point we should only have numeric scalars; anything
             #  else will raise
@@ -715,15 +620,16 @@ def __rfloordiv__(self, other):
         if is_scalar(other):
             if isinstance(other, self._recognized_scalars):
                 other = Timedelta(other)
-                if other is NaT:
+                # mypy assumes that __new__ returns an instance of the class
+                # github.com/python/mypy/issues/1020
+                if cast("Timedelta | NaTType", other) is NaT:
                     # treat this specifically as timedelta-NaT
                     result = np.empty(self.shape, dtype=np.float64)
                     result.fill(np.nan)
                     return result
 
                 # dispatch to Timedelta implementation
-                result = other.__floordiv__(self._ndarray)
-                return result
+                return other.__floordiv__(self._ndarray)
 
             raise TypeError(
                 f"Cannot divide {type(other).__name__} by {type(self).__name__}"
@@ -805,7 +711,7 @@ def __abs__(self) -> TimedeltaArray:
     # ----------------------------------------------------------------
     # Conversion Methods - Vectorized analogues of Timedelta methods
 
-    def total_seconds(self) -> np.ndarray:
+    def total_seconds(self) -> npt.NDArray[np.float64]:
         """
         Return total duration of each element expressed in seconds.
 
@@ -857,21 +763,21 @@ def total_seconds(self) -> np.ndarray:
                        dtype='timedelta64[ns]', freq=None)
 
         >>> idx.total_seconds()
-        Float64Index([0.0, 86400.0, 172800.0, 259200.00000000003, 345600.0],
+        Float64Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0],
                      dtype='float64')
         """
-        return self._maybe_mask_results(1e-9 * self.asi8, fill_value=None)
+        pps = periods_per_second(self._reso)
+        return self._maybe_mask_results(self.asi8 / pps, fill_value=None)
 
-    def to_pytimedelta(self) -> np.ndarray:
+    def to_pytimedelta(self) -> npt.NDArray[np.object_]:
         """
-        Return Timedelta Array/Index as object ndarray of datetime.timedelta
-        objects.
+        Return an ndarray of datetime.timedelta objects.
 
         Returns
         -------
         timedeltas : ndarray[object]
         """
-        return tslibs.ints_to_pytimedelta(self.asi8)
+        return ints_to_pytimedelta(self._ndarray)
 
     days = _field_accessor("days", "days", "Number of days for each element.")
     seconds = _field_accessor(
@@ -893,8 +799,10 @@ def to_pytimedelta(self) -> np.ndarray:
     @property
     def components(self) -> DataFrame:
         """
-        Return a dataframe of the components (days, hours, minutes,
-        seconds, milliseconds, microseconds, nanoseconds) of the Timedeltas.
+        Return a DataFrame of the individual resolution components of the Timedeltas.
+
+        The components (days, hours, minutes seconds, milliseconds, microseconds,
+        nanoseconds) are returned as columns in a DataFrame.
 
         Returns
         -------
@@ -911,7 +819,7 @@ def components(self) -> DataFrame:
             "microseconds",
             "nanoseconds",
         ]
-        hasnans = self._hasnans
+        hasnans = self._hasna
         if hasnans:
 
             def f(x):
@@ -967,30 +875,15 @@ def sequence_to_td64ns(
     errors to be ignored; they are caught and subsequently ignored at a
     higher level.
     """
+    assert unit not in ["Y", "y", "M"]  # caller is responsible for checking
+
     inferred_freq = None
     if unit is not None:
         unit = parse_timedelta_unit(unit)
 
-    # Unwrap whatever we have into a np.ndarray
-    if not hasattr(data, "dtype"):
-        # e.g. list, tuple
-        if np.ndim(data) == 0:
-            # i.e. generator
-            data = list(data)
-        data = np.array(data, copy=False)
-    elif isinstance(data, ABCMultiIndex):
-        raise TypeError("Cannot create a DatetimeArray from a MultiIndex.")
-    else:
-        data = extract_array(data, extract_numpy=True)
-
-    if isinstance(data, IntegerArray):
-        data = data.to_numpy("int64", na_value=iNaT)
-    elif not isinstance(data, (np.ndarray, ExtensionArray)):
-        # GH#24539 e.g. xarray, dask object
-        data = np.asarray(data)
-    elif isinstance(data, ABCCategorical):
-        data = data.categories.take(data.codes, fill_value=NaT)._values
-        copy = False
+    data, copy = dtl.ensure_arraylike_for_datetimelike(
+        data, copy, cls_name="TimedeltaArray"
+    )
 
     if isinstance(data, TimedeltaArray):
         inferred_freq = data.freq
@@ -998,7 +891,7 @@ def sequence_to_td64ns(
     # Convert whatever we have into timedelta64[ns] dtype
     if is_object_dtype(data.dtype) or is_string_dtype(data.dtype):
         # no need to make a copy, need to convert if string-dtyped
-        data = objects_to_td64ns(data, unit=unit, errors=errors)
+        data = _objects_to_td64ns(data, unit=unit, errors=errors)
         copy = False
 
     elif is_integer_dtype(data.dtype):
@@ -1010,6 +903,7 @@ def sequence_to_td64ns(
         # cast the unit, multiply base/frac separately
         # to avoid precision issues from float -> int
         mask = np.isnan(data)
+        # The next few lines are effectively a vectorized 'cast_from_unit'
         m, p = precision_from_unit(unit or "ns")
         base = data.astype(np.int64)
         frac = data - base
@@ -1022,7 +916,7 @@ def sequence_to_td64ns(
     elif is_timedelta64_dtype(data.dtype):
         if data.dtype != TD64NS_DTYPE:
             # non-nano unit
-            data = ensure_timedelta64ns(data)
+            data = astype_overflowsafe(data, dtype=TD64NS_DTYPE)
             copy = False
 
     else:
@@ -1064,7 +958,7 @@ def ints_to_td64ns(data, unit="ns"):
         dtype_str = f"timedelta64[{unit}]"
         data = data.view(dtype_str)
 
-        data = ensure_timedelta64ns(data)
+        data = astype_overflowsafe(data, dtype=TD64NS_DTYPE)
 
         # the astype conversion makes a copy, so we can avoid re-copying later
         copy_made = True
@@ -1075,7 +969,7 @@ def ints_to_td64ns(data, unit="ns"):
     return data, copy_made
 
 
-def objects_to_td64ns(data, unit=None, errors="raise"):
+def _objects_to_td64ns(data, unit=None, errors="raise"):
     """
     Convert a object-dtyped or string-dtyped array into an
     timedelta64[ns]-dtyped array.
diff --git a/pandas/core/base.py b/pandas/core/base.py
index ef3a60f46283a..b04d4348cb9f6 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -16,6 +16,7 @@
     final,
     overload,
 )
+import warnings
 
 import numpy as np
 
@@ -35,6 +36,7 @@
     cache_readonly,
     doc,
 )
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
@@ -77,9 +79,13 @@
     from pandas._typing import (
         NumpySorter,
         NumpyValueArrayLike,
+        ScalarLike_co,
     )
 
-    from pandas import Categorical
+    from pandas import (
+        Categorical,
+        Series,
+    )
 
 
 _shared_docs: dict[str, str] = {}
@@ -159,7 +165,7 @@ def _freeze(self):
         object.__setattr__(self, "__frozen", True)
 
     # prevent adding any attribute via s.xxx.new_attribute = ...
-    def __setattr__(self, key: str, value):
+    def __setattr__(self, key: str, value) -> None:
         # _cache is used by a decorator
         # We need to check both 1.) cls.__dict__ and 2.) getattr(self, key)
         # because
@@ -174,14 +180,6 @@ def __setattr__(self, key: str, value):
         object.__setattr__(self, key, value)
 
 
-class DataError(Exception):
-    pass
-
-
-class SpecificationError(Exception):
-    pass
-
-
 class SelectionMixin(Generic[NDFrameT]):
     """
     mixin implementing the selection & aggregation interface on a group-like
@@ -224,9 +222,9 @@ def _obj_with_exclusions(self):
         if len(self.exclusions) > 0:
             # equivalent to `self.obj.drop(self.exclusions, axis=1)
             #  but this avoids consolidating and making a copy
-            return self.obj._drop_axis(
-                self.exclusions, axis=1, consolidate=False, only_slice=True
-            )
+            # TODO: following GH#45287 can we now use .drop directly without
+            #  making a copy?
+            return self.obj._drop_axis(self.exclusions, axis=1, only_slice=True)
         else:
             return self.obj
 
@@ -324,7 +322,7 @@ def __len__(self) -> int:
         raise AbstractMethodError(self)
 
     @property
-    def ndim(self) -> int:
+    def ndim(self) -> Literal[1]:
         """
         Number of dimensions of the underlying data, by definition 1.
         """
@@ -431,7 +429,7 @@ def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
         **kwargs,
     ) -> np.ndarray:
         """
@@ -539,7 +537,7 @@ def to_numpy(
         if copy or na_value is not lib.no_default:
             result = result.copy()
             if na_value is not lib.no_default:
-                result[self.isna()] = na_value
+                result[np.asanyarray(self.isna())] = na_value
         return result
 
     @property
@@ -601,7 +599,7 @@ def argmax(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:
         Parameters
         ----------
         axis : {{None}}
-            Dummy argument for consistency with Series.
+            Unused. Parameter needed for compatibility with DataFrame.
         skipna : bool, default True
             Exclude NA/null values when showing the result.
         *args, **kwargs
@@ -763,11 +761,15 @@ def __iter__(self):
     @cache_readonly
     def hasnans(self) -> bool:
         """
-        Return if I have any nans; enables various perf speedups.
+        Return True if there are any NaNs.
+
+        Enables various performance speedups.
         """
-        return bool(isna(self).any())
+        # error: Item "bool" of "Union[bool, ndarray[Any, dtype[bool_]], NDFrame]"
+        # has no attribute "any"
+        return bool(isna(self).any())  # type: ignore[union-attr]
 
-    def isna(self):
+    def isna(self) -> npt.NDArray[np.bool_]:
         return isna(self._values)
 
     def _reduce(
@@ -836,6 +838,16 @@ def _map_values(self, mapper, na_action=None):
                 )
 
         if isinstance(mapper, ABCSeries):
+            if na_action not in (None, "ignore"):
+                msg = (
+                    "na_action must either be 'ignore' or None, "
+                    f"{na_action} was passed"
+                )
+                raise ValueError(msg)
+
+            if na_action == "ignore":
+                mapper = mapper[mapper.index.notna()]
+
             # Since values were input this means we came from either
             # a dict or a series and mapper should be an index
             if is_categorical_dtype(self.dtype):
@@ -886,7 +898,7 @@ def value_counts(
         ascending: bool = False,
         bins=None,
         dropna: bool = True,
-    ):
+    ) -> Series:
         """
         Return a Series containing counts of unique values.
 
@@ -979,10 +991,12 @@ def unique(self):
 
         if not isinstance(values, np.ndarray):
             result: ArrayLike = values.unique()
-            if self.dtype.kind in ["m", "M"] and isinstance(self, ABCSeries):
-                # GH#31182 Series._values returns EA, unpack for backward-compat
-                if getattr(self.dtype, "tz", None) is None:
-                    result = np.asarray(result)
+            if (
+                isinstance(self.dtype, np.dtype) and self.dtype.kind in ["m", "M"]
+            ) and isinstance(self, ABCSeries):
+                # GH#31182 Series._values returns EA
+                # unpack numpy datetime for backward-compat
+                result = np.asarray(result)
         else:
             result = unique1d(values)
 
@@ -1041,30 +1055,41 @@ def is_unique(self) -> bool:
     @property
     def is_monotonic(self) -> bool:
         """
-        Return boolean if values in the object are
-        monotonic_increasing.
+        Return boolean if values in the object are monotonically increasing.
+
+        .. deprecated:: 1.5.0
+            is_monotonic is deprecated and will be removed in a future version.
+            Use is_monotonic_increasing instead.
 
         Returns
         -------
         bool
         """
-        from pandas import Index
-
-        return Index(self).is_monotonic
+        warnings.warn(
+            "is_monotonic is deprecated and will be removed in a future version. "
+            "Use is_monotonic_increasing instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        return self.is_monotonic_increasing
 
     @property
     def is_monotonic_increasing(self) -> bool:
         """
-        Alias for is_monotonic.
+        Return boolean if values in the object are monotonically increasing.
+
+        Returns
+        -------
+        bool
         """
-        # mypy complains if we alias directly
-        return self.is_monotonic
+        from pandas import Index
+
+        return Index(self).is_monotonic_increasing
 
     @property
     def is_monotonic_decreasing(self) -> bool:
         """
-        Return boolean if values in the object are
-        monotonic_decreasing.
+        Return boolean if values in the object are monotonically decreasing.
 
         Returns
         -------
@@ -1122,8 +1147,15 @@ def _memory_usage(self, deep: bool = False) -> int:
             """
         ),
     )
-    def factorize(self, sort: bool = False, na_sentinel: int | None = -1):
-        return algorithms.factorize(self, sort=sort, na_sentinel=na_sentinel)
+    def factorize(
+        self,
+        sort: bool = False,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
+    ):
+        return algorithms.factorize(
+            self, sort=sort, na_sentinel=na_sentinel, use_na_sentinel=use_na_sentinel
+        )
 
     _shared_docs[
         "searchsorted"
@@ -1235,7 +1267,7 @@ def factorize(self, sort: bool = False, na_sentinel: int | None = -1):
     # return types  [misc]
     def searchsorted(  # type: ignore[misc]
         self,
-        value: npt._ScalarLike_co,
+        value: ScalarLike_co,
         side: Literal["left", "right"] = ...,
         sorter: NumpySorter = ...,
     ) -> np.intp:
diff --git a/pandas/core/common.py b/pandas/core/common.py
index e3989238be849..641ddba0222e9 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -35,7 +35,6 @@
     ArrayLike,
     NpDtype,
     RandomState,
-    Scalar,
     T,
 )
 from pandas.util._exceptions import find_stack_level
@@ -59,14 +58,6 @@
     from pandas import Index
 
 
-class SettingWithCopyError(ValueError):
-    pass
-
-
-class SettingWithCopyWarning(Warning):
-    pass
-
-
 def flatten(line):
     """
     Flatten an arbitrarily nested sequence.
@@ -134,11 +125,11 @@ def is_bool_indexer(key: Any) -> bool:
         is_array_like(key) and is_extension_array_dtype(key.dtype)
     ):
         if key.dtype == np.object_:
-            key = np.asarray(key)
+            key_array = np.asarray(key)
 
-            if not lib.is_bool_array(key):
+            if not lib.is_bool_array(key_array):
                 na_msg = "Cannot mask with non-boolean array containing NA / NaN values"
-                if lib.infer_dtype(key) == "boolean" and isna(key).any():
+                if lib.infer_dtype(key_array) == "boolean" and isna(key_array).any():
                     # Don't raise on e.g. ["A", "B", np.nan], see
                     #  test_loc_getitem_list_of_labels_categoricalindex_with_na
                     raise ValueError(na_msg)
@@ -226,19 +217,42 @@ def count_not_none(*args) -> int:
     return sum(x is not None for x in args)
 
 
-def asarray_tuplesafe(values, dtype: NpDtype | None = None) -> np.ndarray:
+@overload
+def asarray_tuplesafe(
+    values: ArrayLike | list | tuple | zip, dtype: NpDtype | None = ...
+) -> np.ndarray:
+    # ExtensionArray can only be returned when values is an Index, all other iterables
+    # will return np.ndarray. Unfortunately "all other" cannot be encoded in a type
+    # signature, so instead we special-case some common types.
+    ...
+
+
+@overload
+def asarray_tuplesafe(values: Iterable, dtype: NpDtype | None = ...) -> ArrayLike:
+    ...
+
+
+def asarray_tuplesafe(values: Iterable, dtype: NpDtype | None = None) -> ArrayLike:
 
     if not (isinstance(values, (list, tuple)) or hasattr(values, "__array__")):
         values = list(values)
     elif isinstance(values, ABCIndex):
-        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
-        # expected "ndarray")
-        return values._values  # type: ignore[return-value]
+        return values._values
 
     if isinstance(values, list) and dtype in [np.object_, object]:
         return construct_1d_object_array_from_listlike(values)
 
-    result = np.asarray(values, dtype=dtype)
+    try:
+        with warnings.catch_warnings():
+            # Can remove warning filter once NumPy 1.24 is min version
+            warnings.simplefilter("ignore", np.VisibleDeprecationWarning)
+            result = np.asarray(values, dtype=dtype)
+    except ValueError:
+        # Using try/except since it's more performant than checking is_list_like
+        # over each element
+        # error: Argument 1 to "construct_1d_object_array_from_listlike"
+        # has incompatible type "Iterable[Any]"; expected "Sized"
+        return construct_1d_object_array_from_listlike(values)  # type: ignore[arg-type]
 
     if issubclass(result.dtype.type, str):
         result = np.asarray(values, dtype=object)
@@ -251,7 +265,9 @@ def asarray_tuplesafe(values, dtype: NpDtype | None = None) -> np.ndarray:
     return result
 
 
-def index_labels_to_array(labels, dtype: NpDtype | None = None) -> np.ndarray:
+def index_labels_to_array(
+    labels: np.ndarray | Iterable, dtype: NpDtype | None = None
+) -> np.ndarray:
     """
     Transform label or iterable of labels to array, for use in Index.
 
@@ -475,7 +491,7 @@ def pipe(
     func : callable or tuple of (callable, str)
         Function to apply to this object or, alternatively, a
         ``(callable, data_keyword)`` tuple where ``data_keyword`` is a
-        string indicating the keyword of `callable`` that expects the
+        string indicating the keyword of ``callable`` that expects the
         object.
     *args : iterable, optional
         Positional arguments passed into ``func``.
@@ -502,22 +518,18 @@ def get_rename_function(mapper):
     Returns a function that will map names/labels, dependent if mapper
     is a dict, Series or just a function.
     """
-    if isinstance(mapper, (abc.Mapping, ABCSeries)):
-
-        def f(x):
-            if x in mapper:
-                return mapper[x]
-            else:
-                return x
 
-    else:
-        f = mapper
+    def f(x):
+        if x in mapper:
+            return mapper[x]
+        else:
+            return x
 
-    return f
+    return f if isinstance(mapper, (abc.Mapping, ABCSeries)) else mapper
 
 
 def convert_to_list_like(
-    values: Scalar | Iterable | AnyArrayLike,
+    values: Hashable | Iterable | AnyArrayLike,
 ) -> list | AnyArrayLike:
     """
     Convert list-like or scalar input to list-like. List, numpy and pandas array-like
@@ -545,11 +557,13 @@ def temp_setattr(obj, attr: str, value) -> Iterator[None]:
     """
     old_value = getattr(obj, attr)
     setattr(obj, attr, value)
-    yield obj
-    setattr(obj, attr, old_value)
+    try:
+        yield obj
+    finally:
+        setattr(obj, attr, old_value)
 
 
-def require_length_match(data, index: Index):
+def require_length_match(data, index: Index) -> None:
     """
     Check the length of data matches the length of the index.
     """
@@ -609,7 +623,7 @@ def get_cython_func(arg: Callable) -> str | None:
 
 def is_builtin_func(arg):
     """
-    if we define an builtin function for this argument, return it,
+    if we define a builtin function for this argument, return it,
     otherwise return the arg
     """
     return _builtin_table.get(arg, arg)
@@ -632,3 +646,65 @@ def fill_missing_names(names: Sequence[Hashable | None]) -> list[Hashable]:
         list of column names with the None values replaced.
     """
     return [f"level_{i}" if name is None else name for i, name in enumerate(names)]
+
+
+def resolve_numeric_only(numeric_only: bool | None | lib.NoDefault) -> bool:
+    """Determine the Boolean value of numeric_only.
+
+    See GH#46560 for details on the deprecation.
+
+    Parameters
+    ----------
+    numeric_only : bool, None, or lib.no_default
+        Value passed to the method.
+
+    Returns
+    -------
+    Resolved value of numeric_only.
+    """
+    if numeric_only is lib.no_default:
+        # Methods that behave like numeric_only=True and only got the numeric_only
+        # arg in 1.5.0 default to lib.no_default
+        result = True
+    elif numeric_only is None:
+        # Methods that had the numeric_only arg prior to 1.5.0 and try all columns
+        # first default to None
+        result = False
+    else:
+        result = numeric_only
+    return result
+
+
+def deprecate_numeric_only_default(
+    cls: type, name: str, deprecate_none: bool = False
+) -> None:
+    """Emit FutureWarning message for deprecation of numeric_only.
+
+    See GH#46560 for details on the deprecation.
+
+    Parameters
+    ----------
+    cls : type
+        pandas type that is generating the warning.
+    name : str
+        Name of the method that is generating the warning.
+    deprecate_none : bool, default False
+        Whether to also warn about the deprecation of specifying ``numeric_only=None``.
+    """
+    if name in ["all", "any"]:
+        arg_name = "bool_only"
+    else:
+        arg_name = "numeric_only"
+
+    msg = (
+        f"The default value of {arg_name} in {cls.__name__}.{name} is "
+        "deprecated. In a future version, it will default to False. "
+    )
+    if deprecate_none:
+        msg += f"In addition, specifying '{arg_name}=None' is deprecated. "
+    msg += (
+        f"Select only valid columns or specify the value of {arg_name} to silence "
+        "this warning."
+    )
+
+    warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
diff --git a/pandas/core/computation/align.py b/pandas/core/computation/align.py
index f14882227ddd9..2e7a0f842ee6d 100644
--- a/pandas/core/computation/align.py
+++ b/pandas/core/computation/align.py
@@ -9,6 +9,7 @@
 )
 from typing import (
     TYPE_CHECKING,
+    Callable,
     Sequence,
 )
 import warnings
@@ -28,6 +29,8 @@
 from pandas.core.computation.common import result_type_many
 
 if TYPE_CHECKING:
+    from pandas._typing import F
+
     from pandas.core.generic import NDFrame
     from pandas.core.indexes.api import Index
 
@@ -62,7 +65,7 @@ def _any_pandas_objects(terms) -> bool:
     return any(isinstance(term.value, PandasObject) for term in terms)
 
 
-def _filter_special_cases(f):
+def _filter_special_cases(f) -> Callable[[F], F]:
     @wraps(f)
     def wrapper(terms):
         # single unary operand
diff --git a/pandas/core/computation/check.py b/pandas/core/computation/check.py
index 7be617de63a40..3221b158241f5 100644
--- a/pandas/core/computation/check.py
+++ b/pandas/core/computation/check.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pandas.compat._optional import import_optional_dependency
 
 ne = import_optional_dependency("numexpr", errors="warn")
diff --git a/pandas/core/computation/common.py b/pandas/core/computation/common.py
index 8a9583c465f50..a1ac3dfa06ee0 100644
--- a/pandas/core/computation/common.py
+++ b/pandas/core/computation/common.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from functools import reduce
 
 import numpy as np
@@ -5,7 +7,7 @@
 from pandas._config import get_option
 
 
-def ensure_decoded(s):
+def ensure_decoded(s) -> str:
     """
     If we have bytes, decode them to unicode.
     """
diff --git a/pandas/core/computation/engines.py b/pandas/core/computation/engines.py
index ec3548c9efc6c..2ea5a5367611f 100644
--- a/pandas/core/computation/engines.py
+++ b/pandas/core/computation/engines.py
@@ -4,12 +4,14 @@
 from __future__ import annotations
 
 import abc
+from typing import TYPE_CHECKING
+
+from pandas.errors import NumExprClobberingError
 
 from pandas.core.computation.align import (
     align_terms,
     reconstruct_object,
 )
-from pandas.core.computation.expr import Expr
 from pandas.core.computation.ops import (
     MATHOPS,
     REDUCTIONS,
@@ -17,11 +19,10 @@
 
 import pandas.io.formats.printing as printing
 
-_ne_builtins = frozenset(MATHOPS + REDUCTIONS)
-
+if TYPE_CHECKING:
+    from pandas.core.computation.expr import Expr
 
-class NumExprClobberingError(NameError):
-    pass
+_ne_builtins = frozenset(MATHOPS + REDUCTIONS)
 
 
 def _check_ne_builtin_clash(expr: Expr) -> None:
@@ -48,7 +49,7 @@ class AbstractEngine(metaclass=abc.ABCMeta):
 
     has_neg_frac = False
 
-    def __init__(self, expr):
+    def __init__(self, expr) -> None:
         self.expr = expr
         self.aligned_axes = None
         self.result_type = None
diff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py
index d82cc37b90ad4..f833b59a2484d 100644
--- a/pandas/core/computation/eval.py
+++ b/pandas/core/computation/eval.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import tokenize
+from typing import TYPE_CHECKING
 import warnings
 
 from pandas._libs.lib import no_default
@@ -15,12 +16,15 @@
     PARSERS,
     Expr,
 )
-from pandas.core.computation.ops import BinOp
 from pandas.core.computation.parsing import tokenize_string
 from pandas.core.computation.scope import ensure_scope
+from pandas.core.generic import NDFrame
 
 from pandas.io.formats.printing import pprint_thing
 
+if TYPE_CHECKING:
+    from pandas.core.computation.ops import BinOp
+
 
 def _check_engine(engine: str | None) -> str:
     """
@@ -206,12 +210,11 @@ def eval(
 
         The engine used to evaluate the expression. Supported engines are
 
-        - None         : tries to use ``numexpr``, falls back to ``python``
-        - ``'numexpr'``: This default engine evaluates pandas objects using
-                         numexpr for large speed ups in complex expressions
-                         with large frames.
-        - ``'python'``: Performs operations as if you had ``eval``'d in top
-                        level python. This engine is generally not that useful.
+        - None : tries to use ``numexpr``, falls back to ``python``
+        - ``'numexpr'`` : This default engine evaluates pandas objects using
+          numexpr for large speed ups in complex expressions with large frames.
+        - ``'python'`` : Performs operations as if you had ``eval``'d in top
+          level python. This engine is generally not that useful.
 
         More backends may be available in the future.
 
@@ -384,7 +387,10 @@ def eval(
             try:
                 with warnings.catch_warnings(record=True):
                     # TODO: Filter the warnings we actually care about here.
-                    target[assigner] = ret
+                    if inplace and isinstance(target, NDFrame):
+                        target.loc[:, assigner] = ret
+                    else:
+                        target[assigner] = ret
             except (TypeError, IndexError) as err:
                 raise ValueError("Cannot assign expression output to target") from err
 
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index f8716ca1bafe0..ff3f259f49955 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -18,6 +18,7 @@
 import numpy as np
 
 from pandas.compat import PY39
+from pandas.errors import UndefinedVariableError
 
 import pandas.core.common as com
 from pandas.core.computation.ops import (
@@ -35,7 +36,6 @@
     Op,
     Term,
     UnaryOp,
-    UndefinedVariableError,
     is_term,
 )
 from pandas.core.computation.parsing import (
@@ -393,7 +393,7 @@ class BaseExprVisitor(ast.NodeVisitor):
 
     unsupported_nodes: tuple[str, ...]
 
-    def __init__(self, env, engine, parser, preparser=_preparse):
+    def __init__(self, env, engine, parser, preparser=_preparse) -> None:
         self.env = env
         self.engine = engine
         self.parser = parser
@@ -548,13 +548,13 @@ def visit_UnaryOp(self, node, **kwargs):
     def visit_Name(self, node, **kwargs):
         return self.term_type(node.id, self.env, **kwargs)
 
-    def visit_NameConstant(self, node, **kwargs):
+    def visit_NameConstant(self, node, **kwargs) -> Term:
         return self.const_type(node.value, self.env)
 
-    def visit_Num(self, node, **kwargs):
+    def visit_Num(self, node, **kwargs) -> Term:
         return self.const_type(node.n, self.env)
 
-    def visit_Constant(self, node, **kwargs):
+    def visit_Constant(self, node, **kwargs) -> Term:
         return self.const_type(node.n, self.env)
 
     def visit_Str(self, node, **kwargs):
@@ -768,13 +768,15 @@ def __init__(
             _preparse,
             f=_compose(_replace_locals, _replace_booleans, clean_backtick_quoted_toks),
         ),
-    ):
+    ) -> None:
         super().__init__(env, engine, parser, preparser)
 
 
 @disallow(_unsupported_nodes | _python_not_supported | frozenset(["Not"]))
 class PythonExprVisitor(BaseExprVisitor):
-    def __init__(self, env, engine, parser, preparser=lambda x: x):
+    def __init__(
+        self, env, engine, parser, preparser=lambda source, f=None: source
+    ) -> None:
         super().__init__(env, engine, parser, preparser=preparser)
 
 
@@ -802,7 +804,7 @@ def __init__(
         parser: str = "pandas",
         env: Scope | None = None,
         level: int = 0,
-    ):
+    ) -> None:
         self.expr = expr
         self.env = env or Scope(level=level + 1)
         self.engine = engine
diff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py
index 9e180f11c4211..afb4d0d549c45 100644
--- a/pandas/core/computation/expressions.py
+++ b/pandas/core/computation/expressions.py
@@ -15,6 +15,7 @@
 from pandas._config import get_option
 
 from pandas._typing import FuncType
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.computation.check import NUMEXPR_INSTALLED
 from pandas.core.ops import roperator
@@ -38,7 +39,7 @@
 _MIN_ELEMENTS = 1_000_000
 
 
-def set_use_numexpr(v=True):
+def set_use_numexpr(v=True) -> None:
     # set/unset to use numexpr
     global USE_NUMEXPR
     if NUMEXPR_INSTALLED:
@@ -51,7 +52,7 @@ def set_use_numexpr(v=True):
     _where = _where_numexpr if USE_NUMEXPR else _where_standard
 
 
-def set_numexpr_threads(n=None):
+def set_numexpr_threads(n=None) -> None:
     # if we are using numexpr, set the threads to n
     # otherwise reset
     if NUMEXPR_INSTALLED and USE_NUMEXPR:
@@ -214,7 +215,8 @@ def _bool_arith_fallback(op_str, a, b):
             warnings.warn(
                 f"evaluating in Python space because the {repr(op_str)} "
                 "operator is not supported by numexpr for the bool dtype, "
-                f"use {repr(_BOOL_OP_UNSUPPORTED[op_str])} instead."
+                f"use {repr(_BOOL_OP_UNSUPPORTED[op_str])} instead.",
+                stacklevel=find_stack_level(),
             )
             return True
     return False
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 8758565cf9f2a..cb7b33e40d989 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -10,6 +10,7 @@
 from typing import (
     Callable,
     Iterable,
+    Literal,
 )
 
 import numpy as np
@@ -65,20 +66,6 @@
 LOCAL_TAG = "__pd_eval_local_"
 
 
-class UndefinedVariableError(NameError):
-    """
-    NameError subclass for local variables.
-    """
-
-    def __init__(self, name: str, is_local: bool | None = None):
-        base_msg = f"{repr(name)} is not defined"
-        if is_local:
-            msg = f"local variable {base_msg}"
-        else:
-            msg = f"name {base_msg}"
-        super().__init__(msg)
-
-
 class Term:
     def __new__(cls, name, env, side=None, encoding=None):
         klass = Constant if not isinstance(name, str) else cls
@@ -88,7 +75,7 @@ def __new__(cls, name, env, side=None, encoding=None):
 
     is_local: bool
 
-    def __init__(self, name, env, side=None, encoding=None):
+    def __init__(self, name, env, side=None, encoding=None) -> None:
         # name is a str for Term, but may be something else for subclasses
         self._name = name
         self.env = env
@@ -108,11 +95,18 @@ def __repr__(self) -> str:
     def __call__(self, *args, **kwargs):
         return self.value
 
-    def evaluate(self, *args, **kwargs):
+    def evaluate(self, *args, **kwargs) -> Term:
         return self
 
     def _resolve_name(self):
-        res = self.env.resolve(self.local_name, is_local=self.is_local)
+        local_name = str(self.local_name)
+        is_local = self.is_local
+        if local_name in self.env.scope and isinstance(
+            self.env.scope[local_name], type
+        ):
+            is_local = False
+
+        res = self.env.resolve(local_name, is_local=is_local)
         self.update(res)
 
         if hasattr(res, "ndim") and res.ndim > 2:
@@ -121,7 +115,7 @@ def _resolve_name(self):
             )
         return res
 
-    def update(self, value):
+    def update(self, value) -> None:
         """
         search order for local (i.e., @variable) variables:
 
@@ -189,7 +183,7 @@ def ndim(self) -> int:
 
 
 class Constant(Term):
-    def __init__(self, value, env, side=None, encoding=None):
+    def __init__(self, value, env, side=None, encoding=None) -> None:
         super().__init__(value, env, side=side, encoding=encoding)
 
     def _resolve_name(self):
@@ -215,7 +209,7 @@ class Op:
 
     op: str
 
-    def __init__(self, op: str, operands: Iterable[Term | Op], encoding=None):
+    def __init__(self, op: str, operands: Iterable[Term | Op], encoding=None) -> None:
         self.op = _bool_op_map.get(op, op)
         self.operands = operands
         self.encoding = encoding
@@ -375,7 +369,7 @@ class BinOp(Op):
     rhs : Term or Op
     """
 
-    def __init__(self, op: str, lhs, rhs):
+    def __init__(self, op: str, lhs, rhs) -> None:
         super().__init__(op, (lhs, rhs))
         self.lhs = lhs
         self.rhs = rhs
@@ -461,7 +455,7 @@ def evaluate(self, env, engine: str, parser, term_type, eval_in_python):
         name = env.add_tmp(res)
         return term_type(name, env=env)
 
-    def convert_values(self):
+    def convert_values(self) -> None:
         """
         Convert datetimes to a comparable value in an expression.
         """
@@ -530,7 +524,7 @@ class Div(BinOp):
         The Terms or Ops in the ``/`` expression.
     """
 
-    def __init__(self, lhs, rhs):
+    def __init__(self, lhs, rhs) -> None:
         super().__init__("/", lhs, rhs)
 
         if not isnumeric(lhs.return_type) or not isnumeric(rhs.return_type):
@@ -566,7 +560,7 @@ class UnaryOp(Op):
         * If no function associated with the passed operator token is found.
     """
 
-    def __init__(self, op: str, operand):
+    def __init__(self, op: Literal["+", "-", "~", "not"], operand) -> None:
         super().__init__(op, (operand,))
         self.operand = operand
 
@@ -578,9 +572,10 @@ def __init__(self, op: str, operand):
                 f"valid operators are {UNARY_OPS_SYMS}"
             ) from err
 
-    def __call__(self, env):
+    def __call__(self, env) -> MathCall:
         operand = self.operand(env)
-        return self.func(operand)
+        # error: Cannot call function of unknown type
+        return self.func(operand)  # type: ignore[operator]
 
     def __repr__(self) -> str:
         return pprint_thing(f"{self.op}({self.operand})")
@@ -598,7 +593,7 @@ def return_type(self) -> np.dtype:
 
 
 class MathCall(Op):
-    def __init__(self, func, args):
+    def __init__(self, func, args) -> None:
         super().__init__(func.name, args)
         self.func = func
 
@@ -614,7 +609,7 @@ def __repr__(self) -> str:
 
 
 class FuncNode:
-    def __init__(self, name: str):
+    def __init__(self, name: str) -> None:
         if name not in MATHOPS:
             raise ValueError(f'"{name}" is not a supported function')
         self.name = name
diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index 3e041c088f566..5fbc26c057862 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -3,7 +3,10 @@
 
 import ast
 from functools import partial
-from typing import Any
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
 
 import numpy as np
 
@@ -12,7 +15,7 @@
     Timestamp,
 )
 from pandas._typing import npt
-from pandas.compat.chainmap import DeepChainMap
+from pandas.errors import UndefinedVariableError
 
 from pandas.core.dtypes.common import is_list_like
 
@@ -24,10 +27,7 @@
 )
 from pandas.core.computation.common import ensure_decoded
 from pandas.core.computation.expr import BaseExprVisitor
-from pandas.core.computation.ops import (
-    UndefinedVariableError,
-    is_term,
-)
+from pandas.core.computation.ops import is_term
 from pandas.core.construction import extract_array
 from pandas.core.indexes.base import Index
 
@@ -36,6 +36,9 @@
     pprint_thing_encoded,
 )
 
+if TYPE_CHECKING:
+    from pandas.compat.chainmap import DeepChainMap
+
 
 class PyTablesScope(_scope.Scope):
     __slots__ = ("queryables",)
@@ -48,7 +51,7 @@ def __init__(
         global_dict=None,
         local_dict=None,
         queryables: dict[str, Any] | None = None,
-    ):
+    ) -> None:
         super().__init__(level + 1, global_dict=global_dict, local_dict=local_dict)
         self.queryables = queryables or {}
 
@@ -63,7 +66,7 @@ def __new__(cls, name, env, side=None, encoding=None):
             klass = Constant
         return object.__new__(klass)
 
-    def __init__(self, name, env: PyTablesScope, side=None, encoding=None):
+    def __init__(self, name, env: PyTablesScope, side=None, encoding=None) -> None:
         super().__init__(name, env, side=side, encoding=encoding)
 
     def _resolve_name(self):
@@ -87,7 +90,7 @@ def value(self):
 
 
 class Constant(Term):
-    def __init__(self, value, env: PyTablesScope, side=None, encoding=None):
+    def __init__(self, value, env: PyTablesScope, side=None, encoding=None) -> None:
         assert isinstance(env, PyTablesScope), type(env)
         super().__init__(value, env, side=side, encoding=encoding)
 
@@ -103,7 +106,7 @@ class BinOp(ops.BinOp):
     queryables: dict[str, Any]
     condition: str | None
 
-    def __init__(self, op: str, lhs, rhs, queryables: dict[str, Any], encoding):
+    def __init__(self, op: str, lhs, rhs, queryables: dict[str, Any], encoding) -> None:
         super().__init__(op, lhs, rhs)
         self.queryables = queryables
         self.encoding = encoding
@@ -407,7 +410,7 @@ class PyTablesExprVisitor(BaseExprVisitor):
     const_type = Constant
     term_type = Term
 
-    def __init__(self, env, engine, parser, **kwargs):
+    def __init__(self, env, engine, parser, **kwargs) -> None:
         super().__init__(env, engine, parser)
         for bin_op in self.binary_ops:
             bin_node = self.binary_op_nodes_map[bin_op]
@@ -552,7 +555,7 @@ def __init__(
         queryables: dict[str, Any] | None = None,
         encoding=None,
         scope_level: int = 0,
-    ):
+    ) -> None:
 
         where = _validate_where(where)
 
@@ -563,7 +566,7 @@ def __init__(
         self._visitor = None
 
         # capture the environment if needed
-        local_dict: DeepChainMap[Any, Any] = DeepChainMap()
+        local_dict: DeepChainMap[Any, Any] | None = None
 
         if isinstance(where, PyTablesExpr):
             local_dict = where.env.scope
@@ -624,7 +627,7 @@ def evaluate(self):
 class TermValue:
     """hold a term value the we use to construct a condition/filter"""
 
-    def __init__(self, value, converted, kind: str):
+    def __init__(self, value, converted, kind: str) -> None:
         assert isinstance(kind, str), kind
         self.value = value
         self.converted = converted
diff --git a/pandas/core/computation/scope.py b/pandas/core/computation/scope.py
index a561824f868f2..5188b44618b4d 100644
--- a/pandas/core/computation/scope.py
+++ b/pandas/core/computation/scope.py
@@ -15,6 +15,7 @@
 
 from pandas._libs.tslibs import Timestamp
 from pandas.compat.chainmap import DeepChainMap
+from pandas.errors import UndefinedVariableError
 
 
 def ensure_scope(
@@ -113,7 +114,7 @@ class Scope:
 
     def __init__(
         self, level: int, global_dict=None, local_dict=None, resolvers=(), target=None
-    ):
+    ) -> None:
         self.level = level + 1
 
         # shallow copy because we don't want to keep filling this up with what
@@ -133,11 +134,13 @@ def __init__(
             # shallow copy here because we don't want to replace what's in
             # scope when we align terms (alignment accesses the underlying
             # numpy array of pandas objects)
-            scope_global = self.scope.new_child((global_dict or frame.f_globals).copy())
+            scope_global = self.scope.new_child(
+                (global_dict if global_dict is not None else frame.f_globals).copy()
+            )
             self.scope = DeepChainMap(scope_global)
             if not isinstance(local_dict, Scope):
                 scope_local = self.scope.new_child(
-                    (local_dict or frame.f_locals).copy()
+                    (local_dict if local_dict is not None else frame.f_locals).copy()
                 )
                 self.scope = DeepChainMap(scope_local)
         finally:
@@ -205,9 +208,6 @@ def resolve(self, key: str, is_local: bool):
                 # e.g., df[df > 0]
                 return self.temps[key]
             except KeyError as err:
-                # runtime import because ops imports from scope
-                from pandas.core.computation.ops import UndefinedVariableError
-
                 raise UndefinedVariableError(key, is_local) from err
 
     def swapkey(self, old_key: str, new_key: str, new_value=None) -> None:
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index bf2d770ee1e7f..e6beab0b34038 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -9,6 +9,8 @@
 module is imported, register them here rather than in the module.
 
 """
+from __future__ import annotations
+
 import os
 from typing import Callable
 import warnings
@@ -37,7 +39,7 @@
 """
 
 
-def use_bottleneck_cb(key):
+def use_bottleneck_cb(key) -> None:
     from pandas.core import nanops
 
     nanops.set_use_bottleneck(cf.get_option(key))
@@ -51,7 +53,7 @@ def use_bottleneck_cb(key):
 """
 
 
-def use_numexpr_cb(key):
+def use_numexpr_cb(key) -> None:
     from pandas.core.computation import expressions
 
     expressions.set_use_numexpr(cf.get_option(key))
@@ -65,7 +67,7 @@ def use_numexpr_cb(key):
 """
 
 
-def use_numba_cb(key):
+def use_numba_cb(key) -> None:
     from pandas.core.util import numba_
 
     numba_.set_use_numba(cf.get_option(key))
@@ -259,7 +261,7 @@ def use_numba_cb(key):
 
 pc_chop_threshold_doc = """
 : float or None
-    if set to a float value, all float values smaller then the given threshold
+    if set to a float value, all float values smaller than the given threshold
     will be displayed as exactly 0 by repr and friends.
 """
 
@@ -329,7 +331,7 @@ def use_numba_cb(key):
 """
 
 
-def table_schema_cb(key):
+def table_schema_cb(key) -> None:
     from pandas.io.formats.printing import enable_data_resource_formatter
 
     enable_data_resource_formatter(cf.get_option(key))
@@ -361,7 +363,17 @@ def is_terminal() -> bool:
         float_format_doc,
         validator=is_one_of_factory([None, is_callable]),
     )
-    cf.register_option("column_space", 12, validator=is_int)
+
+    def _deprecate_column_space(key):
+        warnings.warn(
+            "column_space is deprecated and will be removed "
+            "in a future version. Use df.to_string(col_space=...) "
+            "instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    cf.register_option("column_space", 12, validator=is_int, cb=_deprecate_column_space)
     cf.register_option(
         "max_info_rows",
         1690785,
@@ -490,7 +502,7 @@ def _deprecate_negative_int_max_colwidth(key):
 # or we'll hit circular deps.
 
 
-def use_inf_as_na_cb(key):
+def use_inf_as_na_cb(key) -> None:
     from pandas.core.dtypes.missing import _use_inf_as_na
 
     _use_inf_as_na(key)
@@ -527,6 +539,26 @@ def use_inf_as_na_cb(key):
     )
 
 
+# TODO better name?
+copy_on_write_doc = """
+: bool
+    Use new copy-view behaviour using Copy-on-Write. Defaults to False,
+    unless overridden by the 'PANDAS_COPY_ON_WRITE' environment variable
+    (if set to "1" for True, needs to be set before pandas is imported).
+"""
+
+
+with cf.config_prefix("mode"):
+    cf.register_option(
+        "copy_on_write",
+        # Get the default from an environment variable, if set, otherwise defaults
+        # to False. This environment variable can be set for testing.
+        os.environ.get("PANDAS_COPY_ON_WRITE", "0") == "1",
+        copy_on_write_doc,
+        validator=is_bool,
+    )
+
+
 # user warnings
 chained_assignment = """
 : string
@@ -710,7 +742,7 @@ def use_inf_as_na_cb(key):
 """
 
 
-def register_plotting_backend_cb(key):
+def register_plotting_backend_cb(key) -> None:
     if key == "matplotlib":
         # We defer matplotlib validation, since it's the default
         return
@@ -736,7 +768,7 @@ def register_plotting_backend_cb(key):
 """
 
 
-def register_converter_cb(key):
+def register_converter_cb(key) -> None:
     from pandas.plotting import (
         deregister_matplotlib_converters,
         register_matplotlib_converters,
@@ -876,7 +908,7 @@ def register_converter_cb(key):
 
     cf.register_option(
         "render.max_elements",
-        2 ** 18,
+        2**18,
         styler_max_elements,
         validator=is_nonnegative_int,
     )
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index e496125683c09..4b63d492ec1dd 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -9,8 +9,11 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Optional,
     Sequence,
+    Union,
     cast,
+    overload,
 )
 import warnings
 
@@ -18,11 +21,13 @@
 import numpy.ma as ma
 
 from pandas._libs import lib
+from pandas._libs.tslibs.period import Period
 from pandas._typing import (
     AnyArrayLike,
     ArrayLike,
     Dtype,
     DtypeObj,
+    T,
 )
 from pandas.errors import IntCastingNaNError
 from pandas.util._exceptions import find_stack_level
@@ -329,7 +334,8 @@ def array(
     if dtype is None:
         inferred_dtype = lib.infer_dtype(data, skipna=True)
         if inferred_dtype == "period":
-            return PeriodArray._from_sequence(data, copy=copy)
+            period_data = cast(Union[Sequence[Optional[Period]], AnyArrayLike], data)
+            return PeriodArray._from_sequence(period_data, copy=copy)
 
         elif inferred_dtype == "interval":
             return IntervalArray(data, copy=copy)
@@ -376,9 +382,23 @@ def array(
     return PandasArray._from_sequence(data, dtype=dtype, copy=copy)
 
 
+@overload
 def extract_array(
-    obj: object, extract_numpy: bool = False, extract_range: bool = False
-) -> Any | ArrayLike:
+    obj: Series | Index, extract_numpy: bool = ..., extract_range: bool = ...
+) -> ArrayLike:
+    ...
+
+
+@overload
+def extract_array(
+    obj: T, extract_numpy: bool = ..., extract_range: bool = ...
+) -> T | ArrayLike:
+    ...
+
+
+def extract_array(
+    obj: T, extract_numpy: bool = False, extract_range: bool = False
+) -> T | ArrayLike:
     """
     Extract the ndarray or ExtensionArray from a Series or Index.
 
@@ -425,12 +445,15 @@ def extract_array(
         if isinstance(obj, ABCRangeIndex):
             if extract_range:
                 return obj._values
-            return obj
+            # https://github.com/python/mypy/issues/1081
+            # error: Incompatible return value type (got "RangeIndex", expected
+            # "Union[T, Union[ExtensionArray, ndarray[Any, Any]]]")
+            return obj  # type: ignore[return-value]
 
-        obj = obj._values
+        return obj._values
 
     elif extract_numpy and isinstance(obj, ABCPandasArray):
-        obj = obj.to_numpy()
+        return obj.to_numpy()
 
     return obj
 
@@ -508,7 +531,7 @@ def sanitize_array(
         dtype = dtype.numpy_dtype
 
     # extract ndarray or ExtensionArray, ensure we have no PandasArray
-    data = extract_array(data, extract_numpy=True)
+    data = extract_array(data, extract_numpy=True, extract_range=True)
 
     if isinstance(data, np.ndarray) and data.ndim == 0:
         if dtype is None:
@@ -533,7 +556,10 @@ def sanitize_array(
         if dtype is not None and is_float_dtype(data.dtype) and is_integer_dtype(dtype):
             # possibility of nan -> garbage
             try:
-                subarr = _try_cast(data, dtype, copy, True)
+                # GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int
+                # casting aligning with IntCastingNaNError below
+                with np.errstate(invalid="ignore"):
+                    subarr = _try_cast(data, dtype, copy, True)
             except IntCastingNaNError:
                 warnings.warn(
                     "In a future version, passing float-dtype values containing NaN "
@@ -561,6 +587,10 @@ def sanitize_array(
                     #  it is lossy.
                     dtype = cast(np.dtype, dtype)
                     return np.array(data, dtype=dtype, copy=copy)
+
+                # We ignore the dtype arg and return floating values,
+                #  e.g. test_constructor_floating_data_int_dtype
+                # TODO: where is the discussion that documents the reason for this?
                 subarr = np.array(data, copy=copy)
         else:
             # we will try to copy by-definition here
@@ -583,12 +613,31 @@ def sanitize_array(
         # materialize e.g. generators, convert e.g. tuples, abc.ValueView
         if hasattr(data, "__array__"):
             # e.g. dask array GH#38645
-            data = np.asarray(data)
+            data = np.array(data, copy=copy)
         else:
             data = list(data)
 
         if dtype is not None or len(data) == 0:
-            subarr = _try_cast(data, dtype, copy, raise_cast_failure)
+            try:
+                subarr = _try_cast(data, dtype, copy, raise_cast_failure)
+            except ValueError:
+                if is_integer_dtype(dtype):
+                    casted = np.array(data, copy=False)
+                    if casted.dtype.kind == "f":
+                        # GH#40110 match the behavior we have if we passed
+                        #  a ndarray[float] to begin with
+                        return sanitize_array(
+                            casted,
+                            index,
+                            dtype,
+                            copy=False,
+                            raise_cast_failure=raise_cast_failure,
+                            allow_2d=allow_2d,
+                        )
+                    else:
+                        raise
+                else:
+                    raise
         else:
             subarr = maybe_convert_platform(data)
             if subarr.dtype == object:
@@ -746,7 +795,8 @@ def _try_cast(
             #  data differently; _from_sequence treats naive as wall times,
             #  while maybe_cast_to_datetime treats it as UTC
             #  see test_maybe_promote_any_numpy_dtype_with_datetimetz
-
+            # TODO(2.0): with deprecations enforced, should be able to remove
+            #  special case.
             return maybe_cast_to_datetime(arr, dtype)
             # TODO: copy?
 
@@ -762,7 +812,16 @@ def _try_cast(
 
     elif dtype.kind == "U":
         # TODO: test cases with arr.dtype.kind in ["m", "M"]
-        return lib.ensure_string_array(arr, convert_na_value=False, copy=copy)
+        if is_ndarray:
+            arr = cast(np.ndarray, arr)
+            shape = arr.shape
+            if arr.ndim > 1:
+                arr = arr.ravel()
+        else:
+            shape = (len(arr),)
+        return lib.ensure_string_array(arr, convert_na_value=False, copy=copy).reshape(
+            shape
+        )
 
     elif dtype.kind in ["m", "M"]:
         return maybe_cast_to_datetime(arr, dtype)
diff --git a/pandas/core/describe.py b/pandas/core/describe.py
index 8d88ce280d5c8..ce2fa950e6e62 100644
--- a/pandas/core/describe.py
+++ b/pandas/core/describe.py
@@ -22,17 +22,24 @@
 import numpy as np
 
 from pandas._libs.tslibs import Timestamp
-from pandas._typing import NDFrameT
+from pandas._typing import (
+    DtypeObj,
+    NDFrameT,
+    npt,
+)
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import validate_percentile
 
 from pandas.core.dtypes.common import (
     is_bool_dtype,
+    is_complex_dtype,
     is_datetime64_any_dtype,
+    is_extension_array_dtype,
     is_numeric_dtype,
     is_timedelta64_dtype,
 )
 
+import pandas as pd
 from pandas.core.reshape.concat import concat
 
 from pandas.io.formats.format import format_percentiles
@@ -106,7 +113,7 @@ class NDFrameDescriberAbstract(ABC):
         Whether to treat datetime dtypes as numeric.
     """
 
-    def __init__(self, obj: DataFrame | Series, datetime_is_numeric: bool):
+    def __init__(self, obj: DataFrame | Series, datetime_is_numeric: bool) -> None:
         self.obj = obj
         self.datetime_is_numeric = datetime_is_numeric
 
@@ -156,7 +163,7 @@ def __init__(
         include: str | Sequence[str] | None,
         exclude: str | Sequence[str] | None,
         datetime_is_numeric: bool,
-    ):
+    ) -> None:
         self.include = include
         self.exclude = exclude
 
@@ -186,11 +193,9 @@ def _select_data(self):
         """Select columns to be described."""
         if (self.include is None) and (self.exclude is None):
             # when some numerics are found, keep only numerics
-            default_include = [np.number]
+            default_include: list[npt.DTypeLike] = [np.number]
             if self.datetime_is_numeric:
-                # error: Argument 1 to "append" of "list" has incompatible type "str";
-                # expected "Type[number[Any]]"
-                default_include.append("datetime")  # type: ignore[arg-type]
+                default_include.append("datetime")
             data = self.obj.select_dtypes(include=default_include)
             if len(data.columns) == 0:
                 data = self.obj
@@ -230,10 +235,7 @@ def describe_numeric_1d(series: Series, percentiles: Sequence[float]) -> Series:
     """
     from pandas import Series
 
-    # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
-    # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
-    # float]]]"
-    formatted_percentiles = format_percentiles(percentiles)  # type: ignore[arg-type]
+    formatted_percentiles = format_percentiles(percentiles)
 
     stat_index = ["count", "mean", "std", "min"] + formatted_percentiles + ["max"]
     d = (
@@ -241,7 +243,15 @@ def describe_numeric_1d(series: Series, percentiles: Sequence[float]) -> Series:
         + series.quantile(percentiles).tolist()
         + [series.max()]
     )
-    return Series(d, index=stat_index, name=series.name)
+    # GH#48340 - always return float on non-complex numeric data
+    dtype: DtypeObj | None
+    if is_extension_array_dtype(series):
+        dtype = pd.Float64Dtype()
+    elif is_numeric_dtype(series) and not is_complex_dtype(series):
+        dtype = np.dtype("float")
+    else:
+        dtype = None
+    return Series(d, index=stat_index, name=series.name, dtype=dtype)
 
 
 def describe_categorical_1d(
@@ -337,10 +347,7 @@ def describe_timestamp_1d(data: Series, percentiles: Sequence[float]) -> Series:
     # GH-30164
     from pandas import Series
 
-    # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
-    # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
-    # float]]]"
-    formatted_percentiles = format_percentiles(percentiles)  # type: ignore[arg-type]
+    formatted_percentiles = format_percentiles(percentiles)
 
     stat_index = ["count", "mean", "min"] + formatted_percentiles + ["max"]
     d = (
diff --git a/pandas/core/dtypes/api.py b/pandas/core/dtypes/api.py
index bb6bfda183802..e6a59bf12d7cc 100644
--- a/pandas/core/dtypes/api.py
+++ b/pandas/core/dtypes/api.py
@@ -1,5 +1,3 @@
-# flake8: noqa:F401
-
 from pandas.core.dtypes.common import (
     is_array_like,
     is_bool,
@@ -43,3 +41,47 @@
     is_unsigned_integer_dtype,
     pandas_dtype,
 )
+
+__all__ = [
+    "is_array_like",
+    "is_bool",
+    "is_bool_dtype",
+    "is_categorical",
+    "is_categorical_dtype",
+    "is_complex",
+    "is_complex_dtype",
+    "is_datetime64_any_dtype",
+    "is_datetime64_dtype",
+    "is_datetime64_ns_dtype",
+    "is_datetime64tz_dtype",
+    "is_dict_like",
+    "is_dtype_equal",
+    "is_extension_array_dtype",
+    "is_extension_type",
+    "is_file_like",
+    "is_float",
+    "is_float_dtype",
+    "is_hashable",
+    "is_int64_dtype",
+    "is_integer",
+    "is_integer_dtype",
+    "is_interval",
+    "is_interval_dtype",
+    "is_iterator",
+    "is_list_like",
+    "is_named_tuple",
+    "is_number",
+    "is_numeric_dtype",
+    "is_object_dtype",
+    "is_period_dtype",
+    "is_re",
+    "is_re_compilable",
+    "is_scalar",
+    "is_signed_integer_dtype",
+    "is_sparse",
+    "is_string_dtype",
+    "is_timedelta64_dtype",
+    "is_timedelta64_ns_dtype",
+    "is_unsigned_integer_dtype",
+    "pandas_dtype",
+]
diff --git a/pandas/core/dtypes/astype.py b/pandas/core/dtypes/astype.py
new file mode 100644
index 0000000000000..7fb58468746a8
--- /dev/null
+++ b/pandas/core/dtypes/astype.py
@@ -0,0 +1,418 @@
+"""
+Functions for implementing 'astype' methods according to pandas conventions,
+particularly ones that differ from numpy.
+"""
+from __future__ import annotations
+
+import inspect
+from typing import (
+    TYPE_CHECKING,
+    cast,
+    overload,
+)
+import warnings
+
+import numpy as np
+
+from pandas._libs import lib
+from pandas._libs.tslibs import is_unitless
+from pandas._libs.tslibs.timedeltas import array_to_timedelta64
+from pandas._typing import (
+    ArrayLike,
+    DtypeObj,
+    IgnoreRaise,
+)
+from pandas.errors import IntCastingNaNError
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.common import (
+    is_datetime64_dtype,
+    is_datetime64tz_dtype,
+    is_dtype_equal,
+    is_integer_dtype,
+    is_object_dtype,
+    is_timedelta64_dtype,
+    pandas_dtype,
+)
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    ExtensionDtype,
+    PandasDtype,
+)
+from pandas.core.dtypes.missing import isna
+
+if TYPE_CHECKING:
+    from pandas.core.arrays import (
+        DatetimeArray,
+        ExtensionArray,
+    )
+
+
+_dtype_obj = np.dtype(object)
+
+
+@overload
+def astype_nansafe(
+    arr: np.ndarray, dtype: np.dtype, copy: bool = ..., skipna: bool = ...
+) -> np.ndarray:
+    ...
+
+
+@overload
+def astype_nansafe(
+    arr: np.ndarray, dtype: ExtensionDtype, copy: bool = ..., skipna: bool = ...
+) -> ExtensionArray:
+    ...
+
+
+def astype_nansafe(
+    arr: np.ndarray, dtype: DtypeObj, copy: bool = True, skipna: bool = False
+) -> ArrayLike:
+    """
+    Cast the elements of an array to a given dtype a nan-safe manner.
+
+    Parameters
+    ----------
+    arr : ndarray
+    dtype : np.dtype or ExtensionDtype
+    copy : bool, default True
+        If False, a view will be attempted but may fail, if
+        e.g. the item sizes don't align.
+    skipna: bool, default False
+        Whether or not we should skip NaN when casting as a string-type.
+
+    Raises
+    ------
+    ValueError
+        The dtype was a datetime64/timedelta64 dtype, but it had no unit.
+    """
+
+    # We get here with 0-dim from sparse
+    arr = np.atleast_1d(arr)
+
+    # dispatch on extension dtype if needed
+    if isinstance(dtype, ExtensionDtype):
+        return dtype.construct_array_type()._from_sequence(arr, dtype=dtype, copy=copy)
+
+    elif not isinstance(dtype, np.dtype):  # pragma: no cover
+        raise ValueError("dtype must be np.dtype or ExtensionDtype")
+
+    if arr.dtype.kind in ["m", "M"] and (
+        issubclass(dtype.type, str) or dtype == _dtype_obj
+    ):
+        from pandas.core.construction import ensure_wrapped_if_datetimelike
+
+        arr = ensure_wrapped_if_datetimelike(arr)
+        return arr.astype(dtype, copy=copy)
+
+    if issubclass(dtype.type, str):
+        shape = arr.shape
+        if arr.ndim > 1:
+            arr = arr.ravel()
+        return lib.ensure_string_array(
+            arr, skipna=skipna, convert_na_value=False
+        ).reshape(shape)
+
+    elif is_datetime64_dtype(arr.dtype):
+        if dtype == np.int64:
+            if isna(arr).any():
+                raise ValueError("Cannot convert NaT values to integer")
+            return arr.view(dtype)
+
+        # allow frequency conversions
+        if dtype.kind == "M":
+            return arr.astype(dtype)
+
+        raise TypeError(f"cannot astype a datetimelike from [{arr.dtype}] to [{dtype}]")
+
+    elif is_timedelta64_dtype(arr.dtype):
+        if dtype == np.int64:
+            if isna(arr).any():
+                raise ValueError("Cannot convert NaT values to integer")
+            return arr.view(dtype)
+
+        elif dtype.kind == "m":
+            return astype_td64_unit_conversion(arr, dtype, copy=copy)
+
+        raise TypeError(f"cannot astype a timedelta from [{arr.dtype}] to [{dtype}]")
+
+    elif np.issubdtype(arr.dtype, np.floating) and is_integer_dtype(dtype):
+        return _astype_float_to_int_nansafe(arr, dtype, copy)
+
+    elif is_object_dtype(arr.dtype):
+
+        # if we have a datetime/timedelta array of objects
+        # then coerce to a proper dtype and recall astype_nansafe
+
+        if is_datetime64_dtype(dtype):
+            from pandas import to_datetime
+
+            return astype_nansafe(
+                to_datetime(arr.ravel()).values.reshape(arr.shape),
+                dtype,
+                copy=copy,
+            )
+        elif is_timedelta64_dtype(dtype):
+            # bc we know arr.dtype == object, this is equivalent to
+            #  `np.asarray(to_timedelta(arr))`, but using a lower-level API that
+            #  does not require a circular import.
+            return array_to_timedelta64(arr).view("m8[ns]").astype(dtype, copy=False)
+
+    if dtype.name in ("datetime64", "timedelta64"):
+        msg = (
+            f"The '{dtype.name}' dtype has no unit. Please pass in "
+            f"'{dtype.name}[ns]' instead."
+        )
+        raise ValueError(msg)
+
+    if copy or is_object_dtype(arr.dtype) or is_object_dtype(dtype):
+        # Explicit copy, or required since NumPy can't view from / to object.
+        return arr.astype(dtype, copy=True)
+
+    return arr.astype(dtype, copy=copy)
+
+
+def _astype_float_to_int_nansafe(
+    values: np.ndarray, dtype: np.dtype, copy: bool
+) -> np.ndarray:
+    """
+    astype with a check preventing converting NaN to an meaningless integer value.
+    """
+    if not np.isfinite(values).all():
+        raise IntCastingNaNError(
+            "Cannot convert non-finite values (NA or inf) to integer"
+        )
+    if dtype.kind == "u":
+        # GH#45151
+        if not (values >= 0).all():
+            raise ValueError(f"Cannot losslessly cast from {values.dtype} to {dtype}")
+    return values.astype(dtype, copy=copy)
+
+
+def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> ArrayLike:
+    """
+    Cast array (ndarray or ExtensionArray) to the new dtype.
+
+    Parameters
+    ----------
+    values : ndarray or ExtensionArray
+    dtype : dtype object
+    copy : bool, default False
+        copy if indicated
+
+    Returns
+    -------
+    ndarray or ExtensionArray
+    """
+    if (
+        values.dtype.kind in ["m", "M"]
+        and dtype.kind in ["i", "u"]
+        and isinstance(dtype, np.dtype)
+        and dtype.itemsize != 8
+    ):
+        # TODO(2.0) remove special case once deprecation on DTA/TDA is enforced
+        msg = rf"cannot astype a datetimelike from [{values.dtype}] to [{dtype}]"
+        raise TypeError(msg)
+
+    if is_datetime64tz_dtype(dtype) and is_datetime64_dtype(values.dtype):
+        return astype_dt64_to_dt64tz(values, dtype, copy, via_utc=True)
+
+    if is_dtype_equal(values.dtype, dtype):
+        if copy:
+            return values.copy()
+        return values
+
+    if not isinstance(values, np.ndarray):
+        # i.e. ExtensionArray
+        values = values.astype(dtype, copy=copy)
+
+    else:
+        values = astype_nansafe(values, dtype, copy=copy)
+
+    # in pandas we don't store numpy str dtypes, so convert to object
+    if isinstance(dtype, np.dtype) and issubclass(values.dtype.type, str):
+        values = np.array(values, dtype=object)
+
+    return values
+
+
+def astype_array_safe(
+    values: ArrayLike, dtype, copy: bool = False, errors: IgnoreRaise = "raise"
+) -> ArrayLike:
+    """
+    Cast array (ndarray or ExtensionArray) to the new dtype.
+
+    This basically is the implementation for DataFrame/Series.astype and
+    includes all custom logic for pandas (NaN-safety, converting str to object,
+    not allowing )
+
+    Parameters
+    ----------
+    values : ndarray or ExtensionArray
+    dtype : str, dtype convertible
+    copy : bool, default False
+        copy if indicated
+    errors : str, {'raise', 'ignore'}, default 'raise'
+        - ``raise`` : allow exceptions to be raised
+        - ``ignore`` : suppress exceptions. On error return original object
+
+    Returns
+    -------
+    ndarray or ExtensionArray
+    """
+    errors_legal_values = ("raise", "ignore")
+
+    if errors not in errors_legal_values:
+        invalid_arg = (
+            "Expected value of kwarg 'errors' to be one of "
+            f"{list(errors_legal_values)}. Supplied value is '{errors}'"
+        )
+        raise ValueError(invalid_arg)
+
+    if inspect.isclass(dtype) and issubclass(dtype, ExtensionDtype):
+        msg = (
+            f"Expected an instance of {dtype.__name__}, "
+            "but got the class instead. Try instantiating 'dtype'."
+        )
+        raise TypeError(msg)
+
+    dtype = pandas_dtype(dtype)
+    if isinstance(dtype, PandasDtype):
+        # Ensure we don't end up with a PandasArray
+        dtype = dtype.numpy_dtype
+
+    if (
+        is_datetime64_dtype(values.dtype)
+        # need to do np.dtype check instead of is_datetime64_dtype
+        #  otherwise pyright complains
+        and isinstance(dtype, np.dtype)
+        and dtype.kind == "M"
+        and not is_unitless(dtype)
+        and not is_dtype_equal(dtype, values.dtype)
+    ):
+        # unit conversion, we would re-cast to nanosecond, so this is
+        #  effectively just a copy (regardless of copy kwd)
+        # TODO(2.0): remove special-case
+        return values.copy()
+
+    try:
+        new_values = astype_array(values, dtype, copy=copy)
+    except (ValueError, TypeError):
+        # e.g. astype_nansafe can fail on object-dtype of strings
+        #  trying to convert to float
+        if errors == "ignore":
+            new_values = values
+        else:
+            raise
+
+    return new_values
+
+
+def astype_td64_unit_conversion(
+    values: np.ndarray, dtype: np.dtype, copy: bool
+) -> np.ndarray:
+    """
+    By pandas convention, converting to non-nano timedelta64
+    returns an int64-dtyped array with ints representing multiples
+    of the desired timedelta unit.  This is essentially division.
+
+    Parameters
+    ----------
+    values : np.ndarray[timedelta64[ns]]
+    dtype : np.dtype
+        timedelta64 with unit not-necessarily nano
+    copy : bool
+
+    Returns
+    -------
+    np.ndarray
+    """
+    if is_dtype_equal(values.dtype, dtype):
+        if copy:
+            return values.copy()
+        return values
+
+    # otherwise we are converting to non-nano
+    result = values.astype(dtype, copy=False)  # avoid double-copying
+    result = result.astype(np.float64)
+
+    mask = isna(values)
+    np.putmask(result, mask, np.nan)
+    return result
+
+
+def astype_dt64_to_dt64tz(
+    values: ArrayLike, dtype: DtypeObj, copy: bool, via_utc: bool = False
+) -> DatetimeArray:
+    # GH#33401 we have inconsistent behaviors between
+    #  Datetimeindex[naive].astype(tzaware)
+    #  Series[dt64].astype(tzaware)
+    # This collects them in one place to prevent further fragmentation.
+
+    from pandas.core.construction import ensure_wrapped_if_datetimelike
+
+    values = ensure_wrapped_if_datetimelike(values)
+    values = cast("DatetimeArray", values)
+    aware = isinstance(dtype, DatetimeTZDtype)
+
+    if via_utc:
+        # Series.astype behavior
+
+        # caller is responsible for checking this
+        assert values.tz is None and aware
+        dtype = cast(DatetimeTZDtype, dtype)
+
+        if copy:
+            # this should be the only copy
+            values = values.copy()
+
+        warnings.warn(
+            "Using .astype to convert from timezone-naive dtype to "
+            "timezone-aware dtype is deprecated and will raise in a "
+            "future version.  Use ser.dt.tz_localize instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+        # GH#33401 this doesn't match DatetimeArray.astype, which
+        #  goes through the `not via_utc` path
+        return values.tz_localize("UTC").tz_convert(dtype.tz)
+
+    else:
+        # DatetimeArray/DatetimeIndex.astype behavior
+        if values.tz is None and aware:
+            dtype = cast(DatetimeTZDtype, dtype)
+            warnings.warn(
+                "Using .astype to convert from timezone-naive dtype to "
+                "timezone-aware dtype is deprecated and will raise in a "
+                "future version.  Use obj.tz_localize instead.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+            return values.tz_localize(dtype.tz)
+
+        elif aware:
+            # GH#18951: datetime64_tz dtype but not equal means different tz
+            dtype = cast(DatetimeTZDtype, dtype)
+            result = values.tz_convert(dtype.tz)
+            if copy:
+                result = result.copy()
+            return result
+
+        elif values.tz is not None:
+            warnings.warn(
+                "Using .astype to convert from timezone-aware dtype to "
+                "timezone-naive dtype is deprecated and will raise in a "
+                "future version.  Use obj.tz_localize(None) or "
+                "obj.tz_convert('UTC').tz_localize(None) instead",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+            result = values.tz_convert("UTC").tz_localize(None)
+            if copy:
+                result = result.copy()
+            return result
+
+        raise NotImplementedError("dtype_equal case should be handled elsewhere")
diff --git a/pandas/core/dtypes/base.py b/pandas/core/dtypes/base.py
index fa07b5fea5ea3..5ec2aaab98ba1 100644
--- a/pandas/core/dtypes/base.py
+++ b/pandas/core/dtypes/base.py
@@ -1,7 +1,6 @@
 """
 Extend pandas with custom array types.
 """
-
 from __future__ import annotations
 
 from typing import (
@@ -14,6 +13,7 @@
 
 import numpy as np
 
+from pandas._libs import missing as libmissing
 from pandas._libs.hashtable import object_hash
 from pandas._typing import (
     DtypeObj,
@@ -391,6 +391,35 @@ def _can_hold_na(self) -> bool:
         return True
 
 
+class StorageExtensionDtype(ExtensionDtype):
+    """ExtensionDtype that may be backed by more than one implementation."""
+
+    name: str
+    _metadata = ("storage",)
+
+    def __init__(self, storage=None) -> None:
+        self.storage = storage
+
+    def __repr__(self) -> str:
+        return f"{self.name}[{self.storage}]"
+
+    def __str__(self):
+        return self.name
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str) and other == self.name:
+            return True
+        return super().__eq__(other)
+
+    def __hash__(self) -> int:
+        # custom __eq__ so have to override __hash__
+        return super().__hash__()
+
+    @property
+    def na_value(self) -> libmissing.NAType:
+        return libmissing.NA
+
+
 def register_extension_dtype(cls: type_t[ExtensionDtypeT]) -> type_t[ExtensionDtypeT]:
     """
     Register an ExtensionType with pandas as class decorator.
@@ -430,7 +459,7 @@ class Registry:
     These are tried in order.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.dtypes: list[type_t[ExtensionDtype]] = []
 
     def register(self, dtype: type_t[ExtensionDtype]) -> None:
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 14cd725c8f066..f7df0b8a3d035 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -10,7 +10,6 @@
     timedelta,
 )
 import functools
-import inspect
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -21,6 +20,7 @@
 )
 import warnings
 
+from dateutil.parser import ParserError
 import numpy as np
 
 from pandas._libs import lib
@@ -30,7 +30,7 @@
     OutOfBoundsTimedelta,
     Timedelta,
     Timestamp,
-    conversion,
+    astype_overflowsafe,
 )
 from pandas._libs.tslibs.timedeltas import array_to_timedelta64
 from pandas._typing import (
@@ -43,6 +43,7 @@
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import validate_bool_kwarg
 
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.common import (
     DT64NS_DTYPE,
     TD64NS_DTYPE,
@@ -77,15 +78,16 @@
     DatetimeTZDtype,
     ExtensionDtype,
     IntervalDtype,
-    PandasDtype,
     PeriodDtype,
 )
 from pandas.core.dtypes.generic import (
     ABCExtensionArray,
+    ABCIndex,
     ABCSeries,
 )
 from pandas.core.dtypes.inference import is_list_like
 from pandas.core.dtypes.missing import (
+    array_equivalent,
     is_valid_na_for_dtype,
     isna,
     na_value_for_dtype,
@@ -94,7 +96,9 @@
 
 if TYPE_CHECKING:
 
+    from pandas import Index
     from pandas.core.arrays import (
+        Categorical,
         DatetimeArray,
         ExtensionArray,
         IntervalArray,
@@ -102,6 +106,7 @@
         TimedeltaArray,
     )
 
+
 _int8_max = np.iinfo(np.int8).max
 _int16_max = np.iinfo(np.int16).max
 _int32_max = np.iinfo(np.int32).max
@@ -200,7 +205,7 @@ def maybe_box_native(value: Scalar) -> Scalar:
     return value
 
 
-def maybe_unbox_datetimelike(value: Scalar, dtype: DtypeObj) -> Scalar:
+def _maybe_unbox_datetimelike(value: Scalar, dtype: DtypeObj) -> Scalar:
     """
     Convert a Timedelta or Timestamp to timedelta64 or datetime64 for setting
     into a numpy array.  Failing to unbox would risk dropping nanoseconds.
@@ -241,6 +246,16 @@ def _disallow_mismatched_datetimelike(value, dtype: DtypeObj):
         raise TypeError(f"Cannot cast {repr(value)} to {dtype}")
 
 
+@overload
+def maybe_downcast_to_dtype(result: np.ndarray, dtype: str | np.dtype) -> np.ndarray:
+    ...
+
+
+@overload
+def maybe_downcast_to_dtype(result: ExtensionArray, dtype: str | np.dtype) -> ArrayLike:
+    ...
+
+
 def maybe_downcast_to_dtype(result: ArrayLike, dtype: str | np.dtype) -> ArrayLike:
     """
     try to cast to the specified dtype (e.g. convert back to bool/int
@@ -257,7 +272,7 @@ def maybe_downcast_to_dtype(result: ArrayLike, dtype: str | np.dtype) -> ArrayLi
                 dtype = "int64"
             elif inferred_type == "datetime64":
                 dtype = "datetime64[ns]"
-            elif inferred_type == "timedelta64":
+            elif inferred_type in ["timedelta", "timedelta64"]:
                 dtype = "timedelta64[ns]"
 
             # try to upcast here
@@ -285,9 +300,31 @@ def maybe_downcast_to_dtype(result: ArrayLike, dtype: str | np.dtype) -> ArrayLi
     if dtype.kind in ["M", "m"] and result.dtype.kind in ["i", "f"]:
         result = result.astype(dtype)
 
+    elif dtype.kind == "m" and result.dtype == _dtype_obj:
+        # test_where_downcast_to_td64
+        result = cast(np.ndarray, result)
+        result = array_to_timedelta64(result)
+
+    elif dtype == np.dtype("M8[ns]") and result.dtype == _dtype_obj:
+        return np.asarray(maybe_cast_to_datetime(result, dtype=dtype))
+
     return result
 
 
+@overload
+def maybe_downcast_numeric(
+    result: np.ndarray, dtype: np.dtype, do_round: bool = False
+) -> np.ndarray:
+    ...
+
+
+@overload
+def maybe_downcast_numeric(
+    result: ExtensionArray, dtype: DtypeObj, do_round: bool = False
+) -> ArrayLike:
+    ...
+
+
 def maybe_downcast_numeric(
     result: ArrayLike, dtype: DtypeObj, do_round: bool = False
 ) -> ArrayLike:
@@ -354,7 +391,24 @@ def trans(x):
         and not is_bool_dtype(result.dtype)
         and not is_string_dtype(result.dtype)
     ):
-        return result.astype(dtype)
+        new_result = result.astype(dtype)
+
+        # Adjust tolerances based on floating point size
+        size_tols = {4: 5e-4, 8: 5e-8, 16: 5e-16}
+
+        atol = size_tols.get(new_result.dtype.itemsize, 0.0)
+
+        # Check downcast float values are still equal within 7 digits when
+        # converting from float64 to float32
+        if np.allclose(new_result, result, equal_nan=True, rtol=0.0, atol=atol):
+            return new_result
+
+    elif dtype.kind == result.dtype.kind == "c":
+        new_result = result.astype(dtype)
+
+        if array_equivalent(new_result, result):
+            # TODO: use tolerance like we do for float?
+            return new_result
 
     return result
 
@@ -456,10 +510,15 @@ def ensure_dtype_can_hold_na(dtype: DtypeObj) -> DtypeObj:
     If we have a dtype that cannot hold NA values, find the best match that can.
     """
     if isinstance(dtype, ExtensionDtype):
-        # TODO: ExtensionDtype.can_hold_na?
-        return dtype
+        if dtype._can_hold_na:
+            return dtype
+        elif isinstance(dtype, IntervalDtype):
+            # TODO(GH#45349): don't special-case IntervalDtype, allow
+            #  overriding instead of returning object below.
+            return IntervalDtype(np.float64, closed=dtype.closed)
+        return _dtype_obj
     elif dtype.kind == "b":
-        return np.dtype(object)
+        return _dtype_obj
     elif dtype.kind in ["i", "u"]:
         return np.dtype(np.float64)
     return dtype
@@ -522,7 +581,7 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
             # with object dtype there is nothing to promote, and the user can
             #  pass pretty much any weird fill_value they like
             raise ValueError("fill_value must be a scalar")
-        dtype = np.dtype(object)
+        dtype = _dtype_obj
         return dtype, fill_value
 
     kinds = ["i", "u", "f", "c", "m", "M"]
@@ -531,8 +590,14 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
         fv = na_value_for_dtype(dtype)
         return dtype, fv
 
+    elif isinstance(dtype, CategoricalDtype):
+        if fill_value in dtype.categories or isna(fill_value):
+            return dtype, fill_value
+        else:
+            return object, ensure_object(fill_value)
+
     elif isna(fill_value):
-        dtype = np.dtype(object)
+        dtype = _dtype_obj
         if fill_value is None:
             # but we retain e.g. pd.NA
             fill_value = np.nan
@@ -551,7 +616,7 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
         #      fv = dta._validate_setitem_value(fill_value)
         #      return dta.dtype, fv
         #  except (ValueError, TypeError):
-        #      return np.dtype(object), fill_value
+        #      return _dtype_obj, fill_value
         if isinstance(fill_value, date) and not isinstance(fill_value, datetime):
             # deprecate casting of date object to match infer_dtype_from_scalar
             #  and DatetimeArray._validate_setitem_value
@@ -575,7 +640,7 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
             except (ValueError, TypeError):
                 pass
             else:
-                if fv.tz is None:
+                if isna(fv) or fv.tz is None:
                     return dtype, fv.asm8
 
         return np.dtype("object"), fill_value
@@ -699,7 +764,7 @@ def infer_dtype_from_scalar(val, pandas_dtype: bool = False) -> tuple[DtypeObj,
         If False, scalar belongs to pandas extension types is inferred as
         object
     """
-    dtype: DtypeObj = np.dtype(object)
+    dtype: DtypeObj = _dtype_obj
 
     # a 1-element ndarray
     if isinstance(val, np.ndarray):
@@ -718,13 +783,13 @@ def infer_dtype_from_scalar(val, pandas_dtype: bool = False) -> tuple[DtypeObj,
         # instead of np.empty (but then you still don't want things
         # coming out as np.str_!
 
-        dtype = np.dtype(object)
+        dtype = _dtype_obj
 
     elif isinstance(val, (np.datetime64, datetime)):
         try:
             val = Timestamp(val)
         except OutOfBoundsDatetime:
-            return np.dtype(object), val
+            return _dtype_obj, val
 
         # error: Non-overlapping identity check (left operand type: "Timestamp",
         # right operand type: "NaTType")
@@ -736,13 +801,13 @@ def infer_dtype_from_scalar(val, pandas_dtype: bool = False) -> tuple[DtypeObj,
                 dtype = DatetimeTZDtype(unit="ns", tz=val.tz)
             else:
                 # return datetimetz as object
-                return np.dtype(object), val
+                return _dtype_obj, val
 
     elif isinstance(val, (np.timedelta64, timedelta)):
         try:
             val = Timedelta(val)
         except (OutOfBoundsTimedelta, OverflowError):
-            dtype = np.dtype(object)
+            dtype = _dtype_obj
         else:
             dtype = np.dtype("m8[ns]")
             val = np.timedelta64(val.value, "ns")
@@ -851,7 +916,7 @@ def infer_dtype_from_array(
     return arr.dtype, arr
 
 
-def maybe_infer_dtype_type(element):
+def _maybe_infer_dtype_type(element):
     """
     Try to infer an object's dtype, for use in arithmetic ops.
 
@@ -873,7 +938,7 @@ def maybe_infer_dtype_type(element):
     --------
     >>> from collections import namedtuple
     >>> Foo = namedtuple("Foo", "dtype")
-    >>> maybe_infer_dtype_type(Foo(np.dtype("i8")))
+    >>> _maybe_infer_dtype_type(Foo(np.dtype("i8")))
     dtype('int64')
     """
     tipo = None
@@ -919,7 +984,7 @@ def maybe_upcast(
     return upcast_values, fill_value  # type: ignore[return-value]
 
 
-def invalidate_string_dtypes(dtype_set: set[DtypeObj]):
+def invalidate_string_dtypes(dtype_set: set[DtypeObj]) -> None:
     """
     Change string like dtypes to object for
     ``DataFrame.select_dtypes()``.
@@ -936,7 +1001,7 @@ def invalidate_string_dtypes(dtype_set: set[DtypeObj]):
         raise TypeError("string dtypes are not allowed, use 'object' instead")
 
 
-def coerce_indexer_dtype(indexer, categories):
+def coerce_indexer_dtype(indexer, categories) -> np.ndarray:
     """coerce the indexer input array to the smallest dtype possible"""
     length = len(categories)
     if length < _int8_max:
@@ -948,377 +1013,6 @@ def coerce_indexer_dtype(indexer, categories):
     return ensure_int64(indexer)
 
 
-def astype_dt64_to_dt64tz(
-    values: ArrayLike, dtype: DtypeObj, copy: bool, via_utc: bool = False
-) -> DatetimeArray:
-    # GH#33401 we have inconsistent behaviors between
-    #  Datetimeindex[naive].astype(tzaware)
-    #  Series[dt64].astype(tzaware)
-    # This collects them in one place to prevent further fragmentation.
-
-    from pandas.core.construction import ensure_wrapped_if_datetimelike
-
-    values = ensure_wrapped_if_datetimelike(values)
-    values = cast("DatetimeArray", values)
-    aware = isinstance(dtype, DatetimeTZDtype)
-
-    if via_utc:
-        # Series.astype behavior
-
-        # caller is responsible for checking this
-        assert values.tz is None and aware
-        dtype = cast(DatetimeTZDtype, dtype)
-
-        if copy:
-            # this should be the only copy
-            values = values.copy()
-
-        warnings.warn(
-            "Using .astype to convert from timezone-naive dtype to "
-            "timezone-aware dtype is deprecated and will raise in a "
-            "future version.  Use ser.dt.tz_localize instead.",
-            FutureWarning,
-            stacklevel=find_stack_level(),
-        )
-
-        # GH#33401 this doesn't match DatetimeArray.astype, which
-        #  goes through the `not via_utc` path
-        return values.tz_localize("UTC").tz_convert(dtype.tz)
-
-    else:
-        # DatetimeArray/DatetimeIndex.astype behavior
-        if values.tz is None and aware:
-            dtype = cast(DatetimeTZDtype, dtype)
-            warnings.warn(
-                "Using .astype to convert from timezone-naive dtype to "
-                "timezone-aware dtype is deprecated and will raise in a "
-                "future version.  Use obj.tz_localize instead.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-
-            return values.tz_localize(dtype.tz)
-
-        elif aware:
-            # GH#18951: datetime64_tz dtype but not equal means different tz
-            dtype = cast(DatetimeTZDtype, dtype)
-            result = values.tz_convert(dtype.tz)
-            if copy:
-                result = result.copy()
-            return result
-
-        elif values.tz is not None:
-            warnings.warn(
-                "Using .astype to convert from timezone-aware dtype to "
-                "timezone-naive dtype is deprecated and will raise in a "
-                "future version.  Use obj.tz_localize(None) or "
-                "obj.tz_convert('UTC').tz_localize(None) instead",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-
-            result = values.tz_convert("UTC").tz_localize(None)
-            if copy:
-                result = result.copy()
-            return result
-
-        raise NotImplementedError("dtype_equal case should be handled elsewhere")
-
-
-def astype_td64_unit_conversion(
-    values: np.ndarray, dtype: np.dtype, copy: bool
-) -> np.ndarray:
-    """
-    By pandas convention, converting to non-nano timedelta64
-    returns an int64-dtyped array with ints representing multiples
-    of the desired timedelta unit.  This is essentially division.
-
-    Parameters
-    ----------
-    values : np.ndarray[timedelta64[ns]]
-    dtype : np.dtype
-        timedelta64 with unit not-necessarily nano
-    copy : bool
-
-    Returns
-    -------
-    np.ndarray
-    """
-    if is_dtype_equal(values.dtype, dtype):
-        if copy:
-            return values.copy()
-        return values
-
-    # otherwise we are converting to non-nano
-    result = values.astype(dtype, copy=False)  # avoid double-copying
-    result = result.astype(np.float64)
-
-    mask = isna(values)
-    np.putmask(result, mask, np.nan)
-    return result
-
-
-@overload
-def astype_nansafe(
-    arr: np.ndarray, dtype: np.dtype, copy: bool = ..., skipna: bool = ...
-) -> np.ndarray:
-    ...
-
-
-@overload
-def astype_nansafe(
-    arr: np.ndarray, dtype: ExtensionDtype, copy: bool = ..., skipna: bool = ...
-) -> ExtensionArray:
-    ...
-
-
-def astype_nansafe(
-    arr: np.ndarray, dtype: DtypeObj, copy: bool = True, skipna: bool = False
-) -> ArrayLike:
-    """
-    Cast the elements of an array to a given dtype a nan-safe manner.
-
-    Parameters
-    ----------
-    arr : ndarray
-    dtype : np.dtype or ExtensionDtype
-    copy : bool, default True
-        If False, a view will be attempted but may fail, if
-        e.g. the item sizes don't align.
-    skipna: bool, default False
-        Whether or not we should skip NaN when casting as a string-type.
-
-    Raises
-    ------
-    ValueError
-        The dtype was a datetime64/timedelta64 dtype, but it had no unit.
-    """
-    if arr.ndim > 1:
-        flat = arr.ravel()
-        result = astype_nansafe(flat, dtype, copy=copy, skipna=skipna)
-        # error: Item "ExtensionArray" of "Union[ExtensionArray, ndarray]" has no
-        # attribute "reshape"
-        return result.reshape(arr.shape)  # type: ignore[union-attr]
-
-    # We get here with 0-dim from sparse
-    arr = np.atleast_1d(arr)
-
-    # dispatch on extension dtype if needed
-    if isinstance(dtype, ExtensionDtype):
-        return dtype.construct_array_type()._from_sequence(arr, dtype=dtype, copy=copy)
-
-    elif not isinstance(dtype, np.dtype):  # pragma: no cover
-        raise ValueError("dtype must be np.dtype or ExtensionDtype")
-
-    if arr.dtype.kind in ["m", "M"] and (
-        issubclass(dtype.type, str) or dtype == _dtype_obj
-    ):
-        from pandas.core.construction import ensure_wrapped_if_datetimelike
-
-        arr = ensure_wrapped_if_datetimelike(arr)
-        return arr.astype(dtype, copy=copy)
-
-    if issubclass(dtype.type, str):
-        return lib.ensure_string_array(arr, skipna=skipna, convert_na_value=False)
-
-    elif is_datetime64_dtype(arr.dtype):
-        # Non-overlapping equality check (left operand type: "dtype[Any]", right
-        # operand type: "Type[signedinteger[Any]]")
-        if dtype == np.int64:  # type: ignore[comparison-overlap]
-            warnings.warn(
-                f"casting {arr.dtype} values to int64 with .astype(...) "
-                "is deprecated and will raise in a future version. "
-                "Use .view(...) instead.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-            if isna(arr).any():
-                raise ValueError("Cannot convert NaT values to integer")
-            return arr.view(dtype)
-
-        # allow frequency conversions
-        if dtype.kind == "M":
-            return arr.astype(dtype)
-
-        raise TypeError(f"cannot astype a datetimelike from [{arr.dtype}] to [{dtype}]")
-
-    elif is_timedelta64_dtype(arr.dtype):
-        # error: Non-overlapping equality check (left operand type: "dtype[Any]", right
-        # operand type: "Type[signedinteger[Any]]")
-        if dtype == np.int64:  # type: ignore[comparison-overlap]
-            warnings.warn(
-                f"casting {arr.dtype} values to int64 with .astype(...) "
-                "is deprecated and will raise in a future version. "
-                "Use .view(...) instead.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-            if isna(arr).any():
-                raise ValueError("Cannot convert NaT values to integer")
-            return arr.view(dtype)
-
-        elif dtype.kind == "m":
-            return astype_td64_unit_conversion(arr, dtype, copy=copy)
-
-        raise TypeError(f"cannot astype a timedelta from [{arr.dtype}] to [{dtype}]")
-
-    elif np.issubdtype(arr.dtype, np.floating) and np.issubdtype(dtype, np.integer):
-        return astype_float_to_int_nansafe(arr, dtype, copy)
-
-    elif is_object_dtype(arr.dtype):
-
-        # work around NumPy brokenness, #1987
-        if np.issubdtype(dtype.type, np.integer):
-            return lib.astype_intsafe(arr, dtype)
-
-        # if we have a datetime/timedelta array of objects
-        # then coerce to a proper dtype and recall astype_nansafe
-
-        elif is_datetime64_dtype(dtype):
-            from pandas import to_datetime
-
-            return astype_nansafe(
-                to_datetime(arr).values,
-                dtype,
-                copy=copy,
-            )
-        elif is_timedelta64_dtype(dtype):
-            from pandas import to_timedelta
-
-            return astype_nansafe(to_timedelta(arr)._values, dtype, copy=copy)
-
-    if dtype.name in ("datetime64", "timedelta64"):
-        msg = (
-            f"The '{dtype.name}' dtype has no unit. Please pass in "
-            f"'{dtype.name}[ns]' instead."
-        )
-        raise ValueError(msg)
-
-    if copy or is_object_dtype(arr.dtype) or is_object_dtype(dtype):
-        # Explicit copy, or required since NumPy can't view from / to object.
-        return arr.astype(dtype, copy=True)
-
-    return arr.astype(dtype, copy=copy)
-
-
-def astype_float_to_int_nansafe(
-    values: np.ndarray, dtype: np.dtype, copy: bool
-) -> np.ndarray:
-    """
-    astype with a check preventing converting NaN to an meaningless integer value.
-    """
-    if not np.isfinite(values).all():
-        raise IntCastingNaNError(
-            "Cannot convert non-finite values (NA or inf) to integer"
-        )
-    return values.astype(dtype, copy=copy)
-
-
-def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> ArrayLike:
-    """
-    Cast array (ndarray or ExtensionArray) to the new dtype.
-
-    Parameters
-    ----------
-    values : ndarray or ExtensionArray
-    dtype : dtype object
-    copy : bool, default False
-        copy if indicated
-
-    Returns
-    -------
-    ndarray or ExtensionArray
-    """
-    if (
-        values.dtype.kind in ["m", "M"]
-        and dtype.kind in ["i", "u"]
-        and isinstance(dtype, np.dtype)
-        and dtype.itemsize != 8
-    ):
-        # TODO(2.0) remove special case once deprecation on DTA/TDA is enforced
-        msg = rf"cannot astype a datetimelike from [{values.dtype}] to [{dtype}]"
-        raise TypeError(msg)
-
-    if is_datetime64tz_dtype(dtype) and is_datetime64_dtype(values.dtype):
-        return astype_dt64_to_dt64tz(values, dtype, copy, via_utc=True)
-
-    if is_dtype_equal(values.dtype, dtype):
-        if copy:
-            return values.copy()
-        return values
-
-    if not isinstance(values, np.ndarray):
-        # i.e. ExtensionArray
-        values = values.astype(dtype, copy=copy)
-
-    else:
-        values = astype_nansafe(values, dtype, copy=copy)
-
-    # in pandas we don't store numpy str dtypes, so convert to object
-    if isinstance(dtype, np.dtype) and issubclass(values.dtype.type, str):
-        values = np.array(values, dtype=object)
-
-    return values
-
-
-def astype_array_safe(
-    values: ArrayLike, dtype, copy: bool = False, errors: str = "raise"
-) -> ArrayLike:
-    """
-    Cast array (ndarray or ExtensionArray) to the new dtype.
-
-    This basically is the implementation for DataFrame/Series.astype and
-    includes all custom logic for pandas (NaN-safety, converting str to object,
-    not allowing )
-
-    Parameters
-    ----------
-    values : ndarray or ExtensionArray
-    dtype : str, dtype convertible
-    copy : bool, default False
-        copy if indicated
-    errors : str, {'raise', 'ignore'}, default 'raise'
-        - ``raise`` : allow exceptions to be raised
-        - ``ignore`` : suppress exceptions. On error return original object
-
-    Returns
-    -------
-    ndarray or ExtensionArray
-    """
-    errors_legal_values = ("raise", "ignore")
-
-    if errors not in errors_legal_values:
-        invalid_arg = (
-            "Expected value of kwarg 'errors' to be one of "
-            f"{list(errors_legal_values)}. Supplied value is '{errors}'"
-        )
-        raise ValueError(invalid_arg)
-
-    if inspect.isclass(dtype) and issubclass(dtype, ExtensionDtype):
-        msg = (
-            f"Expected an instance of {dtype.__name__}, "
-            "but got the class instead. Try instantiating 'dtype'."
-        )
-        raise TypeError(msg)
-
-    dtype = pandas_dtype(dtype)
-    if isinstance(dtype, PandasDtype):
-        # Ensure we don't end up with a PandasArray
-        dtype = dtype.numpy_dtype
-
-    try:
-        new_values = astype_array(values, dtype, copy=copy)
-    except (ValueError, TypeError):
-        # e.g. astype_nansafe can fail on object-dtype of strings
-        #  trying to convert to float
-        if errors == "ignore":
-            new_values = values
-        else:
-            raise
-
-    return new_values
-
-
 def soft_convert_objects(
     values: np.ndarray,
     datetime: bool = True,
@@ -1611,9 +1305,9 @@ def maybe_cast_to_datetime(
 
     if is_timedelta64_dtype(dtype):
         # TODO: _from_sequence would raise ValueError in cases where
-        #  ensure_nanosecond_dtype raises TypeError
+        #  _ensure_nanosecond_dtype raises TypeError
         dtype = cast(np.dtype, dtype)
-        dtype = ensure_nanosecond_dtype(dtype)
+        dtype = _ensure_nanosecond_dtype(dtype)
         res = TimedeltaArray._from_sequence(value, dtype=dtype)
         return res
 
@@ -1624,7 +1318,7 @@ def maybe_cast_to_datetime(
         vdtype = getattr(value, "dtype", None)
 
         if is_datetime64 or is_datetime64tz:
-            dtype = ensure_nanosecond_dtype(dtype)
+            dtype = _ensure_nanosecond_dtype(dtype)
 
             value = np.array(value, copy=False)
 
@@ -1694,9 +1388,8 @@ def maybe_cast_to_datetime(
                             value = dta.tz_localize("UTC").tz_convert(dtype.tz)
                 except OutOfBoundsDatetime:
                     raise
-                except ValueError:
-                    # TODO(GH#40048): only catch dateutil's ParserError
-                    #  once we can reliably import it in all supported versions
+                except ParserError:
+                    # Note: this is dateutil's ParserError, not ours.
                     pass
 
         elif getattr(vdtype, "kind", None) in ["m", "M"]:
@@ -1732,10 +1425,10 @@ def sanitize_to_nanoseconds(values: np.ndarray, copy: bool = False) -> np.ndarra
     """
     dtype = values.dtype
     if dtype.kind == "M" and dtype != DT64NS_DTYPE:
-        values = conversion.ensure_datetime64ns(values)
+        values = astype_overflowsafe(values, dtype=DT64NS_DTYPE)
 
     elif dtype.kind == "m" and dtype != TD64NS_DTYPE:
-        values = conversion.ensure_timedelta64ns(values)
+        values = astype_overflowsafe(values, dtype=TD64NS_DTYPE)
 
     elif copy:
         values = values.copy()
@@ -1743,14 +1436,14 @@ def sanitize_to_nanoseconds(values: np.ndarray, copy: bool = False) -> np.ndarra
     return values
 
 
-def ensure_nanosecond_dtype(dtype: DtypeObj) -> DtypeObj:
+def _ensure_nanosecond_dtype(dtype: DtypeObj) -> DtypeObj:
     """
     Convert dtypes with granularity less than nanosecond to nanosecond
 
-    >>> ensure_nanosecond_dtype(np.dtype("M8[s]"))
+    >>> _ensure_nanosecond_dtype(np.dtype("M8[s]"))
     dtype('<M8[ns]')
 
-    >>> ensure_nanosecond_dtype(np.dtype("m8[ps]"))
+    >>> _ensure_nanosecond_dtype(np.dtype("m8[ps]"))
     Traceback (most recent call last):
         ...
     TypeError: cannot convert timedeltalike to dtype [timedelta64[ps]]
@@ -1789,6 +1482,95 @@ def ensure_nanosecond_dtype(dtype: DtypeObj) -> DtypeObj:
     return dtype
 
 
+# TODO: other value-dependent functions to standardize here include
+#  dtypes.concat.cast_to_common_type and Index._find_common_type_compat
+def find_result_type(left: ArrayLike, right: Any) -> DtypeObj:
+    """
+    Find the type/dtype for a the result of an operation between these objects.
+
+    This is similar to find_common_type, but looks at the objects instead
+    of just their dtypes. This can be useful in particular when one of the
+    objects does not have a `dtype`.
+
+    Parameters
+    ----------
+    left : np.ndarray or ExtensionArray
+    right : Any
+
+    Returns
+    -------
+    np.dtype or ExtensionDtype
+
+    See also
+    --------
+    find_common_type
+    numpy.result_type
+    """
+    new_dtype: DtypeObj
+
+    if (
+        isinstance(left, np.ndarray)
+        and left.dtype.kind in ["i", "u", "c"]
+        and (lib.is_integer(right) or lib.is_float(right))
+    ):
+        # e.g. with int8 dtype and right=512, we want to end up with
+        # np.int16, whereas infer_dtype_from(512) gives np.int64,
+        #  which will make us upcast too far.
+        if lib.is_float(right) and right.is_integer() and left.dtype.kind != "f":
+            right = int(right)
+
+        new_dtype = np.result_type(left, right)
+
+    elif is_valid_na_for_dtype(right, left.dtype):
+        # e.g. IntervalDtype[int] and None/np.nan
+        new_dtype = ensure_dtype_can_hold_na(left.dtype)
+
+    else:
+        dtype, _ = infer_dtype_from(right, pandas_dtype=True)
+
+        new_dtype = find_common_type([left.dtype, dtype])
+
+    return new_dtype
+
+
+def common_dtype_categorical_compat(
+    objs: list[Index | ArrayLike], dtype: DtypeObj
+) -> DtypeObj:
+    """
+    Update the result of find_common_type to account for NAs in a Categorical.
+
+    Parameters
+    ----------
+    objs : list[np.ndarray | ExtensionArray | Index]
+    dtype : np.dtype or ExtensionDtype
+
+    Returns
+    -------
+    np.dtype or ExtensionDtype
+    """
+    # GH#38240
+
+    # TODO: more generally, could do `not can_hold_na(dtype)`
+    if isinstance(dtype, np.dtype) and dtype.kind in ["i", "u"]:
+
+        for obj in objs:
+            # We don't want to accientally allow e.g. "categorical" str here
+            obj_dtype = getattr(obj, "dtype", None)
+            if isinstance(obj_dtype, CategoricalDtype):
+                if isinstance(obj, ABCIndex):
+                    # This check may already be cached
+                    hasnas = obj.hasnans
+                else:
+                    # Categorical
+                    hasnas = cast("Categorical", obj)._hasna
+
+                if hasnas:
+                    # see test_union_int_categorical_with_nan
+                    dtype = np.dtype(np.float64)
+                    break
+    return dtype
+
+
 @overload
 def find_common_type(types: list[np.dtype]) -> np.dtype:
     ...
@@ -1866,7 +1648,7 @@ def construct_2d_arraylike_from_scalar(
     shape = (length, width)
 
     if dtype.kind in ["m", "M"]:
-        value = maybe_unbox_datetimelike_tz_deprecation(value, dtype)
+        value = _maybe_unbox_datetimelike_tz_deprecation(value, dtype)
     elif dtype == _dtype_obj:
         if isinstance(value, (np.timedelta64, np.datetime64)):
             # calling np.array below would cast to pytimedelta/pydatetime
@@ -1911,11 +1693,12 @@ def construct_1d_arraylike_from_scalar(
         try:
             dtype, value = infer_dtype_from_scalar(value, pandas_dtype=True)
         except OutOfBoundsDatetime:
-            dtype = np.dtype(object)
+            dtype = _dtype_obj
 
     if isinstance(dtype, ExtensionDtype):
         cls = dtype.construct_array_type()
-        subarr = cls._from_sequence([value] * length, dtype=dtype)
+        seq = [] if length == 0 else [value]
+        subarr = cls._from_sequence(seq, dtype=dtype).repeat(length)
 
     else:
 
@@ -1929,17 +1712,19 @@ def construct_1d_arraylike_from_scalar(
             if not isna(value):
                 value = ensure_str(value)
         elif dtype.kind in ["M", "m"]:
-            value = maybe_unbox_datetimelike_tz_deprecation(value, dtype)
+            value = _maybe_unbox_datetimelike_tz_deprecation(value, dtype)
 
         subarr = np.empty(length, dtype=dtype)
-        subarr.fill(value)
+        if length:
+            # GH 47391: numpy > 1.24 will raise filling np.nan into int dtypes
+            subarr.fill(value)
 
     return subarr
 
 
-def maybe_unbox_datetimelike_tz_deprecation(value: Scalar, dtype: DtypeObj):
+def _maybe_unbox_datetimelike_tz_deprecation(value: Scalar, dtype: DtypeObj):
     """
-    Wrap maybe_unbox_datetimelike with a check for a timezone-aware Timestamp
+    Wrap _maybe_unbox_datetimelike with a check for a timezone-aware Timestamp
     along with a timezone-naive datetime64 dtype, which is deprecated.
     """
     # Caller is responsible for checking dtype.kind in ["m", "M"]
@@ -1949,7 +1734,7 @@ def maybe_unbox_datetimelike_tz_deprecation(value: Scalar, dtype: DtypeObj):
         value = maybe_box_datetimelike(value, dtype)
 
     try:
-        value = maybe_unbox_datetimelike(value, dtype)
+        value = _maybe_unbox_datetimelike(value, dtype)
     except TypeError:
         if (
             isinstance(value, Timestamp)
@@ -1969,7 +1754,7 @@ def maybe_unbox_datetimelike_tz_deprecation(value: Scalar, dtype: DtypeObj):
                 stacklevel=find_stack_level(),
             )
             new_value = value.tz_localize(None)
-            return maybe_unbox_datetimelike(new_value, dtype)
+            return _maybe_unbox_datetimelike(new_value, dtype)
         else:
             raise
     return value
@@ -2037,7 +1822,7 @@ def maybe_cast_to_integer_array(
 
     Also, if you try to coerce float values to integers, it raises:
 
-    >>> pd.Series([1, 2, 3.5], dtype="int64")
+    >>> maybe_cast_to_integer_array([1, 2, 3.5], dtype=np.dtype("int64"))
     Traceback (most recent call last):
         ...
     ValueError: Trying to coerce float values to integers
@@ -2103,65 +1888,6 @@ def maybe_cast_to_integer_array(
     raise ValueError(f"values cannot be losslessly cast to {dtype}")
 
 
-def convert_scalar_for_putitemlike(scalar: Scalar, dtype: np.dtype) -> Scalar:
-    """
-    Convert datetimelike scalar if we are setting into a datetime64
-    or timedelta64 ndarray.
-
-    Parameters
-    ----------
-    scalar : scalar
-    dtype : np.dtype
-
-    Returns
-    -------
-    scalar
-    """
-    if dtype.kind in ["m", "M"]:
-        scalar = maybe_box_datetimelike(scalar, dtype)
-        return maybe_unbox_datetimelike(scalar, dtype)
-    else:
-        validate_numeric_casting(dtype, scalar)
-    return scalar
-
-
-def validate_numeric_casting(dtype: np.dtype, value: Scalar) -> None:
-    """
-    Check that we can losslessly insert the given value into an array
-    with the given dtype.
-
-    Parameters
-    ----------
-    dtype : np.dtype
-    value : scalar
-
-    Raises
-    ------
-    ValueError
-    """
-    # error: Argument 1 to "__call__" of "ufunc" has incompatible type
-    # "Union[Union[str, int, float, bool], Union[Any, Timestamp, Timedelta, Any]]";
-    # expected "Union[Union[int, float, complex, str, bytes, generic],
-    # Sequence[Union[int, float, complex, str, bytes, generic]],
-    # Sequence[Sequence[Any]], _SupportsArray]"
-    if (
-        issubclass(dtype.type, (np.integer, np.bool_))
-        and is_float(value)
-        and np.isnan(value)  # type: ignore[arg-type]
-    ):
-        raise ValueError("Cannot assign nan to integer series")
-
-    elif dtype.kind in ["i", "u", "f", "c"]:
-        if is_bool(value) or isinstance(value, np.timedelta64):
-            # numpy will cast td64 to integer if we're not careful
-            raise ValueError(
-                f"Cannot assign {type(value).__name__} to float/integer series"
-            )
-    elif dtype.kind == "b":
-        if is_scalar(value) and not is_bool(value):
-            raise ValueError(f"Cannot assign {type(value).__name__} to bool series")
-
-
 def can_hold_element(arr: ArrayLike, element: Any) -> bool:
     """
     Can we do an inplace setitem with this element in an array with this dtype?
@@ -2187,6 +1913,8 @@ def can_hold_element(arr: ArrayLike, element: Any) -> bool:
                 arr._validate_setitem_value(element)
                 return True
             except (ValueError, TypeError):
+                # TODO(2.0): stop catching ValueError for tzaware, see
+                #  _catch_deprecated_value_error
                 return False
 
         # This is technically incorrect, but maintains the behavior of
@@ -2196,7 +1924,7 @@ def can_hold_element(arr: ArrayLike, element: Any) -> bool:
     try:
         np_can_hold_element(dtype, element)
         return True
-    except (TypeError, ValueError):
+    except (TypeError, LossySetitemError):
         return False
 
 
@@ -2220,94 +1948,129 @@ def np_can_hold_element(dtype: np.dtype, element: Any) -> Any:
     if dtype == _dtype_obj:
         return element
 
-    tipo = maybe_infer_dtype_type(element)
+    tipo = _maybe_infer_dtype_type(element)
 
     if dtype.kind in ["i", "u"]:
         if isinstance(element, range):
             if _dtype_can_hold_range(element, dtype):
                 return element
-            raise ValueError
+            raise LossySetitemError
+
+        elif is_integer(element) or (is_float(element) and element.is_integer()):
+            # e.g. test_setitem_series_int8 if we have a python int 1
+            #  tipo may be np.int32, despite the fact that it will fit
+            #  in smaller int dtypes.
+            info = np.iinfo(dtype)
+            if info.min <= element <= info.max:
+                return dtype.type(element)
+            raise LossySetitemError
 
         if tipo is not None:
             if tipo.kind not in ["i", "u"]:
-                if is_float(element) and element.is_integer():
-                    return element
-
                 if isinstance(element, np.ndarray) and element.dtype.kind == "f":
                     # If all can be losslessly cast to integers, then we can hold them
-                    #  We do something similar in putmask_smart
-                    casted = element.astype(dtype)
+                    with np.errstate(invalid="ignore"):
+                        # We check afterwards if cast was losslessly, so no need to show
+                        # the warning
+                        casted = element.astype(dtype)
                     comp = casted == element
                     if comp.all():
-                        return element
-                    raise ValueError
+                        # Return the casted values bc they can be passed to
+                        #  np.putmask, whereas the raw values cannot.
+                        #  see TestSetitemFloatNDarrayIntoIntegerSeries
+                        return casted
+                    raise LossySetitemError
 
                 # Anything other than integer we cannot hold
-                raise ValueError
+                raise LossySetitemError
+            elif (
+                dtype.kind == "u"
+                and isinstance(element, np.ndarray)
+                and element.dtype.kind == "i"
+            ):
+                # see test_where_uint64
+                casted = element.astype(dtype)
+                if (casted == element).all():
+                    # TODO: faster to check (element >=0).all()?  potential
+                    #  itemsize issues there?
+                    return casted
+                raise LossySetitemError
             elif dtype.itemsize < tipo.itemsize:
-                if is_integer(element):
-                    # e.g. test_setitem_series_int8 if we have a python int 1
-                    #  tipo may be np.int32, despite the fact that it will fit
-                    #  in smaller int dtypes.
-                    info = np.iinfo(dtype)
-                    if info.min <= element <= info.max:
-                        return element
-                    raise ValueError
-                raise ValueError
+                raise LossySetitemError
             elif not isinstance(tipo, np.dtype):
                 # i.e. nullable IntegerDtype; we can put this into an ndarray
                 #  losslessly iff it has no NAs
-                hasnas = element._mask.any()
-                # TODO: don't rely on implementation detail
-                if hasnas:
-                    raise ValueError
+                if element._hasna:
+                    raise LossySetitemError
                 return element
 
             return element
 
-        # We have not inferred an integer from the dtype
-        # check if we have a builtin int or a float equal to an int
-        if is_integer(element) or (is_float(element) and element.is_integer()):
-            return element
-        raise ValueError
+        raise LossySetitemError
 
     elif dtype.kind == "f":
+        if lib.is_integer(element) or lib.is_float(element):
+            casted = dtype.type(element)
+            if np.isnan(casted) or casted == element:
+                return casted
+            # otherwise e.g. overflow see TestCoercionFloat32
+            raise LossySetitemError
+
         if tipo is not None:
             # TODO: itemsize check?
             if tipo.kind not in ["f", "i", "u"]:
                 # Anything other than float/integer we cannot hold
-                raise ValueError
+                raise LossySetitemError
             elif not isinstance(tipo, np.dtype):
                 # i.e. nullable IntegerDtype or FloatingDtype;
                 #  we can put this into an ndarray losslessly iff it has no NAs
-                hasnas = element._mask.any()
-                # TODO: don't rely on implementation detail
-                if hasnas:
-                    raise ValueError
+                if element._hasna:
+                    raise LossySetitemError
                 return element
-            return element
+            elif tipo.itemsize > dtype.itemsize or tipo.kind != dtype.kind:
+                if isinstance(element, np.ndarray):
+                    # e.g. TestDataFrameIndexingWhere::test_where_alignment
+                    casted = element.astype(dtype)
+                    # TODO(np>=1.20): we can just use np.array_equal with equal_nan
+                    if array_equivalent(casted, element):
+                        return casted
+                    raise LossySetitemError
 
-        if lib.is_integer(element) or lib.is_float(element):
             return element
-        raise ValueError
+
+        raise LossySetitemError
 
     elif dtype.kind == "c":
+        if lib.is_integer(element) or lib.is_complex(element) or lib.is_float(element):
+            if np.isnan(element):
+                # see test_where_complex GH#6345
+                return dtype.type(element)
+
+            casted = dtype.type(element)
+            if casted == element:
+                return casted
+            # otherwise e.g. overflow see test_32878_complex_itemsize
+            raise LossySetitemError
+
         if tipo is not None:
             if tipo.kind in ["c", "f", "i", "u"]:
                 return element
-            raise ValueError
-        if lib.is_integer(element) or lib.is_complex(element) or lib.is_float(element):
-            return element
-        raise ValueError
+            raise LossySetitemError
+        raise LossySetitemError
 
     elif dtype.kind == "b":
         if tipo is not None:
-            if tipo.kind == "b":  # FIXME: wrong with BooleanArray?
+            if tipo.kind == "b":
+                if not isinstance(tipo, np.dtype):
+                    # i.e. we have a BooleanArray
+                    if element._hasna:
+                        # i.e. there are pd.NA elements
+                        raise LossySetitemError
                 return element
-            raise ValueError
+            raise LossySetitemError
         if lib.is_bool(element):
             return element
-        raise ValueError
+        raise LossySetitemError
 
     elif dtype.kind == "S":
         # TODO: test tests.frame.methods.test_replace tests get here,
@@ -2315,20 +2078,28 @@ def np_can_hold_element(dtype: np.dtype, element: Any) -> Any:
         if tipo is not None:
             if tipo.kind == "S" and tipo.itemsize <= dtype.itemsize:
                 return element
-            raise ValueError
+            raise LossySetitemError
         if isinstance(element, bytes) and len(element) <= dtype.itemsize:
             return element
-        raise ValueError
+        raise LossySetitemError
 
     raise NotImplementedError(dtype)
 
 
 def _dtype_can_hold_range(rng: range, dtype: np.dtype) -> bool:
     """
-    maybe_infer_dtype_type infers to int64 (and float64 for very large endpoints),
+    _maybe_infer_dtype_type infers to int64 (and float64 for very large endpoints),
     but in many cases a range can be held by a smaller integer dtype.
     Check if this is one of those cases.
     """
     if not len(rng):
         return True
     return np.can_cast(rng[0], dtype) and np.can_cast(rng[-1], dtype)
+
+
+class LossySetitemError(Exception):
+    """
+    Raised when trying to do a __setitem__ on an np.ndarray that is not lossless.
+    """
+
+    pass
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 3a7d8a3191ef3..9355e81f41cda 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -36,7 +36,7 @@
     ABCCategorical,
     ABCIndex,
 )
-from pandas.core.dtypes.inference import (  # noqa:F401
+from pandas.core.dtypes.inference import (
     is_array_like,
     is_bool,
     is_complex,
@@ -99,6 +99,7 @@ def ensure_float(arr):
 ensure_int8 = algos.ensure_int8
 ensure_platform_int = algos.ensure_platform_int
 ensure_object = algos.ensure_object
+ensure_uint64 = algos.ensure_uint64
 
 
 def ensure_str(value: bytes | Any) -> str:
@@ -278,6 +279,9 @@ def is_categorical(arr) -> bool:
     """
     Check whether an array-like is a Categorical instance.
 
+    .. deprecated:: 1.1.0
+        Use ``is_categorical_dtype`` instead.
+
     Parameters
     ----------
     arr : array-like
@@ -534,9 +538,7 @@ def is_string_or_object_np_dtype(dtype: np.dtype) -> bool:
     """
     Faster alternative to is_string_dtype, assumes we have a np.dtype object.
     """
-    # error: Non-overlapping equality check (left operand type: "dtype[Any]",
-    # right operand type: "Type[object]")
-    return dtype == object or dtype.kind in "SU"  # type: ignore[comparison-overlap]
+    return dtype == object or dtype.kind in "SU"
 
 
 def is_string_dtype(arr_or_dtype) -> bool:
@@ -968,7 +970,9 @@ def is_datetime64_ns_dtype(arr_or_dtype) -> bool:
             tipo = get_dtype(arr_or_dtype.dtype)
         else:
             return False
-    return tipo == DT64NS_DTYPE or getattr(tipo, "base", None) == DT64NS_DTYPE
+    return tipo == DT64NS_DTYPE or (
+        isinstance(tipo, DatetimeTZDtype) and tipo._unit == "ns"
+    )
 
 
 def is_timedelta64_ns_dtype(arr_or_dtype) -> bool:
@@ -1041,7 +1045,7 @@ def is_datetime_or_timedelta_dtype(arr_or_dtype) -> bool:
 
 
 # This exists to silence numpy deprecation warnings, see GH#29553
-def is_numeric_v_string_like(a: ArrayLike, b):
+def is_numeric_v_string_like(a: ArrayLike, b) -> bool:
     """
     Check if we are comparing a string-like object to a numeric ndarray.
     NumPy doesn't like to compare such objects, especially numeric arrays
@@ -1090,7 +1094,7 @@ def is_numeric_v_string_like(a: ArrayLike, b):
 
 
 # This exists to silence numpy deprecation warnings, see GH#29553
-def is_datetimelike_v_numeric(a, b):
+def is_datetimelike_v_numeric(a, b) -> bool:
     """
     Check if we are comparing a datetime-like object to a numeric object.
     By "numeric," we mean an object that is either of an int or float dtype.
@@ -1183,10 +1187,10 @@ def needs_i8_conversion(arr_or_dtype) -> bool:
     """
     if arr_or_dtype is None:
         return False
-    if isinstance(arr_or_dtype, (np.dtype, ExtensionDtype)):
-        # fastpath
-        dtype = arr_or_dtype
-        return dtype.kind in ["m", "M"] or dtype.type is Period
+    if isinstance(arr_or_dtype, np.dtype):
+        return arr_or_dtype.kind in ["m", "M"]
+    elif isinstance(arr_or_dtype, ExtensionDtype):
+        return isinstance(arr_or_dtype, (PeriodDtype, DatetimeTZDtype))
 
     try:
         dtype = get_dtype(arr_or_dtype)
@@ -1243,8 +1247,6 @@ def is_float_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of a float dtype.
 
-    This function is internal and should not be exposed in the public API.
-
     Parameters
     ----------
     arr_or_dtype : array-like or dtype
@@ -1321,7 +1323,7 @@ def is_bool_dtype(arr_or_dtype) -> bool:
         return False
 
     if isinstance(dtype, CategoricalDtype):
-        arr_or_dtype = arr_or_dtype.categories
+        arr_or_dtype = dtype.categories
         # now we use the special definition for Index
 
     if isinstance(arr_or_dtype, ABCIndex):
@@ -1814,3 +1816,70 @@ def is_all_strings(value: ArrayLike) -> bool:
     elif isinstance(dtype, CategoricalDtype):
         return dtype.categories.inferred_type == "string"
     return dtype == "string"
+
+
+__all__ = [
+    "classes",
+    "classes_and_not_datetimelike",
+    "DT64NS_DTYPE",
+    "ensure_float",
+    "ensure_float64",
+    "ensure_python_int",
+    "ensure_str",
+    "get_dtype",
+    "infer_dtype_from_object",
+    "INT64_DTYPE",
+    "is_1d_only_ea_dtype",
+    "is_1d_only_ea_obj",
+    "is_all_strings",
+    "is_any_int_dtype",
+    "is_array_like",
+    "is_bool",
+    "is_bool_dtype",
+    "is_categorical",
+    "is_categorical_dtype",
+    "is_complex",
+    "is_complex_dtype",
+    "is_dataclass",
+    "is_datetime64_any_dtype",
+    "is_datetime64_dtype",
+    "is_datetime64_ns_dtype",
+    "is_datetime64tz_dtype",
+    "is_datetimelike_v_numeric",
+    "is_datetime_or_timedelta_dtype",
+    "is_decimal",
+    "is_dict_like",
+    "is_dtype_equal",
+    "is_ea_or_datetimelike_dtype",
+    "is_extension_array_dtype",
+    "is_extension_type",
+    "is_file_like",
+    "is_float_dtype",
+    "is_int64_dtype",
+    "is_integer_dtype",
+    "is_interval",
+    "is_interval_dtype",
+    "is_iterator",
+    "is_named_tuple",
+    "is_nested_list_like",
+    "is_number",
+    "is_numeric_dtype",
+    "is_numeric_v_string_like",
+    "is_object_dtype",
+    "is_period_dtype",
+    "is_re",
+    "is_re_compilable",
+    "is_scipy_sparse",
+    "is_sequence",
+    "is_signed_integer_dtype",
+    "is_sparse",
+    "is_string_dtype",
+    "is_string_or_object_np_dtype",
+    "is_timedelta64_dtype",
+    "is_timedelta64_ns_dtype",
+    "is_unsigned_integer_dtype",
+    "needs_i8_conversion",
+    "pandas_dtype",
+    "TD64NS_DTYPE",
+    "validate_all_hashable",
+]
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 2dc4241c6a303..5fb63e09ae1fb 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -1,6 +1,8 @@
 """
 Utility functions related to concat.
 """
+from __future__ import annotations
+
 from typing import (
     TYPE_CHECKING,
     cast,
@@ -15,16 +17,19 @@
 )
 from pandas.util._exceptions import find_stack_level
 
+from pandas.core.dtypes.astype import astype_array
 from pandas.core.dtypes.cast import (
-    astype_array,
+    common_dtype_categorical_compat,
     find_common_type,
 )
 from pandas.core.dtypes.common import (
-    is_categorical_dtype,
     is_dtype_equal,
     is_sparse,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    ExtensionDtype,
+)
 from pandas.core.dtypes.generic import (
     ABCCategoricalIndex,
     ABCExtensionArray,
@@ -32,6 +37,7 @@
 )
 
 if TYPE_CHECKING:
+    from pandas.core.arrays import Categorical
     from pandas.core.arrays.sparse import SparseArray
 
 
@@ -42,19 +48,10 @@ def cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
     """
     if is_dtype_equal(arr.dtype, dtype):
         return arr
-    if (
-        is_categorical_dtype(arr.dtype)
-        and isinstance(dtype, np.dtype)
-        and np.issubdtype(dtype, np.integer)
-    ):
-        # problem case: categorical of int -> gives int as result dtype,
-        # but categorical can contain NAs -> fall back to object dtype
-        try:
-            return arr.astype(dtype, copy=False)
-        except ValueError:
-            return arr.astype(object, copy=False)
 
     if is_sparse(arr) and not is_sparse(dtype):
+        # TODO(2.0): remove special case once SparseArray.astype deprecation
+        #  is enforced.
         # problem case: SparseArray.astype(dtype) doesn't follow the specified
         # dtype exactly, but converts this to Sparse[dtype] -> first manually
         # convert to dense array
@@ -108,10 +105,12 @@ def is_nonempty(x) -> bool:
         # ea_compat_axis see GH#39574
         to_concat = non_empties
 
+    dtypes = {obj.dtype for obj in to_concat}
     kinds = {obj.dtype.kind for obj in to_concat}
-    contains_datetime = any(kind in ["m", "M"] for kind in kinds) or any(
-        isinstance(obj, ABCExtensionArray) and obj.ndim > 1 for obj in to_concat
-    )
+    contains_datetime = any(
+        isinstance(dtype, (np.dtype, DatetimeTZDtype)) and dtype.kind in ["m", "M"]
+        for dtype in dtypes
+    ) or any(isinstance(obj, ABCExtensionArray) and obj.ndim > 1 for obj in to_concat)
 
     all_empty = not len(non_empties)
     single_dtype = len({x.dtype for x in to_concat}) == 1
@@ -125,6 +124,7 @@ def is_nonempty(x) -> bool:
         # for axis=0
         if not single_dtype:
             target_dtype = find_common_type([x.dtype for x in to_concat])
+            target_dtype = common_dtype_categorical_compat(to_concat, target_dtype)
             to_concat = [cast_to_common_type(arr, target_dtype) for arr in to_concat]
 
         if isinstance(to_concat[0], ABCExtensionArray):
@@ -164,7 +164,7 @@ def is_nonempty(x) -> bool:
 
 def union_categoricals(
     to_union, sort_categories: bool = False, ignore_order: bool = False
-):
+) -> Categorical:
     """
     Combine list-like of Categorical-like, unioning categories.
 
@@ -202,8 +202,6 @@ def union_categoricals(
 
     Examples
     --------
-    >>> from pandas.api.types import union_categoricals
-
     If you want to combine categoricals that do not necessarily have
     the same categories, `union_categoricals` will combine a list-like
     of categoricals. The new categories will be the union of the
@@ -211,7 +209,7 @@ def union_categoricals(
 
     >>> a = pd.Categorical(["b", "c"])
     >>> b = pd.Categorical(["a", "b"])
-    >>> union_categoricals([a, b])
+    >>> pd.api.types.union_categoricals([a, b])
     ['b', 'c', 'a', 'b']
     Categories (3, object): ['b', 'c', 'a']
 
@@ -219,7 +217,7 @@ def union_categoricals(
     in the `categories` of the data. If you want the categories to be
     lexsorted, use `sort_categories=True` argument.
 
-    >>> union_categoricals([a, b], sort_categories=True)
+    >>> pd.api.types.union_categoricals([a, b], sort_categories=True)
     ['b', 'c', 'a', 'b']
     Categories (3, object): ['a', 'b', 'c']
 
@@ -229,7 +227,7 @@ def union_categoricals(
 
     >>> a = pd.Categorical(["a", "b"], ordered=True)
     >>> b = pd.Categorical(["a", "b", "a"], ordered=True)
-    >>> union_categoricals([a, b])
+    >>> pd.api.types.union_categoricals([a, b])
     ['a', 'b', 'a', 'b', 'a']
     Categories (2, object): ['a' < 'b']
 
@@ -237,7 +235,7 @@ def union_categoricals(
 
     >>> a = pd.Categorical(["a", "b"], ordered=True)
     >>> b = pd.Categorical(["a", "b", "c"], ordered=True)
-    >>> union_categoricals([a, b])
+    >>> pd.api.types.union_categoricals([a, b])
     Traceback (most recent call last):
         ...
     TypeError: to union ordered Categoricals, all categories must be the same
@@ -249,7 +247,7 @@ def union_categoricals(
 
     >>> a = pd.Categorical(["a", "b", "c"], ordered=True)
     >>> b = pd.Categorical(["c", "b", "a"], ordered=True)
-    >>> union_categoricals([a, b], ignore_order=True)
+    >>> pd.api.types.union_categoricals([a, b], ignore_order=True)
     ['a', 'b', 'c', 'c', 'b', 'a']
     Categories (3, object): ['a', 'b', 'c']
 
@@ -259,7 +257,7 @@ def union_categoricals(
 
     >>> a = pd.Series(["b", "c"], dtype='category')
     >>> b = pd.Series(["a", "b"], dtype='category')
-    >>> union_categoricals([a, b])
+    >>> pd.api.types.union_categoricals([a, b])
     ['b', 'c', 'a', 'b']
     Categories (3, object): ['b', 'c', 'a']
     """
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index e74d73b84e94b..e2570e6be4879 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -14,11 +14,13 @@
 import numpy as np
 import pytz
 
+from pandas._libs import missing as libmissing
 from pandas._libs.interval import Interval
 from pandas._libs.properties import cache_readonly
 from pandas._libs.tslibs import (
     BaseOffset,
     NaT,
+    NaTType,
     Period,
     Timestamp,
     dtypes,
@@ -57,6 +59,7 @@
         Index,
     )
     from pandas.core.arrays import (
+        BaseMaskedArray,
         DatetimeArray,
         IntervalArray,
         PandasArray,
@@ -179,7 +182,7 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
     _metadata = ("categories", "ordered")
     _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
 
-    def __init__(self, categories=None, ordered: Ordered = False):
+    def __init__(self, categories=None, ordered: Ordered = False) -> None:
         self._finalize(categories, ordered, fastpath=False)
 
     @classmethod
@@ -662,15 +665,21 @@ class DatetimeTZDtype(PandasExtensionDtype):
 
     type: type[Timestamp] = Timestamp
     kind: str_type = "M"
-    str = "|M8[ns]"
     num = 101
-    base = np.dtype("M8[ns]")
-    na_value = NaT
+    base = np.dtype("M8[ns]")  # TODO: depend on reso?
     _metadata = ("unit", "tz")
     _match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
     _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
 
-    def __init__(self, unit: str_type | DatetimeTZDtype = "ns", tz=None):
+    @property
+    def na_value(self) -> NaTType:
+        return NaT
+
+    @cache_readonly
+    def str(self):
+        return f"|M8[{self._unit}]"
+
+    def __init__(self, unit: str_type | DatetimeTZDtype = "ns", tz=None) -> None:
         if isinstance(unit, DatetimeTZDtype):
             # error: "str" has no attribute "tz"
             unit, tz = unit.unit, unit.tz  # type: ignore[attr-defined]
@@ -688,8 +697,8 @@ def __init__(self, unit: str_type | DatetimeTZDtype = "ns", tz=None):
                     "'DatetimeTZDtype.construct_from_string()' instead."
                 )
                 raise ValueError(msg)
-            else:
-                raise ValueError("DatetimeTZDtype only supports ns units")
+            if unit not in ["s", "ms", "us", "ns"]:
+                raise ValueError("DatetimeTZDtype only supports s, ms, us, ns units")
 
         if tz:
             tz = timezones.maybe_get_tz(tz)
@@ -702,6 +711,19 @@ def __init__(self, unit: str_type | DatetimeTZDtype = "ns", tz=None):
         self._unit = unit
         self._tz = tz
 
+    @cache_readonly
+    def _reso(self) -> int:
+        """
+        The NPY_DATETIMEUNIT corresponding to this dtype's resolution.
+        """
+        reso = {
+            "s": dtypes.NpyDatetimeUnit.NPY_FR_s,
+            "ms": dtypes.NpyDatetimeUnit.NPY_FR_ms,
+            "us": dtypes.NpyDatetimeUnit.NPY_FR_us,
+            "ns": dtypes.NpyDatetimeUnit.NPY_FR_ns,
+        }[self._unit]
+        return reso.value
+
     @property
     def unit(self) -> str_type:
         """
@@ -919,7 +941,7 @@ def name(self) -> str_type:
         return f"period[{self.freq.freqstr}]"
 
     @property
-    def na_value(self):
+    def na_value(self) -> NaTType:
         return NaT
 
     def __hash__(self) -> int:
@@ -946,7 +968,7 @@ def __eq__(self, other: Any) -> bool:
     def __ne__(self, other: Any) -> bool:
         return not self.__eq__(other)
 
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         # for pickle compat. __getstate__ is defined in the
         # PandasExtensionDtype superclass and uses the public properties to
         # pickle -> need to set the settable private ones here (see GH26067)
@@ -995,7 +1017,9 @@ def __from_arrow__(
         import pyarrow
 
         from pandas.core.arrays import PeriodArray
-        from pandas.core.arrays._arrow_utils import pyarrow_array_to_numpy_and_mask
+        from pandas.core.arrays.arrow._arrow_utils import (
+            pyarrow_array_to_numpy_and_mask,
+        )
 
         if isinstance(array, pyarrow.Array):
             chunks = [array]
@@ -1004,9 +1028,11 @@ def __from_arrow__(
 
         results = []
         for arr in chunks:
-            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype="int64")
+            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype=np.dtype(np.int64))
             parr = PeriodArray(data.copy(), freq=self.freq, copy=False)
-            parr[~mask] = NaT
+            # error: Invalid index type "ndarray[Any, dtype[bool_]]" for "PeriodArray";
+            # expected type "Union[int, Sequence[int], Sequence[bool], slice]"
+            parr[~mask] = NaT  # type: ignore[index]
             results.append(parr)
 
         if not results:
@@ -1049,9 +1075,12 @@ class IntervalDtype(PandasExtensionDtype):
         "subtype",
         "closed",
     )
+
     _match = re.compile(
-        r"(I|i)nterval\[(?P<subtype>[^,]+)(, (?P<closed>(right|left|both|neither)))?\]"
+        r"(I|i)nterval\[(?P<subtype>[^,]+(\[.+\])?)"
+        r"(, (?P<closed>(right|left|both|neither)))?\]"
     )
+
     _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
 
     def __new__(cls, subtype=None, closed: str_type | None = None):
@@ -1117,6 +1146,18 @@ def __new__(cls, subtype=None, closed: str_type | None = None):
             cls._cache_dtypes[key] = u
             return u
 
+    @cache_readonly
+    def _can_hold_na(self) -> bool:
+        subtype = self._subtype
+        if subtype is None:
+            # partially-initialized
+            raise NotImplementedError(
+                "_can_hold_na is not defined for partially-initialized IntervalDtype"
+            )
+        if subtype.kind in ["i", "u"]:
+            return False
+        return True
+
     @property
     def closed(self):
         return self._closed
@@ -1164,7 +1205,7 @@ def construct_from_string(cls, string: str_type) -> IntervalDtype:
         raise TypeError(msg)
 
     @property
-    def type(self):
+    def type(self) -> type[Interval]:
         return Interval
 
     def __str__(self) -> str_type:
@@ -1194,7 +1235,7 @@ def __eq__(self, other: Any) -> bool:
 
             return is_dtype_equal(self.subtype, other.subtype)
 
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         # for pickle compat. __get_state__ is defined in the
         # PandasExtensionDtype superclass and uses the public properties to
         # pickle -> need to set the settable private ones here (see GH26067)
@@ -1239,16 +1280,18 @@ def __from_arrow__(
 
         results = []
         for arr in chunks:
-            left = np.asarray(arr.storage.field("left"), dtype=self.subtype)
-            right = np.asarray(arr.storage.field("right"), dtype=self.subtype)
-            iarr = IntervalArray.from_arrays(left, right, closed=array.type.closed)
+            if isinstance(arr, pyarrow.ExtensionArray):
+                arr = arr.storage
+            left = np.asarray(arr.field("left"), dtype=self.subtype)
+            right = np.asarray(arr.field("right"), dtype=self.subtype)
+            iarr = IntervalArray.from_arrays(left, right, closed=self.closed)
             results.append(iarr)
 
         if not results:
             return IntervalArray.from_arrays(
                 np.array([], dtype=self.subtype),
                 np.array([], dtype=self.subtype),
-                closed=array.type.closed,
+                closed=self.closed,
             )
         return IntervalArray._concat_same_type(results)
 
@@ -1287,7 +1330,7 @@ class PandasDtype(ExtensionDtype):
 
     _metadata = ("_dtype",)
 
-    def __init__(self, dtype: npt.DTypeLike | PandasDtype | None):
+    def __init__(self, dtype: npt.DTypeLike | PandasDtype | None) -> None:
         if isinstance(dtype, PandasDtype):
             # make constructor univalent
             dtype = dtype.numpy_dtype
@@ -1364,3 +1407,81 @@ def itemsize(self) -> int:
         The element size of this data-type object.
         """
         return self._dtype.itemsize
+
+
+class BaseMaskedDtype(ExtensionDtype):
+    """
+    Base class for dtypes for BaseMaskedArray subclasses.
+    """
+
+    name: str
+    base = None
+    type: type
+
+    @property
+    def na_value(self) -> libmissing.NAType:
+        return libmissing.NA
+
+    @cache_readonly
+    def numpy_dtype(self) -> np.dtype:
+        """Return an instance of our numpy dtype"""
+        return np.dtype(self.type)
+
+    @cache_readonly
+    def kind(self) -> str:
+        return self.numpy_dtype.kind
+
+    @cache_readonly
+    def itemsize(self) -> int:
+        """Return the number of bytes in this dtype"""
+        return self.numpy_dtype.itemsize
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[BaseMaskedArray]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def from_numpy_dtype(cls, dtype: np.dtype) -> BaseMaskedDtype:
+        """
+        Construct the MaskedDtype corresponding to the given numpy dtype.
+        """
+        if dtype.kind == "b":
+            from pandas.core.arrays.boolean import BooleanDtype
+
+            return BooleanDtype()
+        elif dtype.kind in ["i", "u"]:
+            from pandas.core.arrays.integer import INT_STR_TO_DTYPE
+
+            return INT_STR_TO_DTYPE[dtype.name]
+        elif dtype.kind == "f":
+            from pandas.core.arrays.floating import FLOAT_STR_TO_DTYPE
+
+            return FLOAT_STR_TO_DTYPE[dtype.name]
+        else:
+            raise NotImplementedError(dtype)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        # We unwrap any masked dtypes, find the common dtype we would use
+        #  for that, then re-mask the result.
+        from pandas.core.dtypes.cast import find_common_type
+
+        new_dtype = find_common_type(
+            [
+                dtype.numpy_dtype if isinstance(dtype, BaseMaskedDtype) else dtype
+                for dtype in dtypes
+            ]
+        )
+        if not isinstance(new_dtype, np.dtype):
+            # If we ever support e.g. Masked[DatetimeArray] then this will change
+            return None
+        try:
+            return type(self).from_numpy_dtype(new_dtype)
+        except (KeyError, NotImplementedError):
+            return None
diff --git a/pandas/core/dtypes/generic.py b/pandas/core/dtypes/generic.py
index d6dbc83934db0..a6634cca12e93 100644
--- a/pandas/core/dtypes/generic.py
+++ b/pandas/core/dtypes/generic.py
@@ -37,14 +37,25 @@
 # define abstract base classes to enable isinstance type checking on our
 # objects
 def create_pandas_abc_type(name, attr, comp):
+    def _check(inst):
+        return getattr(inst, attr, "_typ") in comp
 
     # https://github.com/python/mypy/issues/1006
     # error: 'classmethod' used with a non-method
     @classmethod  # type: ignore[misc]
-    def _check(cls, inst) -> bool:
-        return getattr(inst, attr, "_typ") in comp
+    def _instancecheck(cls, inst) -> bool:
+        return _check(inst) and not isinstance(inst, type)
+
+    @classmethod  # type: ignore[misc]
+    def _subclasscheck(cls, inst) -> bool:
+        # Raise instead of returning False
+        # This is consistent with default __subclasscheck__ behavior
+        if not isinstance(inst, type):
+            raise TypeError("issubclass() arg 1 must be a class")
+
+        return _check(inst)
 
-    dct = {"__instancecheck__": _check, "__subclasscheck__": _check}
+    dct = {"__instancecheck__": _instancecheck, "__subclasscheck__": _subclasscheck}
     meta = type("ABCBase", (type,), dct)
     return meta(name, (), dct)
 
diff --git a/pandas/core/dtypes/inference.py b/pandas/core/dtypes/inference.py
index 1f1486b1b29a7..893e4a9be58ef 100644
--- a/pandas/core/dtypes/inference.py
+++ b/pandas/core/dtypes/inference.py
@@ -1,14 +1,18 @@
 """ basic inference routines """
 
+from __future__ import annotations
+
 from collections import abc
 from numbers import Number
 import re
 from typing import Pattern
+import warnings
 
 import numpy as np
 
 from pandas._libs import lib
 from pandas._typing import ArrayLike
+from pandas.util._exceptions import find_stack_level
 
 is_bool = lib.is_bool
 
@@ -447,5 +451,16 @@ def is_inferred_bool_dtype(arr: ArrayLike) -> bool:
     if dtype == np.dtype(bool):
         return True
     elif dtype == np.dtype("object"):
-        return lib.is_bool_array(arr)
+        result = lib.is_bool_array(arr)
+        if result:
+            # GH#46188
+            warnings.warn(
+                "In a future version, object-dtype columns with all-bool values "
+                "will not be included in reductions with bool_only=True. "
+                "Explicitly cast to bool dtype instead.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+        return result
+
     return False
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index dd3fcb260fdbd..e7f57ae0e6658 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -5,6 +5,10 @@
 
 from decimal import Decimal
 from functools import partial
+from typing import (
+    TYPE_CHECKING,
+    overload,
+)
 
 import numpy as np
 
@@ -14,13 +18,9 @@
 import pandas._libs.missing as libmissing
 from pandas._libs.tslibs import (
     NaT,
+    Period,
     iNaT,
 )
-from pandas._typing import (
-    ArrayLike,
-    DtypeObj,
-    npt,
-)
 
 from pandas.core.dtypes.common import (
     DT64NS_DTYPE,
@@ -41,6 +41,7 @@
 )
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
+    DatetimeTZDtype,
     ExtensionDtype,
     IntervalDtype,
     PeriodDtype,
@@ -54,6 +55,19 @@
 )
 from pandas.core.dtypes.inference import is_list_like
 
+if TYPE_CHECKING:
+    from pandas._typing import (
+        ArrayLike,
+        DtypeObj,
+        NDFrame,
+        NDFrameT,
+        Scalar,
+        npt,
+    )
+
+    from pandas.core.indexes.base import Index
+
+
 isposinf_scalar = libmissing.isposinf_scalar
 isneginf_scalar = libmissing.isneginf_scalar
 
@@ -63,7 +77,35 @@
 _dtype_str = np.dtype(str)
 
 
-def isna(obj):
+@overload
+def isna(obj: Scalar) -> bool:
+    ...
+
+
+@overload
+def isna(
+    obj: ArrayLike | Index | list,
+) -> npt.NDArray[np.bool_]:
+    ...
+
+
+@overload
+def isna(obj: NDFrameT) -> NDFrameT:
+    ...
+
+
+# handle unions
+@overload
+def isna(obj: NDFrameT | ArrayLike | Index | list) -> NDFrameT | npt.NDArray[np.bool_]:
+    ...
+
+
+@overload
+def isna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    ...
+
+
+def isna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
     """
     Detect missing values for an array-like object.
 
@@ -284,7 +326,35 @@ def _isna_string_dtype(values: np.ndarray, inf_as_na: bool) -> npt.NDArray[np.bo
     return result
 
 
-def notna(obj):
+@overload
+def notna(obj: Scalar) -> bool:
+    ...
+
+
+@overload
+def notna(
+    obj: ArrayLike | Index | list,
+) -> npt.NDArray[np.bool_]:
+    ...
+
+
+@overload
+def notna(obj: NDFrameT) -> NDFrameT:
+    ...
+
+
+# handle unions
+@overload
+def notna(obj: NDFrameT | ArrayLike | Index | list) -> NDFrameT | npt.NDArray[np.bool_]:
+    ...
+
+
+@overload
+def notna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    ...
+
+
+def notna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
     """
     Detect non-missing values for an array-like object.
 
@@ -362,7 +432,7 @@ def notna(obj):
     Name: 1, dtype: bool
     """
     res = isna(obj)
-    if is_scalar(res):
+    if isinstance(res, bool):
         return not res
     return ~res
 
@@ -524,6 +594,10 @@ def _array_equivalent_object(left: np.ndarray, right: np.ndarray, strict_nan: bo
                 if "boolean value of NA is ambiguous" in str(err):
                     return False
                 raise
+            except ValueError:
+                # numpy can raise a ValueError if left and right cannot be
+                # compared (e.g. nested arrays)
+                return False
     return True
 
 
@@ -648,6 +722,9 @@ def is_valid_na_for_dtype(obj, dtype: DtypeObj) -> bool:
     elif dtype.kind in ["i", "u", "f", "c"]:
         # Numeric
         return obj is not NaT and not isinstance(obj, (np.datetime64, np.timedelta64))
+    elif dtype.kind == "b":
+        # We allow pd.NA, None, np.nan in BooleanArray (same as IntervalDtype)
+        return lib.is_float(obj) or obj is None or obj is libmissing.NA
 
     elif dtype == _dtype_str:
         # numpy string dtypes to avoid float np.nan
@@ -668,3 +745,39 @@ def is_valid_na_for_dtype(obj, dtype: DtypeObj) -> bool:
 
     # fallback, default to allowing NaN, None, NA, NaT
     return not isinstance(obj, (np.datetime64, np.timedelta64, Decimal))
+
+
+def isna_all(arr: ArrayLike) -> bool:
+    """
+    Optimized equivalent to isna(arr).all()
+    """
+    total_len = len(arr)
+
+    # Usually it's enough to check but a small fraction of values to see if
+    #  a block is NOT null, chunks should help in such cases.
+    #  parameters 1000 and 40 were chosen arbitrarily
+    chunk_len = max(total_len // 40, 1000)
+
+    dtype = arr.dtype
+    if dtype.kind == "f" and isinstance(dtype, np.dtype):
+        checker = nan_checker
+
+    elif (
+        (isinstance(dtype, np.dtype) and dtype.kind in ["m", "M"])
+        or isinstance(dtype, DatetimeTZDtype)
+        or dtype.type is Period
+    ):
+        # error: Incompatible types in assignment (expression has type
+        # "Callable[[Any], Any]", variable has type "ufunc")
+        checker = lambda x: np.asarray(x.view("i8")) == iNaT  # type: ignore[assignment]
+
+    else:
+        # error: Incompatible types in assignment (expression has type "Callable[[Any],
+        # Any]", variable has type "ufunc")
+        checker = lambda x: _isna_array(  # type: ignore[assignment]
+            x, inf_as_na=INF_AS_NA
+        )
+
+    return all(
+        checker(arr[i : i + chunk_len]).all() for i in range(0, total_len, chunk_len)
+    )
diff --git a/pandas/core/flags.py b/pandas/core/flags.py
index 54be212c5633c..f07c6917d91e5 100644
--- a/pandas/core/flags.py
+++ b/pandas/core/flags.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import weakref
 
 
@@ -44,7 +46,7 @@ class Flags:
 
     _keys = {"allows_duplicate_labels"}
 
-    def __init__(self, obj, *, allows_duplicate_labels):
+    def __init__(self, obj, *, allows_duplicate_labels) -> None:
         self._allows_duplicate_labels = allows_duplicate_labels
         self._obj = weakref.ref(obj)
 
@@ -81,7 +83,7 @@ def allows_duplicate_labels(self) -> bool:
         return self._allows_duplicate_labels
 
     @allows_duplicate_labels.setter
-    def allows_duplicate_labels(self, value: bool):
+    def allows_duplicate_labels(self, value: bool) -> None:
         value = bool(value)
         obj = self._obj()
         if obj is None:
@@ -99,12 +101,12 @@ def __getitem__(self, key):
 
         return getattr(self, key)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         if key not in self._keys:
             raise ValueError(f"Unknown flag {key}. Must be one of {self._keys}")
         setattr(self, key, value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Flags(allows_duplicate_labels={self.allows_duplicate_labels})>"
 
     def __eq__(self, other):
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index cbc40c5d0aa75..9e0f1363e073c 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -18,7 +18,6 @@
 import itertools
 from textwrap import dedent
 from typing import (
-    IO,
     TYPE_CHECKING,
     Any,
     Callable,
@@ -26,6 +25,7 @@
     Iterable,
     Iterator,
     Literal,
+    Mapping,
     Sequence,
     cast,
     overload,
@@ -43,7 +43,10 @@
     properties,
 )
 from pandas._libs.hashtable import duplicated
-from pandas._libs.lib import no_default
+from pandas._libs.lib import (
+    NoDefault,
+    no_default,
+)
 from pandas._typing import (
     AggFuncType,
     AnyArrayLike,
@@ -59,13 +62,17 @@
     FloatFormatType,
     FormattersType,
     Frequency,
+    IgnoreRaise,
     IndexKeyFunc,
     IndexLabel,
     Level,
+    NaPosition,
     PythonFuncType,
+    QuantileInterpolation,
     ReadBuffer,
     Renamer,
     Scalar,
+    SortKind,
     StorageOptions,
     Suffixes,
     TimedeltaConvertibleTypes,
@@ -75,7 +82,11 @@
     npt,
 )
 from pandas.compat._optional import import_optional_dependency
-from pandas.compat.numpy import function as nv
+from pandas.compat.numpy import (
+    function as nv,
+    np_percentile_argname,
+)
+from pandas.errors import InvalidIndexError
 from pandas.util._decorators import (
     Appender,
     Substitution,
@@ -93,6 +104,7 @@
 )
 
 from pandas.core.dtypes.cast import (
+    LossySetitemError,
     can_hold_element,
     construct_1d_arraylike_from_scalar,
     construct_2d_arraylike_from_scalar,
@@ -106,7 +118,6 @@
     ensure_platform_int,
     infer_dtype_from_object,
     is_1d_only_ea_dtype,
-    is_1d_only_ea_obj,
     is_bool_dtype,
     is_dataclass,
     is_datetime64_any_dtype,
@@ -120,9 +131,11 @@
     is_integer_dtype,
     is_iterator,
     is_list_like,
+    is_numeric_dtype,
     is_object_dtype,
     is_scalar,
     is_sequence,
+    needs_i8_conversion,
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import ExtensionDtype
@@ -147,6 +160,7 @@
 from pandas.core.arrays import (
     DatetimeArray,
     ExtensionArray,
+    PeriodArray,
     TimedeltaArray,
 )
 from pandas.core.arrays.sparse import SparseFrameAccessor
@@ -214,6 +228,7 @@
 if TYPE_CHECKING:
 
     from pandas.core.groupby.generic import DataFrameGroupBy
+    from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
     from pandas.core.internals import SingleDataManager
     from pandas.core.resample import Resampler
 
@@ -231,7 +246,7 @@
         If 1 or 'columns': apply function to each row.""",
     "inplace": """
     inplace : bool, default False
-        If True, performs operation inplace and returns None.""",
+        Whether to modify the DataFrame rather than creating a new one.""",
     "optional_by": """
         by : str or list of str
             Name or list of names to sort by.
@@ -489,6 +504,8 @@ class DataFrame(NDFrame, OpsMixin):
         Copy data from inputs.
         For dict data, the default of None behaves like ``copy=True``.  For DataFrame
         or 2d ndarray input, the default of None behaves like ``copy=False``.
+        If data is a dict containing one or more Series (possibly of different dtypes),
+        ``copy=False`` will ensure that these inputs are not copied.
 
         .. versionchanged:: 1.3.0
 
@@ -500,6 +517,10 @@ class DataFrame(NDFrame, OpsMixin):
     read_table : Read general delimited file into DataFrame.
     read_clipboard : Read text from clipboard into DataFrame.
 
+    Notes
+    -----
+    Please reference the :ref:`User Guide <basics.dataframe>` for more information.
+
     Examples
     --------
     Constructing DataFrame from a dictionary.
@@ -577,10 +598,10 @@ class DataFrame(NDFrame, OpsMixin):
     _mgr: BlockManager | ArrayManager
 
     @property
-    def _constructor(self) -> type[DataFrame]:
+    def _constructor(self) -> Callable[..., DataFrame]:
         return DataFrame
 
-    _constructor_sliced: type[Series] = Series
+    _constructor_sliced: Callable[..., Series] = Series
 
     # ----------------------------------------------------------------------
     # Constructors
@@ -592,7 +613,7 @@ def __init__(
         columns: Axes | None = None,
         dtype: Dtype | None = None,
         copy: bool | None = None,
-    ):
+    ) -> None:
 
         if data is None:
             data = {}
@@ -612,6 +633,12 @@ def __init__(
 
         manager = get_option("mode.data_manager")
 
+        # GH47215
+        if index is not None and isinstance(index, set):
+            raise ValueError("index cannot be a set")
+        if columns is not None and isinstance(columns, set):
+            raise ValueError("columns cannot be a set")
+
         if copy is None:
             if isinstance(data, dict):
                 # retain pre-GH#38939 default behavior
@@ -715,10 +742,7 @@ def __init__(
                 if not isinstance(data, np.ndarray) and treat_as_nested(data):
                     # exclude ndarray as we may have cast it a few lines above
                     if columns is not None:
-                        # error: Argument 1 to "ensure_index" has incompatible type
-                        # "Collection[Any]"; expected "Union[Union[Union[ExtensionArray,
-                        # ndarray], Index, Series], Sequence[Any]]"
-                        columns = ensure_index(columns)  # type: ignore[arg-type]
+                        columns = ensure_index(columns)
                     arrays, columns, index = nested_data_to_arrays(
                         # error: Argument 3 to "nested_data_to_arrays" has incompatible
                         # type "Optional[Collection[Any]]"; expected "Optional[Index]"
@@ -756,14 +780,8 @@ def __init__(
             if index is None or columns is None:
                 raise ValueError("DataFrame constructor not properly called!")
 
-            # Argument 1 to "ensure_index" has incompatible type "Collection[Any]";
-            # expected "Union[Union[Union[ExtensionArray, ndarray],
-            # Index, Series], Sequence[Any]]"
-            index = ensure_index(index)  # type: ignore[arg-type]
-            # Argument 1 to "ensure_index" has incompatible type "Collection[Any]";
-            # expected "Union[Union[Union[ExtensionArray, ndarray],
-            # Index, Series], Sequence[Any]]"
-            columns = ensure_index(columns)  # type: ignore[arg-type]
+            index = ensure_index(index)
+            columns = ensure_index(columns)
 
             if not dtype:
                 dtype, _ = infer_dtype_from_scalar(data, pandas_dtype=True)
@@ -800,6 +818,40 @@ def __init__(
 
         NDFrame.__init__(self, mgr)
 
+    # ----------------------------------------------------------------------
+    def __dataframe__(
+        self, nan_as_null: bool = False, allow_copy: bool = True
+    ) -> DataFrameXchg:
+        """
+        Return the dataframe interchange object implementing the interchange protocol.
+
+        Parameters
+        ----------
+        nan_as_null : bool, default False
+            Whether to tell the DataFrame to overwrite null values in the data
+            with ``NaN`` (or ``NaT``).
+        allow_copy : bool, default True
+            Whether to allow memory copying when exporting. If set to False
+            it would cause non-zero-copy exports to fail.
+
+        Returns
+        -------
+        DataFrame interchange object
+            The object which consuming library can use to ingress the dataframe.
+
+        Notes
+        -----
+        Details on the interchange protocol:
+        https://data-apis.org/dataframe-protocol/latest/index.html
+
+        `nan_as_null` currently has no effect; once support for nullable extension
+        dtypes is added, this value should be propagated to columns.
+        """
+
+        from pandas.core.interchange.dataframe import PandasDataFrameXchg
+
+        return PandasDataFrameXchg(self, nan_as_null, allow_copy)
+
     # ----------------------------------------------------------------------
 
     @property
@@ -899,7 +951,7 @@ def _can_fast_transpose(self) -> bool:
     @property
     def _values(  # type: ignore[override]
         self,
-    ) -> np.ndarray | DatetimeArray | TimedeltaArray:
+    ) -> np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray:
         """
         Analogue to ._values that may return a 2D ExtensionArray.
         """
@@ -908,7 +960,7 @@ def _values(  # type: ignore[override]
         mgr = self._mgr
 
         if isinstance(mgr, ArrayManager):
-            if len(mgr.arrays) == 1 and not is_1d_only_ea_obj(mgr.arrays[0]):
+            if len(mgr.arrays) == 1 and not is_1d_only_ea_dtype(mgr.arrays[0].dtype):
                 # error: Item "ExtensionArray" of "Union[ndarray, ExtensionArray]"
                 # has no attribute "reshape"
                 return mgr.arrays[0].reshape(-1, 1)  # type: ignore[union-attr]
@@ -924,7 +976,7 @@ def _values(  # type: ignore[override]
             return self.values
 
         # more generally, whatever we allow in NDArrayBackedExtensionBlock
-        arr = cast("np.ndarray | DatetimeArray | TimedeltaArray", arr)
+        arr = cast("np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray", arr)
         return arr.T
 
     # ----------------------------------------------------------------------
@@ -960,7 +1012,7 @@ def _repr_fits_horizontal_(self, ignore_width: bool = False) -> bool:
 
         # used by repr_html under IPython notebook or scripts ignore terminal
         # dims
-        if ignore_width or not console.in_interactive_session():
+        if ignore_width or width is None or not console.in_interactive_session():
             return True
 
         if get_option("display.width") is not None or console.in_ipython_frontend():
@@ -1273,8 +1325,42 @@ def items(self) -> Iterable[tuple[Hashable, Series]]:
             for i, k in enumerate(self.columns):
                 yield k, self._ixs(i, axis=1)
 
-    @Appender(_shared_docs["items"])
+    _shared_docs[
+        "iteritems"
+    ] = r"""
+        Iterate over (column name, Series) pairs.
+
+        .. deprecated:: 1.5.0
+            iteritems is deprecated and will be removed in a future version.
+            Use .items instead.
+
+        Iterates over the DataFrame columns, returning a tuple with
+        the column name and the content as a Series.
+
+        Yields
+        ------
+        label : object
+            The column names for the DataFrame being iterated over.
+        content : Series
+            The column entries belonging to each label, as a Series.
+
+        See Also
+        --------
+        DataFrame.iter : Recommended alternative.
+        DataFrame.iterrows : Iterate over DataFrame rows as
+            (index, Series) pairs.
+        DataFrame.itertuples : Iterate over DataFrame rows as namedtuples
+            of the values.
+        """
+
+    @Appender(_shared_docs["iteritems"])
     def iteritems(self) -> Iterable[tuple[Hashable, Series]]:
+        warnings.warn(
+            "iteritems is deprecated and will be removed in a future version. "
+            "Use .items instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
         yield from self.items()
 
     def iterrows(self) -> Iterable[tuple[Hashable, Series]]:
@@ -1322,7 +1408,7 @@ def iterrows(self) -> Iterable[tuple[Hashable, Series]]:
         columns = self.columns
         klass = self._constructor_sliced
         for k, v in zip(self.index, self.values):
-            s = klass(v, index=columns, name=k)
+            s = klass(v, index=columns, name=k).__finalize__(self)
             yield k, s
 
     def itertuples(
@@ -1356,8 +1442,6 @@ def itertuples(
         -----
         The column names will be renamed to positional names if they are
         invalid Python identifiers, repeated, or start with an underscore.
-        On python versions < 3.7 regular tuples are returned for DataFrames
-        with a large number of columns (>254).
 
         Examples
         --------
@@ -1540,20 +1624,16 @@ def __matmul__(self, other: Series) -> Series:
         ...
 
     @overload
-    def __matmul__(
-        self, other: AnyArrayLike | DataFrame | Series
-    ) -> DataFrame | Series:
+    def __matmul__(self, other: AnyArrayLike | DataFrame) -> DataFrame | Series:
         ...
 
-    def __matmul__(
-        self, other: AnyArrayLike | DataFrame | Series
-    ) -> DataFrame | Series:
+    def __matmul__(self, other: AnyArrayLike | DataFrame) -> DataFrame | Series:
         """
         Matrix multiplication using binary `@` operator in Python>=3.5.
         """
         return self.dot(other)
 
-    def __rmatmul__(self, other):
+    def __rmatmul__(self, other) -> DataFrame:
         """
         Matrix multiplication using binary `@` operator in Python>=3.5.
         """
@@ -1572,10 +1652,10 @@ def __rmatmul__(self, other):
     @classmethod
     def from_dict(
         cls,
-        data,
+        data: dict,
         orient: str = "columns",
         dtype: Dtype | None = None,
-        columns=None,
+        columns: Axes | None = None,
     ) -> DataFrame:
         """
         Construct DataFrame from dict of array-like or dicts.
@@ -1667,12 +1747,18 @@ def from_dict(
                 if isinstance(list(data.values())[0], (Series, dict)):
                     data = _from_nested_dict(data)
                 else:
-                    data, index = list(data.values()), list(data.keys())
+                    index = list(data.keys())
+                    # error: Incompatible types in assignment (expression has type
+                    # "List[Any]", variable has type "Dict[Any, Any]")
+                    data = list(data.values())  # type: ignore[assignment]
         elif orient == "columns" or orient == "tight":
             if columns is not None:
                 raise ValueError(f"cannot use columns parameter with orient='{orient}'")
         else:  # pragma: no cover
-            raise ValueError("only recognize index or columns for orient")
+            raise ValueError(
+                f"Expected 'index', 'columns' or 'tight' for orient parameter. "
+                f"Got '{orient}' instead"
+            )
 
         if orient != "tight":
             return cls(data, index=index, columns=columns, dtype=dtype)
@@ -1695,7 +1781,7 @@ def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Convert the DataFrame to a NumPy array.
@@ -1760,7 +1846,25 @@ def to_numpy(
 
         return result
 
-    def to_dict(self, orient: str = "dict", into=dict):
+    @overload
+    def to_dict(
+        self,
+        orient: Literal["dict", "list", "series", "split", "tight", "index"] = ...,
+        into: type[dict] = ...,
+    ) -> dict:
+        ...
+
+    @overload
+    def to_dict(self, orient: Literal["records"], into: type[dict] = ...) -> list[dict]:
+        ...
+
+    def to_dict(
+        self,
+        orient: Literal[
+            "dict", "list", "series", "split", "tight", "records", "index"
+        ] = "dict",
+        into: type[dict] = dict,
+    ) -> dict | list[dict]:
         """
         Convert the DataFrame to a dictionary.
 
@@ -1769,7 +1873,7 @@ def to_dict(self, orient: str = "dict", into=dict):
 
         Parameters
         ----------
-        orient : str {'dict', 'list', 'series', 'split', 'records', 'index'}
+        orient : str {'dict', 'list', 'series', 'split', 'tight', 'records', 'index'}
             Determines the type of the values of the dictionary.
 
             - 'dict' (default) : dict like {column -> {index -> value}}
@@ -1866,7 +1970,10 @@ def to_dict(self, orient: str = "dict", into=dict):
         # GH16122
         into_c = com.standardize_mapping(into)
 
-        orient = orient.lower()
+        #  error: Incompatible types in assignment (expression has type "str",
+        # variable has type "Literal['dict', 'list', 'series', 'split', 'tight',
+        # 'records', 'index']")
+        orient = orient.lower()  # type: ignore[assignment]
         # GH32515
         if orient.startswith(("d", "l", "s", "r", "i")) and orient not in {
             "dict",
@@ -1902,7 +2009,9 @@ def to_dict(self, orient: str = "dict", into=dict):
             return into_c((k, v.to_dict(into)) for k, v in self.items())
 
         elif orient == "list":
-            return into_c((k, v.tolist()) for k, v in self.items())
+            return into_c(
+                (k, list(map(maybe_box_native, v.tolist()))) for k, v in self.items()
+            )
 
         elif orient == "split":
             return into_c(
@@ -1953,7 +2062,7 @@ def to_dict(self, orient: str = "dict", into=dict):
             if not self.index.is_unique:
                 raise ValueError("DataFrame index must be unique for orient='index'.")
             return into_c(
-                (t[0], dict(zip(self.columns, t[1:])))
+                (t[0], dict(zip(self.columns, map(maybe_box_native, t[1:]))))
                 for t in self.itertuples(name=None)
             )
 
@@ -1967,7 +2076,7 @@ def to_gbq(
         chunksize: int | None = None,
         reauth: bool = False,
         if_exists: str = "fail",
-        auth_local_webserver: bool = False,
+        auth_local_webserver: bool = True,
         table_schema: list[dict[str, str]] | None = None,
         location: str | None = None,
         progress_bar: bool = True,
@@ -2005,7 +2114,7 @@ def to_gbq(
                 If table exists, drop it, recreate it, and insert data.
             ``'append'``
                 If table exists, insert data. Create if does not exist.
-        auth_local_webserver : bool, default False
+        auth_local_webserver : bool, default True
             Use the `local webserver flow`_ instead of the `console flow`_
             when getting user credentials.
 
@@ -2015,6 +2124,12 @@ def to_gbq(
                 https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
 
             *New in version 0.2.0 of pandas-gbq*.
+
+            .. versionchanged:: 1.5.0
+               Default value is changed to ``True``. Google has deprecated the
+               ``auth_local_webserver = False`` `"out of band" (copy-paste)
+               flow
+               <https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html?m=1#disallowed-oob>`_.
         table_schema : list of dicts, optional
             List of BigQuery table fields to which according DataFrame
             columns conform to, e.g. ``[{'name': 'col1', 'type':
@@ -2276,7 +2391,7 @@ def maybe_reorder(
         return cls(mgr)
 
     def to_records(
-        self, index=True, column_dtypes=None, index_dtypes=None
+        self, index: bool = True, column_dtypes=None, index_dtypes=None
     ) -> np.recarray:
         """
         Convert DataFrame to a NumPy record array.
@@ -2359,13 +2474,10 @@ def to_records(
                   dtype=[('I', 'S1'), ('A', '<i8'), ('B', '<f8')])
         """
         if index:
-            if isinstance(self.index, MultiIndex):
-                # array of tuples to numpy cols. copy copy copy
-                ix_vals = list(map(np.array, zip(*self.index._values)))
-            else:
-                # error: List item 0 has incompatible type "ArrayLike"; expected
-                # "ndarray"
-                ix_vals = [self.index.values]  # type: ignore[list-item]
+            ix_vals = [
+                np.asarray(self.index.get_level_values(i))
+                for i in range(self.index.nlevels)
+            ]
 
             arrays = ix_vals + [
                 np.asarray(self.iloc[:, i]) for i in range(len(self.columns))
@@ -2388,7 +2500,7 @@ def to_records(
         formats = []
 
         for i, v in enumerate(arrays):
-            index = i
+            index_int = i
 
             # When the names and arrays are collected, we
             # first collect those in the DataFrame's index,
@@ -2399,13 +2511,13 @@ def to_records(
             #
             # This check allows us to see whether we are
             # handling a name / array in the index or column.
-            if index < index_len:
+            if index_int < index_len:
                 dtype_mapping = index_dtypes
-                name = index_names[index]
+                name = index_names[index_int]
             else:
-                index -= index_len
+                index_int -= index_len
                 dtype_mapping = column_dtypes
-                name = self.columns[index]
+                name = self.columns[index_int]
 
             # We have a dictionary, so we get the data type
             # associated with the index or column (which can
@@ -2415,8 +2527,8 @@ def to_records(
             if is_dict_like(dtype_mapping):
                 if name in dtype_mapping:
                     dtype_mapping = dtype_mapping[name]
-                elif index in dtype_mapping:
-                    dtype_mapping = dtype_mapping[index]
+                elif index_int in dtype_mapping:
+                    dtype_mapping = dtype_mapping[index_int]
                 else:
                     dtype_mapping = None
 
@@ -2428,7 +2540,9 @@ def to_records(
             if dtype_mapping is None:
                 formats.append(v.dtype)
             elif isinstance(dtype_mapping, (type, np.dtype, str)):
-                formats.append(dtype_mapping)
+                # error: Argument 1 to "append" of "list" has incompatible
+                # type "Union[type, dtype[Any], str]"; expected "dtype[Any]"
+                formats.append(dtype_mapping)  # type: ignore[arg-type]
             else:
                 element = "row" if i < index_len else "column"
                 msg = f"Invalid dtype {dtype_mapping} specified for {element} {name}"
@@ -2491,6 +2605,7 @@ def _from_arrays(
         compression_options=_shared_docs["compression_options"] % "path",
     )
     @deprecate_kwarg(old_arg_name="fname", new_arg_name="path")
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "path"])
     def to_stata(
         self,
         path: FilePath | WriteBuffer[bytes],
@@ -2505,7 +2620,7 @@ def to_stata(
         compression: CompressionOptions = "infer",
         storage_options: StorageOptions = None,
         *,
-        value_labels: dict[Hashable, dict[float | int, str]] | None = None,
+        value_labels: dict[Hashable, dict[float, str]] | None = None,
     ) -> None:
         """
         Export DataFrame object to Stata dta format.
@@ -2707,7 +2822,7 @@ def to_feather(self, path: FilePath | WriteBuffer[bytes], **kwargs) -> None:
     )
     def to_markdown(
         self,
-        buf: IO[str] | str | None = None,
+        buf: FilePath | WriteBuffer[str] | None = None,
         mode: str = "wt",
         index: bool = True,
         storage_options: StorageOptions = None,
@@ -2733,6 +2848,32 @@ def to_markdown(
             handles.handle.write(result)
         return None
 
+    @overload
+    def to_parquet(
+        self,
+        path: None = ...,
+        engine: str = ...,
+        compression: str | None = ...,
+        index: bool | None = ...,
+        partition_cols: list[str] | None = ...,
+        storage_options: StorageOptions = ...,
+        **kwargs,
+    ) -> bytes:
+        ...
+
+    @overload
+    def to_parquet(
+        self,
+        path: FilePath | WriteBuffer[bytes],
+        engine: str = ...,
+        compression: str | None = ...,
+        index: bool | None = ...,
+        partition_cols: list[str] | None = ...,
+        storage_options: StorageOptions = ...,
+        **kwargs,
+    ) -> None:
+        ...
+
     @doc(storage_options=_shared_docs["storage_options"])
     @deprecate_kwarg(old_arg_name="fname", new_arg_name="path")
     def to_parquet(
@@ -2799,6 +2940,7 @@ def to_parquet(
         See Also
         --------
         read_parquet : Read a parquet file.
+        DataFrame.to_orc : Write an orc file.
         DataFrame.to_csv : Write a csv file.
         DataFrame.to_sql : Write to a sql table.
         DataFrame.to_hdf : Write to hdf.
@@ -2842,6 +2984,151 @@ def to_parquet(
             **kwargs,
         )
 
+    def to_orc(
+        self,
+        path: FilePath | WriteBuffer[bytes] | None = None,
+        *,
+        engine: Literal["pyarrow"] = "pyarrow",
+        index: bool | None = None,
+        engine_kwargs: dict[str, Any] | None = None,
+    ) -> bytes | None:
+        """
+        Write a DataFrame to the ORC format.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        path : str, file-like object or None, default None
+            If a string, it will be used as Root Directory path
+            when writing a partitioned dataset. By file-like object,
+            we refer to objects with a write() method, such as a file handle
+            (e.g. via builtin open function). If path is None,
+            a bytes object is returned.
+        engine : str, default 'pyarrow'
+            ORC library to use. Pyarrow must be >= 7.0.0.
+        index : bool, optional
+            If ``True``, include the dataframe's index(es) in the file output.
+            If ``False``, they will not be written to the file.
+            If ``None``, similar to ``infer`` the dataframe's index(es)
+            will be saved. However, instead of being saved as values,
+            the RangeIndex will be stored as a range in the metadata so it
+            doesn't require much space and is faster. Other indexes will
+            be included as columns in the file output.
+        engine_kwargs : dict[str, Any] or None, default None
+            Additional keyword arguments passed to :func:`pyarrow.orc.write_table`.
+
+        Returns
+        -------
+        bytes if no path argument is provided else None
+
+        Raises
+        ------
+        NotImplementedError
+            Dtype of one or more columns is category, unsigned integers, interval,
+            period or sparse.
+        ValueError
+            engine is not pyarrow.
+
+        See Also
+        --------
+        read_orc : Read a ORC file.
+        DataFrame.to_parquet : Write a parquet file.
+        DataFrame.to_csv : Write a csv file.
+        DataFrame.to_sql : Write to a sql table.
+        DataFrame.to_hdf : Write to hdf.
+
+        Notes
+        -----
+        * Before using this function you should read the :ref:`user guide about
+          ORC <io.orc>` and :ref:`install optional dependencies <install.warn_orc>`.
+        * This function requires `pyarrow <https://arrow.apache.org/docs/python/>`_
+          library.
+        * For supported dtypes please refer to `supported ORC features in Arrow
+          <https://arrow.apache.org/docs/cpp/orc.html#data-types>`__.
+        * Currently timezones in datetime columns are not preserved when a
+          dataframe is converted into ORC files.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [4, 3]})
+        >>> df.to_orc('df.orc')  # doctest: +SKIP
+        >>> pd.read_orc('df.orc')  # doctest: +SKIP
+           col1  col2
+        0     1     4
+        1     2     3
+
+        If you want to get a buffer to the orc content you can write it to io.BytesIO
+        >>> import io
+        >>> b = io.BytesIO(df.to_orc())  # doctest: +SKIP
+        >>> b.seek(0)  # doctest: +SKIP
+        0
+        >>> content = b.read()  # doctest: +SKIP
+        """
+        from pandas.io.orc import to_orc
+
+        return to_orc(
+            self, path, engine=engine, index=index, engine_kwargs=engine_kwargs
+        )
+
+    @overload
+    def to_html(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        columns: Sequence[Level] | None = ...,
+        col_space: ColspaceArgType | None = ...,
+        header: bool | Sequence[str] = ...,
+        index: bool = ...,
+        na_rep: str = ...,
+        formatters: FormattersType | None = ...,
+        float_format: FloatFormatType | None = ...,
+        sparsify: bool | None = ...,
+        index_names: bool = ...,
+        justify: str | None = ...,
+        max_rows: int | None = ...,
+        max_cols: int | None = ...,
+        show_dimensions: bool | str = ...,
+        decimal: str = ...,
+        bold_rows: bool = ...,
+        classes: str | list | tuple | None = ...,
+        escape: bool = ...,
+        notebook: bool = ...,
+        border: int | bool | None = ...,
+        table_id: str | None = ...,
+        render_links: bool = ...,
+        encoding: str | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def to_html(
+        self,
+        buf: None = ...,
+        columns: Sequence[Level] | None = ...,
+        col_space: ColspaceArgType | None = ...,
+        header: bool | Sequence[str] = ...,
+        index: bool = ...,
+        na_rep: str = ...,
+        formatters: FormattersType | None = ...,
+        float_format: FloatFormatType | None = ...,
+        sparsify: bool | None = ...,
+        index_names: bool = ...,
+        justify: str | None = ...,
+        max_rows: int | None = ...,
+        max_cols: int | None = ...,
+        show_dimensions: bool | str = ...,
+        decimal: str = ...,
+        bold_rows: bool = ...,
+        classes: str | list | tuple | None = ...,
+        escape: bool = ...,
+        notebook: bool = ...,
+        border: int | bool | None = ...,
+        table_id: str | None = ...,
+        render_links: bool = ...,
+        encoding: str | None = ...,
+    ) -> str:
+        ...
+
     @Substitution(
         header_type="bool",
         header="Whether to print column labels, default True",
@@ -2855,7 +3142,7 @@ def to_parquet(
     def to_html(
         self,
         buf: FilePath | WriteBuffer[str] | None = None,
-        columns: Sequence[str] | None = None,
+        columns: Sequence[Level] | None = None,
         col_space: ColspaceArgType | None = None,
         header: bool | Sequence[str] = True,
         index: bool = True,
@@ -2873,11 +3160,11 @@ def to_html(
         classes: str | list | tuple | None = None,
         escape: bool = True,
         notebook: bool = False,
-        border: int | None = None,
+        border: int | bool | None = None,
         table_id: str | None = None,
         render_links: bool = False,
         encoding: str | None = None,
-    ):
+    ) -> str | None:
         """
         Render a DataFrame as an HTML table.
         %(shared_params)s
@@ -3210,6 +3497,11 @@ def memory_usage(self, index: bool = True, deep: bool = False) -> Series:
             many repeated values.
         DataFrame.info : Concise summary of a DataFrame.
 
+        Notes
+        -----
+        See the :ref:`Frequently Asked Questions <df-memory-usage>` for more
+        details.
+
         Examples
         --------
         >>> dtypes = ['int64', 'float64', 'complex128', 'object', 'bool']
@@ -3261,6 +3553,7 @@ def memory_usage(self, index: bool = True, deep: bool = False) -> Series:
         result = self._constructor_sliced(
             [c.memory_usage(index=False, deep=deep) for col, c in self.items()],
             index=self.columns,
+            dtype=np.intp,
         )
         if index:
             index_memory_usage = self._constructor_sliced(
@@ -3407,28 +3700,25 @@ def T(self) -> DataFrame:
     # ----------------------------------------------------------------------
     # Indexing Methods
 
-    def _ixs(self, i: int, axis: int = 0):
+    def _ixs(self, i: int, axis: int = 0) -> Series:
         """
         Parameters
         ----------
         i : int
         axis : int
 
-        Notes
-        -----
-        If slice passed, the resulting data will be a view.
+        Returns
+        -------
+        Series
         """
         # irow
         if axis == 0:
-            new_values = self._mgr.fast_xs(i)
+            new_mgr = self._mgr.fast_xs(i)
 
             # if we are a copy, mark as such
-            copy = isinstance(new_values, np.ndarray) and new_values.base is None
-            result = self._constructor_sliced(
-                new_values,
-                index=self.columns,
-                name=self.index[i],
-                dtype=new_values.dtype,
+            copy = isinstance(new_mgr.array, np.ndarray) and new_mgr.array.base is None
+            result = self._constructor_sliced(new_mgr, name=self.index[i]).__finalize__(
+                self
             )
             result._set_is_copy(self, copy=copy)
             return result
@@ -3448,6 +3738,9 @@ def _get_column_array(self, i: int) -> ArrayLike:
         """
         Get the values of the i'th column (ndarray or ExtensionArray, as stored
         in the Block)
+
+        Warning! The returned array is a view but doesn't handle Copy-on-Write,
+        so this should be used with caution (for read-only purposes).
         """
         return self._mgr.iget_values(i)
 
@@ -3455,6 +3748,9 @@ def _iter_column_arrays(self) -> Iterator[ArrayLike]:
         """
         Iterate over the arrays of all columns in order.
         This returns the values as stored in the Block (ndarray or ExtensionArray).
+
+        Warning! The returned array is a view but doesn't handle Copy-on-Write,
+        so this should be used with caution (for read-only purposes).
         """
         for i in range(len(self.columns)):
             yield self._get_column_array(i)
@@ -3467,11 +3763,18 @@ def __getitem__(self, key):
         if is_hashable(key) and not is_iterator(key):
             # is_iterator to exclude generator e.g. test_getitem_listlike
             # shortcut if the key is in columns
-            if self.columns.is_unique and key in self.columns:
-                if isinstance(self.columns, MultiIndex):
-                    return self._getitem_multilevel(key)
+            is_mi = isinstance(self.columns, MultiIndex)
+            # GH#45316 Return view if key is not duplicated
+            # Only use drop_duplicates with duplicates for performance
+            if not is_mi and (
+                self.columns.is_unique
+                and key in self.columns
+                or key in self.columns.drop_duplicates(keep=False)
+            ):
                 return self._get_item_cache(key)
 
+            elif is_mi and self.columns.is_unique and key in self.columns:
+                return self._getitem_multilevel(key)
         # Do we have a slicer (on rows)?
         indexer = convert_to_index_sliceable(self, key)
         if indexer is not None:
@@ -3626,6 +3929,29 @@ def _get_value(self, index, col, takeable: bool = False) -> Scalar:
         loc = engine.get_loc(index)
         return series._values[loc]
 
+    def isetitem(self, loc, value) -> None:
+        """
+        Set the given value in the column with position 'loc'.
+
+        This is a positional analogue to __setitem__.
+
+        Parameters
+        ----------
+        loc : int or sequence of ints
+        value : scalar or arraylike
+
+        Notes
+        -----
+        Unlike `frame.iloc[:, i] = value`, `frame.isetitem(loc, value)` will
+        _never_ try to set the values in place, but will always insert a new
+        array.
+
+        In cases where `frame.columns` is unique, this is equivalent to
+        `frame[frame.columns[i]] = value`.
+        """
+        arraylike = self._sanitize_column(value)
+        self._iset_item_mgr(loc, arraylike, inplace=False)
+
     def __setitem__(self, key, value):
         key = com.apply_if_callable(key, self)
 
@@ -3778,13 +4104,30 @@ def _set_item_frame_value(self, key, value: DataFrame) -> None:
             if isinstance(self.columns, MultiIndex) and isinstance(
                 loc, (slice, Series, np.ndarray, Index)
             ):
-                cols = maybe_droplevels(cols, key)
-                if len(cols) and not cols.equals(value.columns):
-                    value = value.reindex(cols, axis=1)
+                cols_droplevel = maybe_droplevels(cols, key)
+                if len(cols_droplevel) and not cols_droplevel.equals(value.columns):
+                    value = value.reindex(cols_droplevel, axis=1)
+
+                for col, col_droplevel in zip(cols, cols_droplevel):
+                    self[col] = value[col_droplevel]
+                return
+
+            if is_scalar(cols):
+                self[cols] = value[value.columns[0]]
+                return
+
+            # now align rows
+            arraylike = _reindex_for_setitem(value, self.index)
+            self._set_item_mgr(key, arraylike)
+            return
+
+        if len(value.columns) != 1:
+            raise ValueError(
+                "Cannot set a DataFrame with multiple columns to the single "
+                f"column {key}"
+            )
 
-        # now align rows
-        arraylike = _reindex_for_setitem(value, self.index)
-        self._set_item_mgr(key, arraylike)
+        self[key] = value[value.columns[0]]
 
     def _iset_item_mgr(
         self, loc: int | slice | np.ndarray, value, inplace: bool = False
@@ -3861,20 +4204,19 @@ def _set_value(
         """
         try:
             if takeable:
-                series = self._ixs(col, axis=1)
-                series._set_value(index, value, takeable=True)
-                return
-
-            series = self._get_item_cache(col)
-            loc = self.index.get_loc(index)
-            if not can_hold_element(series._values, value):
-                # We'll go through loc and end up casting.
-                raise TypeError
-
-            series._mgr.setitem_inplace(loc, value)
-            # Note: trying to use series._set_value breaks tests in
-            #  tests.frame.indexing.test_indexing and tests.indexing.test_partial
-        except (KeyError, TypeError):
+                icol = col
+                iindex = cast(int, index)
+            else:
+                icol = self.columns.get_loc(col)
+                iindex = self.index.get_loc(index)
+            self._mgr.column_setitem(icol, iindex, value, inplace=True)
+            self._clear_item_cache()
+
+        except (KeyError, TypeError, ValueError, LossySetitemError):
+            # get_loc might raise a KeyError for missing labels (falling back
+            #  to (i)loc will do expansion of the index)
+            # column_setitem will do validation that may raise TypeError,
+            #  ValueError, or LossySetitemError
             # set using a non-recursive method & reset the cache
             if takeable:
                 self.iloc[index, col] = value
@@ -3882,6 +4224,13 @@ def _set_value(
                 self.loc[index, col] = value
             self._item_cache.pop(col, None)
 
+        except InvalidIndexError as ii_err:
+            # GH48729: Seems like you are trying to assign a value to a
+            # row when only scalar options are permitted
+            raise InvalidIndexError(
+                f"You can only assign a scalar value not a {type(value)}"
+            ) from ii_err
+
     def _ensure_valid_index(self, value) -> None:
         """
         Ensure that if we don't have an index, that we can create one from the
@@ -3949,12 +4298,31 @@ def _maybe_cache_changed(self, item, value: Series, inplace: bool) -> None:
         """
         loc = self._info_axis.get_loc(item)
         arraylike = value._values
+
+        old = self._ixs(loc, axis=1)
+        if old._values is value._values and inplace:
+            # GH#46149 avoid making unnecessary copies/block-splitting
+            return
+
         self._mgr.iset(loc, arraylike, inplace=inplace)
 
     # ----------------------------------------------------------------------
     # Unsorted
 
-    def query(self, expr: str, inplace: bool = False, **kwargs):
+    @overload
+    def query(self, expr: str, *, inplace: Literal[False] = ..., **kwargs) -> DataFrame:
+        ...
+
+    @overload
+    def query(self, expr: str, *, inplace: Literal[True], **kwargs) -> None:
+        ...
+
+    @overload
+    def query(self, expr: str, *, inplace: bool = ..., **kwargs) -> DataFrame | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "expr"])
+    def query(self, expr: str, inplace: bool = False, **kwargs) -> DataFrame | None:
         """
         Query the columns of a DataFrame with a boolean expression.
 
@@ -3984,8 +4352,7 @@ def query(self, expr: str, inplace: bool = False, **kwargs):
                 Expanding functionality of backtick quoting for more than only spaces.
 
         inplace : bool
-            Whether the query should modify the data in place or return
-            a modified copy.
+            Whether to modify the DataFrame rather than creating a new one.
         **kwargs
             See the documentation for :func:`eval` for complete details
             on the keyword arguments accepted by :meth:`DataFrame.query`.
@@ -4102,7 +4469,7 @@ def query(self, expr: str, inplace: bool = False, **kwargs):
         if not isinstance(expr, str):
             msg = f"expr must be a string to be evaluated, {type(expr)} given"
             raise ValueError(msg)
-        kwargs["level"] = kwargs.pop("level", 0) + 1
+        kwargs["level"] = kwargs.pop("level", 0) + 2
         kwargs["target"] = None
         res = self.eval(expr, **kwargs)
 
@@ -4119,7 +4486,16 @@ def query(self, expr: str, inplace: bool = False, **kwargs):
         else:
             return result
 
-    def eval(self, expr: str, inplace: bool = False, **kwargs):
+    @overload
+    def eval(self, expr: str, *, inplace: Literal[False] = ..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def eval(self, expr: str, *, inplace: Literal[True], **kwargs) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "expr"])
+    def eval(self, expr: str, inplace: bool = False, **kwargs) -> Any | None:
         """
         Evaluate a string describing operations on DataFrame columns.
 
@@ -4225,7 +4601,7 @@ def eval(self, expr: str, inplace: bool = False, **kwargs):
         from pandas.core.computation.eval import eval as _eval
 
         inplace = validate_bool_kwarg(inplace, "inplace")
-        kwargs["level"] = kwargs.pop("level", 0) + 1
+        kwargs["level"] = kwargs.pop("level", 0) + 2
         index_resolvers = self._get_index_resolvers()
         column_resolvers = self._get_cleaned_column_resolvers()
         resolvers = column_resolvers, index_resolvers
@@ -4355,8 +4731,11 @@ def check_int_infer_dtype(dtypes):
             raise ValueError(f"include and exclude overlap on {(include & exclude)}")
 
         def dtype_predicate(dtype: DtypeObj, dtypes_set) -> bool:
+            # GH 46870: BooleanDtype._is_numeric == True but should be excluded
             return issubclass(dtype.type, tuple(dtypes_set)) or (
-                np.number in dtypes_set and getattr(dtype, "_is_numeric", False)
+                np.number in dtypes_set
+                and getattr(dtype, "_is_numeric", False)
+                and not is_bool_dtype(dtype)
             )
 
         def predicate(arr: ArrayLike) -> bool:
@@ -4371,7 +4750,7 @@ def predicate(arr: ArrayLike) -> bool:
 
             return True
 
-        mgr = self._mgr._get_data_subset(predicate)
+        mgr = self._mgr._get_data_subset(predicate).copy(deep=None)
         return type(self)(mgr).__finalize__(self)
 
     def insert(
@@ -4379,7 +4758,7 @@ def insert(
         loc: int,
         column: Hashable,
         value: Scalar | AnyArrayLike,
-        allow_duplicates: bool = False,
+        allow_duplicates: bool | lib.NoDefault = lib.no_default,
     ) -> None:
         """
         Insert column into DataFrame at specified location.
@@ -4394,7 +4773,7 @@ def insert(
         column : str, number, or hashable object
             Label of the inserted column.
         value : Scalar, Series, or array-like
-        allow_duplicates : bool, optional default False
+        allow_duplicates : bool, optional, default lib.no_default
 
         See Also
         --------
@@ -4426,6 +4805,8 @@ def insert(
         0   NaN   100     1      99     3
         1   5.0   100     2      99     4
         """
+        if allow_duplicates is lib.no_default:
+            allow_duplicates = False
         if allow_duplicates and not self.flags.allows_duplicate_labels:
             raise ValueError(
                 "Cannot specify 'allow_duplicates=True' when "
@@ -4523,9 +4904,12 @@ def _sanitize_column(self, value) -> ArrayLike:
         """
         self._ensure_valid_index(value)
 
-        # We should never get here with DataFrame value
-        if isinstance(value, Series):
+        # We can get there through isetitem with a DataFrame
+        # or through loc single_block_path
+        if isinstance(value, DataFrame):
             return _reindex_for_setitem(value, self.index)
+        elif is_dict_like(value):
+            return _reindex_for_setitem(Series(value), self.index)
 
         if is_list_like(value):
             com.require_length_match(value, self.index)
@@ -4545,15 +4929,16 @@ def lookup(
     ) -> np.ndarray:
         """
         Label-based "fancy indexing" function for DataFrame.
-        Given equal-length arrays of row and column labels, return an
-        array of the values corresponding to each (row, col) pair.
 
         .. deprecated:: 1.2.0
             DataFrame.lookup is deprecated,
-            use DataFrame.melt and DataFrame.loc instead.
+            use pandas.factorize and NumPy indexing instead.
             For further details see
             :ref:`Looking up values by index/column labels <indexing.lookup>`.
 
+        Given equal-length arrays of row and column labels, return an
+        array of the values corresponding to each (row, col) pair.
+
         Parameters
         ----------
         row_labels : sequence
@@ -4691,14 +5076,14 @@ def _reindex_multi(
     @doc(NDFrame.align, **_shared_doc_kwargs)
     def align(
         self,
-        other,
-        join: str = "outer",
+        other: DataFrame,
+        join: Literal["outer", "inner", "left", "right"] = "outer",
         axis: Axis | None = None,
-        level: Level | None = None,
+        level: Level = None,
         copy: bool = True,
         fill_value=None,
-        method: str | None = None,
-        limit=None,
+        method: FillnaOptions | None = None,
+        limit: int | None = None,
         fill_axis: Axis = 0,
         broadcast_axis: Axis | None = None,
     ) -> DataFrame:
@@ -4717,24 +5102,38 @@ def align(
 
     @overload
     def set_axis(
-        self, labels, axis: Axis = ..., inplace: Literal[False] = ...
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[False] | lib.NoDefault = ...,
+        copy: bool | lib.NoDefault = ...,
     ) -> DataFrame:
         ...
 
     @overload
-    def set_axis(self, labels, axis: Axis, inplace: Literal[True]) -> None:
-        ...
-
-    @overload
-    def set_axis(self, labels, *, inplace: Literal[True]) -> None:
+    def set_axis(
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[True],
+        copy: bool | lib.NoDefault = ...,
+    ) -> None:
         ...
 
     @overload
     def set_axis(
-        self, labels, axis: Axis = ..., inplace: bool = ...
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: bool | lib.NoDefault = ...,
+        copy: bool | lib.NoDefault = ...,
     ) -> DataFrame | None:
         ...
 
+    # error: Signature of "set_axis" incompatible with supertype "NDFrame"
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
     @Appender(
         """
@@ -4758,10 +5157,9 @@ def set_axis(
         1  2   5
         2  3   6
 
-        Now, update the labels inplace.
+        Now, update the labels without copying the underlying data.
 
-        >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
-        >>> df
+        >>> df.set_axis(['i', 'ii'], axis='columns', copy=False)
            i  ii
         0  1   4
         1  2   5
@@ -4775,8 +5173,15 @@ def set_axis(
         see_also_sub=" or columns",
     )
     @Appender(NDFrame.set_axis.__doc__)
-    def set_axis(self, labels, axis: Axis = 0, inplace: bool = False):
-        return super().set_axis(labels, axis=axis, inplace=inplace)
+    def set_axis(
+        self,
+        labels,
+        axis: Axis = 0,
+        inplace: bool | lib.NoDefault = lib.no_default,
+        *,
+        copy: bool | lib.NoDefault = lib.no_default,
+    ):
+        return super().set_axis(labels, axis=axis, inplace=inplace, copy=copy)
 
     @Substitution(**_shared_doc_kwargs)
     @Appender(NDFrame.reindex.__doc__)
@@ -4784,7 +5189,7 @@ def set_axis(self, labels, axis: Axis = 0, inplace: bool = False):
         "labels",
         [
             ("method", None),
-            ("copy", True),
+            ("copy", None),
             ("level", None),
             ("fill_value", np.nan),
             ("limit", None),
@@ -4799,17 +5204,61 @@ def reindex(self, *args, **kwargs) -> DataFrame:
         kwargs.pop("labels", None)
         return super().reindex(**kwargs)
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    @overload
+    def drop(
+        self,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level = ...,
+        inplace: Literal[True],
+        errors: IgnoreRaise = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def drop(
+        self,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level = ...,
+        inplace: Literal[False] = ...,
+        errors: IgnoreRaise = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
     def drop(
         self,
-        labels=None,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level = ...,
+        inplace: bool = ...,
+        errors: IgnoreRaise = ...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "drop" incompatible with supertype "NDFrame"
+    # github.com/python/mypy/issues/12387
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    def drop(  # type: ignore[override]
+        self,
+        labels: IndexLabel = None,
         axis: Axis = 0,
-        index=None,
-        columns=None,
-        level: Level | None = None,
+        index: IndexLabel = None,
+        columns: IndexLabel = None,
+        level: Level = None,
         inplace: bool = False,
-        errors: str = "raise",
-    ):
+        errors: IgnoreRaise = "raise",
+    ) -> DataFrame | None:
         """
         Drop specified labels from rows or columns.
 
@@ -4957,6 +5406,51 @@ def drop(
             errors=errors,
         )
 
+    @overload
+    def rename(
+        self,
+        mapper: Renamer | None = ...,
+        *,
+        index: Renamer | None = ...,
+        columns: Renamer | None = ...,
+        axis: Axis | None = ...,
+        copy: bool | None = ...,
+        inplace: Literal[True],
+        level: Level = ...,
+        errors: IgnoreRaise = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def rename(
+        self,
+        mapper: Renamer | None = ...,
+        *,
+        index: Renamer | None = ...,
+        columns: Renamer | None = ...,
+        axis: Axis | None = ...,
+        copy: bool | None = ...,
+        inplace: Literal[False] = ...,
+        level: Level = ...,
+        errors: IgnoreRaise = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def rename(
+        self,
+        mapper: Renamer | None = ...,
+        *,
+        index: Renamer | None = ...,
+        columns: Renamer | None = ...,
+        axis: Axis | None = ...,
+        copy: bool | None = ...,
+        inplace: bool = ...,
+        level: Level = ...,
+        errors: IgnoreRaise = ...,
+    ) -> DataFrame | None:
+        ...
+
     def rename(
         self,
         mapper: Renamer | None = None,
@@ -4964,10 +5458,10 @@ def rename(
         index: Renamer | None = None,
         columns: Renamer | None = None,
         axis: Axis | None = None,
-        copy: bool = True,
+        copy: bool | None = None,
         inplace: bool = False,
-        level: Level | None = None,
-        errors: str = "ignore",
+        level: Level = None,
+        errors: IgnoreRaise = "ignore",
     ) -> DataFrame | None:
         """
         Alter axes labels.
@@ -4997,8 +5491,8 @@ def rename(
         copy : bool, default True
             Also copy underlying data.
         inplace : bool, default False
-            Whether to return a new DataFrame. If True then value of copy is
-            ignored.
+            Whether to modify the DataFrame rather than creating a new one.
+            If True then value of copy is ignored.
         level : int or level name, default None
             In case of a MultiIndex, only rename labels in the specified
             level.
@@ -5090,128 +5584,53 @@ def rename(
     @overload
     def fillna(
         self,
-        value=...,
+        value: Hashable | Mapping | Series | DataFrame = ...,
+        *,
         method: FillnaOptions | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> DataFrame:
         ...
 
     @overload
     def fillna(
         self,
-        value,
-        method: FillnaOptions | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value,
-        *,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: FillnaOptions | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: FillnaOptions | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value,
+        value: Hashable | Mapping | Series | DataFrame = ...,
         *,
-        axis: Axis | None,
+        method: FillnaOptions | None = ...,
+        axis: Axis | None = ...,
         inplace: Literal[True],
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> None:
         ...
 
     @overload
     def fillna(
         self,
-        value,
-        method: FillnaOptions | None,
+        value: Hashable | Mapping | Series | DataFrame = ...,
         *,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value=...,
         method: FillnaOptions | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> DataFrame | None:
         ...
 
+    # error: Signature of "fillna" incompatible with supertype "NDFrame"
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "value"])
     @doc(NDFrame.fillna, **_shared_doc_kwargs)
-    def fillna(
+    def fillna(  # type: ignore[override]
         self,
-        value: object | ArrayLike | None = None,
+        value: Hashable | Mapping | Series | DataFrame = None,
         method: FillnaOptions | None = None,
         axis: Axis | None = None,
         inplace: bool = False,
-        limit=None,
-        downcast=None,
+        limit: int | None = None,
+        downcast: dict | None = None,
     ) -> DataFrame | None:
         return super().fillna(
             value=value,
@@ -5265,16 +5684,47 @@ def pop(self, item: Hashable) -> Series:
         """
         return super().pop(item=item)
 
-    @doc(NDFrame.replace, **_shared_doc_kwargs)
+    # error: Signature of "replace" incompatible with supertype "NDFrame"
+    @overload  # type: ignore[override]
+    def replace(
+        self,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        regex: bool = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
     def replace(
+        self,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[True],
+        limit: int | None = ...,
+        regex: bool = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    # error: Signature of "replace" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "to_replace", "value"]
+    )
+    @doc(NDFrame.replace, **_shared_doc_kwargs)
+    def replace(  # type: ignore[override]
         self,
         to_replace=None,
         value=lib.no_default,
         inplace: bool = False,
-        limit=None,
+        limit: int | None = None,
         regex: bool = False,
-        method: str | lib.NoDefault = lib.no_default,
-    ):
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = lib.no_default,
+    ) -> DataFrame | None:
         return super().replace(
             to_replace=to_replace,
             value=value,
@@ -5312,7 +5762,7 @@ def _replace_columnwise(
                 target, value = mapping[ax[i]]
                 newobj = ser.replace(target, value, regex=regex)
 
-                res.iloc[:, i] = newobj
+                res._iset_item(i, newobj)
 
         if inplace:
             return
@@ -5321,15 +5771,21 @@ def _replace_columnwise(
     @doc(NDFrame.shift, klass=_shared_doc_kwargs["klass"])
     def shift(
         self,
-        periods=1,
+        periods: int = 1,
         freq: Frequency | None = None,
         axis: Axis = 0,
-        fill_value=lib.no_default,
+        fill_value: Hashable = lib.no_default,
     ) -> DataFrame:
         axis = self._get_axis_number(axis)
 
         ncols = len(self.columns)
-        if axis == 1 and periods != 0 and fill_value is lib.no_default and ncols > 0:
+        if (
+            axis == 1
+            and periods != 0
+            and freq is None
+            and fill_value is lib.no_default
+            and ncols > 0
+        ):
             # We will infer fill_value to match the closest column
 
             # Use a column that we know is valid for our column's dtype GH#38434
@@ -5353,11 +5809,77 @@ def shift(
 
             result.columns = self.columns.copy()
             return result
+        elif (
+            axis == 1
+            and periods != 0
+            and fill_value is not lib.no_default
+            and ncols > 0
+        ):
+            arrays = self._mgr.arrays
+            if len(arrays) > 1 or (
+                # If we only have one block and we know that we can't
+                #  keep the same dtype (i.e. the _can_hold_element check)
+                #  then we can go through the reindex_indexer path
+                #  (and avoid casting logic in the Block method).
+                #  The exception to this (until 2.0) is datetimelike
+                #  dtypes with integers, which cast.
+                not can_hold_element(arrays[0], fill_value)
+                # TODO(2.0): remove special case for integer-with-datetimelike
+                #  once deprecation is enforced
+                and not (
+                    lib.is_integer(fill_value) and needs_i8_conversion(arrays[0].dtype)
+                )
+            ):
+                # GH#35488 we need to watch out for multi-block cases
+                # We only get here with fill_value not-lib.no_default
+                nper = abs(periods)
+                nper = min(nper, ncols)
+                if periods > 0:
+                    indexer = np.array(
+                        [-1] * nper + list(range(ncols - periods)), dtype=np.intp
+                    )
+                else:
+                    indexer = np.array(
+                        list(range(nper, ncols)) + [-1] * nper, dtype=np.intp
+                    )
+                mgr = self._mgr.reindex_indexer(
+                    self.columns,
+                    indexer,
+                    axis=0,
+                    fill_value=fill_value,
+                    allow_dups=True,
+                )
+                res_df = self._constructor(mgr)
+                return res_df.__finalize__(self, method="shift")
 
         return super().shift(
             periods=periods, freq=freq, axis=axis, fill_value=fill_value
         )
 
+    @overload
+    def set_index(
+        self,
+        keys,
+        *,
+        drop: bool = ...,
+        append: bool = ...,
+        inplace: Literal[False] = ...,
+        verify_integrity: bool = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def set_index(
+        self,
+        keys,
+        *,
+        drop: bool = ...,
+        append: bool = ...,
+        inplace: Literal[True],
+        verify_integrity: bool = ...,
+    ) -> None:
+        ...
+
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "keys"])
     def set_index(
         self,
@@ -5366,7 +5888,7 @@ def set_index(
         append: bool = False,
         inplace: bool = False,
         verify_integrity: bool = False,
-    ):
+    ) -> DataFrame | None:
         """
         Set the DataFrame index using existing columns.
 
@@ -5387,7 +5909,7 @@ def set_index(
         append : bool, default False
             Whether to append columns to existing index.
         inplace : bool, default False
-            If True, modifies the DataFrame in place (do not create a new object).
+            Whether to modify the DataFrame rather than creating a new one.
         verify_integrity : bool, default False
             Check the new index for duplicates. Otherwise defer the check until
             necessary. Setting to False will improve the performance of this
@@ -5559,80 +6081,60 @@ def set_index(
 
         if not inplace:
             return frame
+        return None
 
     @overload
     def reset_index(
         self,
-        level: Hashable | Sequence[Hashable] | None = ...,
+        level: IndexLabel = ...,
+        *,
         drop: bool = ...,
         inplace: Literal[False] = ...,
         col_level: Hashable = ...,
         col_fill: Hashable = ...,
+        allow_duplicates: bool | lib.NoDefault = ...,
+        names: Hashable | Sequence[Hashable] = None,
     ) -> DataFrame:
         ...
 
     @overload
     def reset_index(
         self,
-        level: Hashable | Sequence[Hashable] | None,
-        drop: bool,
-        inplace: Literal[True],
-        col_level: Hashable = ...,
-        col_fill: Hashable = ...,
-    ) -> None:
-        ...
-
-    @overload
-    def reset_index(
-        self,
-        *,
-        drop: bool,
-        inplace: Literal[True],
-        col_level: Hashable = ...,
-        col_fill: Hashable = ...,
-    ) -> None:
-        ...
-
-    @overload
-    def reset_index(
-        self,
-        level: Hashable | Sequence[Hashable] | None,
+        level: IndexLabel = ...,
         *,
+        drop: bool = ...,
         inplace: Literal[True],
         col_level: Hashable = ...,
         col_fill: Hashable = ...,
+        allow_duplicates: bool | lib.NoDefault = ...,
+        names: Hashable | Sequence[Hashable] = None,
     ) -> None:
         ...
 
     @overload
     def reset_index(
         self,
+        level: IndexLabel = ...,
         *,
-        inplace: Literal[True],
-        col_level: Hashable = ...,
-        col_fill: Hashable = ...,
-    ) -> None:
-        ...
-
-    @overload
-    def reset_index(
-        self,
-        level: Hashable | Sequence[Hashable] | None = ...,
         drop: bool = ...,
         inplace: bool = ...,
         col_level: Hashable = ...,
         col_fill: Hashable = ...,
+        allow_duplicates: bool | lib.NoDefault = ...,
+        names: Hashable | Sequence[Hashable] = None,
     ) -> DataFrame | None:
         ...
 
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "level"])
     def reset_index(
         self,
-        level: Hashable | Sequence[Hashable] | None = None,
+        level: IndexLabel = None,
         drop: bool = False,
         inplace: bool = False,
         col_level: Hashable = 0,
         col_fill: Hashable = "",
+        allow_duplicates: bool | lib.NoDefault = lib.no_default,
+        names: Hashable | Sequence[Hashable] = None,
     ) -> DataFrame | None:
         """
         Reset the index, or a level of it.
@@ -5650,7 +6152,7 @@ def reset_index(
             Do not try to insert index into dataframe columns. This resets
             the index to the default integer index.
         inplace : bool, default False
-            Modify the DataFrame in place (do not create a new object).
+            Whether to modify the DataFrame rather than creating a new one.
         col_level : int or str, default 0
             If the columns have multiple levels, determines which level the
             labels are inserted into. By default it is inserted into the first
@@ -5658,6 +6160,17 @@ def reset_index(
         col_fill : object, default ''
             If the columns have multiple levels, determines how the other
             levels are named. If None then the index name is repeated.
+        allow_duplicates : bool, optional, default lib.no_default
+            Allow duplicate column labels to be created.
+
+            .. versionadded:: 1.5.0
+
+        names : int, str or 1-dimensional list, default None
+            Using the given string, rename the DataFrame column which contains the
+            index data. If the DataFrame has a MultiIndex, this has to be a list or
+            tuple with length equal to the number of levels.
+
+            .. versionadded:: 1.5.0
 
         Returns
         -------
@@ -5729,6 +6242,16 @@ class  name
         mammal lion     80.5     run
                monkey    NaN    jump
 
+        Using the `names` parameter, choose a name for the index column:
+
+        >>> df.reset_index(names=['classes', 'names'])
+          classes   names  speed species
+                             max    type
+        0    bird  falcon  389.0     fly
+        1    bird  parrot   24.0     fly
+        2  mammal    lion   80.5     run
+        3  mammal  monkey    NaN    jump
+
         If the index has multiple levels, we can reset a subset of them:
 
         >>> df.reset_index(level='class')
@@ -5780,7 +6303,9 @@ class    max    type
         if inplace:
             new_obj = self
         else:
-            new_obj = self.copy()
+            new_obj = self.copy(deep=None)
+        if allow_duplicates is not lib.no_default:
+            allow_duplicates = validate_bool_kwarg(allow_duplicates, "allow_duplicates")
 
         new_index = default_index(len(new_obj))
         if level is not None:
@@ -5792,12 +6317,13 @@ class    max    type
 
         if not drop:
             to_insert: Iterable[tuple[Any, Any | None]]
+
+            default = "index" if "index" not in self else "level_0"
+            names = self.index._get_default_index_names(names, default)
+
             if isinstance(self.index, MultiIndex):
-                names = com.fill_missing_names(self.index.names)
                 to_insert = zip(self.index.levels, self.index.codes)
             else:
-                default = "index" if "index" not in self else "level_0"
-                names = [default] if self.index.name is None else [self.index.name]
                 to_insert = ((self.index, None),)
 
             multi_col = isinstance(self.columns, MultiIndex)
@@ -5832,7 +6358,12 @@ class    max    type
                         level_values, lab, allow_fill=True, fill_value=lev._na_value
                     )
 
-                new_obj.insert(0, name, level_values)
+                new_obj.insert(
+                    0,
+                    name,
+                    level_values,
+                    allow_duplicates=allow_duplicates,
+                )
 
         new_obj.index = new_index
         if not inplace:
@@ -5866,15 +6397,39 @@ def notnull(self) -> DataFrame:
         """
         return ~self.isna()
 
+    @overload
+    def dropna(
+        self,
+        *,
+        axis: Axis = ...,
+        how: str | NoDefault = ...,
+        thresh: int | NoDefault = ...,
+        subset: IndexLabel = ...,
+        inplace: Literal[False] = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def dropna(
+        self,
+        *,
+        axis: Axis = ...,
+        how: str | NoDefault = ...,
+        thresh: int | NoDefault = ...,
+        subset: IndexLabel = ...,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def dropna(
         self,
         axis: Axis = 0,
-        how: str = "any",
-        thresh=None,
+        how: str | NoDefault = no_default,
+        thresh: int | NoDefault = no_default,
         subset: IndexLabel = None,
         inplace: bool = False,
-    ):
+    ) -> DataFrame | None:
         """
         Remove missing values.
 
@@ -5903,12 +6458,12 @@ def dropna(
             * 'all' : If all values are NA, drop that row or column.
 
         thresh : int, optional
-            Require that many non-NA values.
+            Require that many non-NA values. Cannot be combined with how.
         subset : column label or sequence of labels, optional
             Labels along other axis to consider, e.g. if you are dropping rows
             these would be a list of columns to include.
         inplace : bool, default False
-            If True, do operation inplace and return None.
+            Whether to modify the DataFrame rather than creating a new one.
 
         Returns
         -------
@@ -5978,6 +6533,14 @@ def dropna(
              name        toy       born
         1  Batman  Batmobile 1940-04-25
         """
+        if (how is not no_default) and (thresh is not no_default):
+            raise TypeError(
+                "You cannot set both the how and thresh arguments at the same time."
+            )
+
+        if how is no_default:
+            how = "any"
+
         inplace = validate_bool_kwarg(inplace, "inplace")
         if isinstance(axis, (tuple, list)):
             # GH20987
@@ -5998,7 +6561,7 @@ def dropna(
                 raise KeyError(np.array(subset)[check].tolist())
             agg_obj = self.take(indices, axis=agg_axis)
 
-        if thresh is not None:
+        if thresh is not no_default:
             count = agg_obj.count(axis=agg_axis)
             mask = count >= thresh
         elif how == "any":
@@ -6008,26 +6571,23 @@ def dropna(
             # faster equivalent to 'agg_obj.count(agg_axis) > 0'
             mask = notna(agg_obj).any(axis=agg_axis, bool_only=False)
         else:
-            if how is not None:
-                raise ValueError(f"invalid how option: {how}")
-            else:
-                raise TypeError("must specify how or thresh")
+            raise ValueError(f"invalid how option: {how}")
 
         if np.all(mask):
             result = self.copy()
         else:
             result = self.loc(axis=axis)[mask]
 
-        if inplace:
-            self._update_inplace(result)
-        else:
+        if not inplace:
             return result
+        self._update_inplace(result)
+        return None
 
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "subset"])
     def drop_duplicates(
         self,
         subset: Hashable | Sequence[Hashable] | None = None,
-        keep: Literal["first"] | Literal["last"] | Literal[False] = "first",
+        keep: Literal["first", "last", False] = "first",
         inplace: bool = False,
         ignore_index: bool = False,
     ) -> DataFrame | None:
@@ -6048,7 +6608,7 @@ def drop_duplicates(
             - ``last`` : Drop duplicates except for the last occurrence.
             - False : Drop all duplicates.
         inplace : bool, default False
-            Whether to drop duplicates in place or to return a copy.
+            Whether to modify the DataFrame rather than creating a new one.
         ignore_index : bool, default False
             If True, the resulting axis will be labeled 0, 1, …, n - 1.
 
@@ -6124,7 +6684,7 @@ def drop_duplicates(
     def duplicated(
         self,
         subset: Hashable | Sequence[Hashable] | None = None,
-        keep: Literal["first"] | Literal["last"] | Literal[False] = "first",
+        keep: Literal["first", "last", False] = "first",
     ) -> Series:
         """
         Return boolean Series denoting duplicate rows.
@@ -6241,50 +6801,93 @@ def f(vals) -> tuple[np.ndarray, int]:
         # Verify all columns in subset exist in the queried dataframe
         # Otherwise, raise a KeyError, same as if you try to __getitem__ with a
         # key that doesn't exist.
-        diff = Index(subset).difference(self.columns)
-        if not diff.empty:
-            raise KeyError(diff)
-
-        vals = (col.values for name, col in self.items() if name in subset)
-        labels, shape = map(list, zip(*map(f, vals)))
-
-        ids = get_group_index(
-            labels,
-            # error: Argument 1 to "tuple" has incompatible type "List[_T]";
-            # expected "Iterable[int]"
-            tuple(shape),  # type: ignore[arg-type]
-            sort=False,
-            xnull=False,
-        )
-        result = self._constructor_sliced(duplicated(ids, keep), index=self.index)
+        diff = set(subset) - set(self.columns)
+        if diff:
+            raise KeyError(Index(diff))
+
+        if len(subset) == 1 and self.columns.is_unique:
+            # GH#45236 This is faster than get_group_index below
+            result = self[subset[0]].duplicated(keep)
+            result.name = None
+        else:
+            vals = (col.values for name, col in self.items() if name in subset)
+            labels, shape = map(list, zip(*map(f, vals)))
+
+            ids = get_group_index(
+                labels,
+                # error: Argument 1 to "tuple" has incompatible type "List[_T]";
+                # expected "Iterable[int]"
+                tuple(shape),  # type: ignore[arg-type]
+                sort=False,
+                xnull=False,
+            )
+            result = self._constructor_sliced(duplicated(ids, keep), index=self.index)
         return result.__finalize__(self, method="duplicated")
 
     # ----------------------------------------------------------------------
     # Sorting
+    # error: Signature of "sort_values" incompatible with supertype "NDFrame"
+    @overload  # type: ignore[override]
+    def sort_values(
+        self,
+        by: IndexLabel,
+        *,
+        axis: Axis = ...,
+        ascending=...,
+        inplace: Literal[False] = ...,
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool = ...,
+        key: ValueKeyFunc = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def sort_values(
+        self,
+        by: IndexLabel,
+        *,
+        axis: Axis = ...,
+        ascending=...,
+        inplace: Literal[True],
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool = ...,
+        key: ValueKeyFunc = ...,
+    ) -> None:
+        ...
+
     # TODO: Just move the sort_values doc here.
+    # error: Signature of "sort_values" incompatible with supertype "NDFrame"
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "by"])
     @Substitution(**_shared_doc_kwargs)
     @Appender(NDFrame.sort_values.__doc__)
-    # error: Signature of "sort_values" incompatible with supertype "NDFrame"
     def sort_values(  # type: ignore[override]
         self,
-        by,
+        by: IndexLabel,
         axis: Axis = 0,
-        ascending=True,
+        ascending: bool | list[bool] | tuple[bool, ...] = True,
         inplace: bool = False,
         kind: str = "quicksort",
         na_position: str = "last",
         ignore_index: bool = False,
         key: ValueKeyFunc = None,
-    ):
+    ) -> DataFrame | None:
         inplace = validate_bool_kwarg(inplace, "inplace")
         axis = self._get_axis_number(axis)
         ascending = validate_ascending(ascending)
         if not isinstance(by, list):
             by = [by]
-        if is_sequence(ascending) and len(by) != len(ascending):
+        # error: Argument 1 to "len" has incompatible type "Union[bool, List[bool]]";
+        # expected "Sized"
+        if is_sequence(ascending) and (
+            len(by) != len(ascending)  # type: ignore[arg-type]
+        ):
+            # error: Argument 1 to "len" has incompatible type "Union[bool,
+            # List[bool]]"; expected "Sized"
             raise ValueError(
-                f"Length of ascending ({len(ascending)}) != length of by ({len(by)})"
+                f"Length of ascending ({len(ascending)})"  # type: ignore[arg-type]
+                f" != length of by ({len(by)})"
             )
         if len(by) > 1:
 
@@ -6338,19 +6941,68 @@ def sort_values(  # type: ignore[override]
         else:
             return result.__finalize__(self, method="sort_values")
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def sort_index(
+        self,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: Literal[True],
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def sort_index(
+        self,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: Literal[False] = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def sort_index(
+        self,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: bool = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "sort_index" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def sort_index(  # type: ignore[override]
         self,
         axis: Axis = 0,
-        level: Level | None = None,
-        ascending: bool | int | Sequence[bool | int] = True,
+        level: IndexLabel = None,
+        ascending: bool | Sequence[bool] = True,
         inplace: bool = False,
-        kind: str = "quicksort",
-        na_position: str = "last",
+        kind: SortKind = "quicksort",
+        na_position: NaPosition = "last",
         sort_remaining: bool = True,
         ignore_index: bool = False,
         key: IndexKeyFunc = None,
-    ):
+    ) -> DataFrame | None:
         """
         Sort object by labels (along an axis).
 
@@ -6368,7 +7020,7 @@ def sort_index(
             Sort ascending vs. descending. When the index is a MultiIndex the
             sort direction can be controlled for each level individually.
         inplace : bool, default False
-            If True, perform operation in-place.
+            Whether to modify the DataFrame rather than creating a new one.
         kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'
             Choice of sorting algorithm. See also :func:`numpy.sort` for more
             information. `mergesort` and `stable` are the only stable algorithms. For
@@ -6441,15 +7093,15 @@ def sort_index(
         d  4
         """
         return super().sort_index(
-            axis,
-            level,
-            ascending,
-            inplace,
-            kind,
-            na_position,
-            sort_remaining,
-            ignore_index,
-            key,
+            axis=axis,
+            level=level,
+            ascending=ascending,
+            inplace=inplace,
+            kind=kind,
+            na_position=na_position,
+            sort_remaining=sort_remaining,
+            ignore_index=ignore_index,
+            key=key,
         )
 
     def value_counts(
@@ -6459,7 +7111,7 @@ def value_counts(
         sort: bool = True,
         ascending: bool = False,
         dropna: bool = True,
-    ):
+    ) -> Series:
         """
         Return a Series containing counts of unique rows in the DataFrame.
 
@@ -7138,6 +7790,14 @@ def __rdivmod__(self, other) -> tuple[DataFrame, DataFrame]:
 0    a     c  NaN   NaN
 2  NaN   NaN  3.0   4.0
 
+Assign result_names
+
+>>> df.compare(df2, result_names=("left", "right"))
+  col1       col3
+  left right left right
+0    a     c  NaN   NaN
+2  NaN   NaN  3.0   4.0
+
 Stack the differences on rows
 
 >>> df.compare(df2, align_axis=0)
@@ -7185,16 +7845,22 @@ def compare(
         align_axis: Axis = 1,
         keep_shape: bool = False,
         keep_equal: bool = False,
+        result_names: Suffixes = ("self", "other"),
     ) -> DataFrame:
         return super().compare(
             other=other,
             align_axis=align_axis,
             keep_shape=keep_shape,
             keep_equal=keep_equal,
+            result_names=result_names,
         )
 
     def combine(
-        self, other: DataFrame, func, fill_value=None, overwrite: bool = True
+        self,
+        other: DataFrame,
+        func: Callable[[Series, Series], Series | Hashable],
+        fill_value=None,
+        overwrite: bool = True,
     ) -> DataFrame:
         """
         Perform column-wise combine with another DataFrame.
@@ -7356,7 +8022,11 @@ def combine(
             if isinstance(new_dtype, np.dtype):
                 # if new_dtype is an EA Dtype, then `func` is expected to return
                 # the correct dtype without any additional casting
-                arr = maybe_downcast_to_dtype(arr, new_dtype)
+                # error: No overload variant of "maybe_downcast_to_dtype" matches
+                # argument types "Union[Series, Hashable]", "dtype[Any]"
+                arr = maybe_downcast_to_dtype(  # type: ignore[call-overload]
+                    arr, new_dtype
+                )
 
             result[col] = arr
 
@@ -7369,7 +8039,11 @@ def combine_first(self, other: DataFrame) -> DataFrame:
 
         Combine two DataFrame objects by filling null values in one DataFrame
         with non-null values from other DataFrame. The row and column indexes
-        of the resulting DataFrame will be the union of the two.
+        of the resulting DataFrame will be the union of the two. The resulting
+        dataframe contains the 'first' dataframe values and overrides the
+        second one values where both first.loc[index, col] and
+        second.loc[index, col] are not missing values, upon calling
+        first.combine_first(second).
 
         Parameters
         ----------
@@ -7584,7 +8258,9 @@ def update(
             if mask.all():
                 continue
 
-            self[col] = expressions.where(mask, this, that)
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", "In a future version, `df.iloc")
+                self.loc[:, col] = expressions.where(mask, this, that)
 
     # ----------------------------------------------------------------------
     # Data reshaping
@@ -7669,6 +8345,27 @@ def update(
 a   13.0   13.0
 b   12.3  123.0
 NaN 12.3   33.0
+
+When using ``.apply()``, use ``group_keys`` to include or exclude the group keys.
+The ``group_keys`` argument defaults to ``True`` (include).
+
+>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
+...                               'Parrot', 'Parrot'],
+...                    'Max Speed': [380., 370., 24., 26.]})
+>>> df.groupby("Animal", group_keys=True).apply(lambda x: x)
+          Animal  Max Speed
+Animal
+Falcon 0  Falcon      380.0
+       1  Falcon      370.0
+Parrot 2  Parrot       24.0
+       3  Parrot       26.0
+
+>>> df.groupby("Animal", group_keys=False).apply(lambda x: x)
+   Animal  Max Speed
+0  Falcon      380.0
+1  Falcon      370.0
+2  Parrot       24.0
+3  Parrot       26.0
 """
     )
     @Appender(_shared_docs["groupby"] % _shared_doc_kwargs)
@@ -7676,10 +8373,10 @@ def groupby(
         self,
         by=None,
         axis: Axis = 0,
-        level: Level | None = None,
+        level: IndexLabel | None = None,
         as_index: bool = True,
         sort: bool = True,
-        group_keys: bool = True,
+        group_keys: bool | lib.NoDefault = no_default,
         squeeze: bool | lib.NoDefault = no_default,
         observed: bool = False,
         dropna: bool = True,
@@ -7702,9 +8399,6 @@ def groupby(
             raise TypeError("You have to supply one of 'by' and 'level'")
         axis = self._get_axis_number(axis)
 
-        # https://github.com/python/mypy/issues/7642
-        # error: Argument "squeeze" to "DataFrameGroupBy" has incompatible type
-        # "Union[bool, NoDefault]"; expected "bool"
         return DataFrameGroupBy(
             obj=self,
             keys=by,
@@ -7713,7 +8407,7 @@ def groupby(
             as_index=as_index,
             sort=sort,
             group_keys=group_keys,
-            squeeze=squeeze,  # type: ignore[arg-type]
+            squeeze=squeeze,
             observed=observed,
             dropna=dropna,
         )
@@ -7774,6 +8468,8 @@ def groupby(
         For finer-tuned control, see hierarchical indexing documentation along
         with the related stack/unstack methods.
 
+        Reference :ref:`the user guide <reshaping.pivot>` for more examples.
+
         Examples
         --------
         >>> df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
@@ -7864,6 +8560,7 @@ def groupby(
 
     @Substitution("")
     @Appender(_shared_docs["pivot"])
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     def pivot(self, index=None, columns=None, values=None) -> DataFrame:
         from pandas.core.reshape.pivot import pivot
 
@@ -7902,7 +8599,9 @@ def pivot(self, index=None, columns=None, values=None) -> DataFrame:
         margins : bool, default False
             Add all row / columns (e.g. for subtotal / grand totals).
         dropna : bool, default True
-            Do not include columns whose entries are all NaN.
+            Do not include columns whose entries are all NaN. If True,
+            rows with a NaN value in any column will be omitted before
+            computing margins.
         margins_name : str, default 'All'
             Name of the row / column that will contain the totals
             when margins is True.
@@ -7932,6 +8631,10 @@ def pivot(self, index=None, columns=None, values=None) -> DataFrame:
         wide_to_long : Wide panel to long format. Less flexible but more
             user-friendly than melt.
 
+        Notes
+        -----
+        Reference :ref:`the user guide <reshaping.pivot>` for more examples.
+
         Examples
         --------
         >>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
@@ -8088,6 +8791,8 @@ def stack(self, level: Level = -1, dropna: bool = True):
         vertically on top of each other (in the index of the
         dataframe).
 
+        Reference :ref:`the user guide <reshaping.stacking>` for more examples.
+
         Examples
         --------
         **Single level columns**
@@ -8267,6 +8972,8 @@ def explode(
         result in a np.nan for that row. In addition, the ordering of rows in the
         output will be non-deterministic when exploding sets.
 
+        Reference :ref:`the user guide <reshaping.explode>` for more examples.
+
         Examples
         --------
         >>> df = pd.DataFrame({'A': [[0, 1, 2], 'foo', [], [3, 4]],
@@ -8310,7 +9017,7 @@ def explode(
         if is_scalar(column) or isinstance(column, tuple):
             columns = [column]
         elif isinstance(column, list) and all(
-            map(lambda c: is_scalar(c) or isinstance(c, tuple), column)
+            is_scalar(c) or isinstance(c, tuple) for c in column
         ):
             if not column:
                 raise ValueError("column must be nonempty")
@@ -8337,7 +9044,7 @@ def explode(
             result.index = self.index.take(result.index)
         result = result.reindex(columns=self.columns, copy=False)
 
-        return result
+        return result.__finalize__(self, method="explode")
 
     def unstack(self, level: Level = -1, fill_value=None):
         """
@@ -8366,6 +9073,10 @@ def unstack(self, level: Level = -1, fill_value=None):
         DataFrame.stack : Pivot a level of the column labels (inverse operation
             from `unstack`).
 
+        Notes
+        -----
+        Reference :ref:`the user guide <reshaping.stacking>` for more examples.
+
         Examples
         --------
         >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
@@ -8409,7 +9120,7 @@ def melt(
         value_vars=None,
         var_name=None,
         value_name="value",
-        col_level: Level | None = None,
+        col_level: Level = None,
         ignore_index: bool = True,
     ) -> DataFrame:
 
@@ -8421,14 +9132,14 @@ def melt(
             value_name=value_name,
             col_level=col_level,
             ignore_index=ignore_index,
-        )
+        ).__finalize__(self, method="melt")
 
     # ----------------------------------------------------------------------
     # Time series-related
 
     @doc(
         Series.diff,
-        klass="Dataframe",
+        klass="DataFrame",
         extra_params="axis : {0 or 'index', 1 or 'columns'}, default 0\n    "
         "Take difference over rows (0) or columns (1).\n",
         other_klass="Series",
@@ -8646,6 +9357,42 @@ def aggregate(self, func=None, axis: Axis = 0, *args, **kwargs):
 
     agg = aggregate
 
+    # error: Signature of "any" incompatible with supertype "NDFrame"  [override]
+    @overload  # type: ignore[override]
+    def any(
+        self,
+        *,
+        axis: Axis = ...,
+        bool_only: bool | None = ...,
+        skipna: bool = ...,
+        level: None = ...,
+        **kwargs,
+    ) -> Series:
+        ...
+
+    @overload
+    def any(
+        self,
+        *,
+        axis: Axis = ...,
+        bool_only: bool | None = ...,
+        skipna: bool = ...,
+        level: Level,
+        **kwargs,
+    ) -> DataFrame | Series:
+        ...
+
+    @doc(NDFrame.any, **_shared_doc_kwargs)
+    def any(
+        self,
+        axis: Axis = 0,
+        bool_only: bool | None = None,
+        skipna: bool = True,
+        level: Level = None,
+        **kwargs,
+    ) -> DataFrame | Series:
+        ...
+
     @doc(
         _shared_docs["transform"],
         klass=_shared_doc_kwargs["klass"],
@@ -8666,7 +9413,7 @@ def apply(
         func: AggFuncType,
         axis: Axis = 0,
         raw: bool = False,
-        result_type=None,
+        result_type: Literal["expand", "reduce", "broadcast"] | None = None,
         args=(),
         **kwargs,
     ):
@@ -8871,9 +9618,9 @@ def applymap(
         >>> df_copy = df.copy()
         >>> df_copy.iloc[0, 0] = pd.NA
         >>> df_copy.applymap(lambda x: len(str(x)), na_action='https://github.com/ignore')
-              0  1
-        0  <NA>  4
-        1     5  5
+             0  1
+        0  NaN  4
+        1  5.0  5
 
         Note that a vectorized version of `func` often exists, which will
         be much faster. You could square each number elementwise.
@@ -8918,6 +9665,10 @@ def append(
         """
         Append rows of `other` to the end of caller, returning a new object.
 
+        .. deprecated:: 1.4.0
+            Use :func:`concat` instead. For further details see
+            :ref:`whatsnew_140.deprecations.frame_series_append`
+
         Columns in `other` that are not in the caller are added as new columns.
 
         Parameters
@@ -9023,7 +9774,6 @@ def _append(
         verify_integrity: bool = False,
         sort: bool = False,
     ) -> DataFrame:
-        combined_columns = None
         if isinstance(other, (Series, dict)):
             if isinstance(other, dict):
                 if not ignore_index:
@@ -9036,8 +9786,6 @@ def _append(
                 )
 
             index = Index([other.name], name=self.index.name)
-            idx_diff = other.index.difference(self.columns)
-            combined_columns = self.columns.append(idx_diff)
             row_df = other.to_frame().T
             # infer_objects is needed for
             #  test_append_empty_frame_to_series_with_dateutil_tz
@@ -9063,26 +9811,17 @@ def _append(
             verify_integrity=verify_integrity,
             sort=sort,
         )
-        if (
-            combined_columns is not None
-            and not sort
-            and not combined_columns.equals(result.columns)
-        ):
-            # TODO: reindexing here is a kludge bc union_indexes does not
-            #  pass sort to index.union, xref #43375
-            # combined_columns.equals check is necessary for preserving dtype
-            #  in test_crosstab_normalize
-            result = result.reindex(combined_columns, axis=1)
         return result.__finalize__(self, method="append")
 
     def join(
         self,
-        other: DataFrame | Series,
+        other: DataFrame | Series | list[DataFrame | Series],
         on: IndexLabel | None = None,
         how: str = "left",
         lsuffix: str = "",
         rsuffix: str = "",
         sort: bool = False,
+        validate: str | None = None,
     ) -> DataFrame:
         """
         Join columns of another DataFrame.
@@ -9093,7 +9832,7 @@ def join(
 
         Parameters
         ----------
-        other : DataFrame, Series, or list of DataFrame
+        other : DataFrame, Series, or a list containing any combination of them
             Index should be similar to one of the columns in this one. If a
             Series is passed, its name attribute must be set, and that will be
             used as the column name in the resulting joined DataFrame.
@@ -9126,6 +9865,14 @@ def join(
         sort : bool, default False
             Order result DataFrame lexicographically by the join key. If False,
             the order of the join key depends on the join type (how keyword).
+        validate : str, optional
+            If specified, checks if join is of specified type.
+            * "one_to_one" or "1:1": check if join keys are unique in both left
+            and right datasets.
+            * "one_to_many" or "1:m": check if join keys are unique in left dataset.
+            * "many_to_one" or "m:1": check if join keys are unique in right dataset.
+            * "many_to_many" or "m:m": allowed, but does not result in checks.
+            .. versionadded:: 1.5.0
 
         Returns
         -------
@@ -9220,7 +9967,7 @@ def join(
         4  K0  A4
         5  K1  A5
 
-        >>> df.join(other.set_index('key'), on='key')
+        >>> df.join(other.set_index('key'), on='key', validate='m:1')
           key   A    B
         0  K0  A0   B0
         1  K1  A1   B1
@@ -9230,17 +9977,24 @@ def join(
         5  K1  A5   B1
         """
         return self._join_compat(
-            other, on=on, how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort
+            other,
+            on=on,
+            how=how,
+            lsuffix=lsuffix,
+            rsuffix=rsuffix,
+            sort=sort,
+            validate=validate,
         )
 
     def _join_compat(
         self,
-        other: DataFrame | Series,
+        other: DataFrame | Series | Iterable[DataFrame | Series],
         on: IndexLabel | None = None,
         how: str = "left",
         lsuffix: str = "",
         rsuffix: str = "",
         sort: bool = False,
+        validate: str | None = None,
     ):
         from pandas.core.reshape.concat import concat
         from pandas.core.reshape.merge import merge
@@ -9259,6 +10013,7 @@ def _join_compat(
                     on=on,
                     suffixes=(lsuffix, rsuffix),
                     sort=sort,
+                    validate=validate,
                 )
             return merge(
                 self,
@@ -9269,6 +10024,7 @@ def _join_compat(
                 right_index=True,
                 suffixes=(lsuffix, rsuffix),
                 sort=sort,
+                validate=validate,
             )
         else:
             if on is not None:
@@ -9276,7 +10032,16 @@ def _join_compat(
                     "Joining multiple DataFrames only supported for joining on index"
                 )
 
-            frames = [self] + list(other)
+            if rsuffix or lsuffix:
+                raise ValueError(
+                    "Suffixes not supported when joining multiple DataFrames"
+                )
+
+            # Mypy thinks the RHS is a
+            # "Union[DataFrame, Series, Iterable[Union[DataFrame, Series]]]" whereas
+            # the LHS is an "Iterable[DataFrame]", but in reality both types are
+            # "Iterable[Union[DataFrame, Series]]" due to the if statements
+            frames = [cast("DataFrame | Series", self)] + list(other)
 
             can_concat = all(df.index.is_unique for df in frames)
 
@@ -9296,7 +10061,12 @@ def _join_compat(
 
             for frame in frames[1:]:
                 joined = merge(
-                    joined, frame, how=how, left_index=True, right_index=True
+                    joined,
+                    frame,
+                    how=how,
+                    left_index=True,
+                    right_index=True,
+                    validate=validate,
                 )
 
             return joined
@@ -9448,7 +10218,7 @@ def _series_round(ser: Series, decimals: int):
         if len(new_cols) > 0:
             return self._constructor(
                 concat(new_cols, axis=1), index=self.index, columns=self.columns
-            )
+            ).__finalize__(self, method="round")
         else:
             return self
 
@@ -9459,6 +10229,7 @@ def corr(
         self,
         method: str | Callable[[np.ndarray, np.ndarray], float] = "pearson",
         min_periods: int = 1,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
     ) -> DataFrame:
         """
         Compute pairwise correlation of columns, excluding NA/null values.
@@ -9479,6 +10250,14 @@ def corr(
             Minimum number of observations required per pair of columns
             to have a valid result. Currently only available for Pearson
             and Spearman correlation.
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
+            .. deprecated:: 1.5.0
+                The default value of ``numeric_only`` will be ``False`` in a future
+                version of pandas.
 
         Returns
         -------
@@ -9491,6 +10270,14 @@ def corr(
             DataFrame or Series.
         Series.corr : Compute the correlation between two Series.
 
+        Notes
+        -----
+        Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations.
+
+        * `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_
+        * `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_
+        * `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_
+
         Examples
         --------
         >>> def histogram_intersection(a, b):
@@ -9502,11 +10289,22 @@ def corr(
               dogs  cats
         dogs   1.0   0.3
         cats   0.3   1.0
-        """
-        numeric_df = self._get_numeric_data()
-        cols = numeric_df.columns
+
+        >>> df = pd.DataFrame([(1, 1), (2, np.nan), (np.nan, 3), (4, 4)],
+        ...                   columns=['dogs', 'cats'])
+        >>> df.corr(min_periods=3)
+              dogs  cats
+        dogs   1.0   NaN
+        cats   NaN   1.0
+        """  # noqa:E501
+        numeric_only_bool = com.resolve_numeric_only(numeric_only)
+        data = self._get_numeric_data() if numeric_only_bool else self
+        if numeric_only is lib.no_default and len(data.columns) < len(self.columns):
+            com.deprecate_numeric_only_default(type(self), "corr")
+
+        cols = data.columns
         idx = cols.copy()
-        mat = numeric_df.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        mat = data.to_numpy(dtype=float, na_value=np.nan, copy=False)
 
         if method == "pearson":
             correl = libalgos.nancorr(mat, minp=min_periods)
@@ -9545,7 +10343,12 @@ def corr(
 
         return self._constructor(correl, index=idx, columns=cols)
 
-    def cov(self, min_periods: int | None = None, ddof: int | None = 1) -> DataFrame:
+    def cov(
+        self,
+        min_periods: int | None = None,
+        ddof: int | None = 1,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+    ) -> DataFrame:
         """
         Compute pairwise covariance of columns, excluding NA/null values.
 
@@ -9576,6 +10379,15 @@ def cov(self, min_periods: int | None = None, ddof: int | None = 1) -> DataFrame
 
             .. versionadded:: 1.1.0
 
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
+            .. deprecated:: 1.5.0
+                The default value of ``numeric_only`` will be ``False`` in a future
+                version of pandas.
+
         Returns
         -------
         DataFrame
@@ -9584,9 +10396,10 @@ def cov(self, min_periods: int | None = None, ddof: int | None = 1) -> DataFrame
         See Also
         --------
         Series.cov : Compute covariance with another Series.
-        core.window.ExponentialMovingWindow.cov: Exponential weighted sample covariance.
-        core.window.Expanding.cov : Expanding sample covariance.
-        core.window.Rolling.cov : Rolling sample covariance.
+        core.window.ewm.ExponentialMovingWindow.cov : Exponential weighted sample
+            covariance.
+        core.window.expanding.Expanding.cov : Expanding sample covariance.
+        core.window.rolling.Rolling.cov : Rolling sample covariance.
 
         Notes
         -----
@@ -9644,10 +10457,14 @@ def cov(self, min_periods: int | None = None, ddof: int | None = 1) -> DataFrame
         b       NaN  1.248003  0.191417
         c -0.150812  0.191417  0.895202
         """
-        numeric_df = self._get_numeric_data()
-        cols = numeric_df.columns
+        numeric_only_bool = com.resolve_numeric_only(numeric_only)
+        data = self._get_numeric_data() if numeric_only_bool else self
+        if numeric_only is lib.no_default and len(data.columns) < len(self.columns):
+            com.deprecate_numeric_only_default(type(self), "cov")
+
+        cols = data.columns
         idx = cols.copy()
-        mat = numeric_df.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        mat = data.to_numpy(dtype=float, na_value=np.nan, copy=False)
 
         if notna(mat).all():
             if min_periods is not None and min_periods > len(mat):
@@ -9661,7 +10478,15 @@ def cov(self, min_periods: int | None = None, ddof: int | None = 1) -> DataFrame
 
         return self._constructor(base_cov, index=idx, columns=cols)
 
-    def corrwith(self, other, axis: Axis = 0, drop=False, method="pearson") -> Series:
+    def corrwith(
+        self,
+        other: DataFrame | Series,
+        axis: Axis = 0,
+        drop: bool = False,
+        method: Literal["pearson", "kendall", "spearman"]
+        | Callable[[np.ndarray, np.ndarray], float] = "pearson",
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+    ) -> Series:
         """
         Compute pairwise correlation.
 
@@ -9675,8 +10500,8 @@ def corrwith(self, other, axis: Axis = 0, drop=False, method="pearson") -> Serie
         other : DataFrame, Series
             Object with which to compute correlations.
         axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis to use. 0 or 'index' to compute column-wise, 1 or 'columns' for
-            row-wise.
+            The axis to use. 0 or 'index' to compute row-wise, 1 or 'columns' for
+            column-wise.
         drop : bool, default False
             Drop missing indices from result.
         method : {'pearson', 'kendall', 'spearman'} or callable
@@ -9688,6 +10513,15 @@ def corrwith(self, other, axis: Axis = 0, drop=False, method="pearson") -> Serie
             * callable: callable with input two 1d ndarrays
                 and returning a float.
 
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
+            .. deprecated:: 1.5.0
+                The default value of ``numeric_only`` will be ``False`` in a future
+                version of pandas.
+
         Returns
         -------
         Series
@@ -9696,14 +10530,39 @@ def corrwith(self, other, axis: Axis = 0, drop=False, method="pearson") -> Serie
         See Also
         --------
         DataFrame.corr : Compute pairwise correlation of columns.
-        """
+
+        Examples
+        --------
+        >>> index = ["a", "b", "c", "d", "e"]
+        >>> columns = ["one", "two", "three", "four"]
+        >>> df1 = pd.DataFrame(np.arange(20).reshape(5, 4), index=index, columns=columns)
+        >>> df2 = pd.DataFrame(np.arange(16).reshape(4, 4), index=index[:4], columns=columns)
+        >>> df1.corrwith(df2)
+        one      1.0
+        two      1.0
+        three    1.0
+        four     1.0
+        dtype: float64
+
+        >>> df2.corrwith(df1, axis=1)
+        a    1.0
+        b    1.0
+        c    1.0
+        d    1.0
+        e    NaN
+        dtype: float64
+        """  # noqa:E501
         axis = self._get_axis_number(axis)
-        this = self._get_numeric_data()
+        numeric_only_bool = com.resolve_numeric_only(numeric_only)
+        this = self._get_numeric_data() if numeric_only_bool else self
+        if numeric_only is lib.no_default and len(this.columns) < len(self.columns):
+            com.deprecate_numeric_only_default(type(self), "corrwith")
 
         if isinstance(other, Series):
             return this.apply(lambda x: other.corr(x, method=method), axis=axis)
 
-        other = other._get_numeric_data()
+        if numeric_only_bool:
+            other = other._get_numeric_data()
         left, right = this.align(other, join="inner", copy=False)
 
         if axis == 1:
@@ -9716,11 +10575,15 @@ def corrwith(self, other, axis: Axis = 0, drop=False, method="pearson") -> Serie
             right = right + left * 0
 
             # demeaned data
-            ldem = left - left.mean()
-            rdem = right - right.mean()
+            ldem = left - left.mean(numeric_only=numeric_only_bool)
+            rdem = right - right.mean(numeric_only=numeric_only_bool)
 
             num = (ldem * rdem).sum()
-            dom = (left.count() - 1) * left.std() * right.std()
+            dom = (
+                (left.count() - 1)
+                * left.std(numeric_only=numeric_only_bool)
+                * right.std(numeric_only=numeric_only_bool)
+            )
 
             correl = num / dom
 
@@ -9757,9 +10620,7 @@ def c(x):
     # ----------------------------------------------------------------------
     # ndarray-like stats methods
 
-    def count(
-        self, axis: Axis = 0, level: Level | None = None, numeric_only: bool = False
-    ):
+    def count(self, axis: Axis = 0, level: Level = None, numeric_only: bool = False):
         """
         Count non-NA cells for each column or row.
 
@@ -9836,7 +10697,8 @@ def count(
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            return self._count_level(level, axis=axis, numeric_only=numeric_only)
+            res = self._count_level(level, axis=axis, numeric_only=numeric_only)
+            return res.__finalize__(self, method="count")
 
         if numeric_only:
             frame = self._get_numeric_data()
@@ -9859,7 +10721,7 @@ def count(
                     counts, index=frame._get_agg_axis(axis)
                 )
 
-        return result.astype("int64")
+        return result.astype("int64").__finalize__(self, method="count")
 
     def _count_level(self, level: Level, axis: int = 0, numeric_only: bool = False):
         if numeric_only:
@@ -9891,12 +10753,14 @@ def _count_level(self, level: Level, axis: int = 0, numeric_only: bool = False):
         else:
             mask = index_mask.reshape(-1, 1) & values_mask
 
-        if isinstance(level, str):
-            level = count_axis._get_level_number(level)
+        if isinstance(level, int):
+            level_number = level
+        else:
+            level_number = count_axis._get_level_number(level)
 
-        level_name = count_axis._names[level]
-        level_index = count_axis.levels[level]._rename(name=level_name)
-        level_codes = ensure_platform_int(count_axis.codes[level])
+        level_name = count_axis._names[level_number]
+        level_index = count_axis.levels[level_number]._rename(name=level_name)
+        level_codes = ensure_platform_int(count_axis.codes[level_number])
         counts = lib.count_level_2d(mask, level_codes, len(level_index), axis=axis)
 
         if axis == 1:
@@ -9917,7 +10781,6 @@ def _reduce(
         filter_type=None,
         **kwds,
     ):
-
         assert filter_type is None or filter_type == "bool", filter_type
         out_dtype = "bool" if filter_type == "bool" else None
 
@@ -9955,7 +10818,7 @@ def func(values: np.ndarray):
 
         def blk_func(values, axis=1):
             if isinstance(values, ExtensionArray):
-                if not is_1d_only_ea_obj(values) and not isinstance(
+                if not is_1d_only_ea_dtype(values.dtype) and not isinstance(
                     self._mgr, ArrayManager
                 ):
                     return values._reduce(name, axis=1, skipna=skipna, **kwds)
@@ -9972,6 +10835,7 @@ def _get_data() -> DataFrame:
                 data = self._get_bool_data()
             return data
 
+        numeric_only_bool = com.resolve_numeric_only(numeric_only)
         if numeric_only is not None or axis == 0:
             # For numeric_only non-None and axis non-None, we know
             #  which blocks to use and no try/except is needed.
@@ -9979,7 +10843,7 @@ def _get_data() -> DataFrame:
             #  dtypes are unambiguous can be handled with BlockManager.reduce
             # Case with EAs see GH#35881
             df = self
-            if numeric_only is True:
+            if numeric_only_bool:
                 df = _get_data()
             if axis == 1:
                 df = df.T
@@ -10000,16 +10864,8 @@ def _get_data() -> DataFrame:
 
             if numeric_only is None and out.shape[0] != df.shape[1]:
                 # columns have been dropped GH#41480
-                arg_name = "numeric_only"
-                if name in ["all", "any"]:
-                    arg_name = "bool_only"
-                warnings.warn(
-                    "Dropping of nuisance columns in DataFrame reductions "
-                    f"(with '{arg_name}=None') is deprecated; in a future "
-                    "version this will raise TypeError.  Select only valid "
-                    "columns before calling the reduction.",
-                    FutureWarning,
-                    stacklevel=find_stack_level(),
+                com.deprecate_numeric_only_default(
+                    type(self), name, deprecate_none=True
                 )
 
             return out
@@ -10126,70 +10982,17 @@ def nunique(self, axis: Axis = 0, dropna: bool = True) -> Series:
         """
         return self.apply(Series.nunique, axis=axis, dropna=dropna)
 
-    def idxmin(self, axis: Axis = 0, skipna: bool = True) -> Series:
-        """
-        Return index of first occurrence of minimum over requested axis.
-
-        NA/null values are excluded.
-
-        Parameters
-        ----------
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
-        skipna : bool, default True
-            Exclude NA/null values. If an entire row/column is NA, the result
-            will be NA.
-
-        Returns
-        -------
-        Series
-            Indexes of minima along the specified axis.
-
-        Raises
-        ------
-        ValueError
-            * If the row/column is empty
-
-        See Also
-        --------
-        Series.idxmin : Return index of the minimum element.
-
-        Notes
-        -----
-        This method is the DataFrame version of ``ndarray.argmin``.
-
-        Examples
-        --------
-        Consider a dataset containing food consumption in Argentina.
-
-        >>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
-        ...                    'co2_emissions': [37.2, 19.66, 1712]},
-        ...                    index=['Pork', 'Wheat Products', 'Beef'])
-
-        >>> df
-                        consumption  co2_emissions
-        Pork                  10.51         37.20
-        Wheat Products       103.11         19.66
-        Beef                  55.48       1712.00
-
-        By default, it returns the index for the minimum value in each column.
-
-        >>> df.idxmin()
-        consumption                Pork
-        co2_emissions    Wheat Products
-        dtype: object
-
-        To return the index for the minimum value in each row, use ``axis="columns"``.
-
-        >>> df.idxmin(axis="columns")
-        Pork                consumption
-        Wheat Products    co2_emissions
-        Beef                consumption
-        dtype: object
-        """
+    @doc(_shared_docs["idxmin"], numeric_only_default="False")
+    def idxmin(
+        self, axis: Axis = 0, skipna: bool = True, numeric_only: bool = False
+    ) -> Series:
         axis = self._get_axis_number(axis)
+        if numeric_only:
+            data = self._get_numeric_data()
+        else:
+            data = self
 
-        res = self._reduce(
+        res = data._reduce(
             nanops.nanargmin, "argmin", axis=axis, skipna=skipna, numeric_only=False
         )
         indices = res._values
@@ -10199,74 +11002,23 @@ def idxmin(self, axis: Axis = 0, skipna: bool = True) -> Series:
         # error: Item "int" of "Union[int, Any]" has no attribute "__iter__"
         assert isinstance(indices, np.ndarray)  # for mypy
 
-        index = self._get_axis(axis)
+        index = data._get_axis(axis)
         result = [index[i] if i >= 0 else np.nan for i in indices]
-        return self._constructor_sliced(result, index=self._get_agg_axis(axis))
-
-    def idxmax(self, axis: Axis = 0, skipna: bool = True) -> Series:
-        """
-        Return index of first occurrence of maximum over requested axis.
-
-        NA/null values are excluded.
+        final_result = data._constructor_sliced(result, index=data._get_agg_axis(axis))
+        return final_result.__finalize__(self, method="idxmin")
 
-        Parameters
-        ----------
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
-        skipna : bool, default True
-            Exclude NA/null values. If an entire row/column is NA, the result
-            will be NA.
-
-        Returns
-        -------
-        Series
-            Indexes of maxima along the specified axis.
-
-        Raises
-        ------
-        ValueError
-            * If the row/column is empty
-
-        See Also
-        --------
-        Series.idxmax : Return index of the maximum element.
-
-        Notes
-        -----
-        This method is the DataFrame version of ``ndarray.argmax``.
-
-        Examples
-        --------
-        Consider a dataset containing food consumption in Argentina.
-
-        >>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
-        ...                    'co2_emissions': [37.2, 19.66, 1712]},
-        ...                    index=['Pork', 'Wheat Products', 'Beef'])
-
-        >>> df
-                        consumption  co2_emissions
-        Pork                  10.51         37.20
-        Wheat Products       103.11         19.66
-        Beef                  55.48       1712.00
-
-        By default, it returns the index for the maximum value in each column.
-
-        >>> df.idxmax()
-        consumption     Wheat Products
-        co2_emissions             Beef
-        dtype: object
-
-        To return the index for the maximum value in each row, use ``axis="columns"``.
+    @doc(_shared_docs["idxmax"], numeric_only_default="False")
+    def idxmax(
+        self, axis: Axis = 0, skipna: bool = True, numeric_only: bool = False
+    ) -> Series:
 
-        >>> df.idxmax(axis="columns")
-        Pork              co2_emissions
-        Wheat Products     consumption
-        Beef              co2_emissions
-        dtype: object
-        """
         axis = self._get_axis_number(axis)
+        if numeric_only:
+            data = self._get_numeric_data()
+        else:
+            data = self
 
-        res = self._reduce(
+        res = data._reduce(
             nanops.nanargmax, "argmax", axis=axis, skipna=skipna, numeric_only=False
         )
         indices = res._values
@@ -10276,9 +11028,10 @@ def idxmax(self, axis: Axis = 0, skipna: bool = True) -> Series:
         # error: Item "int" of "Union[int, Any]" has no attribute "__iter__"
         assert isinstance(indices, np.ndarray)  # for mypy
 
-        index = self._get_axis(axis)
+        index = data._get_axis(axis)
         result = [index[i] if i >= 0 else np.nan for i in indices]
-        return self._constructor_sliced(result, index=self._get_agg_axis(axis))
+        final_result = data._constructor_sliced(result, index=data._get_agg_axis(axis))
+        return final_result.__finalize__(self, method="idxmax")
 
     def _get_agg_axis(self, axis_num: int) -> Index:
         """
@@ -10383,13 +11136,44 @@ def f(s):
 
         return data
 
+    @overload
+    def quantile(
+        self,
+        q: float = ...,
+        axis: Axis = ...,
+        numeric_only: bool | lib.NoDefault = ...,
+        interpolation: QuantileInterpolation = ...,
+    ) -> Series:
+        ...
+
+    @overload
     def quantile(
         self,
-        q=0.5,
+        q: AnyArrayLike | Sequence[float],
+        axis: Axis = ...,
+        numeric_only: bool | lib.NoDefault = ...,
+        interpolation: QuantileInterpolation = ...,
+    ) -> Series | DataFrame:
+        ...
+
+    @overload
+    def quantile(
+        self,
+        q: float | AnyArrayLike | Sequence[float] = ...,
+        axis: Axis = ...,
+        numeric_only: bool | lib.NoDefault = ...,
+        interpolation: QuantileInterpolation = ...,
+    ) -> Series | DataFrame:
+        ...
+
+    def quantile(
+        self,
+        q: float | AnyArrayLike | Sequence[float] = 0.5,
         axis: Axis = 0,
-        numeric_only: bool = True,
-        interpolation: str = "linear",
-    ):
+        numeric_only: bool | lib.NoDefault = no_default,
+        interpolation: QuantileInterpolation = "linear",
+        method: Literal["single", "table"] = "single",
+    ) -> Series | DataFrame:
         """
         Return values at the given quantile over requested axis.
 
@@ -10397,11 +11181,16 @@ def quantile(
         ----------
         q : float or array-like, default 0.5 (50% quantile)
             Value between 0 <= q <= 1, the quantile(s) to compute.
-        axis : {0, 1, 'index', 'columns'}, default 0
+        axis : {0 or 'index', 1 or 'columns'}, default 0
             Equals 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
         numeric_only : bool, default True
             If False, the quantile of datetime and timedelta data will be
             computed as well.
+
+            .. deprecated:: 1.5.0
+                The default value of ``numeric_only`` will be ``False`` in a future
+                version of pandas.
+
         interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
             This optional parameter specifies the interpolation method to use,
             when the desired quantile lies between two data points `i` and `j`:
@@ -10412,6 +11201,10 @@ def quantile(
             * higher: `j`.
             * nearest: `i` or `j` whichever is nearest.
             * midpoint: (`i` + `j`) / 2.
+        method : {'single', 'table'}, default 'single'
+            Whether to compute quantiles per-column ('single') or over all columns
+            ('table'). When 'table', the only allowed interpolation methods are
+            'nearest', 'lower', and 'higher'.
 
         Returns
         -------
@@ -10425,7 +11218,7 @@ def quantile(
 
         See Also
         --------
-        core.window.Rolling.quantile: Rolling quantile.
+        core.window.rolling.Rolling.quantile: Rolling quantile.
         numpy.percentile: Numpy function to compute the percentile.
 
         Examples
@@ -10441,6 +11234,17 @@ def quantile(
         0.1  1.3   3.7
         0.5  2.5  55.0
 
+        Specifying `method='table'` will compute the quantile over all columns.
+
+        >>> df.quantile(.1, method="table", interpolation="nearest")
+        a    1
+        b    1
+        Name: 0.1, dtype: int64
+        >>> df.quantile([.1, .5], method="table", interpolation="nearest")
+             a    b
+        0.1  1    1
+        0.5  3  100
+
         Specifying `numeric_only=False` will also compute the quantile of
         datetime and timedelta data.
 
@@ -10456,17 +11260,38 @@ def quantile(
         Name: 0.5, dtype: object
         """
         validate_percentile(q)
+        axis = self._get_axis_number(axis)
+        any_not_numeric = any(not is_numeric_dtype(x) for x in self.dtypes)
+        if numeric_only is no_default and any_not_numeric:
+            com.deprecate_numeric_only_default(type(self), "quantile")
+        numeric_only = com.resolve_numeric_only(numeric_only)
 
         if not is_list_like(q):
             # BlockManager.quantile expects listlike, so we wrap and unwrap here
-            res = self.quantile(
-                [q], axis=axis, numeric_only=numeric_only, interpolation=interpolation
+            # error: List item 0 has incompatible type "Union[float, Union[Union[
+            # ExtensionArray, ndarray[Any, Any]], Index, Series], Sequence[float]]";
+            # expected "float"
+            res_df = self.quantile(  # type: ignore[call-overload]
+                [q],
+                axis=axis,
+                numeric_only=numeric_only,
+                interpolation=interpolation,
+                method=method,
             )
-            return res.iloc[0]
+            if method == "single":
+                res = res_df.iloc[0]
+            else:
+                # cannot directly iloc over sparse arrays
+                res = res_df.T.iloc[:, 0]
+            if axis == 1 and len(self) == 0:
+                # GH#41544 try to get an appropriate dtype
+                dtype = find_common_type(list(self.dtypes))
+                if needs_i8_conversion(dtype):
+                    return res.astype(dtype)
+            return res
 
         q = Index(q, dtype=np.float64)
         data = self._get_numeric_data() if numeric_only else self
-        axis = self._get_axis_number(axis)
 
         if axis == 1:
             data = data.T
@@ -10474,23 +11299,70 @@ def quantile(
         if len(data.columns) == 0:
             # GH#23925 _get_numeric_data may have dropped all columns
             cols = Index([], name=self.columns.name)
-            if is_list_like(q):
-                return self._constructor([], index=q, columns=cols)
-            return self._constructor_sliced([], index=cols, name=q, dtype=np.float64)
 
-        res = data._mgr.quantile(qs=q, axis=1, interpolation=interpolation)
+            dtype = np.float64
+            if axis == 1:
+                # GH#41544 try to get an appropriate dtype
+                cdtype = find_common_type(list(self.dtypes))
+                if needs_i8_conversion(cdtype):
+                    dtype = cdtype
+
+            res = self._constructor([], index=q, columns=cols, dtype=dtype)
+            return res.__finalize__(self, method="quantile")
+
+        valid_method = {"single", "table"}
+        if method not in valid_method:
+            raise ValueError(
+                f"Invalid method: {method}. Method must be in {valid_method}."
+            )
+        if method == "single":
+            # error: Argument "qs" to "quantile" of "BlockManager" has incompatible type
+            # "Index"; expected "Float64Index"
+            res = data._mgr.quantile(
+                qs=q, axis=1, interpolation=interpolation  # type: ignore[arg-type]
+            )
+        elif method == "table":
+            valid_interpolation = {"nearest", "lower", "higher"}
+            if interpolation not in valid_interpolation:
+                raise ValueError(
+                    f"Invalid interpolation: {interpolation}. "
+                    f"Interpolation must be in {valid_interpolation}"
+                )
+            # handle degenerate case
+            if len(data) == 0:
+                if data.ndim == 2:
+                    dtype = find_common_type(list(self.dtypes))
+                else:
+                    dtype = self.dtype
+                return self._constructor([], index=q, columns=data.columns, dtype=dtype)
+
+            q_idx = np.quantile(  # type: ignore[call-overload]
+                np.arange(len(data)), q, **{np_percentile_argname: interpolation}
+            )
+
+            by = data.columns
+            if len(by) > 1:
+                keys = [data._get_label_or_level_values(x) for x in by]
+                indexer = lexsort_indexer(keys)
+            else:
+                by = by[0]
+                k = data._get_label_or_level_values(by)  # type: ignore[arg-type]
+                indexer = nargsort(k)
+
+            res = data._mgr.take(indexer[q_idx], verify=False)
+            res.axes[1] = q
 
         result = self._constructor(res)
-        return result
+        return result.__finalize__(self, method="quantile")
 
     @doc(NDFrame.asfreq, **_shared_doc_kwargs)
     def asfreq(
         self,
         freq: Frequency,
-        method=None,
+        method: FillnaOptions | None = None,
         how: str | None = None,
         normalize: bool = False,
-        fill_value=None,
+        fill_value: Hashable = None,
     ) -> DataFrame:
         return super().asfreq(
             freq=freq,
@@ -10504,17 +11376,18 @@ def asfreq(
     def resample(
         self,
         rule,
-        axis=0,
+        axis: Axis = 0,
         closed: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
         loffset=None,
         base: int | None = None,
-        on=None,
-        level=None,
+        on: Level = None,
+        level: Level = None,
         origin: str | TimestampConvertibleTypes = "start_day",
         offset: TimedeltaConvertibleTypes | None = None,
+        group_keys: bool | lib.NoDefault = no_default,
     ) -> Resampler:
         return super().resample(
             rule=rule,
@@ -10529,6 +11402,7 @@ def resample(
             level=level,
             origin=origin,
             offset=offset,
+            group_keys=group_keys,
         )
 
     def to_timestamp(
@@ -10625,7 +11499,7 @@ def to_period(
         setattr(new_obj, axis_name, new_ax)
         return new_obj
 
-    def isin(self, values) -> DataFrame:
+    def isin(self, values: Series | DataFrame | Sequence | Mapping) -> DataFrame:
         """
         Whether each element in the DataFrame is contained in values.
 
@@ -10698,7 +11572,7 @@ def isin(self, values) -> DataFrame:
             from pandas.core.reshape.concat import concat
 
             values = collections.defaultdict(list, values)
-            return concat(
+            result = concat(
                 (
                     self.iloc[:, [i]].isin(values[col])
                     for i, col in enumerate(self.columns)
@@ -10708,11 +11582,11 @@ def isin(self, values) -> DataFrame:
         elif isinstance(values, Series):
             if not values.index.is_unique:
                 raise ValueError("cannot compute isin with a duplicate axis.")
-            return self.eq(values.reindex_like(self), axis="index")
+            result = self.eq(values.reindex_like(self), axis="index")
         elif isinstance(values, DataFrame):
             if not (values.columns.is_unique and values.index.is_unique):
                 raise ValueError("cannot compute isin with a duplicate axis.")
-            return self.eq(values.reindex_like(self))
+            result = self.eq(values.reindex_like(self))
         else:
             if not is_list_like(values):
                 raise TypeError(
@@ -10720,11 +11594,17 @@ def isin(self, values) -> DataFrame:
                     "to be passed to DataFrame.isin(), "
                     f"you passed a '{type(values).__name__}'"
                 )
-            return self._constructor(
-                algorithms.isin(self.values.ravel(), values).reshape(self.shape),
+            # error: Argument 2 to "isin" has incompatible type "Union[Sequence[Any],
+            # Mapping[Any, Any]]"; expected "Union[Union[ExtensionArray,
+            # ndarray[Any, Any]], Index, Series]"
+            result = self._constructor(
+                algorithms.isin(
+                    self.values.ravel(), values  # type: ignore[arg-type]
+                ).reshape(self.shape),
                 self.index,
                 self.columns,
             )
+        return result.__finalize__(self, method="isin")
 
     # ----------------------------------------------------------------------
     # Add index and columns
@@ -10738,12 +11618,10 @@ def isin(self, values) -> DataFrame:
     _info_axis_number = 1
     _info_axis_name = "columns"
 
-    index: Index = properties.AxisProperty(
+    index = properties.AxisProperty(
         axis=1, doc="The index (row labels) of the DataFrame."
     )
-    columns: Index = properties.AxisProperty(
-        axis=0, doc="The column labels of the DataFrame."
-    )
+    columns = properties.AxisProperty(axis=0, doc="The column labels of the DataFrame.")
 
     @property
     def _AXIS_NUMBERS(self) -> dict[str, int]:
@@ -10860,33 +11738,101 @@ def values(self) -> np.ndarray:
         self._consolidate_inplace()
         return self._mgr.as_array()
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def ffill(
-        self: DataFrame,
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def ffill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def ffill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "ffill" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def ffill(  # type: ignore[override]
+        self,
         axis: None | Axis = None,
         inplace: bool = False,
         limit: None | int = None,
-        downcast=None,
+        downcast: dict | None = None,
     ) -> DataFrame | None:
-        return super().ffill(axis, inplace, limit, downcast)
+        return super().ffill(axis=axis, inplace=inplace, limit=limit, downcast=downcast)
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def bfill(
-        self: DataFrame,
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast=...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def bfill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast=...,
+    ) -> None:
+        ...
+
+    @overload
+    def bfill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool = ...,
+        limit: None | int = ...,
+        downcast=...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "bfill" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def bfill(  # type: ignore[override]
+        self,
         axis: None | Axis = None,
         inplace: bool = False,
         limit: None | int = None,
         downcast=None,
     ) -> DataFrame | None:
-        return super().bfill(axis, inplace, limit, downcast)
+        return super().bfill(axis=axis, inplace=inplace, limit=limit, downcast=downcast)
 
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "lower", "upper"]
     )
     def clip(
         self: DataFrame,
-        lower=None,
-        upper=None,
+        lower: float | None = None,
+        upper: float | None = None,
         axis: Axis | None = None,
         inplace: bool = False,
         *args,
@@ -10917,35 +11863,137 @@ def interpolate(
             **kwargs,
         )
 
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: bool = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "where" incompatible with supertype "NDFrame"
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "cond", "other"]
     )
-    def where(
+    def where(  # type: ignore[override]
         self,
         cond,
         other=lib.no_default,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
-        return super().where(cond, other, inplace, axis, level, errors, try_cast)
+        inplace: bool = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = "raise",
+        try_cast: bool | lib.NoDefault = lib.no_default,
+    ) -> DataFrame | None:
+        return super().where(
+            cond,
+            other,
+            inplace=inplace,
+            axis=axis,
+            level=level,
+            try_cast=try_cast,
+        )
+
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> None:
+        ...
 
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: bool = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> DataFrame | None:
+        ...
+
+    # error: Signature of "mask" incompatible with supertype "NDFrame"
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "cond", "other"]
     )
-    def mask(
+    def mask(  # type: ignore[override]
         self,
         cond,
         other=np.nan,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
-        return super().mask(cond, other, inplace, axis, level, errors, try_cast)
+        inplace: bool = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = "raise",
+        try_cast: bool | lib.NoDefault = lib.no_default,
+    ) -> DataFrame | None:
+        return super().mask(
+            cond,
+            other,
+            inplace=inplace,
+            axis=axis,
+            level=level,
+            try_cast=try_cast,
+        )
 
 
 DataFrame._add_numeric_operations()
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index b92272d72b399..958bba2da54ce 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -13,9 +13,11 @@
     TYPE_CHECKING,
     Any,
     Callable,
+    ClassVar,
     Hashable,
     Literal,
     Mapping,
+    NoReturn,
     Sequence,
     Type,
     cast,
@@ -37,22 +39,33 @@
     to_offset,
 )
 from pandas._typing import (
+    AnyArrayLike,
     ArrayLike,
     Axis,
+    ColspaceArgType,
     CompressionOptions,
     Dtype,
     DtypeArg,
     DtypeObj,
     FilePath,
+    FillnaOptions,
+    FloatFormatType,
+    FormattersType,
+    Frequency,
+    IgnoreRaise,
     IndexKeyFunc,
     IndexLabel,
+    IntervalClosedType,
     JSONSerializable,
     Level,
     Manager,
+    NaPosition,
     NDFrameT,
     RandomState,
     Renamer,
+    SortKind,
     StorageOptions,
+    Suffixes,
     T,
     TimedeltaConvertibleTypes,
     TimestampConvertibleTypes,
@@ -65,8 +78,12 @@
 from pandas.errors import (
     AbstractMethodError,
     InvalidIndexError,
+    SettingWithCopyError,
+    SettingWithCopyWarning,
 )
 from pandas.util._decorators import (
+    deprecate_kwarg,
+    deprecate_nonkeyword_arguments,
     doc,
     rewrite_axis_style_signature,
 )
@@ -112,16 +129,17 @@
 )
 
 from pandas.core import (
+    algorithms as algos,
     arraylike,
+    common as com,
     indexing,
     missing,
     nanops,
+    sample,
 )
-import pandas.core.algorithms as algos
 from pandas.core.array_algos.replace import should_use_regex
 from pandas.core.arrays import ExtensionArray
 from pandas.core.base import PandasObject
-import pandas.core.common as com
 from pandas.core.construction import (
     create_series_with_explicit_dtype,
     extract_array,
@@ -146,7 +164,6 @@
 from pandas.core.missing import find_valid_index
 from pandas.core.ops import align_method_FRAME
 from pandas.core.reshape.concat import concat
-import pandas.core.sample as sample
 from pandas.core.shared_docs import _shared_docs
 from pandas.core.sorting import get_indexer_indexer
 from pandas.core.window import (
@@ -172,6 +189,9 @@
     from pandas.core.resample import Resampler
     from pandas.core.series import Series
 
+    from pandas.io.pytables import HDFStore
+
+
 # goal is to be able to define the docs close to function, while still being
 # able to share
 _shared_docs = {**_shared_docs}
@@ -241,7 +261,7 @@ def __init__(
         data: Manager,
         copy: bool_t = False,
         attrs: Mapping[Hashable, Any] | None = None,
-    ):
+    ) -> None:
         # copy kwarg is retained for mypy compat, is not used
 
         object.__setattr__(self, "_is_copy", None)
@@ -284,22 +304,6 @@ def _init_mgr(
                 mgr = mgr.astype(dtype=dtype)
         return mgr
 
-    @classmethod
-    def _from_mgr(cls, mgr: Manager):
-        """
-        Fastpath to create a new DataFrame/Series from just a BlockManager/ArrayManager.
-
-        Notes
-        -----
-        Skips setting `_flags` attribute; caller is responsible for doing so.
-        """
-        obj = cls.__new__(cls)
-        object.__setattr__(obj, "_is_copy", None)
-        object.__setattr__(obj, "_mgr", mgr)
-        object.__setattr__(obj, "_item_cache", {})
-        object.__setattr__(obj, "_attrs", {})
-        return obj
-
     def _as_manager(self: NDFrameT, typ: str, copy: bool_t = True) -> NDFrameT:
         """
         Private helper function to create a DataFrame with specific manager.
@@ -458,7 +462,7 @@ def _validate_dtype(cls, dtype) -> DtypeObj | None:
     # Construction
 
     @property
-    def _constructor(self: NDFrameT) -> type[NDFrameT]:
+    def _constructor(self: NDFrameT) -> Callable[..., NDFrameT]:
         """
         Used when a manipulation result has the same dimensions as the
         original.
@@ -702,29 +706,52 @@ def size(self) -> int:
         >>> df.size
         4
         """
-        return np.prod(self.shape)
+        # error: Incompatible return value type (got "signedinteger[_64Bit]",
+        # expected "int")  [return-value]
+        return np.prod(self.shape)  # type: ignore[return-value]
 
     @overload
     def set_axis(
-        self: NDFrameT, labels, axis: Axis = ..., inplace: Literal[False] = ...
+        self: NDFrameT,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[False] | lib.NoDefault = ...,
+        copy: bool_t | lib.NoDefault = ...,
     ) -> NDFrameT:
         ...
 
     @overload
-    def set_axis(self, labels, axis: Axis, inplace: Literal[True]) -> None:
-        ...
-
-    @overload
-    def set_axis(self, labels, *, inplace: Literal[True]) -> None:
+    def set_axis(
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[True],
+        copy: bool_t | lib.NoDefault = ...,
+    ) -> None:
         ...
 
     @overload
     def set_axis(
-        self: NDFrameT, labels, axis: Axis = ..., inplace: bool_t = ...
+        self: NDFrameT,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: bool_t | lib.NoDefault = ...,
+        copy: bool_t | lib.NoDefault = ...,
     ) -> NDFrameT | None:
         ...
 
-    def set_axis(self, labels, axis: Axis = 0, inplace: bool_t = False):
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    def set_axis(
+        self: NDFrameT,
+        labels,
+        axis: Axis = 0,
+        inplace: bool_t | lib.NoDefault = lib.no_default,
+        *,
+        copy: bool_t | lib.NoDefault = lib.no_default,
+    ) -> NDFrameT | None:
         """
         Assign desired index to given axis.
 
@@ -737,11 +764,19 @@ def set_axis(self, labels, axis: Axis = 0, inplace: bool_t = False):
             The values for the new index.
 
         axis : %(axes_single_arg)s, default 0
-            The axis to update. The value 0 identifies the rows%(axis_description_sub)s.
+            The axis to update. The value 0 identifies the rows. For `Series`
+            this parameter is unused and defaults to 0.
 
         inplace : bool, default False
             Whether to return a new %(klass)s instance.
 
+            .. deprecated:: 1.5.0
+
+        copy : bool, default True
+            Whether to make a copy of the underlying data.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         renamed : %(klass)s or None
@@ -751,26 +786,47 @@ def set_axis(self, labels, axis: Axis = 0, inplace: bool_t = False):
         --------
         %(klass)s.rename_axis : Alter the name of the index%(see_also_sub)s.
         """
+        if inplace is not lib.no_default:
+            warnings.warn(
+                f"{type(self).__name__}.set_axis 'inplace' keyword is deprecated "
+                "and will be removed in a future version. Use "
+                "`obj = obj.set_axis(..., copy=False)` instead",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+        else:
+            inplace = False
+
+        if inplace:
+            if copy is True:
+                raise ValueError("Cannot specify both inplace=True and copy=True")
+            copy = False
+        elif copy is lib.no_default:
+            copy = True
+
         self._check_inplace_and_allows_duplicate_labels(inplace)
-        return self._set_axis_nocheck(labels, axis, inplace)
+        return self._set_axis_nocheck(labels, axis, inplace, copy=copy)
 
     @final
-    def _set_axis_nocheck(self, labels, axis: Axis, inplace: bool_t):
-        # NDFrame.rename with inplace=False calls set_axis(inplace=True) on a copy.
+    def _set_axis_nocheck(self, labels, axis: Axis, inplace: bool_t, copy: bool_t):
         if inplace:
             setattr(self, self._get_axis_name(axis), labels)
         else:
-            obj = self.copy()
-            obj.set_axis(labels, axis=axis, inplace=True)
+            # With copy=False, we create a new object but don't copy the
+            #  underlying data.
+            obj = self.copy(deep=copy)
+            setattr(obj, obj._get_axis_name(axis), labels)
             return obj
 
-    def _set_axis(self, axis: int, labels: Index) -> None:
+    def _set_axis(self, axis: int, labels: AnyArrayLike | list) -> None:
         labels = ensure_index(labels)
         self._mgr.set_axis(axis, labels)
         self._clear_item_cache()
 
     @final
-    def swapaxes(self: NDFrameT, axis1, axis2, copy=True) -> NDFrameT:
+    def swapaxes(
+        self: NDFrameT, axis1: Axis, axis2: Axis, copy: bool_t = True
+    ) -> NDFrameT:
         """
         Interchange axes and swap values axes appropriately.
 
@@ -793,22 +849,14 @@ def swapaxes(self: NDFrameT, axis1, axis2, copy=True) -> NDFrameT:
         if copy:
             new_values = new_values.copy()
 
-        # ignore needed because of NDFrame constructor is different than
-        # DataFrame/Series constructors.
         return self._constructor(
-            # error: Argument 1 to "NDFrame" has incompatible type "ndarray"; expected
-            # "Union[ArrayManager, BlockManager]"
-            # error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
-            # None, None]"; expected "bool" [arg-type]
-            # error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
-            # None, None]"; expected "Optional[Mapping[Hashable, Any]]"
-            new_values,  # type: ignore[arg-type]
-            *new_axes,  # type: ignore[arg-type]
+            new_values,
+            *new_axes,
         ).__finalize__(self, method="swapaxes")
 
     @final
     @doc(klass=_shared_doc_kwargs["klass"])
-    def droplevel(self: NDFrameT, level, axis=0) -> NDFrameT:
+    def droplevel(self: NDFrameT, level: IndexLabel, axis: Axis = 0) -> NDFrameT:
         """
         Return {klass} with requested index / column level(s) removed.
 
@@ -825,6 +873,8 @@ def droplevel(self: NDFrameT, level, axis=0) -> NDFrameT:
             * 0 or 'index': remove level(s) in column.
             * 1 or 'columns': remove level(s) in row.
 
+            For `Series` this parameter is unused and defaults to 0.
+
         Returns
         -------
         {klass}
@@ -867,7 +917,7 @@ def droplevel(self: NDFrameT, level, axis=0) -> NDFrameT:
         """
         labels = self._get_axis(axis)
         new_labels = labels.droplevel(level)
-        return self.set_axis(new_labels, axis=axis, inplace=False)
+        return self.set_axis(new_labels, axis=axis)
 
     def pop(self, item: Hashable) -> Series | Any:
         result = self[item]
@@ -893,7 +943,7 @@ def squeeze(self, axis=None):
         ----------
         axis : {0 or 'index', 1 or 'columns', None}, default None
             A specific axis to squeeze. By default, all length-1 axes are
-            squeezed.
+            squeezed. For `Series` this parameter is unused and defaults to `None`.
 
         Returns
         -------
@@ -997,122 +1047,13 @@ def _rename(
         index: Renamer | None = None,
         columns: Renamer | None = None,
         axis: Axis | None = None,
-        copy: bool_t = True,
+        copy: bool_t | None = None,
         inplace: bool_t = False,
         level: Level | None = None,
         errors: str = "ignore",
     ) -> NDFrameT | None:
-        """
-        Alter axes input function or functions. Function / dict values must be
-        unique (1-to-1). Labels not contained in a dict / Series will be left
-        as-is. Extra labels listed don't throw an error. Alternatively, change
-        ``Series.name`` with a scalar value (Series only).
-
-        Parameters
-        ----------
-        %(axes)s : scalar, list-like, dict-like or function, optional
-            Scalar or list-like will alter the ``Series.name`` attribute,
-            and raise on DataFrame.
-            dict-like or functions are transformations to apply to
-            that axis' values
-        copy : bool, default True
-            Also copy underlying data.
-        inplace : bool, default False
-            Whether to return a new {klass}. If True then value of copy is
-            ignored.
-        level : int or level name, default None
-            In case of a MultiIndex, only rename labels in the specified
-            level.
-        errors : {'ignore', 'raise'}, default 'ignore'
-            If 'raise', raise a `KeyError` when a dict-like `mapper`, `index`,
-            or `columns` contains labels that are not present in the Index
-            being transformed.
-            If 'ignore', existing keys will be renamed and extra keys will be
-            ignored.
-
-        Returns
-        -------
-        renamed : {klass} (new object)
-
-        Raises
-        ------
-        KeyError
-            If any of the labels is not found in the selected axis and
-            "errors='raise'".
-
-        See Also
-        --------
-        NDFrame.rename_axis
-
-        Examples
-        --------
-        >>> s = pd.Series([1, 2, 3])
-        >>> s
-        0    1
-        1    2
-        2    3
-        dtype: int64
-        >>> s.rename("my_name") # scalar, changes Series.name
-        0    1
-        1    2
-        2    3
-        Name: my_name, dtype: int64
-        >>> s.rename(lambda x: x ** 2)  # function, changes labels
-        0    1
-        1    2
-        4    3
-        dtype: int64
-        >>> s.rename({1: 3, 2: 5})  # mapping, changes labels
-        0    1
-        3    2
-        5    3
-        dtype: int64
-
-        Since ``DataFrame`` doesn't have a ``.name`` attribute,
-        only mapping-type arguments are allowed.
+        # called by Series.rename and DataFrame.rename
 
-        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-        >>> df.rename(2)
-        Traceback (most recent call last):
-        ...
-        TypeError: 'int' object is not callable
-
-        ``DataFrame.rename`` supports two calling conventions
-
-        * ``(index=index_mapper, columns=columns_mapper, ...)``
-        * ``(mapper, axis={'index', 'columns'}, ...)``
-
-        We *highly* recommend using keyword arguments to clarify your
-        intent.
-
-        >>> df.rename(index=str, columns={"A": "a", "B": "c"})
-           a  c
-        0  1  4
-        1  2  5
-        2  3  6
-
-        >>> df.rename(index=str, columns={"A": "a", "C": "c"})
-           a  B
-        0  1  4
-        1  2  5
-        2  3  6
-
-        Using axis-style parameters
-
-        >>> df.rename(str.lower, axis='columns')
-           a  b
-        0  1  4
-        1  2  5
-        2  3  6
-
-        >>> df.rename({1: 2, 2: 4}, axis='index')
-           A  B
-        0  1  4
-        2  2  5
-        4  3  6
-
-        See the :ref:`user guide <basics.rename>` for more.
-        """
         if mapper is None and index is None and columns is None:
             raise TypeError("must pass an index to rename")
 
@@ -1161,7 +1102,7 @@ def _rename(
                     raise KeyError(f"{missing_labels} not found in axis")
 
             new_index = ax._transform_index(f, level=level)
-            result._set_axis_nocheck(new_index, axis=axis_no, inplace=True)
+            result._set_axis_nocheck(new_index, axis=axis_no, inplace=True, copy=False)
             result._clear_item_cache()
 
         if inplace:
@@ -1170,8 +1111,44 @@ def _rename(
         else:
             return result.__finalize__(self, method="rename")
 
-    @rewrite_axis_style_signature("mapper", [("copy", True), ("inplace", False)])
-    def rename_axis(self, mapper=lib.no_default, **kwargs):
+    @overload
+    def rename_axis(
+        self: NDFrameT,
+        mapper: IndexLabel | lib.NoDefault = ...,
+        *,
+        inplace: Literal[False] = ...,
+        **kwargs,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def rename_axis(
+        self,
+        mapper: IndexLabel | lib.NoDefault = ...,
+        *,
+        inplace: Literal[True],
+        **kwargs,
+    ) -> None:
+        ...
+
+    @overload
+    def rename_axis(
+        self: NDFrameT,
+        mapper: IndexLabel | lib.NoDefault = ...,
+        *,
+        inplace: bool_t = ...,
+        **kwargs,
+    ) -> NDFrameT | None:
+        ...
+
+    @rewrite_axis_style_signature("mapper", [("copy", True)])
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "mapper"])
+    def rename_axis(
+        self: NDFrameT,
+        mapper: IndexLabel | lib.NoDefault = lib.no_default,
+        inplace: bool_t = False,
+        **kwargs,
+    ) -> NDFrameT | None:
         """
         Set the name of the axis for the index or columns.
 
@@ -1190,7 +1167,7 @@ def rename_axis(self, mapper=lib.no_default, **kwargs):
             specify the axis to target with ``mapper``, or ``index``
             and/or ``columns``.
         axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis to rename.
+            The axis to rename. For `Series` this parameter is unused and defaults to 0.
         copy : bool, default True
             Also copy underlying data.
         inplace : bool, default False
@@ -1295,6 +1272,7 @@ class  name
                cat            4         0
                monkey         2         2
         """
+        kwargs["inplace"] = inplace
         axes, kwargs = self._construct_axes_from_arguments(
             (), kwargs, sentinel=lib.no_default
         )
@@ -1340,6 +1318,7 @@ class  name
                 result._set_axis_name(newnames, axis=axis, inplace=True)
             if not inplace:
                 return result
+            return None
 
     @final
     def _set_axis_name(self, name, axis=0, inplace=False):
@@ -1397,7 +1376,11 @@ def _set_axis_name(self, name, axis=0, inplace=False):
 
         inplace = validate_bool_kwarg(inplace, "inplace")
         renamed = self if inplace else self.copy()
-        renamed.set_axis(idx, axis=axis, inplace=True)
+        if axis == 0:
+            renamed.index = idx
+        else:
+            renamed.columns = idx
+
         if not inplace:
             return renamed
 
@@ -1498,31 +1481,40 @@ def equals(self, other: object) -> bool_t:
     # Unary Methods
 
     @final
-    def __neg__(self):
+    def __neg__(self: NDFrameT) -> NDFrameT:
         def blk_func(values: ArrayLike):
             if is_bool_dtype(values.dtype):
-                return operator.inv(values)
+                # error: Argument 1 to "inv" has incompatible type "Union
+                # [ExtensionArray, ndarray[Any, Any]]"; expected
+                # "_SupportsInversion[ndarray[Any, dtype[bool_]]]"
+                return operator.inv(values)  # type: ignore[arg-type]
             else:
-                return operator.neg(values)
+                # error: Argument 1 to "neg" has incompatible type "Union
+                # [ExtensionArray, ndarray[Any, Any]]"; expected
+                # "_SupportsNeg[ndarray[Any, dtype[Any]]]"
+                return operator.neg(values)  # type: ignore[arg-type]
 
         new_data = self._mgr.apply(blk_func)
         res = self._constructor(new_data)
         return res.__finalize__(self, method="__neg__")
 
     @final
-    def __pos__(self):
+    def __pos__(self: NDFrameT) -> NDFrameT:
         def blk_func(values: ArrayLike):
             if is_bool_dtype(values.dtype):
                 return values.copy()
             else:
-                return operator.pos(values)
+                # error: Argument 1 to "pos" has incompatible type "Union
+                # [ExtensionArray, ndarray[Any, Any]]"; expected
+                # "_SupportsPos[ndarray[Any, dtype[Any]]]"
+                return operator.pos(values)  # type: ignore[arg-type]
 
         new_data = self._mgr.apply(blk_func)
         res = self._constructor(new_data)
         return res.__finalize__(self, method="__pos__")
 
     @final
-    def __invert__(self):
+    def __invert__(self: NDFrameT) -> NDFrameT:
         if not self.size:
             # inv fails with 0 len
             return self
@@ -1531,7 +1523,7 @@ def __invert__(self):
         return self._constructor(new_data).__finalize__(self, method="__invert__")
 
     @final
-    def __nonzero__(self):
+    def __nonzero__(self) -> NoReturn:
         raise ValueError(
             f"The truth value of a {type(self).__name__} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
@@ -1540,7 +1532,7 @@ def __nonzero__(self):
     __bool__ = __nonzero__
 
     @final
-    def bool(self):
+    def bool(self) -> bool_t:
         """
         Return the bool of a single element Series or DataFrame.
 
@@ -1583,6 +1575,8 @@ def bool(self):
             )
 
         self.__nonzero__()
+        # for mypy (__nonzero__ raises)
+        return True
 
     @final
     def abs(self: NDFrameT) -> NDFrameT:
@@ -1661,7 +1655,7 @@ def __abs__(self: NDFrameT) -> NDFrameT:
 
     @final
     def __round__(self: NDFrameT, decimals: int = 0) -> NDFrameT:
-        return self.round(decimals)
+        return self.round(decimals).__finalize__(self, method="__round__")
 
     # -------------------------------------------------------------------------
     # Label or Level Combination Helpers
@@ -1672,7 +1666,7 @@ def __round__(self: NDFrameT, decimals: int = 0) -> NDFrameT:
     # have consistent precedence and validation logic throughout the library.
 
     @final
-    def _is_level_reference(self, key, axis=0):
+    def _is_level_reference(self, key: Level, axis=0) -> bool_t:
         """
         Test whether a key is a level reference for a given axis.
 
@@ -1684,7 +1678,7 @@ def _is_level_reference(self, key, axis=0):
 
         Parameters
         ----------
-        key : str
+        key : Hashable
             Potential level name for the given axis
         axis : int, default 0
             Axis that levels are associated with (0 for index, 1 for columns)
@@ -1703,7 +1697,7 @@ def _is_level_reference(self, key, axis=0):
         )
 
     @final
-    def _is_label_reference(self, key, axis=0) -> bool_t:
+    def _is_label_reference(self, key: Level, axis=0) -> bool_t:
         """
         Test whether a key is a label reference for a given axis.
 
@@ -1713,8 +1707,8 @@ def _is_label_reference(self, key, axis=0) -> bool_t:
 
         Parameters
         ----------
-        key : str
-            Potential label name
+        key : Hashable
+            Potential label name, i.e. Index entry.
         axis : int, default 0
             Axis perpendicular to the axis that labels are associated with
             (0 means search for column labels, 1 means search for index labels)
@@ -1733,7 +1727,7 @@ def _is_label_reference(self, key, axis=0) -> bool_t:
         )
 
     @final
-    def _is_label_or_level_reference(self, key: str, axis: int = 0) -> bool_t:
+    def _is_label_or_level_reference(self, key: Level, axis: int = 0) -> bool_t:
         """
         Test whether a key is a label or level reference for a given axis.
 
@@ -1744,7 +1738,7 @@ def _is_label_or_level_reference(self, key: str, axis: int = 0) -> bool_t:
 
         Parameters
         ----------
-        key : str
+        key : Hashable
             Potential label or level name
         axis : int, default 0
             Axis that levels are associated with (0 for index, 1 for columns)
@@ -1758,7 +1752,7 @@ def _is_label_or_level_reference(self, key: str, axis: int = 0) -> bool_t:
         )
 
     @final
-    def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:
+    def _check_label_or_level_ambiguity(self, key: Level, axis: int = 0) -> None:
         """
         Check whether `key` is ambiguous.
 
@@ -1767,7 +1761,7 @@ def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:
 
         Parameters
         ----------
-        key : str or object
+        key : Hashable
             Label or level name.
         axis : int, default 0
             Axis that levels are associated with (0 for index, 1 for columns).
@@ -1776,6 +1770,7 @@ def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:
         ------
         ValueError: `key` is ambiguous
         """
+
         axis = self._get_axis_number(axis)
         other_axes = (ax for ax in range(self._AXIS_LEN) if ax != axis)
 
@@ -1802,7 +1797,7 @@ def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:
             raise ValueError(msg)
 
     @final
-    def _get_label_or_level_values(self, key: str, axis: int = 0) -> np.ndarray:
+    def _get_label_or_level_values(self, key: Level, axis: int = 0) -> ArrayLike:
         """
         Return a 1-D array of values associated with `key`, a label or level
         from the given `axis`.
@@ -1817,14 +1812,14 @@ def _get_label_or_level_values(self, key: str, axis: int = 0) -> np.ndarray:
 
         Parameters
         ----------
-        key : str
+        key : Hashable
             Label or level name.
         axis : int, default 0
             Axis that levels are associated with (0 for index, 1 for columns)
 
         Returns
         -------
-        values : np.ndarray
+        np.ndarray or ExtensionArray
 
         Raises
         ------
@@ -1843,7 +1838,14 @@ def _get_label_or_level_values(self, key: str, axis: int = 0) -> np.ndarray:
             self._check_label_or_level_ambiguity(key, axis=axis)
             values = self.xs(key, axis=other_axes[0])._values
         elif self._is_level_reference(key, axis=axis):
-            values = self.axes[axis].get_level_values(key)._values
+            # error: Incompatible types in assignment (expression has type "Union[
+            # ExtensionArray, ndarray[Any, Any]]", variable has type "ndarray[Any,
+            # Any]")
+            values = (
+                self.axes[axis]
+                .get_level_values(key)  # type: ignore[assignment]
+                ._values
+            )
         else:
             raise KeyError(key)
 
@@ -1948,7 +1950,7 @@ def _drop_labels_or_levels(self, keys, axis: int = 0):
     # https://github.com/python/typeshed/issues/2148#issuecomment-520783318
     # Incompatible types in assignment (expression has type "None", base class
     # "object" defined the type as "Callable[[object], int]")
-    __hash__: None  # type: ignore[assignment]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
     def __iter__(self):
         """
@@ -1962,7 +1964,7 @@ def __iter__(self):
         return iter(self._info_axis)
 
     # can we get a better explanation of this?
-    def keys(self):
+    def keys(self) -> Index:
         """
         Get the 'info axis' (see Indexing for more).
 
@@ -1988,10 +1990,6 @@ def items(self):
         for h in self._info_axis:
             yield h, self[h]
 
-    @doc(items)
-    def iteritems(self):
-        return self.items()
-
     def __len__(self) -> int:
         """Returns length of info axis"""
         return len(self._info_axis)
@@ -2066,11 +2064,48 @@ def empty(self) -> bool_t:
 
     # This is also set in IndexOpsMixin
     # GH#23114 Ensure ndarray.__op__(DataFrame) returns NotImplemented
-    __array_priority__ = 1000
+    __array_priority__: int = 1000
 
     def __array__(self, dtype: npt.DTypeLike | None = None) -> np.ndarray:
         return np.asarray(self._values, dtype=dtype)
 
+    def __array_wrap__(
+        self,
+        result: np.ndarray,
+        context: tuple[Callable, tuple[Any, ...], int] | None = None,
+    ):
+        """
+        Gets called after a ufunc and other functions.
+
+        Parameters
+        ----------
+        result: np.ndarray
+            The result of the ufunc or other function called on the NumPy array
+            returned by __array__
+        context: tuple of (func, tuple, int)
+            This parameter is returned by ufuncs as a 3-element tuple: (name of the
+            ufunc, arguments of the ufunc, domain of the ufunc), but is not set by
+            other numpy functions.q
+
+        Notes
+        -----
+        Series implements __array_ufunc_ so this not called for ufunc on Series.
+        """
+        # Note: at time of dask 2022.01.0, this is still used by dask
+        warnings.warn(
+            "The __array_wrap__ method of DataFrame and Series will be removed in "
+            "a future version",
+            DeprecationWarning,
+            stacklevel=find_stack_level(),
+        )
+        res = lib.item_from_zerodim(result)
+        if is_scalar(res):
+            # e.g. we get here with np.ptp(series)
+            # ptp also requires the item_from_zerodim
+            return res
+        d = self._construct_axes_dict(self._AXIS_ORDERS, copy=False)
+        return self._constructor(res, **d).__finalize__(self, method="__array_wrap__")
+
     @final
     def __array_ufunc__(
         self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any
@@ -2093,7 +2128,7 @@ def __getstate__(self) -> dict[str, Any]:
         }
 
     @final
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         if isinstance(state, BlockManager):
             self._mgr = state
         elif isinstance(state, dict):
@@ -2126,7 +2161,7 @@ def __setstate__(self, state):
         elif len(state) == 2:
             raise NotImplementedError("Pre-0.12 pickles are no longer supported")
 
-        self._item_cache = {}
+        self._item_cache: dict[Hashable, Series] = {}
 
     # ----------------------------------------------------------------------
     # Rendering Methods
@@ -2165,25 +2200,31 @@ def _repr_data_resource_(self):
     # I/O Methods
 
     @final
-    @doc(klass="object", storage_options=_shared_docs["storage_options"])
+    @deprecate_kwarg(old_arg_name="verbose", new_arg_name=None)
+    @deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
+    @doc(
+        klass="object",
+        storage_options=_shared_docs["storage_options"],
+        storage_options_versionadded="1.2.0",
+    )
     def to_excel(
         self,
         excel_writer,
         sheet_name: str = "Sheet1",
         na_rep: str = "",
         float_format: str | None = None,
-        columns=None,
-        header=True,
-        index=True,
-        index_label=None,
-        startrow=0,
-        startcol=0,
-        engine=None,
-        merge_cells=True,
-        encoding=None,
-        inf_rep="inf",
-        verbose=True,
-        freeze_panes=None,
+        columns: Sequence[Hashable] | None = None,
+        header: Sequence[Hashable] | bool_t = True,
+        index: bool_t = True,
+        index_label: IndexLabel = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        engine: str | None = None,
+        merge_cells: bool_t = True,
+        encoding: lib.NoDefault = lib.no_default,
+        inf_rep: str = "inf",
+        verbose: lib.NoDefault = lib.no_default,
+        freeze_panes: tuple[int, int] | None = None,
         storage_options: StorageOptions = None,
     ) -> None:
         """
@@ -2241,17 +2282,27 @@ def to_excel(
         encoding : str, optional
             Encoding of the resulting excel file. Only necessary for xlwt,
             other writers support unicode natively.
+
+            .. deprecated:: 1.5.0
+
+                This keyword was not used.
+
         inf_rep : str, default 'inf'
             Representation for infinity (there is no native representation for
             infinity in Excel).
         verbose : bool, default True
             Display more information in the error logs.
+
+            .. deprecated:: 1.5.0
+
+                This keyword was not used.
+
         freeze_panes : tuple of int (length 2), optional
             Specifies the one-based bottommost row and rightmost column that
             is to be frozen.
         {storage_options}
 
-            .. versionadded:: 1.2.0
+            .. versionadded:: {storage_options_versionadded}
 
         See Also
         --------
@@ -2259,6 +2310,7 @@ def to_excel(
         ExcelWriter : Class for writing DataFrame objects into excel sheets.
         read_excel : Read an Excel file into a pandas DataFrame.
         read_csv : Read a comma-separated values (csv) file into DataFrame.
+        io.formats.style.Styler.to_excel : Add styles to Excel sheet.
 
         Notes
         -----
@@ -2614,7 +2666,7 @@ def to_json(
     @final
     def to_hdf(
         self,
-        path_or_buf,
+        path_or_buf: FilePath | HDFStore,
         key: str,
         mode: str = "a",
         complevel: int | None = None,
@@ -2684,25 +2736,32 @@ def to_hdf(
               like searching / selecting subsets of the data.
             - If None, pd.get_option('io.hdf.default_format') is checked,
               followed by fallback to "fixed".
-        errors : str, default 'strict'
-            Specifies how encoding and decoding errors are to be handled.
-            See the errors argument for :func:`open` for a full list
-            of options.
-        encoding : str, default "UTF-8"
+        index : bool, default True
+            Write DataFrame index as a column.
         min_itemsize : dict or int, optional
             Map column names to minimum string sizes for columns.
         nan_rep : Any, optional
             How to represent null values as str.
             Not allowed with append=True.
+        dropna : bool, default False, optional
+            Remove missing values.
         data_columns : list of columns or True, optional
             List of columns to create as indexed data columns for on-disk
             queries, or True to use all columns. By default only the axes
-            of the object are indexed. See :ref:`io.hdf5-query-data-columns`.
+            of the object are indexed. See
+            :ref:`Query via data columns<io.hdf5-query-data-columns>`. for
+            more information.
             Applicable only to format='table'.
+        errors : str, default 'strict'
+            Specifies how encoding and decoding errors are to be handled.
+            See the errors argument for :func:`open` for a full list
+            of options.
+        encoding : str, default "UTF-8"
 
         See Also
         --------
         read_hdf : Read from HDF file.
+        DataFrame.to_orc : Write a DataFrame to the binary orc format.
         DataFrame.to_parquet : Write a DataFrame to the binary parquet format.
         DataFrame.to_sql : Write to a SQL table.
         DataFrame.to_feather : Write out feather-format for DataFrames.
@@ -2760,13 +2819,13 @@ def to_sql(
         self,
         name: str,
         con,
-        schema=None,
+        schema: str | None = None,
         if_exists: str = "fail",
         index: bool_t = True,
-        index_label=None,
-        chunksize=None,
+        index_label: IndexLabel = None,
+        chunksize: int | None = None,
         dtype: DtypeArg | None = None,
-        method=None,
+        method: str | None = None,
     ) -> int | None:
         """
         Write records stored in a DataFrame to a SQL database.
@@ -2824,7 +2883,7 @@ def to_sql(
         -------
         None or int
             Number of rows affected by to_sql. None is returned if the callable
-            passed into ``method`` does not return the number of rows.
+            passed into ``method`` does not return an integer number of rows.
 
             The number of returned rows affected is the sum of the ``rowcount``
             attribute of ``sqlite3.Cursor`` or SQLAlchemy connectable which may not
@@ -2945,7 +3004,7 @@ def to_sql(
     )
     def to_pickle(
         self,
-        path,
+        path: FilePath | WriteBuffer[bytes],
         compression: CompressionOptions = "infer",
         protocol: int = pickle.HIGHEST_PROTOCOL,
         storage_options: StorageOptions = None,
@@ -2955,8 +3014,10 @@ def to_pickle(
 
         Parameters
         ----------
-        path : str
-            File path where the pickled object will be stored.
+        path : str, path object, or file-like object
+            String, path object (implementing ``os.PathLike[str]``), or file-like
+            object implementing a binary ``write()`` function. File path where
+            the pickled object will be stored.
         {compression_options}
         protocol : int
             Int which indicates which protocol should be used by the pickler,
@@ -3045,6 +3106,9 @@ def to_clipboard(
           - Windows : none
           - macOS : none
 
+        This method uses the processes developed for the package `pyperclip`. A
+        solution to render any output string format is given in the examples.
+
         Examples
         --------
         Copy the contents of a DataFrame to the clipboard.
@@ -3065,6 +3129,14 @@ def to_clipboard(
         ... # A,B,C
         ... # 1,2,3
         ... # 4,5,6
+
+        Using the original `pyperclip` package for any string output format.
+
+        .. code-block:: python
+
+           import pyperclip
+           html = df.style.to_html()
+           pyperclip.copy(html)
         """
         from pandas.io import clipboards
 
@@ -3140,7 +3212,7 @@ class      (index) object 'bird' 'bird' 'mammal' 'mammal'
 
         >>> df_multiindex.to_xarray()
         <xarray.Dataset>
-        Dimensions:  (animal: 2, date: 2)
+        Dimensions:  (date: 2, animal: 2)
         Coordinates:
           * date     (date) datetime64[ns] 2018-01-01 2018-01-02
           * animal   (animal) object 'falcon' 'parrot'
@@ -3154,35 +3226,91 @@ class      (index) object 'bird' 'bird' 'mammal' 'mammal'
         else:
             return xarray.Dataset.from_dataframe(self)
 
+    @overload
+    def to_latex(
+        self,
+        buf: None = ...,
+        columns: Sequence[Hashable] | None = ...,
+        col_space: ColspaceArgType | None = ...,
+        header: bool_t | Sequence[str] = ...,
+        index: bool_t = ...,
+        na_rep: str = ...,
+        formatters: FormattersType | None = ...,
+        float_format: FloatFormatType | None = ...,
+        sparsify: bool_t | None = ...,
+        index_names: bool_t = ...,
+        bold_rows: bool_t = ...,
+        column_format: str | None = ...,
+        longtable: bool_t | None = ...,
+        escape: bool_t | None = ...,
+        encoding: str | None = ...,
+        decimal: str = ...,
+        multicolumn: bool_t | None = ...,
+        multicolumn_format: str | None = ...,
+        multirow: bool_t | None = ...,
+        caption: str | tuple[str, str] | None = ...,
+        label: str | None = ...,
+        position: str | None = ...,
+    ) -> str:
+        ...
+
+    @overload
+    def to_latex(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        columns: Sequence[Hashable] | None = ...,
+        col_space: ColspaceArgType | None = ...,
+        header: bool_t | Sequence[str] = ...,
+        index: bool_t = ...,
+        na_rep: str = ...,
+        formatters: FormattersType | None = ...,
+        float_format: FloatFormatType | None = ...,
+        sparsify: bool_t | None = ...,
+        index_names: bool_t = ...,
+        bold_rows: bool_t = ...,
+        column_format: str | None = ...,
+        longtable: bool_t | None = ...,
+        escape: bool_t | None = ...,
+        encoding: str | None = ...,
+        decimal: str = ...,
+        multicolumn: bool_t | None = ...,
+        multicolumn_format: str | None = ...,
+        multirow: bool_t | None = ...,
+        caption: str | tuple[str, str] | None = ...,
+        label: str | None = ...,
+        position: str | None = ...,
+    ) -> None:
+        ...
+
     @final
     @doc(returns=fmt.return_docstring)
     def to_latex(
         self,
-        buf=None,
-        columns=None,
-        col_space=None,
-        header=True,
-        index=True,
-        na_rep="NaN",
-        formatters=None,
-        float_format=None,
-        sparsify=None,
-        index_names=True,
-        bold_rows=False,
-        column_format=None,
-        longtable=None,
-        escape=None,
-        encoding=None,
-        decimal=".",
-        multicolumn=None,
-        multicolumn_format=None,
-        multirow=None,
-        caption=None,
-        label=None,
-        position=None,
-    ):
+        buf: FilePath | WriteBuffer[str] | None = None,
+        columns: Sequence[Hashable] | None = None,
+        col_space: ColspaceArgType | None = None,
+        header: bool_t | Sequence[str] = True,
+        index: bool_t = True,
+        na_rep: str = "NaN",
+        formatters: FormattersType | None = None,
+        float_format: FloatFormatType | None = None,
+        sparsify: bool_t | None = None,
+        index_names: bool_t = True,
+        bold_rows: bool_t = False,
+        column_format: str | None = None,
+        longtable: bool_t | None = None,
+        escape: bool_t | None = None,
+        encoding: str | None = None,
+        decimal: str = ".",
+        multicolumn: bool_t | None = None,
+        multicolumn_format: str | None = None,
+        multirow: bool_t | None = None,
+        caption: str | tuple[str, str] | None = None,
+        label: str | None = None,
+        position: str | None = None,
+    ) -> str | None:
         r"""
-        Render object to a LaTeX tabular, longtable, or nested table/tabular.
+        Render object to a LaTeX tabular, longtable, or nested table.
 
         Requires ``\usepackage{{booktabs}}``.  The output can be copy/pasted
         into a main LaTeX document or read from an external file
@@ -3278,7 +3406,8 @@ def to_latex(
         {returns}
         See Also
         --------
-        Styler.to_latex : Render a DataFrame to LaTeX with conditional formatting.
+        io.formats.style.Styler.to_latex : Render a DataFrame to LaTeX
+            with conditional formatting.
         DataFrame.to_string : Render a DataFrame to a console-friendly
             tabular output.
         DataFrame.to_html : Render a DataFrame as an HTML table.
@@ -3350,17 +3479,72 @@ def to_latex(
             position=position,
         )
 
+    @overload
+    def to_csv(
+        self,
+        path_or_buf: None = ...,
+        sep: str = ...,
+        na_rep: str = ...,
+        float_format: str | Callable | None = ...,
+        columns: Sequence[Hashable] | None = ...,
+        header: bool_t | list[str] = ...,
+        index: bool_t = ...,
+        index_label: IndexLabel | None = ...,
+        mode: str = ...,
+        encoding: str | None = ...,
+        compression: CompressionOptions = ...,
+        quoting: int | None = ...,
+        quotechar: str = ...,
+        lineterminator: str | None = ...,
+        chunksize: int | None = ...,
+        date_format: str | None = ...,
+        doublequote: bool_t = ...,
+        escapechar: str | None = ...,
+        decimal: str = ...,
+        errors: str = ...,
+        storage_options: StorageOptions = ...,
+    ) -> str:
+        ...
+
+    @overload
+    def to_csv(
+        self,
+        path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str],
+        sep: str = ...,
+        na_rep: str = ...,
+        float_format: str | Callable | None = ...,
+        columns: Sequence[Hashable] | None = ...,
+        header: bool_t | list[str] = ...,
+        index: bool_t = ...,
+        index_label: IndexLabel | None = ...,
+        mode: str = ...,
+        encoding: str | None = ...,
+        compression: CompressionOptions = ...,
+        quoting: int | None = ...,
+        quotechar: str = ...,
+        lineterminator: str | None = ...,
+        chunksize: int | None = ...,
+        date_format: str | None = ...,
+        doublequote: bool_t = ...,
+        escapechar: str | None = ...,
+        decimal: str = ...,
+        errors: str = ...,
+        storage_options: StorageOptions = ...,
+    ) -> None:
+        ...
+
     @final
     @doc(
         storage_options=_shared_docs["storage_options"],
-        compression_options=_shared_docs["compression_options"],
+        compression_options=_shared_docs["compression_options"] % "path_or_buf",
     )
+    @deprecate_kwarg(old_arg_name="line_terminator", new_arg_name="lineterminator")
     def to_csv(
         self,
         path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None = None,
         sep: str = ",",
         na_rep: str = "",
-        float_format: str | None = None,
+        float_format: str | Callable | None = None,
         columns: Sequence[Hashable] | None = None,
         header: bool_t | list[str] = True,
         index: bool_t = True,
@@ -3370,7 +3554,7 @@ def to_csv(
         compression: CompressionOptions = "infer",
         quoting: int | None = None,
         quotechar: str = '"',
-        line_terminator: str | None = None,
+        lineterminator: str | None = None,
         chunksize: int | None = None,
         date_format: str | None = None,
         doublequote: bool_t = True,
@@ -3399,8 +3583,9 @@ def to_csv(
             String of length 1. Field delimiter for the output file.
         na_rep : str, default ''
             Missing data representation.
-        float_format : str, default None
-            Format string for floating point numbers.
+        float_format : str, Callable, default None
+            Format string for floating point numbers. If a Callable is given, it takes
+            precedence over other numeric formatting parameters, like decimal.
         columns : sequence, optional
             Columns to write.
         header : bool or list of str, default True
@@ -3414,8 +3599,9 @@ def to_csv(
             sequence should be given if the object uses MultiIndex. If
             False do not print fields for index names. Use index_label=False
             for easier importing in R.
-        mode : str
-            Python write mode, default 'w'.
+        mode : str, default 'w'
+            Python write mode. The available write modes are the same as
+            :py:func:`open`.
         encoding : str, optional
             A string representing the encoding to use in the output file,
             defaults to 'utf-8'. `encoding` is not supported if `path_or_buf`
@@ -3449,10 +3635,16 @@ def to_csv(
             will treat them as non-numeric.
         quotechar : str, default '\"'
             String of length 1. Character used to quote fields.
-        line_terminator : str, optional
+        lineterminator : str, optional
             The newline character or character sequence to use in the output
             file. Defaults to `os.linesep`, which depends on the OS in which
             this method is called ('\\n' for linux, '\\r\\n' for Windows, i.e.).
+
+            .. versionchanged:: 1.5.0
+
+                Previously was line_terminator, changed for consistency with
+                read_csv and the standard library 'csv' module.
+
         chunksize : int or None
             Rows to write at a time.
         date_format : str, default None
@@ -3527,7 +3719,7 @@ def to_csv(
 
         return DataFrameRenderer(formatter).to_csv(
             path_or_buf,
-            line_terminator=line_terminator,
+            lineterminator=lineterminator,
             sep=sep,
             encoding=encoding,
             errors=errors,
@@ -3600,6 +3792,7 @@ def take(
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             The axis on which to select elements. ``0`` means that we are
             selecting rows, ``1`` means that we are selecting columns.
+            For `Series` this parameter is unused and defaults to 0.
         is_copy : bool
             Before pandas 1.0, ``is_copy=False`` can be specified to ensure
             that the return value is an actual copy. Starting with pandas 1.0,
@@ -3675,10 +3868,26 @@ class  max_speed
 
         nv.validate_take((), kwargs)
 
+        return self._take(indices, axis)
+
+    def _take(
+        self: NDFrameT,
+        indices,
+        axis=0,
+        convert_indices: bool_t = True,
+    ) -> NDFrameT:
+        """
+        Internal version of the `take` allowing specification of additional args.
+
+        See the docstring of `take` for full explanation of the parameters.
+        """
         self._consolidate_inplace()
 
         new_data = self._mgr.take(
-            indices, axis=self._get_block_manager_axis(axis), verify=True
+            indices,
+            axis=self._get_block_manager_axis(axis),
+            verify=True,
+            convert_indices=convert_indices,
         )
         return self._constructor(new_data).__finalize__(self, method="take")
 
@@ -3690,14 +3899,20 @@ def _take_with_is_copy(self: NDFrameT, indices, axis=0) -> NDFrameT:
 
         See the docstring of `take` for full explanation of the parameters.
         """
-        result = self.take(indices=indices, axis=axis)
+        result = self._take(indices=indices, axis=axis)
         # Maybe set copy if we didn't actually change the index.
         if not result._get_axis(axis).equals(self._get_axis(axis)):
             result._set_is_copy(self)
         return result
 
     @final
-    def xs(self, key, axis=0, level=None, drop_level: bool_t = True):
+    def xs(
+        self: NDFrameT,
+        key: IndexLabel,
+        axis: Axis = 0,
+        level: IndexLabel = None,
+        drop_level: bool_t = True,
+    ) -> NDFrameT:
         """
         Return cross-section from the Series/DataFrame.
 
@@ -3858,14 +4073,11 @@ class   animal   locomotion
                 # so just return them (GH 6394)
                 return self._values[loc]
 
-            new_values = self._mgr.fast_xs(loc)
+            new_mgr = self._mgr.fast_xs(loc)
 
             result = self._constructor_sliced(
-                new_values,
-                index=self.columns,
-                name=self.index[loc],
-                dtype=new_values.dtype,
-            )
+                new_mgr, name=self.index[loc]
+            ).__finalize__(self)
         elif is_scalar(loc):
             result = self.iloc[:, slice(loc, loc + 1)]
         elif axis == 1:
@@ -3948,6 +4160,12 @@ def _check_setitem_copy(self, t="setting", force=False):
         df.iloc[0:5]['group'] = 'a'
 
         """
+        if (
+            config.get_option("mode.copy_on_write")
+            and config.get_option("mode.data_manager") == "block"
+        ):
+            return
+
         # return early if the check is not needed
         if not (force or self._is_copy):
             return
@@ -3990,9 +4208,9 @@ def _check_setitem_copy(self, t="setting", force=False):
             )
 
         if value == "raise":
-            raise com.SettingWithCopyError(t)
+            raise SettingWithCopyError(t)
         elif value == "warn":
-            warnings.warn(t, com.SettingWithCopyWarning, stacklevel=find_stack_level())
+            warnings.warn(t, SettingWithCopyWarning, stacklevel=find_stack_level())
 
     def __delitem__(self, key) -> None:
         """
@@ -4212,16 +4430,59 @@ def reindex_like(
 
         return self.reindex(**d)
 
+    @overload
     def drop(
         self,
-        labels=None,
-        axis=0,
-        index=None,
-        columns=None,
-        level=None,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: Literal[True],
+        errors: IgnoreRaise = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def drop(
+        self: NDFrameT,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: Literal[False] = ...,
+        errors: IgnoreRaise = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def drop(
+        self: NDFrameT,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: bool_t = ...,
+        errors: IgnoreRaise = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    def drop(
+        self: NDFrameT,
+        labels: IndexLabel = None,
+        axis: Axis = 0,
+        index: IndexLabel = None,
+        columns: IndexLabel = None,
+        level: Level | None = None,
         inplace: bool_t = False,
-        errors: str = "raise",
-    ):
+        errors: IgnoreRaise = "raise",
+    ) -> NDFrameT | None:
 
         inplace = validate_bool_kwarg(inplace, "inplace")
 
@@ -4254,8 +4515,7 @@ def _drop_axis(
         labels,
         axis,
         level=None,
-        errors: str = "raise",
-        consolidate: bool_t = True,
+        errors: IgnoreRaise = "raise",
         only_slice: bool_t = False,
     ) -> NDFrameT:
         """
@@ -4270,8 +4530,6 @@ def _drop_axis(
             For MultiIndex
         errors : {'ignore', 'raise'}, default 'raise'
             If 'ignore', suppress error and existing labels are dropped.
-        consolidate : bool, default True
-            Whether to call consolidate_inplace in the reindex_indexer call.
         only_slice : bool, default False
             Whether indexing along columns should be view-only.
 
@@ -4316,6 +4574,10 @@ def _drop_axis(
                 if errors == "raise" and labels_missing:
                     raise KeyError(f"{labels} not found in axis")
 
+            if is_extension_array_dtype(mask.dtype):
+                # GH#45860
+                mask = mask.to_numpy(dtype=bool)
+
             indexer = mask.nonzero()[0]
             new_axis = axis.take(indexer)
 
@@ -4325,7 +4587,6 @@ def _drop_axis(
             indexer,
             axis=bm_axis,
             allow_dups=True,
-            consolidate=consolidate,
             only_slice=only_slice,
         )
         result = self._constructor(new_mgr)
@@ -4350,7 +4611,7 @@ def _update_inplace(self, result, verify_is_copy: bool_t = True) -> None:
         self._reset_cache()
         self._clear_item_cache()
         self._mgr = result._mgr
-        self._maybe_update_cacher(verify_is_copy=verify_is_copy)
+        self._maybe_update_cacher(verify_is_copy=verify_is_copy, inplace=True)
 
     @final
     def add_prefix(self: NDFrameT, prefix: str) -> NDFrameT:
@@ -4480,16 +4741,59 @@ def add_suffix(self: NDFrameT, suffix: str) -> NDFrameT:
         # "**Dict[str, partial[str]]"; expected "Union[str, int, None]"
         return self._rename(**mapper)  # type: ignore[return-value, arg-type]
 
+    @overload
+    def sort_values(
+        self: NDFrameT,
+        *,
+        axis: Axis = ...,
+        ascending=...,
+        inplace: Literal[False] = ...,
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool_t = ...,
+        key: ValueKeyFunc = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
     def sort_values(
         self,
-        axis=0,
+        *,
+        axis: Axis = ...,
+        ascending=...,
+        inplace: Literal[True],
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool_t = ...,
+        key: ValueKeyFunc = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def sort_values(
+        self: NDFrameT,
+        *,
+        axis: Axis = ...,
+        ascending=...,
+        inplace: bool_t = ...,
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool_t = ...,
+        key: ValueKeyFunc = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def sort_values(
+        self: NDFrameT,
+        axis: Axis = 0,
         ascending=True,
         inplace: bool_t = False,
         kind: str = "quicksort",
         na_position: str = "last",
         ignore_index: bool_t = False,
         key: ValueKeyFunc = None,
-    ):
+    ) -> NDFrameT | None:
         """
         Sort by the values along either axis.
 
@@ -4636,18 +4940,66 @@ def sort_values(
         """
         raise AbstractMethodError(self)
 
+    @overload
     def sort_index(
         self,
-        axis=0,
-        level=None,
-        ascending: bool_t | int | Sequence[bool_t | int] = True,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool_t | Sequence[bool_t] = ...,
+        inplace: Literal[True],
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool_t = ...,
+        ignore_index: bool_t = ...,
+        key: IndexKeyFunc = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def sort_index(
+        self: NDFrameT,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool_t | Sequence[bool_t] = ...,
+        inplace: Literal[False] = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool_t = ...,
+        ignore_index: bool_t = ...,
+        key: IndexKeyFunc = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def sort_index(
+        self: NDFrameT,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool_t | Sequence[bool_t] = ...,
+        inplace: bool_t = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool_t = ...,
+        ignore_index: bool_t = ...,
+        key: IndexKeyFunc = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    def sort_index(
+        self: NDFrameT,
+        axis: Axis = 0,
+        level: IndexLabel = None,
+        ascending: bool_t | Sequence[bool_t] = True,
         inplace: bool_t = False,
-        kind: str = "quicksort",
-        na_position: str = "last",
+        kind: SortKind = "quicksort",
+        na_position: NaPosition = "last",
         sort_remaining: bool_t = True,
         ignore_index: bool_t = False,
         key: IndexKeyFunc = None,
-    ):
+    ) -> NDFrameT | None:
 
         inplace = validate_bool_kwarg(inplace, "inplace")
         axis = self._get_axis_number(axis)
@@ -4668,7 +5020,7 @@ def sort_index(
             if ignore_index:
                 result.index = default_index(len(self))
             if inplace:
-                return
+                return None
             else:
                 return result
 
@@ -4902,7 +5254,7 @@ def reindex(self: NDFrameT, *args, **kwargs) -> NDFrameT:
         axes, kwargs = self._construct_axes_from_arguments(args, kwargs)
         method = missing.clean_reindex_fill_method(kwargs.pop("method", None))
         level = kwargs.pop("level", None)
-        copy = kwargs.pop("copy", True)
+        copy = kwargs.pop("copy", None)
         limit = kwargs.pop("limit", None)
         tolerance = kwargs.pop("tolerance", None)
         fill_value = kwargs.pop("fill_value", None)
@@ -4927,9 +5279,7 @@ def reindex(self: NDFrameT, *args, **kwargs) -> NDFrameT:
             for axis, ax in axes.items()
             if ax is not None
         ):
-            if copy:
-                return self.copy()
-            return self
+            return self.copy(deep=copy)
 
         # check if we are a multi reindex
         if self._needs_reindex_multi(axes, method, level):
@@ -5041,8 +5391,8 @@ def filter(
             Keep labels from axis for which re.search(regex, label) == True.
         axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
             The axis to filter on, expressed either as an index (int)
-            or axis name (str). By default this is the info axis,
-            'index' for Series, 'columns' for DataFrame.
+            or axis name (str). By default this is the info axis, 'columns' for
+            DataFrame. For `Series` this parameter is unused and defaults to `None`.
 
         Returns
         -------
@@ -5131,7 +5481,9 @@ def head(self: NDFrameT, n: int = 5) -> NDFrameT:
         has the right type of data in it.
 
         For negative values of `n`, this function returns all rows except
-        the last `n` rows, equivalent to ``df[:-n]``.
+        the last `|n|` rows, equivalent to ``df[:n]``.
+
+        If n is larger than the number of rows, this function returns all rows.
 
         Parameters
         ----------
@@ -5204,7 +5556,9 @@ def tail(self: NDFrameT, n: int = 5) -> NDFrameT:
         after sorting or appending rows.
 
         For negative values of `n`, this function returns all rows except
-        the first `n` rows, equivalent to ``df[n:]``.
+        the first `|n|` rows, equivalent to ``df[|n|:]``.
+
+        If n is larger than the number of rows, this function returns all rows.
 
         Parameters
         ----------
@@ -5322,7 +5676,7 @@ def sample(
 
         axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
             Axis to sample. Accepts axis number or name. Default is stat axis
-            for given data type (0 for Series and DataFrames).
+            for given data type. For `Series` this parameter is unused and defaults to `None`.
         ignore_index : bool, default False
             If True, the resulting index will be labeled 0, 1, …, n - 1.
 
@@ -5433,7 +5787,7 @@ def pipe(
         **kwargs,
     ) -> T:
         r"""
-        Apply func(self, \*args, \*\*kwargs).
+        Apply chainable functions that expect Series or DataFrames.
 
         Parameters
         ----------
@@ -5669,7 +6023,7 @@ def _check_inplace_setting(self, value) -> bool_t:
         return True
 
     @final
-    def _get_numeric_data(self):
+    def _get_numeric_data(self: NDFrameT) -> NDFrameT:
         return self._constructor(self._mgr.get_numeric_data()).__finalize__(self)
 
     @final
@@ -5680,7 +6034,7 @@ def _get_bool_data(self):
     # Internal Interface Methods
 
     @property
-    def values(self) -> np.ndarray:
+    def values(self):
         raise AbstractMethodError(self)
 
     @property
@@ -5720,7 +6074,7 @@ def dtypes(self):
         return self._constructor_sliced(data, index=self._info_axis, dtype=np.object_)
 
     def astype(
-        self: NDFrameT, dtype, copy: bool_t = True, errors: str = "raise"
+        self: NDFrameT, dtype, copy: bool_t = True, errors: IgnoreRaise = "raise"
     ) -> NDFrameT:
         """
         Cast a pandas object to a specified dtype ``dtype``.
@@ -5847,7 +6201,13 @@ def astype(
                 new_type = dtype[self.name]
                 return self.astype(new_type, copy, errors)
 
-            for col_name in dtype.keys():
+            # GH#44417 cast to Series so we can use .iat below, which will be
+            #  robust in case we
+            from pandas import Series
+
+            dtype_ser = Series(dtype, dtype=object)
+
+            for col_name in dtype_ser.index:
                 if col_name not in self:
                     raise KeyError(
                         "Only a column name can be used for the "
@@ -5855,11 +6215,6 @@ def astype(
                         f"'{col_name}' not found in columns."
                     )
 
-            # GH#44417 cast to Series so we can use .iat below, which will be
-            #  robust in case we
-            from pandas import Series
-
-            dtype_ser = Series(dtype, dtype=object)
             dtype_ser = dtype_ser.reindex(self.columns, fill_value=None, copy=False)
 
             results = []
@@ -5891,13 +6246,17 @@ def astype(
 
         # GH 19920: retain column metadata after concat
         result = concat(results, axis=1, copy=False)
+        # GH#40810 retain subclass
+        # error: Incompatible types in assignment
+        # (expression has type "NDFrameT", variable has type "DataFrame")
+        result = self._constructor(result)  # type: ignore[assignment]
         result.columns = self.columns
         result = result.__finalize__(self, method="astype")
         # https://github.com/python/mypy/issues/8354
         return cast(NDFrameT, result)
 
     @final
-    def copy(self: NDFrameT, deep: bool_t = True) -> NDFrameT:
+    def copy(self: NDFrameT, deep: bool_t | None = True) -> NDFrameT:
         """
         Make a copy of this object's indices and data.
 
@@ -5934,6 +6293,10 @@ def copy(self: NDFrameT, deep: bool_t = True) -> NDFrameT:
         immutable, the underlying data can be safely shared and a copy
         is not needed.
 
+        Since pandas is not thread safe, see the
+        :ref:`gotchas <gotchas.thread-safety>` when copying in a threading
+        environment.
+
         Examples
         --------
         >>> s = pd.Series([1, 2], index=["a", "b"])
@@ -6266,18 +6629,57 @@ def convert_dtypes(
             else:
                 return self.copy()
 
-    # ----------------------------------------------------------------------
-    # Filling NA's
+    # ----------------------------------------------------------------------
+    # Filling NA's
+
+    @overload
+    def fillna(
+        self: NDFrameT,
+        value: Hashable | Mapping | Series | DataFrame = ...,
+        *,
+        method: FillnaOptions | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Hashable | Mapping | Series | DataFrame = ...,
+        *,
+        method: FillnaOptions | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[True],
+        limit: int | None = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: NDFrameT,
+        value: Hashable | Mapping | Series | DataFrame = ...,
+        *,
+        method: FillnaOptions | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool_t = ...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT | None:
+        ...
 
     @doc(**_shared_doc_kwargs)
     def fillna(
         self: NDFrameT,
-        value=None,
-        method=None,
-        axis=None,
+        value: Hashable | Mapping | Series | DataFrame = None,
+        method: FillnaOptions | None = None,
+        axis: Axis | None = None,
         inplace: bool_t = False,
-        limit=None,
-        downcast=None,
+        limit: int | None = None,
+        downcast: dict | None = None,
     ) -> NDFrameT | None:
         """
         Fill NA/NaN values using the specified method.
@@ -6295,7 +6697,8 @@ def fillna(
             pad / ffill: propagate last valid observation forward to next valid
             backfill / bfill: use next valid observation to fill gap.
         axis : {axes_single_arg}
-            Axis along which to fill missing values.
+            Axis along which to fill missing values. For `Series`
+            this parameter is unused and defaults to 0.
         inplace : bool, default False
             If True, fill in-place. Note: this will modify any
             other views on this object (e.g., a no-copy slice for a column in a
@@ -6412,7 +6815,6 @@ def fillna(
                 axis=axis,
                 limit=limit,
                 inplace=inplace,
-                coerce=True,
                 downcast=downcast,
             )
         else:
@@ -6454,16 +6856,67 @@ def fillna(
                 for k, v in value.items():
                     if k not in result:
                         continue
-                    downcast_k = downcast if not is_dict else downcast.get(k)
-                    result[k] = result[k].fillna(v, limit=limit, downcast=downcast_k)
+
+                    # error: Item "None" of "Optional[Dict[Any, Any]]" has no
+                    # attribute "get"
+                    downcast_k = (
+                        downcast
+                        if not is_dict
+                        else downcast.get(k)  # type: ignore[union-attr]
+                    )
+
+                    res_k = result[k].fillna(v, limit=limit, downcast=downcast_k)
+
+                    if not inplace:
+                        result[k] = res_k
+                    else:
+                        # We can write into our existing column(s) iff dtype
+                        #  was preserved.
+                        if isinstance(res_k, ABCSeries):
+                            # i.e. 'k' only shows up once in self.columns
+                            if res_k.dtype == result[k].dtype:
+                                result.loc[:, k] = res_k
+                            else:
+                                # Different dtype -> no way to do inplace.
+                                result[k] = res_k
+                        else:
+                            # see test_fillna_dict_inplace_nonunique_columns
+                            locs = result.columns.get_loc(k)
+                            if isinstance(locs, slice):
+                                locs = np.arange(self.shape[1])[locs]
+                            elif (
+                                isinstance(locs, np.ndarray) and locs.dtype.kind == "b"
+                            ):
+                                locs = locs.nonzero()[0]
+                            elif not (
+                                isinstance(locs, np.ndarray) and locs.dtype.kind == "i"
+                            ):
+                                # Should never be reached, but let's cover our bases
+                                raise NotImplementedError(
+                                    "Unexpected get_loc result, please report a bug at "
+                                    "https://github.com/pandas-dev/pandas"
+                                )
+
+                            for i, loc in enumerate(locs):
+                                res_loc = res_k.iloc[:, i]
+                                target = self.iloc[:, loc]
+
+                                if res_loc.dtype == target.dtype:
+                                    result.iloc[:, loc] = res_loc
+                                else:
+                                    result.isetitem(loc, res_loc)
+
                 return result if not inplace else None
 
             elif not is_list_like(value):
-                if not self._mgr.is_single_block and axis == 1:
+                if axis == 1:
 
                     result = self.T.fillna(value=value, limit=limit).T
 
-                    new_data = result
+                    # error: Incompatible types in assignment (expression has type
+                    # "NDFrameT", variable has type "Union[ArrayManager,
+                    # SingleArrayManager, BlockManager, SingleBlockManager]")
+                    new_data = result  # type: ignore[assignment]
                 else:
 
                     new_data = self._mgr.fillna(
@@ -6481,13 +6934,47 @@ def fillna(
         else:
             return result.__finalize__(self, method="fillna")
 
+    @overload
+    def ffill(
+        self: NDFrameT,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def ffill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def ffill(
+        self: NDFrameT,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool_t = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     @doc(klass=_shared_doc_kwargs["klass"])
     def ffill(
         self: NDFrameT,
         axis: None | Axis = None,
         inplace: bool_t = False,
         limit: None | int = None,
-        downcast=None,
+        downcast: dict | None = None,
     ) -> NDFrameT | None:
         """
         Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
@@ -6503,13 +6990,47 @@ def ffill(
 
     pad = ffill
 
+    @overload
+    def bfill(
+        self: NDFrameT,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def bfill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def bfill(
+        self: NDFrameT,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool_t = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
     @doc(klass=_shared_doc_kwargs["klass"])
     def bfill(
         self: NDFrameT,
         axis: None | Axis = None,
         inplace: bool_t = False,
         limit: None | int = None,
-        downcast=None,
+        downcast: dict | None = None,
     ) -> NDFrameT | None:
         """
         Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
@@ -6525,6 +7046,48 @@ def bfill(
 
     backfill = bfill
 
+    @overload
+    def replace(
+        self: NDFrameT,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        regex: bool_t = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def replace(
+        self,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[True],
+        limit: int | None = ...,
+        regex: bool_t = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def replace(
+        self: NDFrameT,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: bool_t = ...,
+        limit: int | None = ...,
+        regex: bool_t = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "to_replace", "value"]
+    )
     @doc(
         _shared_docs["replace"],
         klass=_shared_doc_kwargs["klass"],
@@ -6532,14 +7095,14 @@ def bfill(
         replace_iloc=_shared_doc_kwargs["replace_iloc"],
     )
     def replace(
-        self,
+        self: NDFrameT,
         to_replace=None,
         value=lib.no_default,
         inplace: bool_t = False,
         limit: int | None = None,
-        regex=False,
-        method=lib.no_default,
-    ):
+        regex: bool_t = False,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = lib.no_default,
+    ) -> NDFrameT | None:
         if not (
             is_scalar(to_replace)
             or is_re_compilable(to_replace)
@@ -6573,14 +7136,15 @@ def replace(
 
             if isinstance(to_replace, (tuple, list)):
                 if isinstance(self, ABCDataFrame):
+                    from pandas import Series
+
                     result = self.apply(
-                        self._constructor_sliced._replace_single,
+                        Series._replace_single,
                         args=(to_replace, method, inplace, limit),
                     )
                     if inplace:
-                        return
+                        return None
                     return result
-                self = cast("Series", self)
                 return self._replace_single(to_replace, method, inplace, limit)
 
             if not is_dict_like(to_replace):
@@ -6629,7 +7193,7 @@ def replace(
             # need a non-zero len on all axes
             if not self.size:
                 if inplace:
-                    return
+                    return None
                 return self.copy()
 
             if is_dict_like(to_replace):
@@ -6770,7 +7334,8 @@ def interpolate(
               scipy 0.18.
 
         axis : {{0 or 'index', 1 or 'columns', None}}, default None
-            Axis to interpolate along.
+            Axis to interpolate along. For `Series` this parameter is unused
+            and defaults to 0.
         limit : int, optional
             Maximum number of consecutive NaNs to fill. Must be greater than
             0.
@@ -6835,9 +7400,7 @@ def interpolate(
         similar names. These use the actual numerical values of the index.
         For more information on their behavior, see the
         `SciPy documentation
-        <https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__
-        and `SciPy tutorial
-        <https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__.
+        <https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__.
 
         Examples
         --------
@@ -6979,8 +7542,7 @@ def interpolate(
         # create/use the index
         if method == "linear":
             # prior default
-            index = np.arange(len(obj.index))
-            index = Index(index)
+            index = Index(np.arange(len(obj.index)))
         else:
             index = obj.index
             methods = {"index", "values", "nearest", "time"}
@@ -7119,14 +7681,14 @@ def asof(self, where, subset=None):
         >>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',
         ...                           '2018-02-27 09:04:30']),
         ...         subset=['a'])
-                                 a   b
-        2018-02-27 09:03:30   30.0 NaN
-        2018-02-27 09:04:30   40.0 NaN
+                              a   b
+        2018-02-27 09:03:30  30 NaN
+        2018-02-27 09:04:30  40 NaN
         """
         if isinstance(where, str):
             where = Timestamp(where)
 
-        if not self.index.is_monotonic:
+        if not self.index.is_monotonic_increasing:
             raise ValueError("asof requires a sorted index")
 
         is_series = isinstance(self, ABCSeries)
@@ -7171,7 +7733,7 @@ def asof(self, where, subset=None):
         if not isinstance(where, Index):
             where = Index(where) if is_list else Index([where])
 
-        nulls = self.isna() if is_series else self[subset].isna().any(1)
+        nulls = self.isna() if is_series else self[subset].isna().any(axis=1)
         if nulls.all():
             if is_series:
                 self = cast("Series", self)
@@ -7191,7 +7753,10 @@ def asof(self, where, subset=None):
         missing = locs == -1
         data = self.take(locs)
         data.index = where
-        data.loc[missing] = np.nan
+        if missing.any():
+            # GH#16063 only do this setting when necessary, otherwise
+            #  we'd cast e.g. bools to floats
+            data.loc[missing] = np.nan
         return data if is_list else data.iloc[-1]
 
     # ----------------------------------------------------------------------
@@ -7417,8 +7982,9 @@ def clip(
             Maximum threshold value. All values above this
             threshold will be set to it. A missing
             threshold (e.g `NA`) will not clip the value.
-        axis : int or str axis name, optional
+        axis : {{0 or 'index', 1 or 'columns', None}}, default None
             Align object with lower and upper along the given axis.
+            For `Series` this parameter is unused and defaults to `None`.
         inplace : bool, default False
             Whether to perform the operation in place on the data.
         *args, **kwargs
@@ -7553,11 +8119,11 @@ def clip(
     @doc(**_shared_doc_kwargs)
     def asfreq(
         self: NDFrameT,
-        freq,
-        method=None,
+        freq: Frequency,
+        method: FillnaOptions | None = None,
         how: str | None = None,
         normalize: bool_t = False,
-        fill_value=None,
+        fill_value: Hashable = None,
     ) -> NDFrameT:
         """
         Convert time series to specified frequency.
@@ -7684,6 +8250,7 @@ def at_time(self: NDFrameT, time, asof: bool_t = False, axis=None) -> NDFrameT:
         ----------
         time : datetime.time or str
         axis : {0 or 'index', 1 or 'columns'}, default 0
+            For `Series` this parameter is unused and defaults to 0.
 
         Returns
         -------
@@ -7737,7 +8304,7 @@ def between_time(
         end_time,
         include_start: bool_t | lib.NoDefault = lib.no_default,
         include_end: bool_t | lib.NoDefault = lib.no_default,
-        inclusive: str | None = None,
+        inclusive: IntervalClosedType | None = None,
         axis=None,
     ) -> NDFrameT:
         """
@@ -7770,6 +8337,7 @@ def between_time(
             Include boundaries; whether to set each bound as closed or open.
         axis : {0 or 'index', 1 or 'columns'}, default 0
             Determine range time on index or columns value.
+            For `Series` this parameter is unused and defaults to 0.
 
         Returns
         -------
@@ -7839,10 +8407,10 @@ def between_time(
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            left = True if isinstance(include_start, lib.NoDefault) else include_start
-            right = True if isinstance(include_end, lib.NoDefault) else include_end
+            left = True if include_start is lib.no_default else include_start
+            right = True if include_end is lib.no_default else include_end
 
-            inc_dict = {
+            inc_dict: dict[tuple[bool_t, bool_t], IntervalClosedType] = {
                 (True, True): "both",
                 (True, False): "left",
                 (False, True): "right",
@@ -7865,17 +8433,18 @@ def between_time(
     def resample(
         self,
         rule,
-        axis=0,
+        axis: Axis = 0,
         closed: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
         loffset=None,
         base: int | None = None,
-        on=None,
-        level=None,
+        on: Level = None,
+        level: Level = None,
         origin: str | TimestampConvertibleTypes = "start_day",
         offset: TimedeltaConvertibleTypes | None = None,
+        group_keys: bool_t | lib.NoDefault = lib.no_default,
     ) -> Resampler:
         """
         Resample time-series data.
@@ -7890,8 +8459,8 @@ def resample(
         rule : DateOffset, Timedelta or str
             The offset string or object representing target conversion.
         axis : {{0 or 'index', 1 or 'columns'}}, default 0
-            Which axis to use for up- or down-sampling. For `Series` this
-            will default to 0, i.e. along the rows. Must be
+            Which axis to use for up- or down-sampling. For `Series` this parameter
+            is unused and defaults to 0. Must be
             `DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.
         closed : {{'right', 'left'}}, default None
             Which side of bin interval is closed. The default is 'left'
@@ -7950,6 +8519,17 @@ def resample(
 
             .. versionadded:: 1.1.0
 
+        group_keys : bool, optional
+            Whether to include the group keys in the result index when using
+            ``.apply()`` on the resampled object. Not specifying ``group_keys``
+            will retain values-dependent behavior from pandas 1.4
+            and earlier (see :ref:`pandas 1.5.0 Release notes
+            <whatsnew_150.enhancements.resample_group_keys>`
+            for examples). In a future version of pandas, the behavior will
+            default to the same as specifying ``group_keys=False``.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         pandas.core.Resampler
@@ -8035,9 +8615,9 @@ def resample(
         Freq: 30S, dtype: float64
 
         Upsample the series into 30 second bins and fill the ``NaN``
-        values using the ``pad`` method.
+        values using the ``ffill`` method.
 
-        >>> series.resample('30S').pad()[0:5]
+        >>> series.resample('30S').ffill()[0:5]
         2000-01-01 00:00:00    0
         2000-01-01 00:00:30    0
         2000-01-01 00:01:00    1
@@ -8289,6 +8869,7 @@ def resample(
             level=level,
             origin=origin,
             offset=offset,
+            group_keys=group_keys,
         )
 
     @final
@@ -8448,6 +9029,7 @@ def rank(
         ----------
         axis : {0 or 'index', 1 or 'columns'}, default 0
             Index to direct ranking.
+            For `Series` this parameter is unused and defaults to 0.
         method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
             How to rank the group of records that have the same value (i.e. ties):
 
@@ -8494,6 +9076,18 @@ def rank(
         3   spider          8.0
         4    snake          NaN
 
+        Ties are assigned the mean of the ranks (by default) for the group.
+
+        >>> s = pd.Series(range(5), index=list("abcde"))
+        >>> s["d"] = s["b"]
+        >>> s.rank()
+        a    1.0
+        b    2.5
+        c    4.0
+        d    2.5
+        e    5.0
+        dtype: float64
+
         The following example shows how the method behaves with the above
         parameters:
 
@@ -8587,6 +9181,15 @@ def ranker(data):
                     )
 
         if numeric_only:
+            if self.ndim == 1 and not is_numeric_dtype(self.dtype):
+                # GH#47500
+                warnings.warn(
+                    f"Calling Series.rank with numeric_only={numeric_only} and dtype "
+                    f"{self.dtype} is deprecated and will raise a TypeError in a "
+                    "future version of pandas",
+                    category=FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
             data = self._get_numeric_data()
         else:
             data = self
@@ -8600,6 +9203,7 @@ def compare(
         align_axis: Axis = 1,
         keep_shape: bool_t = False,
         keep_equal: bool_t = False,
+        result_names: Suffixes = ("self", "other"),
     ):
         from pandas.core.reshape.concat import concat
 
@@ -8610,7 +9214,6 @@ def compare(
             )
 
         mask = ~((self == other) | (self.isna() & other.isna()))
-        keys = ["self", "other"]
 
         if not keep_equal:
             self = self.where(mask)
@@ -8625,13 +9228,18 @@ def compare(
             else:
                 self = self[mask]
                 other = other[mask]
+        if not isinstance(result_names, tuple):
+            raise TypeError(
+                f"Passing 'result_names' as a {type(result_names)} is not "
+                "supported. Provide 'result_names' as a tuple instead."
+            )
 
         if align_axis in (1, "columns"):  # This is needed for Series
             axis = 1
         else:
             axis = self._get_axis_number(align_axis)
 
-        diff = concat([self, other], axis=axis, keys=keys)
+        diff = concat([self, other], axis=axis, keys=result_names)
 
         if axis >= self.ndim:
             # No need to reorganize data if stacking on new axis
@@ -8664,18 +9272,18 @@ def compare(
 
     @doc(**_shared_doc_kwargs)
     def align(
-        self,
-        other,
-        join="outer",
-        axis=None,
-        level=None,
-        copy=True,
-        fill_value=None,
-        method=None,
-        limit=None,
-        fill_axis=0,
-        broadcast_axis=None,
-    ):
+        self: NDFrameT,
+        other: NDFrameT,
+        join: Literal["outer", "inner", "left", "right"] = "outer",
+        axis: Axis | None = None,
+        level: Level = None,
+        copy: bool_t = True,
+        fill_value: Hashable = None,
+        method: FillnaOptions | None = None,
+        limit: int | None = None,
+        fill_axis: Axis = 0,
+        broadcast_axis: Axis | None = None,
+    ) -> NDFrameT:
         """
         Align two objects on their axes with the specified join method.
 
@@ -8935,10 +9543,14 @@ def _align_series(
 
         is_series = isinstance(self, ABCSeries)
 
+        if (not is_series and axis is None) or axis not in [None, 0, 1]:
+            raise ValueError("Must specify axis=0 or 1")
+
+        if is_series and axis == 1:
+            raise ValueError("cannot align series to a series other than axis 0")
+
         # series/series compat, other must always be a Series
-        if is_series:
-            if axis:
-                raise ValueError("cannot align series to a series other than axis 0")
+        if not axis:
 
             # equal
             if self.index.equals(other.index):
@@ -8948,26 +9560,31 @@ def _align_series(
                     other.index, how=join, level=level, return_indexers=True
                 )
 
-            left = self._reindex_indexer(join_index, lidx, copy)
+            if is_series:
+                left = self._reindex_indexer(join_index, lidx, copy)
+            elif lidx is None or join_index is None:
+                left = self.copy() if copy else self
+            else:
+                left = self._constructor(
+                    self._mgr.reindex_indexer(join_index, lidx, axis=1, copy=copy)
+                )
+
             right = other._reindex_indexer(join_index, ridx, copy)
 
         else:
+
             # one has > 1 ndim
             fdata = self._mgr
-            if axis in [0, 1]:
-                join_index = self.axes[axis]
-                lidx, ridx = None, None
-                if not join_index.equals(other.index):
-                    join_index, lidx, ridx = join_index.join(
-                        other.index, how=join, level=level, return_indexers=True
-                    )
-
-                if lidx is not None:
-                    bm_axis = self._get_block_manager_axis(axis)
-                    fdata = fdata.reindex_indexer(join_index, lidx, axis=bm_axis)
+            join_index = self.axes[1]
+            lidx, ridx = None, None
+            if not join_index.equals(other.index):
+                join_index, lidx, ridx = join_index.join(
+                    other.index, how=join, level=level, return_indexers=True
+                )
 
-            else:
-                raise ValueError("Must specify axis=0 or 1")
+            if lidx is not None:
+                bm_axis = self._get_block_manager_axis(1)
+                fdata = fdata.reindex_indexer(join_index, lidx, axis=bm_axis)
 
             if copy and fdata is self._mgr:
                 fdata = fdata.copy()
@@ -9002,7 +9619,6 @@ def _where(
         inplace=False,
         axis=None,
         level=None,
-        errors=lib.no_default,
     ):
         """
         Equivalent to public method `where`, except that `other` is not
@@ -9010,14 +9626,6 @@ def _where(
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
 
-        if errors is not lib.no_default:
-            warnings.warn(
-                f"The 'errors' keyword in {type(self).__name__}.where and mask is "
-                "deprecated and will be removed in a future version.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-
         if axis is not None:
             axis = self._get_axis_number(axis)
 
@@ -9107,11 +9715,7 @@ def _where(
 
             # we are the same shape, so create an actual object for alignment
             else:
-                # error: Argument 1 to "NDFrame" has incompatible type "ndarray";
-                # expected "BlockManager"
-                other = self._constructor(
-                    other, **self._construct_axes_dict()  # type: ignore[arg-type]
-                )
+                other = self._constructor(other, **self._construct_axes_dict())
 
         if axis is None:
             axis = 0
@@ -9139,6 +9743,52 @@ def _where(
             result = self._constructor(new_data)
             return result.__finalize__(self)
 
+    @overload
+    def where(
+        self: NDFrameT,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def where(
+        self: NDFrameT,
+        cond,
+        other=...,
+        *,
+        inplace: bool_t = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> NDFrameT | None:
+        ...
+
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "cond", "other"]
+    )
     @doc(
         klass=_shared_doc_kwargs["klass"],
         cond="True",
@@ -9147,15 +9797,15 @@ def _where(
         name_other="mask",
     )
     def where(
-        self,
+        self: NDFrameT,
         cond,
         other=np.nan,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
+        inplace: bool_t = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = "raise",
+        try_cast: bool_t | lib.NoDefault = lib.no_default,
+    ) -> NDFrameT | None:
         """
         Replace values where the condition is {cond_rev}.
 
@@ -9176,7 +9826,8 @@ def where(
         inplace : bool, default False
             Whether to perform the operation in place on the data.
         axis : int, default None
-            Alignment axis if needed.
+            Alignment axis if needed. For `Series` this parameter is
+            unused and defaults to 0.
         level : int, default None
             Alignment level if needed.
         errors : str, {{'raise', 'ignore'}}, default 'raise'
@@ -9186,8 +9837,8 @@ def where(
             - 'raise' : allow exceptions to be raised.
             - 'ignore' : suppress exceptions. On error return original object.
 
-            .. deprecated:: 1.4.0
-                Previously was silently ignored.
+            .. deprecated:: 1.5.0
+               This argument had no effect.
 
         try_cast : bool, default None
             Try to cast the result back to the input type (if possible).
@@ -9209,7 +9860,9 @@ def where(
         The {name} method is an application of the if-then idiom. For each
         element in the calling DataFrame, if ``cond`` is ``{cond}`` the
         element is used; otherwise the corresponding element from the DataFrame
-        ``other`` is used.
+        ``other`` is used. If the axis of ``other`` does not align with axis of
+        ``cond`` {klass}, the misaligned index positions will be filled with
+        {cond_rev}.
 
         The signature for :func:`DataFrame.where` differs from
         :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to
@@ -9218,6 +9871,9 @@ def where(
         For further details and examples see the ``{name}`` documentation in
         :ref:`indexing <indexing.where_mask>`.
 
+        The dtype of the object takes precedence. The fill value is casted to
+        the object's dtype, if this can be done losslessly.
+
         Examples
         --------
         >>> s = pd.Series(range(5))
@@ -9236,6 +9892,23 @@ def where(
         4    NaN
         dtype: float64
 
+        >>> s = pd.Series(range(5))
+        >>> t = pd.Series([True, False])
+        >>> s.where(t, 99)
+        0     0
+        1    99
+        2    99
+        3    99
+        4    99
+        dtype: int64
+        >>> s.mask(t, 99)
+        0    99
+        1     1
+        2    99
+        3    99
+        4    99
+        dtype: int64
+
         >>> s.where(s > 1, 10)
         0    10
         1    10
@@ -9292,8 +9965,54 @@ def where(
                 stacklevel=find_stack_level(),
             )
 
-        return self._where(cond, other, inplace, axis, level, errors=errors)
+        return self._where(cond, other, inplace, axis, level)
+
+    @overload
+    def mask(
+        self: NDFrameT,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> NDFrameT:
+        ...
+
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def mask(
+        self: NDFrameT,
+        cond,
+        other=...,
+        *,
+        inplace: bool_t = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool_t | lib.NoDefault = ...,
+    ) -> NDFrameT | None:
+        ...
 
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "cond", "other"]
+    )
     @doc(
         where,
         klass=_shared_doc_kwargs["klass"],
@@ -9303,15 +10022,15 @@ def where(
         name_other="where",
     )
     def mask(
-        self,
+        self: NDFrameT,
         cond,
         other=np.nan,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
+        inplace: bool_t = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = "raise",
+        try_cast: bool_t | lib.NoDefault = lib.no_default,
+    ) -> NDFrameT | None:
 
         inplace = validate_bool_kwarg(inplace, "inplace")
         cond = com.apply_if_callable(cond, self)
@@ -9334,12 +10053,15 @@ def mask(
             inplace=inplace,
             axis=axis,
             level=level,
-            errors=errors,
         )
 
     @doc(klass=_shared_doc_kwargs["klass"])
     def shift(
-        self: NDFrameT, periods=1, freq=None, axis=0, fill_value=None
+        self: NDFrameT,
+        periods: int = 1,
+        freq=None,
+        axis: Axis = 0,
+        fill_value: Hashable = None,
     ) -> NDFrameT:
         """
         Shift index by desired number of periods with an optional time `freq`.
@@ -9364,7 +10086,7 @@ def shift(
             the freq or inferred_freq attributes of the index. If neither of
             those attributes exist, a ValueError is thrown.
         axis : {{0 or 'index', 1 or 'columns', None}}, default None
-            Shift direction.
+            Shift direction. For `Series` this parameter is unused and defaults to 0.
         fill_value : object, optional
             The scalar value to use for newly introduced missing values.
             the default depends on the dtype of `self`.
@@ -9487,17 +10209,20 @@ def shift(
     def slice_shift(self: NDFrameT, periods: int = 1, axis=0) -> NDFrameT:
         """
         Equivalent to `shift` without copying data.
-        The shifted data will not include the dropped periods and the
-        shifted axis will be smaller than the original.
 
         .. deprecated:: 1.2.0
             slice_shift is deprecated,
             use DataFrame/Series.shift instead.
 
+        The shifted data will not include the dropped periods and the
+        shifted axis will be smaller than the original.
+
         Parameters
         ----------
         periods : int
             Number of periods to move, can be positive or negative.
+        axis : {0 or 'index', 1 or 'columns', None}, default 0
+            For `Series` this parameter is unused and defaults to 0.
 
         Returns
         -------
@@ -9528,8 +10253,7 @@ def slice_shift(self: NDFrameT, periods: int = 1, axis=0) -> NDFrameT:
 
         new_obj = self._slice(vslicer, axis=axis)
         shifted_axis = self._get_axis(axis)[islicer]
-        new_obj.set_axis(shifted_axis, axis=axis, inplace=True)
-
+        new_obj = new_obj.set_axis(shifted_axis, axis=axis, copy=False)
         return new_obj.__finalize__(self, method="slice_shift")
 
     @final
@@ -9549,6 +10273,7 @@ def tshift(self: NDFrameT, periods: int = 1, freq=None, axis: Axis = 0) -> NDFra
             or time rule expressed as a string (e.g. 'EOM').
         axis : {0 or ‘index’, 1 or ‘columns’, None}, default 0
             Corresponds to the axis that contains the Index.
+            For `Series` this parameter is unused and defaults to 0.
 
         Returns
         -------
@@ -9591,6 +10316,7 @@ def truncate(
             Truncate all rows after this index value.
         axis : {0 or 'index', 1 or 'columns'}, optional
             Axis to truncate. Truncates the index (rows) by default.
+            For `Series` this parameter is unused and defaults to 0.
         copy : bool, default is True,
             Return a copy of the truncated section.
 
@@ -9731,6 +10457,7 @@ def truncate(
         return result
 
     @final
+    @doc(klass=_shared_doc_kwargs["klass"])
     def tz_convert(
         self: NDFrameT, tz, axis=0, level=None, copy: bool_t = True
     ) -> NDFrameT:
@@ -9785,10 +10512,11 @@ def _tz_convert(ax, tz):
             ax = _tz_convert(ax, tz)
 
         result = self.copy(deep=copy)
-        result = result.set_axis(ax, axis=axis, inplace=False)
+        result = result.set_axis(ax, axis=axis, copy=False)
         return result.__finalize__(self, method="tz_convert")
 
     @final
+    @doc(klass=_shared_doc_kwargs["klass"])
     def tz_localize(
         self: NDFrameT,
         tz,
@@ -9844,7 +10572,7 @@ def tz_localize(
 
         Returns
         -------
-        Series or DataFrame
+        {klass}
             Same type as the input.
 
         Raises
@@ -9954,7 +10682,7 @@ def _tz_localize(ax, tz, ambiguous, nonexistent):
             ax = _tz_localize(ax, tz, ambiguous, nonexistent)
 
         result = self.copy(deep=copy)
-        result = result.set_axis(ax, axis=axis, inplace=False)
+        result = result.set_axis(ax, axis=axis, copy=False)
         return result.__finalize__(self, method="tz_localize")
 
     # ----------------------------------------------------------------------
@@ -9966,7 +10694,7 @@ def describe(
         percentiles=None,
         include=None,
         exclude=None,
-        datetime_is_numeric=False,
+        datetime_is_numeric: bool_t = False,
     ) -> NDFrameT:
         """
         Generate descriptive statistics.
@@ -10238,7 +10966,7 @@ def pct_change(
         periods : int, default 1
             Periods to shift for forming percent change.
         fill_method : str, default 'pad'
-            How to handle NAs before computing percent changes.
+            How to handle NAs **before** computing percent changes.
         limit : int, default None
             The number of consecutive NAs to fill before stopping.
         freq : DateOffset, timedelta, or str, optional
@@ -10356,7 +11084,7 @@ def pct_change(
             # We want to restore the original index
             rs = rs.loc[~rs.index.duplicated()]
             rs = rs.reindex_like(data)
-        return rs
+        return rs.__finalize__(self, method="pct_change")
 
     @final
     def _agg_by_level(
@@ -10442,7 +11170,7 @@ def any(
         skipna: bool_t = True,
         level: Level | None = None,
         **kwargs,
-    ) -> Series | bool_t:
+    ) -> DataFrame | Series | bool_t:
         return self._logical_func(
             "any", nanops.nanany, axis, bool_only, skipna, level, **kwargs
         )
@@ -10611,7 +11339,6 @@ def _stat_function(
 
         if axis is None:
             axis = self._stat_axis_number
-        axis = cast(Axis, axis)
         if level is not None:
             warnings.warn(
                 "Using the level keyword in DataFrame and Series aggregations is "
@@ -10806,10 +11533,14 @@ def mad(
         """
         {desc}
 
+        .. deprecated:: 1.5.0
+            mad is deprecated.
+
         Parameters
         ----------
         axis : {axis_descr}
             Axis for the function to be applied on.
+            For `Series` this parameter is unused and defaults to 0.
         skipna : bool, default True
             Exclude NA/null values when computing the result.
         level : int or level name, default None
@@ -10822,6 +11553,12 @@ def mad(
         {see_also}\
         {examples}
         """
+        msg = (
+            "The 'mad' method is deprecated and will be removed in a future version. "
+            "To compute the same result, you may do `(df - df.mean()).abs().mean()`."
+        )
+        warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
+
         if not is_bool(skipna):
             warnings.warn(
                 "Passing None for skipna is deprecated and will raise in a future"
@@ -10845,7 +11582,8 @@ def mad(
 
         data = self._get_numeric_data()
         if axis == 0:
-            demeaned = data - data.mean(axis=0)
+            # error: Unsupported operand types for - ("NDFrame" and "float")
+            demeaned = data - data.mean(axis=0)  # type: ignore[operator]
         else:
             demeaned = data.sub(data.mean(axis=1), axis=0)
         return np.abs(demeaned).mean(axis=axis, skipna=skipna)
@@ -10857,6 +11595,11 @@ def _add_numeric_operations(cls):
         """
         axis_descr, name1, name2 = _doc_params(cls)
 
+        @deprecate_nonkeyword_arguments(
+            version=None,
+            allowed_args=["self"],
+            name="DataFrame.any and Series.any",
+        )
         @doc(
             _bool_doc,
             desc=_any_desc,
@@ -11175,8 +11918,7 @@ def median(
 
         setattr(cls, "median", median)
 
-        # error: Untyped decorator makes function "max" untyped
-        @doc(  # type: ignore[misc]
+        @doc(
             _num_doc,
             desc="Return the maximum of the values over the requested axis.\n\n"
             "If you want the *index* of the maximum, use ``idxmax``. This is "
@@ -11200,8 +11942,7 @@ def max(
 
         setattr(cls, "max", max)
 
-        # error: Untyped decorator makes function "max" untyped
-        @doc(  # type: ignore[misc]
+        @doc(
             _num_doc,
             desc="Return the minimum of the values over the requested axis.\n\n"
             "If you want the *index* of the minimum, use ``idxmin``. This is "
@@ -11236,8 +11977,9 @@ def rolling(
         on: str | None = None,
         axis: Axis = 0,
         closed: str | None = None,
+        step: int | None = None,
         method: str = "single",
-    ):
+    ) -> Window | Rolling:
         axis = self._get_axis_number(axis)
 
         if win_type is not None:
@@ -11250,6 +11992,7 @@ def rolling(
                 on=on,
                 axis=axis,
                 closed=closed,
+                step=step,
                 method=method,
             )
 
@@ -11262,6 +12005,7 @@ def rolling(
             on=on,
             axis=axis,
             closed=closed,
+            step=step,
             method=method,
         )
 
@@ -11347,47 +12091,47 @@ def _inplace_method(self, other, op):
         )
         return self
 
-    def __iadd__(self, other):
+    def __iadd__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for + ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__add__)  # type: ignore[operator]
 
-    def __isub__(self, other):
+    def __isub__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for - ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__sub__)  # type: ignore[operator]
 
-    def __imul__(self, other):
+    def __imul__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for * ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__mul__)  # type: ignore[operator]
 
-    def __itruediv__(self, other):
+    def __itruediv__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for / ("Type[NDFrame]")
         return self._inplace_method(
             other, type(self).__truediv__  # type: ignore[operator]
         )
 
-    def __ifloordiv__(self, other):
+    def __ifloordiv__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for // ("Type[NDFrame]")
         return self._inplace_method(
             other, type(self).__floordiv__  # type: ignore[operator]
         )
 
-    def __imod__(self, other):
+    def __imod__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for % ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__mod__)  # type: ignore[operator]
 
-    def __ipow__(self, other):
+    def __ipow__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for ** ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__pow__)  # type: ignore[operator]
 
-    def __iand__(self, other):
+    def __iand__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for & ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__and__)  # type: ignore[operator]
 
-    def __ior__(self, other):
+    def __ior__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for | ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__or__)  # type: ignore[operator]
 
-    def __ixor__(self, other):
+    def __ixor__(self: NDFrameT, other) -> NDFrameT:
         # error: Unsupported left operand type for ^ ("Type[NDFrame]")
         return self._inplace_method(other, type(self).__xor__)  # type: ignore[operator]
 
@@ -11417,7 +12161,7 @@ def _find_valid_index(self, *, how: str) -> Hashable | None:
     @doc(position="first", klass=_shared_doc_kwargs["klass"])
     def first_valid_index(self) -> Hashable | None:
         """
-        Return index for {position} non-NA value or None, if no NA value is found.
+        Return index for {position} non-NA value or None, if no non-NA value is found.
 
         Returns
         -------
@@ -11453,14 +12197,23 @@ def _doc_params(cls):
 ----------
 axis : {axis_descr}
     Axis for the function to be applied on.
+    For `Series` this parameter is unused and defaults to 0.
 skipna : bool, default True
     Exclude NA/null values when computing the result.
 level : int or level name, default None
     If the axis is a MultiIndex (hierarchical), count along a
     particular level, collapsing into a {name1}.
+
+    .. deprecated:: 1.3.0
+        The level keyword is deprecated. Use groupby instead.
 numeric_only : bool, default None
     Include only float, int, boolean columns. If None, will attempt to use
     everything, then use only numeric data. Not implemented for Series.
+
+    .. deprecated:: 1.5.0
+        Specifying ``numeric_only=None`` is deprecated. The default value will be
+        ``False`` in a future version of pandas.
+
 {min_count}\
 **kwargs
     Additional keyword arguments to be passed to the function.
@@ -11478,12 +12231,16 @@ def _doc_params(cls):
 Parameters
 ----------
 axis : {axis_descr}
+    For `Series` this parameter is unused and defaults to 0.
 skipna : bool, default True
     Exclude NA/null values. If an entire row/column is NA, the result
     will be NA.
 level : int or level name, default None
     If the axis is a MultiIndex (hierarchical), count along a
     particular level, collapsing into a {name1}.
+
+    .. deprecated:: 1.3.0
+        The level keyword is deprecated. Use groupby instead.
 ddof : int, default 1
     Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
     where N represents the number of elements.
@@ -11491,6 +12248,10 @@ def _doc_params(cls):
     Include only float, int, boolean columns. If None, will attempt to use
     everything, then use only numeric data. Not implemented for Series.
 
+    .. deprecated:: 1.5.0
+        Specifying ``numeric_only=None`` is deprecated. The default value will be
+        ``False`` in a future version of pandas.
+
 Returns
 -------
 {name1} or {name2} (if level specified) \
@@ -11565,7 +12326,8 @@ def _doc_params(cls):
 Parameters
 ----------
 axis : {{0 or 'index', 1 or 'columns', None}}, default 0
-    Indicate which axis or axes should be reduced.
+    Indicate which axis or axes should be reduced. For `Series` this parameter
+    is unused and defaults to 0.
 
     * 0 / 'index' : reduce the index, return a Series whose index is the
       original column labels.
@@ -11584,6 +12346,9 @@ def _doc_params(cls):
 level : int or level name, default None
     If the axis is a MultiIndex (hierarchical), count along a
     particular level, collapsing into a {name1}.
+
+    .. deprecated:: 1.3.0
+        The level keyword is deprecated. Use groupby instead.
 **kwargs : any, default None
     Additional keywords have no effect but might be accepted for
     compatibility with NumPy.
@@ -11630,14 +12395,14 @@ def _doc_params(cls):
 0  True   True
 1  True  False
 
-Default behaviour checks if column-wise values all return True.
+Default behaviour checks if values in each column all return True.
 
 >>> df.all()
 col1     True
 col2    False
 dtype: bool
 
-Specify ``axis='columns'`` to check if row-wise values all return True.
+Specify ``axis='columns'`` to check if values in each row all return True.
 
 >>> df.all(axis='columns')
 0     True
@@ -11667,6 +12432,7 @@ def _doc_params(cls):
 ----------
 axis : {{0 or 'index', 1 or 'columns'}}, default 0
     The index or the name of the axis. 0 is equivalent to None or 'index'.
+    For `Series` this parameter is unused and defaults to 0.
 skipna : bool, default True
     Exclude NA/null values. If an entire row/column is NA, the result
     will be NA.
@@ -11681,7 +12447,7 @@ def _doc_params(cls):
 
 See Also
 --------
-core.window.Expanding.{accum_func_name} : Similar functionality
+core.window.expanding.Expanding.{accum_func_name} : Similar functionality
     but ignores ``NaN`` values.
 {name2}.{accum_func_name} : Return the {desc} over
     {name2} axis.
@@ -12087,11 +12853,11 @@ def _doc_params(cls):
 >>> pd.Series([np.nan]).sum(min_count=1)
 nan"""
 
-_max_examples = _shared_docs["stat_func_example"].format(
+_max_examples: str = _shared_docs["stat_func_example"].format(
     stat_func="max", verb="Max", default_output=8, level_output_0=4, level_output_1=8
 )
 
-_min_examples = _shared_docs["stat_func_example"].format(
+_min_examples: str = _shared_docs["stat_func_example"].format(
     stat_func="min", verb="Min", default_output=0, level_output_0=2, level_output_1=0
 )
 
diff --git a/pandas/core/groupby/base.py b/pandas/core/groupby/base.py
index 0c8474c9badc7..ad1f36e0cddd8 100644
--- a/pandas/core/groupby/base.py
+++ b/pandas/core/groupby/base.py
@@ -6,7 +6,10 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Hashable
+from typing import (
+    Hashable,
+    Literal,
+)
 
 
 @dataclasses.dataclass(order=True, frozen=True)
@@ -70,7 +73,6 @@ class OutputKey:
         "mean",
         "median",
         "min",
-        "ngroup",
         "nth",
         "nunique",
         "prod",
@@ -93,7 +95,7 @@ class OutputKey:
 
 
 # TODO(2.0) Remove after pad/backfill deprecation enforced
-def maybe_normalize_deprecated_kernels(kernel):
+def maybe_normalize_deprecated_kernels(kernel) -> Literal["bfill", "ffill"]:
     if kernel == "backfill":
         kernel = "bfill"
     elif kernel == "pad":
@@ -113,6 +115,7 @@ def maybe_normalize_deprecated_kernels(kernel):
         "diff",
         "ffill",
         "fillna",
+        "ngroup",
         "pad",
         "pct_change",
         "rank",
diff --git a/pandas/core/groupby/categorical.py b/pandas/core/groupby/categorical.py
index 2a2671374efc4..a9ad2401564ec 100644
--- a/pandas/core/groupby/categorical.py
+++ b/pandas/core/groupby/categorical.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from pandas.core.algorithms import unique1d
@@ -8,7 +10,9 @@
     CategoricalDtype,
     recode_for_categories,
 )
-from pandas.core.indexes.api import CategoricalIndex
+
+if TYPE_CHECKING:
+    from pandas.core.indexes.api import CategoricalIndex
 
 
 def recode_for_groupby(
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 81c5e74957c62..7e6e138fa8fe6 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -11,6 +11,7 @@
 from functools import partial
 from textwrap import dedent
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Hashable,
@@ -26,13 +27,18 @@
 
 import numpy as np
 
-from pandas._libs import reduction as libreduction
+from pandas._libs import (
+    Interval,
+    lib,
+    reduction as libreduction,
+)
 from pandas._typing import (
     ArrayLike,
     Manager,
     Manager2D,
     SingleManager,
 )
+from pandas.errors import SpecificationError
 from pandas.util._decorators import (
     Appender,
     Substitution,
@@ -64,11 +70,10 @@
     reconstruct_func,
     validate_func_kwargs,
 )
-from pandas.core.base import SpecificationError
+from pandas.core.arrays.categorical import Categorical
 import pandas.core.common as com
 from pandas.core.construction import create_series_with_explicit_dtype
 from pandas.core.frame import DataFrame
-from pandas.core.generic import NDFrame
 from pandas.core.groupby import base
 from pandas.core.groupby.groupby import (
     GroupBy,
@@ -83,11 +88,16 @@
     MultiIndex,
     all_indexes_same,
 )
+from pandas.core.indexes.category import CategoricalIndex
 from pandas.core.series import Series
+from pandas.core.shared_docs import _shared_docs
 from pandas.core.util.numba_ import maybe_use_numba
 
 from pandas.plotting import boxplot_frame_groupby
 
+if TYPE_CHECKING:
+    from pandas.core.generic import NDFrame
+
 # TODO(typing) the return value on this callable should be any *scalar*.
 AggScalar = Union[str, Callable[..., Any]]
 # TODO: validate types on ScalarResult and move to _typing
@@ -240,7 +250,7 @@ def _iterate_slices(self) -> Iterable[Series]:
             input="series", examples=_apply_docs["series_examples"]
         )
     )
-    def apply(self, func, *args, **kwargs):
+    def apply(self, func, *args, **kwargs) -> Series:
         return super().apply(func, *args, **kwargs)
 
     @doc(_agg_template, examples=_agg_examples_doc, klass="Series")
@@ -270,9 +280,9 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
             func = maybe_mangle_lambdas(func)
             ret = self._aggregate_multiple_funcs(func)
             if relabeling:
-                # error: Incompatible types in assignment (expression has type
-                # "Optional[List[str]]", variable has type "Index")
-                ret.columns = columns  # type: ignore[assignment]
+                # columns is not narrowed by mypy from relabeling flag
+                assert columns is not None  # for mypy
+                ret.columns = columns
             return ret
 
         else:
@@ -357,6 +367,7 @@ def _wrap_applied_output(
         data: Series,
         values: list[Any],
         not_indexed_same: bool = False,
+        override_group_keys: bool = False,
     ) -> DataFrame | Series:
         """
         Wrap the output of SeriesGroupBy.apply into the expected result.
@@ -395,7 +406,14 @@ def _wrap_applied_output(
             res_ser.name = self.obj.name
             return res_ser
         elif isinstance(values[0], (Series, DataFrame)):
-            return self._concat_objects(values, not_indexed_same=not_indexed_same)
+            result = self._concat_objects(
+                values,
+                not_indexed_same=not_indexed_same,
+                override_group_keys=override_group_keys,
+            )
+            if isinstance(result, Series):
+                result.name = self.obj.name
+            return result
         else:
             # GH #6265 #24880
             result = self.obj._constructor(
@@ -453,7 +471,9 @@ def _transform_general(self, func: Callable, *args, **kwargs) -> Series:
         klass = type(self.obj)
 
         results = []
-        for name, group in self:
+        for name, group in self.grouper.get_iterator(
+            self._selected_obj, axis=self.axis
+        ):
             # this setattr is needed for test_transform_lambda_with_datetimetz
             object.__setattr__(group, "name", name)
             res = func(group, *args, **kwargs)
@@ -472,9 +492,6 @@ def _transform_general(self, func: Callable, *args, **kwargs) -> Series:
         result.name = self.obj.name
         return result
 
-    def _can_use_transform_fast(self, result) -> bool:
-        return True
-
     def filter(self, func, dropna: bool = True, *args, **kwargs):
         """
         Return a copy of a Series excluding elements from groups that
@@ -594,7 +611,7 @@ def value_counts(
         ascending: bool = False,
         bins=None,
         dropna: bool = True,
-    ):
+    ) -> Series:
 
         from pandas.core.reshape.merge import get_join_indexers
         from pandas.core.reshape.tile import cut
@@ -602,23 +619,23 @@ def value_counts(
         ids, _, _ = self.grouper.group_info
         val = self.obj._values
 
-        def apply_series_value_counts():
-            return self.apply(
+        names = self.grouper.names + [self.obj.name]
+
+        if is_categorical_dtype(val.dtype) or (
+            bins is not None and not np.iterable(bins)
+        ):
+            # scalar bins cannot be done at top level
+            # in a backward compatible way
+            # GH38672 relates to categorical dtype
+            ser = self.apply(
                 Series.value_counts,
                 normalize=normalize,
                 sort=sort,
                 ascending=ascending,
                 bins=bins,
             )
-
-        if bins is not None:
-            if not np.iterable(bins):
-                # scalar bins cannot be done at top level
-                # in a backward compatible way
-                return apply_series_value_counts()
-        elif is_categorical_dtype(val.dtype):
-            # GH38672
-            return apply_series_value_counts()
+            ser.index.names = names
+            return ser
 
         # groupby removes null keys from groupings
         mask = ids != -1
@@ -647,12 +664,9 @@ def apply_series_value_counts():
 
         if is_interval_dtype(lab.dtype):
             # TODO: should we do this inside II?
+            lab_interval = cast(Interval, lab)
 
-            # error: "ndarray" has no attribute "left"
-            # error: "ndarray" has no attribute "right"
-            sorter = np.lexsort(
-                (lab.left, lab.right, ids)  # type: ignore[attr-defined]
-            )
+            sorter = np.lexsort((lab_interval.left, lab_interval.right, ids))
         else:
             sorter = np.lexsort((lab, ids))
 
@@ -677,13 +691,17 @@ def apply_series_value_counts():
 
         # multi-index components
         codes = self.grouper.reconstructed_codes
-        codes = [rep(level_codes) for level_codes in codes] + [llab(lab, inc)]
+        # error: Incompatible types in assignment (expression has type
+        # "List[ndarray[Any, dtype[_SCT]]]",
+        # variable has type "List[ndarray[Any, dtype[signedinteger[Any]]]]")
+        codes = [  # type: ignore[assignment]
+            rep(level_codes) for level_codes in codes
+        ] + [llab(lab, inc)]
         # error: List item 0 has incompatible type "Union[ndarray[Any, Any], Index]";
         # expected "Index"
         levels = [ping.group_index for ping in self.grouper.groupings] + [
             lev  # type: ignore[list-item]
         ]
-        names = self.grouper.names + [self.obj.name]
 
         if dropna:
             mask = codes[-1] != -1
@@ -742,7 +760,7 @@ def build_codes(lev_codes: np.ndarray) -> np.ndarray:
         return self.obj._constructor(out, index=mi, name=self.obj.name)
 
     @doc(Series.nlargest)
-    def nlargest(self, n: int = 5, keep: str = "first"):
+    def nlargest(self, n: int = 5, keep: str = "first") -> Series:
         f = partial(Series.nlargest, n=n, keep=keep)
         data = self._obj_with_exclusions
         # Don't change behavior if result index happens to be the same, i.e.
@@ -751,7 +769,7 @@ def nlargest(self, n: int = 5, keep: str = "first"):
         return result
 
     @doc(Series.nsmallest)
-    def nsmallest(self, n: int = 5, keep: str = "first"):
+    def nsmallest(self, n: int = 5, keep: str = "first") -> Series:
         f = partial(Series.nsmallest, n=n, keep=keep)
         data = self._obj_with_exclusions
         # Don't change behavior if result index happens to be the same, i.e.
@@ -809,6 +827,14 @@ class DataFrameGroupBy(GroupBy[DataFrame]):
     1    1    2
     2    3    4
 
+    User-defined function for aggregation
+
+    >>> df.groupby('A').agg(lambda x: sum(x) + 2)
+        B	       C
+    A
+    1	5	2.590715
+    2	9	2.704907
+
     Different aggregations per column
 
     >>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
@@ -952,7 +978,7 @@ def _aggregate_frame(self, func, *args, **kwargs) -> DataFrame:
         result: dict[Hashable, NDFrame | np.ndarray] = {}
         if self.axis == 0:
             # test_pass_args_kwargs_duplicate_columns gets here with non-unique columns
-            for name, data in self:
+            for name, data in self.grouper.get_iterator(obj, self.axis):
                 fres = func(data, *args, **kwargs)
                 result[name] = fres
         else:
@@ -987,7 +1013,11 @@ def _aggregate_item_by_item(self, func, *args, **kwargs) -> DataFrame:
         return res_df
 
     def _wrap_applied_output(
-        self, data: DataFrame, values: list, not_indexed_same: bool = False
+        self,
+        data: DataFrame,
+        values: list,
+        not_indexed_same: bool = False,
+        override_group_keys: bool = False,
     ):
 
         if len(values) == 0:
@@ -1004,7 +1034,11 @@ def _wrap_applied_output(
             # GH9684 - All values are None, return an empty frame.
             return self.obj._constructor()
         elif isinstance(first_not_none, DataFrame):
-            return self._concat_objects(values, not_indexed_same=not_indexed_same)
+            return self._concat_objects(
+                values,
+                not_indexed_same=not_indexed_same,
+                override_group_keys=override_group_keys,
+            )
 
         key_index = self.grouper.result_index if self.as_index else None
 
@@ -1030,7 +1064,11 @@ def _wrap_applied_output(
         else:
             # values are Series
             return self._wrap_applied_output_series(
-                values, not_indexed_same, first_not_none, key_index
+                values,
+                not_indexed_same,
+                first_not_none,
+                key_index,
+                override_group_keys,
             )
 
     def _wrap_applied_output_series(
@@ -1039,6 +1077,7 @@ def _wrap_applied_output_series(
         not_indexed_same: bool,
         first_not_none,
         key_index,
+        override_group_keys: bool,
     ) -> DataFrame | Series:
         # this is to silence a DeprecationWarning
         # TODO(2.0): Remove when default dtype of empty Series is object
@@ -1062,7 +1101,11 @@ def _wrap_applied_output_series(
                 # if any of the sub-series are not indexed the same
                 # OR we don't have a multi-index and we have only a
                 # single values
-                return self._concat_objects(values, not_indexed_same=not_indexed_same)
+                return self._concat_objects(
+                    values,
+                    not_indexed_same=not_indexed_same,
+                    override_group_keys=override_group_keys,
+                )
 
             # still a series
             # path added as of GH 5545
@@ -1073,7 +1116,11 @@ def _wrap_applied_output_series(
 
         if not all_indexed_same:
             # GH 8467
-            return self._concat_objects(values, not_indexed_same=True)
+            return self._concat_objects(
+                values,
+                not_indexed_same=True,
+                override_group_keys=override_group_keys,
+            )
 
         # Combine values
         # vstack+constructor is faster than concat and handles MI-columns
@@ -1103,10 +1150,15 @@ def _wrap_applied_output_series(
         return self._reindex_output(result)
 
     def _cython_transform(
-        self, how: str, numeric_only: bool = True, axis: int = 0, **kwargs
+        self,
+        how: str,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+        axis: int = 0,
+        **kwargs,
     ) -> DataFrame:
         assert axis == 0  # handled by caller
         # TODO: no tests with self.ndim == 1 for DataFrameGroupBy
+        numeric_only_bool = self._resolve_numeric_only(how, numeric_only, axis)
 
         # With self.axis == 0, we have multi-block tests
         #  e.g. test_rank_min_int, test_cython_transform_frame
@@ -1114,7 +1166,8 @@ def _cython_transform(
         # With self.axis == 1, _get_data_to_aggregate does a transpose
         #  so we always have a single block.
         mgr: Manager2D = self._get_data_to_aggregate()
-        if numeric_only:
+        orig_mgr_len = len(mgr)
+        if numeric_only_bool:
             mgr = mgr.get_numeric_data(copy=False)
 
         def arr_func(bvalues: ArrayLike) -> ArrayLike:
@@ -1127,8 +1180,8 @@ def arr_func(bvalues: ArrayLike) -> ArrayLike:
         res_mgr = mgr.grouped_reduce(arr_func, ignore_failures=True)
         res_mgr.set_axis(1, mgr.axes[1])
 
-        if len(res_mgr) < len(mgr):
-            warn_dropping_nuisance_columns_deprecated(type(self), how)
+        if len(res_mgr) < orig_mgr_len:
+            warn_dropping_nuisance_columns_deprecated(type(self), how, numeric_only)
 
         res_df = self.obj._constructor(res_mgr)
         if self.axis == 1:
@@ -1164,14 +1217,33 @@ def _transform_general(self, func, *args, **kwargs):
                 applied.append(res)
 
         # Compute and process with the remaining groups
+        emit_alignment_warning = False
         for name, group in gen:
             if group.size == 0:
                 continue
             object.__setattr__(group, "name", name)
             res = path(group)
+            if (
+                not emit_alignment_warning
+                and res.ndim == 2
+                and not res.index.equals(group.index)
+            ):
+                emit_alignment_warning = True
+
             res = _wrap_transform_general_frame(self.obj, group, res)
             applied.append(res)
 
+        if emit_alignment_warning:
+            # GH#45648
+            warnings.warn(
+                "In a future version of pandas, returning a DataFrame in "
+                "groupby.transform will align with the input's index. Apply "
+                "`.to_numpy()` to the result in the transform function to keep "
+                "the current behavior and silence this warning.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
         concat_index = obj.columns if self.axis == 0 else obj.index
         other_axis = 1 if self.axis == 0 else 0  # switches between 0 & 1
         concatenated = concat(applied, axis=self.axis, verify_integrity=False)
@@ -1185,11 +1257,6 @@ def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
             func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs
         )
 
-    def _can_use_transform_fast(self, result) -> bool:
-        return isinstance(result, DataFrame) and result.columns.equals(
-            self._obj_with_exclusions.columns
-        )
-
     def _define_paths(self, func, *args, **kwargs):
         if isinstance(func, str):
             fast_path = lambda group: getattr(group, func)(*args, **kwargs)
@@ -1207,6 +1274,11 @@ def _choose_path(self, fast_path: Callable, slow_path: Callable, group: DataFram
         path = slow_path
         res = slow_path(group)
 
+        if self.ngroups == 1:
+            # no need to evaluate multiple paths when only
+            # a single group exists
+            return path, res
+
         # if we make it here, test if we can use the fast path
         try:
             res_fast = fast_path(group)
@@ -1217,12 +1289,16 @@ def _choose_path(self, fast_path: Callable, slow_path: Callable, group: DataFram
             #  raised; see test_transform.test_transform_fastpath_raises
             return path, res
 
-        # verify fast path does not change columns (and names), otherwise
-        # its results cannot be joined with those of the slow path
-        if not isinstance(res_fast, DataFrame):
-            return path, res
-
-        if not res_fast.columns.equals(group.columns):
+        # verify fast path returns either:
+        # a DataFrame with columns equal to group.columns
+        # OR a Series with index equal to group.columns
+        if isinstance(res_fast, DataFrame):
+            if not res_fast.columns.equals(group.columns):
+                return path, res
+        elif isinstance(res_fast, Series):
+            if not res_fast.index.equals(group.columns):
+                return path, res
+        else:
             return path, res
 
         if res_fast.equals(res):
@@ -1240,7 +1316,9 @@ def _transform_item_by_item(self, obj: DataFrame, wrapper) -> DataFrame:
                 output[i] = sgb.transform(wrapper)
             except TypeError:
                 # e.g. trying to call nanmean with string values
-                warn_dropping_nuisance_columns_deprecated(type(self), "transform")
+                warn_dropping_nuisance_columns_deprecated(
+                    type(self), "transform", numeric_only=False
+                )
             else:
                 inds.append(i)
 
@@ -1526,49 +1604,87 @@ def nunique(self, dropna: bool = True) -> DataFrame:
 
         return results
 
-    @Appender(DataFrame.idxmax.__doc__)
-    def idxmax(self, axis=0, skipna: bool = True):
+    @doc(
+        _shared_docs["idxmax"],
+        numeric_only_default="True for axis=0, False for axis=1",
+    )
+    def idxmax(
+        self,
+        axis=0,
+        skipna: bool = True,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+    ) -> DataFrame:
         axis = DataFrame._get_axis_number(axis)
-        numeric_only = None if axis == 0 else False
+        if numeric_only is lib.no_default:
+            # Cannot use self._resolve_numeric_only; we must pass None to
+            # DataFrame.idxmax for backwards compatibility
+            numeric_only_arg = None if axis == 0 else False
+        else:
+            numeric_only_arg = numeric_only
 
         def func(df):
-            # NB: here we use numeric_only=None, in DataFrame it is False GH#38217
-            res = df._reduce(
-                nanops.nanargmax,
-                "argmax",
-                axis=axis,
-                skipna=skipna,
-                numeric_only=numeric_only,
-            )
-            indices = res._values
-            index = df._get_axis(axis)
-            result = [index[i] if i >= 0 else np.nan for i in indices]
-            return df._constructor_sliced(result, index=res.index)
+            with warnings.catch_warnings():
+                # Suppress numeric_only warnings here, will warn below
+                warnings.filterwarnings("ignore", ".*numeric_only in DataFrame.argmax")
+                res = df._reduce(
+                    nanops.nanargmax,
+                    "argmax",
+                    axis=axis,
+                    skipna=skipna,
+                    numeric_only=numeric_only_arg,
+                )
+                indices = res._values
+                index = df._get_axis(axis)
+                result = [index[i] if i >= 0 else np.nan for i in indices]
+                return df._constructor_sliced(result, index=res.index)
 
         func.__name__ = "idxmax"
-        return self._python_apply_general(func, self._obj_with_exclusions)
+        result = self._python_apply_general(
+            func, self._obj_with_exclusions, not_indexed_same=True
+        )
+        self._maybe_warn_numeric_only_depr("idxmax", result, numeric_only)
+        return result
 
-    @Appender(DataFrame.idxmin.__doc__)
-    def idxmin(self, axis=0, skipna: bool = True):
+    @doc(
+        _shared_docs["idxmin"],
+        numeric_only_default="True for axis=0, False for axis=1",
+    )
+    def idxmin(
+        self,
+        axis=0,
+        skipna: bool = True,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+    ) -> DataFrame:
         axis = DataFrame._get_axis_number(axis)
-        numeric_only = None if axis == 0 else False
+        if numeric_only is lib.no_default:
+            # Cannot use self._resolve_numeric_only; we must pass None to
+            # DataFrame.idxmin for backwards compatibility
+            numeric_only_arg = None if axis == 0 else False
+        else:
+            numeric_only_arg = numeric_only
 
         def func(df):
-            # NB: here we use numeric_only=None, in DataFrame it is False GH#38217
-            res = df._reduce(
-                nanops.nanargmin,
-                "argmin",
-                axis=axis,
-                skipna=skipna,
-                numeric_only=numeric_only,
-            )
-            indices = res._values
-            index = df._get_axis(axis)
-            result = [index[i] if i >= 0 else np.nan for i in indices]
-            return df._constructor_sliced(result, index=res.index)
+            with warnings.catch_warnings():
+                # Suppress numeric_only warnings here, will warn below
+                warnings.filterwarnings("ignore", ".*numeric_only in DataFrame.argmin")
+                res = df._reduce(
+                    nanops.nanargmin,
+                    "argmin",
+                    axis=axis,
+                    skipna=skipna,
+                    numeric_only=numeric_only_arg,
+                )
+                indices = res._values
+                index = df._get_axis(axis)
+                result = [index[i] if i >= 0 else np.nan for i in indices]
+                return df._constructor_sliced(result, index=res.index)
 
         func.__name__ = "idxmin"
-        return self._python_apply_general(func, self._obj_with_exclusions)
+        result = self._python_apply_general(
+            func, self._obj_with_exclusions, not_indexed_same=True
+        )
+        self._maybe_warn_numeric_only_depr("idxmin", result, numeric_only)
+        return result
 
     boxplot = boxplot_frame_groupby
 
@@ -1632,13 +1748,13 @@ def value_counts(
         ... })
 
         >>> df
-            gender 	education 	country
-        0 	male 	low 	    US
-        1 	male 	medium 	    FR
-        2 	female 	high 	    US
-        3 	male 	low 	    FR
-        4 	female 	high 	    FR
-        5 	male 	low 	    FR
+                gender  education   country
+        0       male    low         US
+        1       male    medium      FR
+        2       female  high        US
+        3       male    low         FR
+        4       female  high        FR
+        5       male    low         FR
 
         >>> df.groupby('gender').value_counts()
         gender  education  country
@@ -1698,21 +1814,31 @@ def value_counts(
                 name = self._selected_obj.name
                 keys = [] if name in in_axis_names else [self._selected_obj]
             else:
+                unique_cols = set(self._selected_obj.columns)
+                if subset is not None:
+                    subsetted = set(subset)
+                    clashing = subsetted & set(in_axis_names)
+                    if clashing:
+                        raise ValueError(
+                            f"Keys {clashing} in subset cannot be in "
+                            "the groupby column keys."
+                        )
+                    doesnt_exist = subsetted - unique_cols
+                    if doesnt_exist:
+                        raise ValueError(
+                            f"Keys {doesnt_exist} in subset do not "
+                            f"exist in the DataFrame."
+                        )
+                else:
+                    subsetted = unique_cols
+
                 keys = [
                     # Can't use .values because the column label needs to be preserved
                     self._selected_obj.iloc[:, idx]
                     for idx, name in enumerate(self._selected_obj.columns)
-                    if name not in in_axis_names
+                    if name not in in_axis_names and name in subsetted
                 ]
 
-            if subset is not None:
-                clashing = set(subset) & set(in_axis_names)
-                if clashing:
-                    raise ValueError(
-                        f"Keys {clashing} in subset cannot be in "
-                        "the groupby column keys"
-                    )
-
             groupings = list(self.grouper.groupings)
             for key in keys:
                 grouper, _, _ = get_grouper(
@@ -1720,6 +1846,7 @@ def value_counts(
                     key=key,
                     axis=self.axis,
                     sort=self.sort,
+                    observed=False,
                     dropna=dropna,
                 )
                 groupings += list(grouper.groupings)
@@ -1731,32 +1858,62 @@ def value_counts(
                 observed=self.observed,
                 dropna=self.dropna,
             )
-            result = cast(Series, gb.size())
+            result_series = cast(Series, gb.size())
+
+            # GH-46357 Include non-observed categories
+            # of non-grouping columns regardless of `observed`
+            if any(
+                isinstance(grouping.grouping_vector, (Categorical, CategoricalIndex))
+                and not grouping._observed
+                for grouping in groupings
+            ):
+                levels_list = [ping.result_index for ping in groupings]
+                multi_index, _ = MultiIndex.from_product(
+                    levels_list, names=[ping.name for ping in groupings]
+                ).sortlevel()
+                result_series = result_series.reindex(multi_index, fill_value=0)
 
             if normalize:
                 # Normalize the results by dividing by the original group sizes.
                 # We are guaranteed to have the first N levels be the
                 # user-requested grouping.
-                levels = list(range(len(self.grouper.groupings), result.index.nlevels))
-                indexed_group_size = result.groupby(
-                    result.index.droplevel(levels),
+                levels = list(
+                    range(len(self.grouper.groupings), result_series.index.nlevels)
+                )
+                indexed_group_size = result_series.groupby(
+                    result_series.index.droplevel(levels),
                     sort=self.sort,
-                    observed=self.observed,
                     dropna=self.dropna,
                 ).transform("sum")
+                result_series /= indexed_group_size
 
-                result /= indexed_group_size
+                # Handle groups of non-observed categories
+                result_series = result_series.fillna(0.0)
 
             if sort:
                 # Sort the values and then resort by the main grouping
                 index_level = range(len(self.grouper.groupings))
-                result = result.sort_values(ascending=ascending).sort_index(
-                    level=index_level, sort_remaining=False
-                )
+                result_series = result_series.sort_values(
+                    ascending=ascending
+                ).sort_index(level=index_level, sort_remaining=False)
 
-            if not self.as_index:
+            result: Series | DataFrame
+            if self.as_index:
+                result = result_series
+            else:
                 # Convert to frame
-                result = result.reset_index(name="proportion" if normalize else "count")
+                name = "proportion" if normalize else "count"
+                index = result_series.index
+                columns = com.fill_missing_names(index.names)
+                if name in columns:
+                    raise ValueError(
+                        f"Column label '{name}' is duplicate of result column"
+                    )
+                result_series.name = name
+                result_series.index = index.set_names(range(len(columns)))
+                result_frame = result_series.reset_index()
+                result_frame.columns = columns + [name]
+                result = result_frame
             return result.__finalize__(self.obj, method="value_counts")
 
 
@@ -1775,7 +1932,7 @@ def _wrap_transform_general_frame(
             res_frame.index = group.index
         else:
             res_frame = obj._constructor(
-                np.concatenate([res.values] * len(group.index)).reshape(group.shape),
+                np.tile(res.values, (len(group.index), 1)),
                 columns=group.columns,
                 index=group.index,
             )
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 4a42e2b61823d..1c3a95b305087 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -8,7 +8,10 @@ class providing the base-class of operations.
 """
 from __future__ import annotations
 
-from contextlib import contextmanager
+from contextlib import (
+    contextmanager,
+    nullcontext,
+)
 import datetime
 from functools import (
     partial,
@@ -18,6 +21,7 @@ class providing the base-class of operations.
 from textwrap import dedent
 import types
 from typing import (
+    TYPE_CHECKING,
     Callable,
     Hashable,
     Iterable,
@@ -53,15 +57,22 @@ class providing the base-class of operations.
     npt,
 )
 from pandas.compat.numpy import function as nv
-from pandas.errors import AbstractMethodError
+from pandas.errors import (
+    AbstractMethodError,
+    DataError,
+)
 from pandas.util._decorators import (
     Appender,
     Substitution,
     cache_readonly,
     doc,
 )
-from pandas.util._exceptions import find_stack_level
+from pandas.util._exceptions import (
+    find_stack_level,
+    rewrite_warning,
+)
 
+from pandas.core.dtypes.cast import ensure_dtype_can_hold_na
 from pandas.core.dtypes.common import (
     is_bool_dtype,
     is_datetime64_dtype,
@@ -88,7 +99,6 @@ class providing the base-class of operations.
     ExtensionArray,
 )
 from pandas.core.base import (
-    DataError,
     PandasObject,
     SelectionMixin,
 )
@@ -108,16 +118,24 @@ class providing the base-class of operations.
     CategoricalIndex,
     Index,
     MultiIndex,
+    RangeIndex,
 )
 from pandas.core.internals.blocks import ensure_block_shape
 import pandas.core.sample as sample
 from pandas.core.series import Series
 from pandas.core.sorting import get_group_index_sorter
 from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
+    get_jit_arguments,
     maybe_use_numba,
 )
 
+if TYPE_CHECKING:
+    from pandas.core.window import (
+        ExpandingGroupby,
+        ExponentialMovingWindowGroupby,
+        RollingGroupby,
+    )
+
 _common_see_also = """
         See Also
         --------
@@ -184,21 +202,33 @@ class providing the base-class of operations.
     >>> df = pd.DataFrame({'A': 'a a b'.split(),
     ...                    'B': [1,2,3],
     ...                    'C': [4,6,5]})
-    >>> g = df.groupby('A')
+    >>> g1 = df.groupby('A', group_keys=False)
+    >>> g2 = df.groupby('A', group_keys=True)
 
-    Notice that ``g`` has two groups, ``a`` and ``b``.
-    Calling `apply` in various ways, we can get different grouping results:
+    Notice that ``g1`` have ``g2`` have two groups, ``a`` and ``b``, and only
+    differ in their ``group_keys`` argument. Calling `apply` in various ways,
+    we can get different grouping results:
 
     Example 1: below the function passed to `apply` takes a DataFrame as
     its argument and returns a DataFrame. `apply` combines the result for
     each group together into a new DataFrame:
 
-    >>> g[['B', 'C']].apply(lambda x: x / x.sum())
+    >>> g1[['B', 'C']].apply(lambda x: x / x.sum())
               B    C
     0  0.333333  0.4
     1  0.666667  0.6
     2  1.000000  1.0
 
+    In the above, the groups are not part of the index. We can have them included
+    by using ``g2`` where ``group_keys=True``:
+
+    >>> g2[['B', 'C']].apply(lambda x: x / x.sum())
+                B    C
+    A
+    a 0  0.333333  0.4
+      1  0.666667  0.6
+    b 2  1.000000  1.0
+
     Example 2: The function passed to `apply` takes a DataFrame as
     its argument and returns a Series.  `apply` combines the result for
     each group together into a new DataFrame.
@@ -207,28 +237,41 @@ class providing the base-class of operations.
 
         The resulting dtype will reflect the return value of the passed ``func``.
 
-    >>> g[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
+    >>> g1[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
+         B    C
+    A
+    a  1.0  2.0
+    b  0.0  0.0
+
+    >>> g2[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
          B    C
     A
     a  1.0  2.0
     b  0.0  0.0
 
+    The ``group_keys`` argument has no effect here because the result is not
+    like-indexed (i.e. :ref:`a transform <groupby.transform>`) when compared
+    to the input.
+
     Example 3: The function passed to `apply` takes a DataFrame as
     its argument and returns a scalar. `apply` combines the result for
     each group together into a Series, including setting the index as
     appropriate:
 
-    >>> g.apply(lambda x: x.C.max() - x.B.min())
+    >>> g1.apply(lambda x: x.C.max() - x.B.min())
     A
     a    5
     b    2
     dtype: int64""",
     "series_examples": """
     >>> s = pd.Series([0, 1, 2], index='a a b'.split())
-    >>> g = s.groupby(s.index)
+    >>> g1 = s.groupby(s.index, group_keys=False)
+    >>> g2 = s.groupby(s.index, group_keys=True)
 
     From ``s`` above we can see that ``g`` has two groups, ``a`` and ``b``.
-    Calling `apply` in various ways, we can get different grouping results:
+    Notice that ``g1`` have ``g2`` have two groups, ``a`` and ``b``, and only
+    differ in their ``group_keys`` argument. Calling `apply` in various ways,
+    we can get different grouping results:
 
     Example 1: The function passed to `apply` takes a Series as
     its argument and returns a Series.  `apply` combines the result for
@@ -238,18 +281,36 @@ class providing the base-class of operations.
 
         The resulting dtype will reflect the return value of the passed ``func``.
 
-    >>> g.apply(lambda x: x*2 if x.name == 'a' else x/2)
+    >>> g1.apply(lambda x: x*2 if x.name == 'a' else x/2)
     a    0.0
     a    2.0
     b    1.0
     dtype: float64
 
+    In the above, the groups are not part of the index. We can have them included
+    by using ``g2`` where ``group_keys=True``:
+
+    >>> g2.apply(lambda x: x*2 if x.name == 'a' else x/2)
+    a  a    0.0
+       a    2.0
+    b  b    1.0
+    dtype: float64
+
     Example 2: The function passed to `apply` takes a Series as
     its argument and returns a scalar. `apply` combines the result for
     each group together into a Series, including setting the index as
     appropriate:
 
-    >>> g.apply(lambda x: x.max() - x.min())
+    >>> g1.apply(lambda x: x.max() - x.min())
+    a    1
+    b    0
+    dtype: int64
+
+    The ``group_keys`` argument has no effect here because the result is not
+    like-indexed (i.e. :ref:`a transform <groupby.transform>`) when compared
+    to the input.
+
+    >>> g2.apply(lambda x: x.max() - x.min())
     a    1
     b    0
     dtype: int64""",
@@ -274,8 +335,7 @@ class providing the base-class of operations.
 """
 
 _pipe_template = """
-Apply a function `func` with arguments to this %(klass)s object and return
-the function's result.
+Apply a ``func`` with arguments to this %(klass)s object and return its result.
 
 Use `.pipe` when you want to improve readability by chaining together
 functions that expect Series, DataFrames, GroupBy or Resampler objects.
@@ -326,14 +386,15 @@ class providing the base-class of operations.
 """
 
 _transform_template = """
-Call function producing a like-indexed %(klass)s on each group and
-return a %(klass)s having the same indexes as the original object
+Call function producing a same-indexed %(klass)s on each group.
+
+Returns a %(klass)s having the same indexes as the original object
 filled with the transformed values.
 
 Parameters
 ----------
 f : function
-    Function to apply to each group.
+    Function to apply to each group. See the Notes section below for requirements.
 
     Can also accept a Numba JIT function with
     ``engine='numba'`` specified.
@@ -375,8 +436,8 @@ class providing the base-class of operations.
     the results together.
 %(klass)s.groupby.aggregate : Aggregate using one or more
     operations over the specified axis.
-%(klass)s.transform : Call ``func`` on self producing a %(klass)s with
-    transformed values.
+%(klass)s.transform : Call ``func`` on self producing a %(klass)s with the
+    same axis shape as self.
 
 Notes
 -----
@@ -404,6 +465,14 @@ class providing the base-class of operations.
     The resulting dtype will reflect the return value of the passed ``func``,
     see the examples below.
 
+.. deprecated:: 1.5.0
+
+    When using ``.transform`` on a grouped DataFrame and the transformation function
+    returns a DataFrame, currently pandas does not align the result's index
+    with the input's index. This behavior is deprecated and alignment will
+    be performed in a future version of pandas. You can apply ``.to_numpy()`` to the
+    result of the transformation function to avoid alignment.
+
 Examples
 --------
 
@@ -413,7 +482,7 @@ class providing the base-class of operations.
 ...                           'two', 'two'],
 ...                    'C' : [1, 5, 5, 2, 5, 5],
 ...                    'D' : [2.0, 5., 8., 1., 2., 9.]})
->>> grouped = df.groupby('A')
+>>> grouped = df.groupby('A')[['C', 'D']]
 >>> grouped.transform(lambda x: (x - x.mean()) / x.std())
           C         D
 0 -1.154701 -0.577350
@@ -426,20 +495,20 @@ class providing the base-class of operations.
 Broadcast result of the transformation
 
 >>> grouped.transform(lambda x: x.max() - x.min())
-   C    D
-0  4  6.0
-1  3  8.0
-2  4  6.0
-3  3  8.0
-4  4  6.0
-5  3  8.0
+     C    D
+0  4.0  6.0
+1  3.0  8.0
+2  4.0  6.0
+3  3.0  8.0
+4  4.0  6.0
+5  3.0  8.0
 
 .. versionchanged:: 1.3.0
 
     The resulting dtype will reflect the return value of the passed ``func``,
     for example:
 
->>> grouped[['C', 'D']].transform(lambda x: x.astype(int).max())
+>>> grouped.transform(lambda x: x.astype(int).max())
    C  D
 0  5  8
 1  5  9
@@ -532,7 +601,7 @@ class GroupByPlot(PandasObject):
     Class implementing the .plot attribute for groupby objects.
     """
 
-    def __init__(self, groupby: GroupBy):
+    def __init__(self, groupby: GroupBy) -> None:
         self._groupby = groupby
 
     def __call__(self, *args, **kwargs):
@@ -582,7 +651,8 @@ class BaseGroupBy(PandasObject, SelectionMixin[NDFrameT], GroupByIndexingMixin):
 
     axis: int
     grouper: ops.BaseGrouper
-    group_keys: bool
+    keys: _KeysArgType | None = None
+    group_keys: bool | lib.NoDefault
 
     @final
     def __len__(self) -> int:
@@ -608,7 +678,7 @@ def ngroups(self) -> int:
 
     @final
     @property
-    def indices(self):
+    def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
         """
         Dict {group name -> group indices}.
         """
@@ -758,6 +828,19 @@ def __iter__(self) -> Iterator[tuple[Hashable, NDFrameT]]:
         Generator yielding sequence of (name, subsetted object)
         for each group
         """
+        keys = self.keys
+        if isinstance(keys, list) and len(keys) == 1:
+            warnings.warn(
+                (
+                    "In a future version of pandas, a length 1 "
+                    "tuple will be returned when iterating over a "
+                    "groupby with a grouper equal to a list of "
+                    "length 1. Don't supply a list with a single grouper "
+                    "to avoid this warning."
+                ),
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
         return self.grouper.get_iterator(self._selected_obj, axis=self.axis)
 
 
@@ -848,12 +931,12 @@ def __init__(
         selection: IndexLabel | None = None,
         as_index: bool = True,
         sort: bool = True,
-        group_keys: bool = True,
+        group_keys: bool | lib.NoDefault = True,
         squeeze: bool = False,
         observed: bool = False,
         mutated: bool = False,
         dropna: bool = True,
-    ):
+    ) -> None:
 
         self._selection = selection
 
@@ -905,15 +988,6 @@ def __getattr__(self, attr: str):
             f"'{type(self).__name__}' object has no attribute '{attr}'"
         )
 
-    def __getattribute__(self, attr: str):
-        # Intercept nth to allow both call and index
-        if attr == "nth":
-            return GroupByNthSelector(self)
-        elif attr == "nth_actual":
-            return super().__getattribute__("nth")
-        else:
-            return super().__getattribute__(attr)
-
     @final
     def _make_wrapper(self, name: str) -> Callable:
         assert name in self._apply_allowlist
@@ -923,7 +997,9 @@ def _make_wrapper(self, name: str) -> Callable:
             # as are not passed directly but in the grouper
             f = getattr(self._obj_with_exclusions, name)
             if not isinstance(f, types.MethodType):
-                return self.apply(lambda self: getattr(self, name))
+                #  error: Incompatible return value type
+                # (got "NDFrameT", expected "Callable[..., Any]")  [return-value]
+                return cast(Callable, self.apply(lambda self: getattr(self, name)))
 
         f = getattr(type(self._obj_with_exclusions), name)
         sig = inspect.signature(f)
@@ -935,8 +1011,15 @@ def wrapper(*args, **kwargs):
                 if kwargs.get("axis", None) is None:
                     kwargs["axis"] = self.axis
 
+            numeric_only = kwargs.get("numeric_only", lib.no_default)
+
             def curried(x):
-                return f(x, *args, **kwargs)
+                with warnings.catch_warnings():
+                    # Catch any warnings from dispatch to DataFrame; we'll emit
+                    # a warning for groupby below
+                    match = "The default value of numeric_only "
+                    warnings.filterwarnings("ignore", match, FutureWarning)
+                    return f(x, *args, **kwargs)
 
             # preserve the name so we can detect it when calling plot methods,
             # to avoid duplicates
@@ -947,7 +1030,31 @@ def curried(x):
             if name in base.plotting_methods:
                 return self.apply(curried)
 
-            return self._python_apply_general(curried, self._obj_with_exclusions)
+            is_transform = name in base.transformation_kernels
+
+            # Transform needs to keep the same schema, including when empty
+            if is_transform and self._obj_with_exclusions.empty:
+                return self._obj_with_exclusions
+
+            result = self._python_apply_general(
+                curried,
+                self._obj_with_exclusions,
+                is_transform=is_transform,
+                not_indexed_same=not is_transform,
+            )
+
+            if self._selected_obj.ndim != 1 and self.axis != 1 and result.ndim != 1:
+                missing = self._obj_with_exclusions.columns.difference(result.columns)
+                if len(missing) > 0:
+                    warn_dropping_nuisance_columns_deprecated(
+                        type(self), name, numeric_only
+                    )
+
+            if self.grouper.has_dropped_na and is_transform:
+                # result will have dropped rows due to nans, fill with null
+                # and ensure index is ordered same as the input
+                result = self._set_result_index_ordered(result)
+            return result
 
         wrapper.__name__ = name
         return wrapper
@@ -1013,7 +1120,12 @@ def _iterate_slices(self) -> Iterable[Series]:
     # Dispatch/Wrapping
 
     @final
-    def _concat_objects(self, values, not_indexed_same: bool = False):
+    def _concat_objects(
+        self,
+        values,
+        not_indexed_same: bool = False,
+        override_group_keys: bool = False,
+    ):
         from pandas.core.reshape.concat import concat
 
         def reset_identity(values):
@@ -1024,28 +1136,7 @@ def reset_identity(values):
                 ax._reset_identity()
             return values
 
-        if not not_indexed_same:
-            result = concat(values, axis=self.axis)
-
-            ax = self._selected_obj._get_axis(self.axis)
-            if self.dropna:
-                labels = self.grouper.group_info[0]
-                mask = labels != -1
-                ax = ax[mask]
-
-            # this is a very unfortunate situation
-            # we can't use reindex to restore the original order
-            # when the ax has duplicates
-            # so we resort to this
-            # GH 14776, 30667
-            if ax.has_duplicates and not result.axes[self.axis].equals(ax):
-                indexer, _ = result.index.get_indexer_non_unique(ax._values)
-                indexer = algorithms.unique1d(indexer)
-                result = result.take(indexer, axis=self.axis)
-            else:
-                result = result.reindex(ax, axis=self.axis, copy=False)
-
-        elif self.group_keys:
+        if self.group_keys and not override_group_keys:
 
             values = reset_identity(values)
             if self.as_index:
@@ -1069,6 +1160,28 @@ def reset_identity(values):
                 # range index
                 keys = list(range(len(values)))
                 result = concat(values, axis=self.axis, keys=keys)
+
+        elif not not_indexed_same:
+            result = concat(values, axis=self.axis)
+
+            ax = self._selected_obj._get_axis(self.axis)
+            if self.dropna:
+                labels = self.grouper.group_info[0]
+                mask = labels != -1
+                ax = ax[mask]
+
+            # this is a very unfortunate situation
+            # we can't use reindex to restore the original order
+            # when the ax has duplicates
+            # so we resort to this
+            # GH 14776, 30667
+            if ax.has_duplicates and not result.axes[self.axis].equals(ax):
+                target = algorithms.unique1d(ax._values)
+                indexer, _ = result.index.get_indexer_non_unique(target)
+                result = result.take(indexer, axis=self.axis)
+            else:
+                result = result.reindex(ax, axis=self.axis, copy=False)
+
         else:
             values = reset_identity(values)
             result = concat(values, axis=self.axis)
@@ -1087,27 +1200,22 @@ def _set_result_index_ordered(
         # set the result index on the passed values object and
         # return the new object, xref 8046
 
-        if self.grouper.is_monotonic:
+        obj_axis = self.obj._get_axis(self.axis)
+
+        if self.grouper.is_monotonic and not self.grouper.has_dropped_na:
             # shortcut if we have an already ordered grouper
-            result.set_axis(self.obj._get_axis(self.axis), axis=self.axis, inplace=True)
+            result = result.set_axis(obj_axis, axis=self.axis, copy=False)
             return result
 
         # row order is scrambled => sort the rows by position in original index
-        original_positions = Index(
-            np.concatenate(self._get_indices(self.grouper.result_index))
-        )
-        result.set_axis(original_positions, axis=self.axis, inplace=True)
+        original_positions = Index(self.grouper.result_ilocs())
+        result = result.set_axis(original_positions, axis=self.axis, copy=False)
         result = result.sort_index(axis=self.axis)
-
-        dropped_rows = len(result.index) < len(self.obj.index)
-
-        if dropped_rows:
-            # get index by slicing original index according to original positions
-            # slice drops attrs => use set_axis when no rows were dropped
-            sorted_indexer = result.index
-            result.index = self._selected_obj.index[sorted_indexer]
-        else:
-            result.set_axis(self.obj._get_axis(self.axis), axis=self.axis, inplace=True)
+        if self.grouper.has_dropped_na:
+            # Add back in any missing rows due to dropna - index here is integral
+            # with values referring to the row of the input so can use RangeIndex
+            result = result.reindex(RangeIndex(len(obj_axis)), axis=self.axis)
+        result = result.set_axis(obj_axis, axis=self.axis, copy=False)
 
         return result
 
@@ -1201,10 +1309,18 @@ def _wrap_transformed_output(
         result.index = self.obj.index
         return result
 
-    def _wrap_applied_output(self, data, values: list, not_indexed_same: bool = False):
+    def _wrap_applied_output(
+        self,
+        data,
+        values: list,
+        not_indexed_same: bool = False,
+        override_group_keys: bool = False,
+    ):
         raise AbstractMethodError(self)
 
-    def _resolve_numeric_only(self, numeric_only: bool | lib.NoDefault) -> bool:
+    def _resolve_numeric_only(
+        self, how: str, numeric_only: bool | lib.NoDefault, axis: int
+    ) -> bool:
         """
         Determine subclass-specific default value for 'numeric_only'.
 
@@ -1214,6 +1330,8 @@ def _resolve_numeric_only(self, numeric_only: bool | lib.NoDefault) -> bool:
         Parameters
         ----------
         numeric_only : bool or lib.no_default
+        axis : int
+            Axis passed to the groupby op (not self.axis).
 
         Returns
         -------
@@ -1224,7 +1342,7 @@ def _resolve_numeric_only(self, numeric_only: bool | lib.NoDefault) -> bool:
             # i.e. not explicitly passed by user
             if self.obj.ndim == 2:
                 # i.e. DataFrameGroupBy
-                numeric_only = True
+                numeric_only = axis != 1
                 # GH#42395 GH#43108 GH#43154
                 # Regression from 1.2.5 to 1.3 caused object columns to be dropped
                 if self.axis:
@@ -1234,30 +1352,66 @@ def _resolve_numeric_only(self, numeric_only: bool | lib.NoDefault) -> bool:
                 check = obj._get_numeric_data()
                 if len(obj.columns) and not len(check.columns) and not obj.empty:
                     numeric_only = False
-                    # TODO: v1.4+ Add FutureWarning
 
             else:
                 numeric_only = False
 
-        # error: Incompatible return value type (got "Union[bool, NoDefault]",
-        # expected "bool")
-        return numeric_only  # type: ignore[return-value]
+        if numeric_only and self.obj.ndim == 1 and not is_numeric_dtype(self.obj.dtype):
+            # GH#47500
+            warnings.warn(
+                f"{type(self).__name__}.{how} called with "
+                f"numeric_only={numeric_only} and dtype {self.obj.dtype}. This will "
+                "raise a TypeError in a future version of pandas",
+                category=FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            raise NotImplementedError(
+                f"{type(self).__name__}.{how} does not implement numeric_only"
+            )
+
+        return numeric_only
+
+    def _maybe_warn_numeric_only_depr(
+        self, how: str, result: DataFrame | Series, numeric_only: bool | lib.NoDefault
+    ) -> None:
+        """Emit warning on numeric_only behavior deprecation when appropriate.
+
+        Parameters
+        ----------
+        how : str
+            Groupby kernel name.
+        result :
+            Result of the groupby operation.
+        numeric_only : bool or lib.no_default
+            Argument as passed by user.
+        """
+        if (
+            self._obj_with_exclusions.ndim != 1
+            and result.ndim > 1
+            and len(result.columns) < len(self._obj_with_exclusions.columns)
+        ):
+            warn_dropping_nuisance_columns_deprecated(type(self), how, numeric_only)
 
     # -----------------------------------------------------------------
     # numba
 
     @final
-    def _numba_prep(self, func, data):
-        if not callable(func):
-            raise NotImplementedError(
-                "Numba engine can only be used with a single function."
-            )
+    def _numba_prep(self, data):
         ids, _, ngroups = self.grouper.group_info
         sorted_index = get_group_index_sorter(ids, ngroups)
         sorted_ids = algorithms.take_nd(ids, sorted_index, allow_fill=False)
 
         sorted_data = data.take(sorted_index, axis=self.axis).to_numpy()
-        sorted_index_data = data.index.take(sorted_index).to_numpy()
+        if len(self.grouper.groupings) > 1:
+            raise NotImplementedError(
+                "More than 1 grouping labels are not supported with engine='numba'"
+            )
+        # GH 46867
+        index_data = data.index
+        if isinstance(index_data, MultiIndex):
+            group_key = self.grouper.groupings[0].name
+            index_data = index_data.get_level_values(group_key)
+        sorted_index_data = index_data.take(sorted_index).to_numpy()
 
         starts, ends = lib.generate_slices(sorted_ids, ngroups)
         return (
@@ -1271,7 +1425,6 @@ def _numba_agg_general(
         self,
         func: Callable,
         engine_kwargs: dict[str, bool] | None,
-        numba_cache_key_str: str,
         *aggregator_args,
     ):
         """
@@ -1288,16 +1441,12 @@ def _numba_agg_general(
         with self._group_selection_context():
             data = self._selected_obj
         df = data if data.ndim == 2 else data.to_frame()
-        starts, ends, sorted_index, sorted_data = self._numba_prep(func, df)
+        starts, ends, sorted_index, sorted_data = self._numba_prep(df)
         aggregator = executor.generate_shared_aggregator(
-            func, engine_kwargs, numba_cache_key_str
+            func, **get_jit_arguments(engine_kwargs)
         )
         result = aggregator(sorted_data, starts, ends, 0, *aggregator_args)
 
-        cache_key = (func, numba_cache_key_str)
-        if cache_key not in NUMBA_FUNC_CACHE:
-            NUMBA_FUNC_CACHE[cache_key] = aggregator
-
         index = self.grouper.result_index
         if data.ndim == 1:
             result_kwargs = {"name": data.name}
@@ -1315,10 +1464,10 @@ def _transform_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
         to generate the indices of each group in the sorted data and then passes the
         data and indices into a Numba jitted function.
         """
-        starts, ends, sorted_index, sorted_data = self._numba_prep(func, data)
-
+        starts, ends, sorted_index, sorted_data = self._numba_prep(data)
+        numba_.validate_udf(func)
         numba_transform_func = numba_.generate_numba_transform_func(
-            kwargs, func, engine_kwargs
+            func, **get_jit_arguments(engine_kwargs, kwargs)
         )
         result = numba_transform_func(
             sorted_data,
@@ -1328,11 +1477,6 @@ def _transform_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
             len(data.columns),
             *args,
         )
-
-        cache_key = (func, "groupby_transform")
-        if cache_key not in NUMBA_FUNC_CACHE:
-            NUMBA_FUNC_CACHE[cache_key] = numba_transform_func
-
         # result values needs to be resorted to their original positions since we
         # evaluated the data sorted by group
         return result.take(np.argsort(sorted_index), axis=0)
@@ -1346,9 +1490,11 @@ def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
         to generate the indices of each group in the sorted data and then passes the
         data and indices into a Numba jitted function.
         """
-        starts, ends, sorted_index, sorted_data = self._numba_prep(func, data)
-
-        numba_agg_func = numba_.generate_numba_agg_func(kwargs, func, engine_kwargs)
+        starts, ends, sorted_index, sorted_data = self._numba_prep(data)
+        numba_.validate_udf(func)
+        numba_agg_func = numba_.generate_numba_agg_func(
+            func, **get_jit_arguments(engine_kwargs, kwargs)
+        )
         result = numba_agg_func(
             sorted_data,
             sorted_index,
@@ -1357,11 +1503,6 @@ def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
             len(data.columns),
             *args,
         )
-
-        cache_key = (func, "groupby_agg")
-        if cache_key not in NUMBA_FUNC_CACHE:
-            NUMBA_FUNC_CACHE[cache_key] = numba_agg_func
-
         return result
 
     # -----------------------------------------------------------------
@@ -1372,14 +1513,25 @@ def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
             input="dataframe", examples=_apply_docs["dataframe_examples"]
         )
     )
-    def apply(self, func, *args, **kwargs):
-
+    def apply(self, func, *args, **kwargs) -> NDFrameT:
+        # GH#50538
+        is_np_func = func in com._cython_table and func not in com._builtin_table
+        orig_func = func
         func = com.is_builtin_func(func)
 
-        # this is needed so we don't try and wrap strings. If we could
-        # resolve functions to their callable functions prior, this
-        # wouldn't be needed
-        if args or kwargs:
+        if isinstance(func, str):
+            if hasattr(self, func):
+                res = getattr(self, func)
+                if callable(res):
+                    return res(*args, **kwargs)
+                elif args or kwargs:
+                    raise ValueError(f"Cannot pass arguments to property {func}")
+                return res
+
+            else:
+                raise TypeError(f"apply func should be callable, not '{func}'")
+
+        elif args or kwargs:
             if callable(func):
 
                 @wraps(func)
@@ -1395,15 +1547,6 @@ def f(g):
                 raise ValueError(
                     "func must be a callable if args or kwargs are supplied"
                 )
-        elif isinstance(func, str):
-            if hasattr(self, func):
-                res = getattr(self, func)
-                if callable(res):
-                    return res()
-                return res
-
-            else:
-                raise TypeError(f"apply func should be callable, not '{func}'")
         else:
 
             f = func
@@ -1411,7 +1554,17 @@ def f(g):
         # ignore SettingWithCopy here in case the user mutates
         with option_context("mode.chained_assignment", None):
             try:
-                result = self._python_apply_general(f, self._selected_obj)
+                # GH#50538
+                old_msg = "The default value of numeric_only"
+                new_msg = (
+                    f"The operation {orig_func} failed on a column. If any error is "
+                    f"raised, this will raise an exception in a future version "
+                    f"of pandas. Drop these columns to avoid this warning."
+                )
+                with rewrite_warning(
+                    old_msg, FutureWarning, new_msg
+                ) if is_np_func else nullcontext():
+                    result = self._python_apply_general(f, self._selected_obj)
             except TypeError:
                 # gh-20949
                 # try again, with .apply acting as a filtering
@@ -1422,7 +1575,17 @@ def f(g):
                 # on a string grouper column
 
                 with self._group_selection_context():
-                    return self._python_apply_general(f, self._selected_obj)
+                    # GH#50538
+                    old_msg = "The default value of numeric_only"
+                    new_msg = (
+                        f"The operation {orig_func} failed on a column. If any error "
+                        f"is raised, this will raise an exception in a future version "
+                        f"of pandas. Drop these columns to avoid this warning."
+                    )
+                    with rewrite_warning(
+                        old_msg, FutureWarning, new_msg
+                    ) if is_np_func else nullcontext():
+                        return self._python_apply_general(f, self._selected_obj)
 
         return result
 
@@ -1432,7 +1595,9 @@ def _python_apply_general(
         f: Callable,
         data: DataFrame | Series,
         not_indexed_same: bool | None = None,
-    ) -> DataFrame | Series:
+        is_transform: bool = False,
+        is_agg: bool = False,
+    ) -> NDFrameT:
         """
         Apply function f in python space
 
@@ -1446,6 +1611,15 @@ def _python_apply_general(
             When specified, overrides the value of not_indexed_same. Apply behaves
             differently when the result index is equal to the input index, but
             this can be coincidental leading to value-dependent behavior.
+        is_transform : bool, default False
+            Indicator for whether the function is actually a transform
+            and should not have group keys prepended. This is used
+            in _make_wrapper which generates both transforms (e.g. diff)
+            and non-transforms (e.g. corr)
+        is_agg : bool, default False
+            Indicator for whether the function is an aggregation. When the
+            result is empty, we don't want to warn for this case.
+            See _GroupBy._python_agg_general.
 
         Returns
         -------
@@ -1453,16 +1627,43 @@ def _python_apply_general(
             data after applying f
         """
         values, mutated = self.grouper.apply(f, data, self.axis)
-
         if not_indexed_same is None:
             not_indexed_same = mutated or self.mutated
+        override_group_keys = False
+
+        is_empty_agg = is_agg and len(values) == 0
+        if (not not_indexed_same and self.group_keys is lib.no_default) and not (
+            is_transform or is_empty_agg
+        ):
+            # We've detected value-dependent behavior: the result's index depends on
+            # whether the user's function `f` returned the same index or not.
+            msg = (
+                "Not prepending group keys to the result index of "
+                "transform-like apply. In the future, the group keys "
+                "will be included in the index, regardless of whether "
+                "the applied function returns a like-indexed object.\n"
+                "To preserve the previous behavior, use\n\n\t"
+                ">>> .groupby(..., group_keys=False)\n\n"
+                "To adopt the future behavior and silence this warning, use "
+                "\n\n\t>>> .groupby(..., group_keys=True)"
+            )
+            warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
+            # We want to behave as if `self.group_keys=False` when reconstructing
+            # the object. However, we don't want to mutate the stateful GroupBy
+            # object, so we just override it.
+            # When this deprecation is enforced then override_group_keys
+            # may be removed.
+            override_group_keys = True
 
         return self._wrap_applied_output(
-            data, values, not_indexed_same=not_indexed_same
+            data,
+            values,
+            not_indexed_same,
+            override_group_keys=is_transform or override_group_keys,
         )
 
     @final
-    def _python_agg_general(self, func, *args, **kwargs):
+    def _python_agg_general(self, func, *args, raise_on_typeerror=False, **kwargs):
         func = com.is_builtin_func(func)
         f = lambda x: func(x, *args, **kwargs)
 
@@ -1471,7 +1672,7 @@ def _python_agg_general(self, func, *args, **kwargs):
 
         if self.ngroups == 0:
             # agg_series below assumes ngroups > 0
-            return self._python_apply_general(f, self._selected_obj)
+            return self._python_apply_general(f, self._selected_obj, is_agg=True)
 
         for idx, obj in enumerate(self._iterate_slices()):
             name = obj.name
@@ -1480,7 +1681,11 @@ def _python_agg_general(self, func, *args, **kwargs):
                 # if this function is invalid for this dtype, we will ignore it.
                 result = self.grouper.agg_series(obj, f)
             except TypeError:
-                warn_dropping_nuisance_columns_deprecated(type(self), "agg")
+                if raise_on_typeerror:
+                    raise
+                warn_dropping_nuisance_columns_deprecated(
+                    type(self), "agg", numeric_only=False
+                )
                 continue
 
             key = base.OutputKey(label=name, position=idx)
@@ -1494,7 +1699,7 @@ def _python_agg_general(self, func, *args, **kwargs):
     @final
     def _agg_general(
         self,
-        numeric_only: bool = True,
+        numeric_only: bool | lib.NoDefault = True,
         min_count: int = -1,
         *,
         alias: str,
@@ -1553,15 +1758,23 @@ def _agg_py_fallback(
 
     @final
     def _cython_agg_general(
-        self, how: str, alt: Callable, numeric_only: bool, min_count: int = -1
+        self,
+        how: str,
+        alt: Callable,
+        numeric_only: bool | lib.NoDefault,
+        min_count: int = -1,
+        ignore_failures: bool = True,
+        **kwargs,
     ):
         # Note: we never get here with how="ohlc" for DataFrameGroupBy;
         #  that goes through SeriesGroupBy
+        numeric_only_bool = self._resolve_numeric_only(how, numeric_only, axis=0)
 
         data = self._get_data_to_aggregate()
         is_ser = data.ndim == 1
 
-        if numeric_only:
+        orig_len = len(data)
+        if numeric_only_bool:
             if is_ser and not is_numeric_dtype(self._selected_obj.dtype):
                 # GH#41291 match Series behavior
                 kwd_name = "numeric_only"
@@ -1576,7 +1789,12 @@ def _cython_agg_general(
         def array_func(values: ArrayLike) -> ArrayLike:
             try:
                 result = self.grouper._cython_operation(
-                    "aggregate", values, how, axis=data.ndim - 1, min_count=min_count
+                    "aggregate",
+                    values,
+                    how,
+                    axis=data.ndim - 1,
+                    min_count=min_count,
+                    **kwargs,
                 )
             except NotImplementedError:
                 # generally if we have numeric_only=False
@@ -1589,10 +1807,10 @@ def array_func(values: ArrayLike) -> ArrayLike:
 
         # TypeError -> we may have an exception in trying to aggregate
         #  continue and exclude the block
-        new_mgr = data.grouped_reduce(array_func, ignore_failures=True)
+        new_mgr = data.grouped_reduce(array_func, ignore_failures=ignore_failures)
 
-        if not is_ser and len(new_mgr) < len(data):
-            warn_dropping_nuisance_columns_deprecated(type(self), how)
+        if not is_ser and len(new_mgr) < orig_len:
+            warn_dropping_nuisance_columns_deprecated(type(self), how, numeric_only)
 
         res = self._wrap_agged_manager(new_mgr)
         if is_ser:
@@ -1648,13 +1866,12 @@ def _transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
             # and deal with possible broadcasting below.
             # Temporarily set observed for dealing with categoricals.
             with com.temp_setattr(self, "observed", True):
-                result = getattr(self, func)(*args, **kwargs)
+                with com.temp_setattr(self, "as_index", True):
+                    # GH#49834 - result needs groups in the index for
+                    # _wrap_transform_fast_result
+                    result = getattr(self, func)(*args, **kwargs)
 
-            if self._can_use_transform_fast(result):
-                return self._wrap_transform_fast_result(result)
-
-            # only reached for DataFrameGroupBy
-            return self._transform_general(func, *args, **kwargs)
+            return self._wrap_transform_fast_result(result)
 
     @final
     def _wrap_transform_fast_result(self, result: NDFrameT) -> NDFrameT:
@@ -1665,15 +1882,20 @@ def _wrap_transform_fast_result(self, result: NDFrameT) -> NDFrameT:
 
         # for each col, reshape to size of original frame by take operation
         ids, _, _ = self.grouper.group_info
-        result = result.reindex(self.grouper.result_index, copy=False)
+        result = result.reindex(self.grouper.result_index, axis=self.axis, copy=False)
 
         if self.obj.ndim == 1:
             # i.e. SeriesGroupBy
             out = algorithms.take_nd(result._values, ids)
             output = obj._constructor(out, index=obj.index, name=obj.name)
         else:
-            output = result.take(ids, axis=0)
-            output.index = obj.index
+            # `.size()` gives Series output on DataFrame input, need axis 0
+            axis = 0 if result.ndim == 1 else self.axis
+            # GH#46209
+            # Don't convert indices: negative indices need to give rise
+            # to null values in the result
+            output = result._take(ids, axis=axis, convert_indices=False)
+            output = output.set_axis(obj._get_axis(self.axis), axis=axis)
         return output
 
     # -----------------------------------------------------------------
@@ -1725,15 +1947,20 @@ def _cumcount_array(self, ascending: bool = True) -> np.ndarray:
         else:
             out = np.repeat(out[np.r_[run[1:], True]], rep) - out
 
+        if self.grouper.has_dropped_na:
+            out = np.where(ids == -1, np.nan, out.astype(np.float64, copy=False))
+        else:
+            out = out.astype(np.int64, copy=False)
+
         rev = np.empty(count, dtype=np.intp)
         rev[sorter] = np.arange(count, dtype=np.intp)
-        return out[rev].astype(np.int64, copy=False)
+        return out[rev]
 
     # -----------------------------------------------------------------
 
     @final
     @property
-    def _obj_1d_constructor(self) -> type[Series]:
+    def _obj_1d_constructor(self) -> Callable:
         # GH28330 preserve subclassed Series/DataFrames
         if isinstance(self.obj, DataFrame):
             return self.obj._constructor_sliced
@@ -1750,7 +1977,9 @@ def objs_to_bool(vals: ArrayLike) -> tuple[np.ndarray, type]:
             if is_object_dtype(vals.dtype):
                 # GH#37501: don't raise on pd.NA when skipna=True
                 if skipna:
-                    func = np.vectorize(lambda x: bool(x) if not isna(x) else True)
+                    func = np.vectorize(
+                        lambda x: bool(x) if not isna(x) else True, otypes=[bool]
+                    )
                     vals = func(vals)
                 else:
                     vals = vals.astype(bool, copy=False)
@@ -1828,7 +2057,7 @@ def all(self, skipna: bool = True):
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def count(self) -> Series | DataFrame:
+    def count(self) -> NDFrameT:
         """
         Compute count of group, excluding missing values.
 
@@ -1944,17 +2173,17 @@ def mean(
         2    4.0
         Name: B, dtype: float64
         """
-        numeric_only_bool = self._resolve_numeric_only(numeric_only)
+        numeric_only_bool = self._resolve_numeric_only("mean", numeric_only, axis=0)
 
         if maybe_use_numba(engine):
             from pandas.core._numba.kernels import sliding_mean
 
-            return self._numba_agg_general(sliding_mean, engine_kwargs, "groupby_mean")
+            return self._numba_agg_general(sliding_mean, engine_kwargs)
         else:
             result = self._cython_agg_general(
                 "mean",
                 alt=lambda x: Series(x).mean(numeric_only=numeric_only_bool),
-                numeric_only=numeric_only_bool,
+                numeric_only=numeric_only,
             )
             return result.__finalize__(self.obj, method="groupby")
 
@@ -1978,12 +2207,12 @@ def median(self, numeric_only: bool | lib.NoDefault = lib.no_default):
         Series or DataFrame
             Median of values within each group.
         """
-        numeric_only_bool = self._resolve_numeric_only(numeric_only)
+        numeric_only_bool = self._resolve_numeric_only("median", numeric_only, axis=0)
 
         result = self._cython_agg_general(
             "median",
             alt=lambda x: Series(x).median(numeric_only=numeric_only_bool),
-            numeric_only=numeric_only_bool,
+            numeric_only=numeric_only,
         )
         return result.__finalize__(self.obj, method="groupby")
 
@@ -1995,6 +2224,7 @@ def std(
         ddof: int = 1,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
     ):
         """
         Compute standard deviation of groups, excluding missing values.
@@ -2023,6 +2253,11 @@ def std(
 
             .. versionadded:: 1.4.0
 
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         Series or DataFrame
@@ -2031,17 +2266,29 @@ def std(
         if maybe_use_numba(engine):
             from pandas.core._numba.kernels import sliding_var
 
-            return np.sqrt(
-                self._numba_agg_general(sliding_var, engine_kwargs, "groupby_std", ddof)
-            )
+            return np.sqrt(self._numba_agg_general(sliding_var, engine_kwargs, ddof))
         else:
-            return self._get_cythonized_result(
+            # Resolve numeric_only so that var doesn't warn
+            numeric_only_bool = self._resolve_numeric_only("std", numeric_only, axis=0)
+            if (
+                numeric_only_bool
+                and self.obj.ndim == 1
+                and not is_numeric_dtype(self.obj.dtype)
+            ):
+                raise TypeError(
+                    f"{type(self).__name__}.std called with "
+                    f"numeric_only={numeric_only} and dtype {self.obj.dtype}"
+                )
+            result = self._get_cythonized_result(
                 libgroupby.group_var,
-                needs_counts=True,
                 cython_dtype=np.dtype(np.float64),
+                numeric_only=numeric_only_bool,
+                needs_counts=True,
                 post_processing=lambda vals, inference: np.sqrt(vals),
                 ddof=ddof,
             )
+            self._maybe_warn_numeric_only_depr("std", result, numeric_only)
+            return result
 
     @final
     @Substitution(name="groupby")
@@ -2051,6 +2298,7 @@ def var(
         ddof: int = 1,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
     ):
         """
         Compute variance of groups, excluding missing values.
@@ -2079,6 +2327,11 @@ def var(
 
             .. versionadded:: 1.4.0
 
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         Series or DataFrame
@@ -2087,26 +2340,20 @@ def var(
         if maybe_use_numba(engine):
             from pandas.core._numba.kernels import sliding_var
 
-            return self._numba_agg_general(
-                sliding_var, engine_kwargs, "groupby_var", ddof
-            )
+            return self._numba_agg_general(sliding_var, engine_kwargs, ddof)
         else:
-            if ddof == 1:
-                numeric_only = self._resolve_numeric_only(lib.no_default)
-                return self._cython_agg_general(
-                    "var",
-                    alt=lambda x: Series(x).var(ddof=ddof),
-                    numeric_only=numeric_only,
-                )
-            else:
-                func = lambda x: x.var(ddof=ddof)
-                with self._group_selection_context():
-                    return self._python_agg_general(func)
+            return self._cython_agg_general(
+                "var",
+                alt=lambda x: Series(x).var(ddof=ddof),
+                numeric_only=numeric_only,
+                ignore_failures=numeric_only is lib.no_default,
+                ddof=ddof,
+            )
 
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def sem(self, ddof: int = 1):
+    def sem(self, ddof: int = 1, numeric_only: bool | lib.NoDefault = lib.no_default):
         """
         Compute standard error of the mean of groups, excluding missing values.
 
@@ -2117,12 +2364,30 @@ def sem(self, ddof: int = 1):
         ddof : int, default 1
             Degrees of freedom.
 
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         Series or DataFrame
             Standard error of the mean of values within each group.
         """
-        result = self.std(ddof=ddof)
+        # Reolve numeric_only so that std doesn't warn
+        numeric_only_bool = self._resolve_numeric_only("sem", numeric_only, axis=0)
+        if (
+            numeric_only_bool
+            and self.obj.ndim == 1
+            and not is_numeric_dtype(self.obj.dtype)
+        ):
+            raise TypeError(
+                f"{type(self).__name__}.sem called with "
+                f"numeric_only={numeric_only} and dtype {self.obj.dtype}"
+            )
+        result = self.std(ddof=ddof, numeric_only=numeric_only_bool)
+        self._maybe_warn_numeric_only_depr("sem", result, numeric_only)
+
         if result.ndim == 1:
             result /= np.sqrt(self.count())
         else:
@@ -2130,7 +2395,13 @@ def sem(self, ddof: int = 1):
             counts = self.count()
             result_ilocs = result.columns.get_indexer_for(cols)
             count_ilocs = counts.columns.get_indexer_for(cols)
-            result.iloc[:, result_ilocs] /= np.sqrt(counts.iloc[:, count_ilocs])
+            with warnings.catch_warnings():
+                # TODO(2.0): once iloc[:, foo] = bar depecation is enforced,
+                #  this catching will be unnecessary
+                warnings.filterwarnings(
+                    "ignore", ".*will attempt to set the values inplace.*"
+                )
+                result.iloc[:, result_ilocs] /= np.sqrt(counts.iloc[:, count_ilocs])
         return result
 
     @final
@@ -2149,14 +2420,15 @@ def size(self) -> DataFrame | Series:
         result = self.grouper.size()
 
         # GH28330 preserve subclassed Series/DataFrames through calls
-        if issubclass(self.obj._constructor, Series):
+        if isinstance(self.obj, Series):
             result = self._obj_1d_constructor(result, name=self.obj.name)
         else:
             result = self._obj_1d_constructor(result)
 
         if not self.as_index:
-            # Item "None" of "Optional[Series]" has no attribute "reset_index"
-            result = result.rename("size").reset_index()  # type: ignore[union-attr]
+            # error: Incompatible types in assignment (expression has
+            # type "DataFrame", variable has type "Series")
+            result = result.rename("size").reset_index()  # type: ignore[assignment]
 
         return self._reindex_output(result, fill_value=0)
 
@@ -2175,11 +2447,8 @@ def sum(
             return self._numba_agg_general(
                 sliding_sum,
                 engine_kwargs,
-                "groupby_sum",
             )
         else:
-            numeric_only = self._resolve_numeric_only(numeric_only)
-
             # If we are grouping on categoricals we want unobserved categories to
             # return zero, rather than the default of NaN which the reindexing in
             # _agg_general() returns. GH #31422
@@ -2187,7 +2456,7 @@ def sum(
                 result = self._agg_general(
                     numeric_only=numeric_only,
                     min_count=min_count,
-                    alias="add",
+                    alias="sum",
                     npfunc=np.sum,
                 )
 
@@ -2198,29 +2467,101 @@ def sum(
     def prod(
         self, numeric_only: bool | lib.NoDefault = lib.no_default, min_count: int = 0
     ):
-        numeric_only = self._resolve_numeric_only(numeric_only)
-
         return self._agg_general(
             numeric_only=numeric_only, min_count=min_count, alias="prod", npfunc=np.prod
         )
 
     @final
     @doc(_groupby_agg_method_template, fname="min", no=False, mc=-1)
-    def min(self, numeric_only: bool = False, min_count: int = -1):
-        return self._agg_general(
-            numeric_only=numeric_only, min_count=min_count, alias="min", npfunc=np.min
-        )
+    def min(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: str | None = None,
+        engine_kwargs: dict[str, bool] | None = None,
+    ):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import sliding_min_max
+
+            return self._numba_agg_general(sliding_min_max, engine_kwargs, False)
+        else:
+            return self._agg_general(
+                numeric_only=numeric_only,
+                min_count=min_count,
+                alias="min",
+                npfunc=np.min,
+            )
 
     @final
     @doc(_groupby_agg_method_template, fname="max", no=False, mc=-1)
-    def max(self, numeric_only: bool = False, min_count: int = -1):
-        return self._agg_general(
-            numeric_only=numeric_only, min_count=min_count, alias="max", npfunc=np.max
-        )
+    def max(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: str | None = None,
+        engine_kwargs: dict[str, bool] | None = None,
+    ):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import sliding_min_max
+
+            return self._numba_agg_general(sliding_min_max, engine_kwargs, True)
+        else:
+            return self._agg_general(
+                numeric_only=numeric_only,
+                min_count=min_count,
+                alias="max",
+                npfunc=np.max,
+            )
 
     @final
-    @doc(_groupby_agg_method_template, fname="first", no=False, mc=-1)
+    @Substitution(name="groupby")
     def first(self, numeric_only: bool = False, min_count: int = -1):
+        """
+        Compute the first non-null entry of each column.
+
+        Parameters
+        ----------
+        numeric_only : bool, default False
+            Include only float, int, boolean columns.
+        min_count : int, default -1
+            The required number of valid values to perform the operation. If fewer
+            than ``min_count`` non-NA values are present the result will be NA.
+
+        Returns
+        -------
+        Series or DataFrame
+            First non-null of values within each group.
+
+        See Also
+        --------
+        DataFrame.groupby : Apply a function groupby to each row or column of a
+            DataFrame.
+        DataFrame.core.groupby.GroupBy.last : Compute the last non-null entry of each
+            column.
+        DataFrame.core.groupby.GroupBy.nth : Take the nth row from each group.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[None, 5, 6], C=[1, 2, 3],
+        ...                        D=['3/11/2000', '3/12/2000', '3/13/2000']))
+        >>> df['D'] = pd.to_datetime(df['D'])
+        >>> df.groupby("A").first()
+             B  C          D
+        A
+        1  5.0  1 2000-03-11
+        3  6.0  3 2000-03-13
+        >>> df.groupby("A").first(min_count=2)
+            B    C          D
+        A
+        1 NaN  1.0 2000-03-11
+        3 NaN  NaN        NaT
+        >>> df.groupby("A").first(numeric_only=True)
+             B  C
+        A
+        1  5.0  1
+        3  6.0  3
+        """
+
         def first_compat(obj: NDFrameT, axis: int = 0):
             def first(x: Series):
                 """Helper function for first item that isn't NA."""
@@ -2244,8 +2585,43 @@ def first(x: Series):
         )
 
     @final
-    @doc(_groupby_agg_method_template, fname="last", no=False, mc=-1)
+    @Substitution(name="groupby")
     def last(self, numeric_only: bool = False, min_count: int = -1):
+        """
+        Compute the last non-null entry of each column.
+
+        Parameters
+        ----------
+        numeric_only : bool, default False
+            Include only float, int, boolean columns. If None, will attempt to use
+            everything, then use only numeric data.
+        min_count : int, default -1
+            The required number of valid values to perform the operation. If fewer
+            than ``min_count`` non-NA values are present the result will be NA.
+
+        Returns
+        -------
+        Series or DataFrame
+            Last non-null of values within each group.
+
+        See Also
+        --------
+        DataFrame.groupby : Apply a function groupby to each row or column of a
+            DataFrame.
+        DataFrame.core.groupby.GroupBy.first : Compute the first non-null entry of each
+            column.
+        DataFrame.core.groupby.GroupBy.nth : Take the nth row from each group.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[5, None, 6], C=[1, 2, 3]))
+        >>> df.groupby("A").last()
+             B  C
+        A
+        1  5.0  2
+        3  6.0  3
+        """
+
         def last_compat(obj: NDFrameT, axis: int = 0):
             def last(x: Series):
                 """Helper function for last item that isn't NA."""
@@ -2307,7 +2683,19 @@ def ohlc(self) -> DataFrame:
     @doc(DataFrame.describe)
     def describe(self, **kwargs):
         with self._group_selection_context():
-            result = self.apply(lambda x: x.describe(**kwargs))
+            if len(self._selected_obj) == 0:
+                described = self._selected_obj.describe(**kwargs)
+                if self._selected_obj.ndim == 1:
+                    result = described
+                else:
+                    result = described.unstack()
+                return result.to_frame().T.iloc[:0]
+
+            result = self._python_apply_general(
+                lambda x: x.describe(**kwargs),
+                self._selected_obj,
+                not_indexed_same=True,
+            )
             if self.axis == 1:
                 return result.T
             return result.unstack()
@@ -2417,7 +2805,7 @@ def resample(self, rule, *args, **kwargs):
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def rolling(self, *args, **kwargs):
+    def rolling(self, *args, **kwargs) -> RollingGroupby:
         """
         Return a rolling grouper, providing rolling functionality per group.
         """
@@ -2434,7 +2822,7 @@ def rolling(self, *args, **kwargs):
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def expanding(self, *args, **kwargs):
+    def expanding(self, *args, **kwargs) -> ExpandingGroupby:
         """
         Return an expanding grouper, providing expanding
         functionality per group.
@@ -2451,7 +2839,7 @@ def expanding(self, *args, **kwargs):
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def ewm(self, *args, **kwargs):
+    def ewm(self, *args, **kwargs) -> ExponentialMovingWindowGroupby:
         """
         Return an ewm grouper, providing ewm functionality per group.
         """
@@ -2522,7 +2910,11 @@ def blk_func(values: ArrayLike) -> ArrayLike:
                 #  then there will be no -1s in indexer, so we can use
                 #  the original dtype (no need to ensure_dtype_can_hold_na)
                 if isinstance(values, np.ndarray):
-                    out = np.empty(values.shape, dtype=values.dtype)
+                    dtype = values.dtype
+                    if self.grouper.has_dropped_na:
+                        # dropped null groups give rise to nan in the result
+                        dtype = ensure_dtype_can_hold_na(values.dtype)
+                    out = np.empty(values.shape, dtype=dtype)
                 else:
                     out = type(values)._empty(values.shape, dtype=values.dtype)
 
@@ -2571,6 +2963,22 @@ def ffill(self, limit=None):
         return self._fill("ffill", limit=limit)
 
     def pad(self, limit=None):
+        """
+        Forward fill the values.
+
+        .. deprecated:: 1.4
+            Use ffill instead.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        Series or DataFrame
+            Object with missing values filled.
+        """
         warnings.warn(
             "pad is deprecated and will be removed in a future version. "
             "Use ffill instead.",
@@ -2579,8 +2987,6 @@ def pad(self, limit=None):
         )
         return self.ffill(limit=limit)
 
-    pad.__doc__ = ffill.__doc__
-
     @final
     @Substitution(name="groupby")
     def bfill(self, limit=None):
@@ -2607,6 +3013,22 @@ def bfill(self, limit=None):
         return self._fill("bfill", limit=limit)
 
     def backfill(self, limit=None):
+        """
+        Backward fill the values.
+
+        .. deprecated:: 1.4
+            Use bfill instead.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        Series or DataFrame
+            Object with missing values filled.
+        """
         warnings.warn(
             "backfill is deprecated and will be removed in a future version. "
             "Use bfill instead.",
@@ -2615,16 +3037,13 @@ def backfill(self, limit=None):
         )
         return self.bfill(limit=limit)
 
-    backfill.__doc__ = bfill.__doc__
-
-    @final
+    # https://github.com/python/mypy/issues/1362
+    # Mypy does not support decorated properties
+    @final  # type: ignore[misc]
+    @property
     @Substitution(name="groupby")
     @Substitution(see_also=_common_see_also)
-    def nth(
-        self,
-        n: PositionalIndexer | tuple,
-        dropna: Literal["any", "all", None] = None,
-    ) -> NDFrameT:
+    def nth(self) -> GroupByNthSelector:
         """
         Take the nth row from each group if n is an int, otherwise a subset of rows.
 
@@ -2641,7 +3060,7 @@ def nth(
             A single nth value for the row or a list of nth values or slices.
 
             .. versionchanged:: 1.4.0
-                Added slice and lists containiing slices.
+                Added slice and lists containing slices.
                 Added index notation.
 
         dropna : {'any', 'all', None}, default None
@@ -2727,6 +3146,13 @@ def nth(
         1  1  2.0
         4  2  5.0
         """
+        return GroupByNthSelector(self)
+
+    def _nth(
+        self,
+        n: PositionalIndexer | tuple,
+        dropna: Literal["any", "all", None] = None,
+    ) -> NDFrameT:
         if not dropna:
             with self._group_selection_context():
                 mask = self._make_mask_from_positional_indexer(n)
@@ -2815,7 +3241,12 @@ def nth(
         return result
 
     @final
-    def quantile(self, q=0.5, interpolation: str = "linear"):
+    def quantile(
+        self,
+        q=0.5,
+        interpolation: str = "linear",
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+    ):
         """
         Return group values at the given quantile, a la numpy.percentile.
 
@@ -2825,6 +3256,10 @@ def quantile(self, q=0.5, interpolation: str = "linear"):
             Value(s) between 0 and 1 providing the quantile(s) to compute.
         interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
             Method to use when the desired quantile falls between two points.
+        numeric_only : bool, default True
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
 
         Returns
         -------
@@ -2849,6 +3284,16 @@ def quantile(self, q=0.5, interpolation: str = "linear"):
         a    2.0
         b    3.0
         """
+        numeric_only_bool = self._resolve_numeric_only("quantile", numeric_only, axis=0)
+        if (
+            numeric_only_bool
+            and self.obj.ndim == 1
+            and not is_numeric_dtype(self.obj.dtype)
+        ):
+            raise TypeError(
+                f"{type(self).__name__}.quantile called with "
+                f"numeric_only={numeric_only} and dtype {self.obj.dtype}"
+            )
 
         def pre_processor(vals: ArrayLike) -> tuple[np.ndarray, np.dtype | None]:
             if is_object_dtype(vals):
@@ -2942,10 +3387,18 @@ def blk_func(values: ArrayLike) -> ArrayLike:
         obj = self._obj_with_exclusions
         is_ser = obj.ndim == 1
         mgr = self._get_data_to_aggregate()
-
-        res_mgr = mgr.grouped_reduce(blk_func, ignore_failures=True)
-        if not is_ser and len(res_mgr.items) != len(mgr.items):
-            warn_dropping_nuisance_columns_deprecated(type(self), "quantile")
+        data = mgr.get_numeric_data() if numeric_only_bool else mgr
+        ignore_failures = numeric_only_bool
+        res_mgr = data.grouped_reduce(blk_func, ignore_failures=ignore_failures)
+
+        if (
+            numeric_only is lib.no_default
+            and not is_ser
+            and len(res_mgr.items) != len(mgr.items)
+        ):
+            warn_dropping_nuisance_columns_deprecated(
+                type(self), "quantile", numeric_only
+            )
 
             if len(res_mgr.items) == 0:
                 # re-call grouped_reduce to get the desired exception message
@@ -3028,9 +3481,16 @@ def ngroup(self, ascending: bool = True):
         """
         with self._group_selection_context():
             index = self._selected_obj.index
-            result = self._obj_1d_constructor(
-                self.grouper.group_info[0], index, dtype=np.int64
-            )
+            comp_ids = self.grouper.group_info[0]
+
+            dtype: type
+            if self.grouper.has_dropped_na:
+                comp_ids = np.where(comp_ids == -1, np.nan, comp_ids)
+                dtype = np.float64
+            else:
+                dtype = np.int64
+
+            result = self._obj_1d_constructor(comp_ids, index, dtype=dtype)
             if not ascending:
                 result = self.ngroups - 1 - result
             return result
@@ -3105,7 +3565,7 @@ def rank(
         na_option: str = "keep",
         pct: bool = False,
         axis: int = 0,
-    ):
+    ) -> NDFrameT:
         """
         Provide the rank of values within each group.
 
@@ -3180,7 +3640,11 @@ def rank(
         if axis != 0:
             # DataFrame uses different keyword name
             kwargs["method"] = kwargs.pop("ties_method")
-            return self.apply(lambda x: x.rank(axis=axis, numeric_only=False, **kwargs))
+            f = lambda x: x.rank(axis=axis, numeric_only=False, **kwargs)
+            result = self._python_apply_general(
+                f, self._selected_obj, is_transform=True
+            )
+            return result
 
         return self._cython_transform(
             "rank",
@@ -3192,7 +3656,7 @@ def rank(
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def cumprod(self, axis=0, *args, **kwargs):
+    def cumprod(self, axis=0, *args, **kwargs) -> NDFrameT:
         """
         Cumulative product for each group.
 
@@ -3202,14 +3666,15 @@ def cumprod(self, axis=0, *args, **kwargs):
         """
         nv.validate_groupby_func("cumprod", args, kwargs, ["numeric_only", "skipna"])
         if axis != 0:
-            return self.apply(lambda x: x.cumprod(axis=axis, **kwargs))
+            f = lambda x: x.cumprod(axis=axis, **kwargs)
+            return self._python_apply_general(f, self._selected_obj, is_transform=True)
 
         return self._cython_transform("cumprod", **kwargs)
 
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def cumsum(self, axis=0, *args, **kwargs):
+    def cumsum(self, axis=0, *args, **kwargs) -> NDFrameT:
         """
         Cumulative sum for each group.
 
@@ -3219,14 +3684,15 @@ def cumsum(self, axis=0, *args, **kwargs):
         """
         nv.validate_groupby_func("cumsum", args, kwargs, ["numeric_only", "skipna"])
         if axis != 0:
-            return self.apply(lambda x: x.cumsum(axis=axis, **kwargs))
+            f = lambda x: x.cumsum(axis=axis, **kwargs)
+            return self._python_apply_general(f, self._selected_obj, is_transform=True)
 
         return self._cython_transform("cumsum", **kwargs)
 
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def cummin(self, axis=0, **kwargs):
+    def cummin(self, axis=0, numeric_only=False, **kwargs) -> NDFrameT:
         """
         Cumulative min for each group.
 
@@ -3236,14 +3702,21 @@ def cummin(self, axis=0, **kwargs):
         """
         skipna = kwargs.get("skipna", True)
         if axis != 0:
-            return self.apply(lambda x: np.minimum.accumulate(x, axis))
+            f = lambda x: np.minimum.accumulate(x, axis)
+            numeric_only_bool = self._resolve_numeric_only("cummax", numeric_only, axis)
+            obj = self._selected_obj
+            if numeric_only_bool:
+                obj = obj._get_numeric_data()
+            return self._python_apply_general(f, obj, is_transform=True)
 
-        return self._cython_transform("cummin", numeric_only=False, skipna=skipna)
+        return self._cython_transform(
+            "cummin", numeric_only=numeric_only, skipna=skipna
+        )
 
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def cummax(self, axis=0, **kwargs):
+    def cummax(self, axis=0, numeric_only=False, **kwargs) -> NDFrameT:
         """
         Cumulative max for each group.
 
@@ -3253,9 +3726,16 @@ def cummax(self, axis=0, **kwargs):
         """
         skipna = kwargs.get("skipna", True)
         if axis != 0:
-            return self.apply(lambda x: np.maximum.accumulate(x, axis))
+            f = lambda x: np.maximum.accumulate(x, axis)
+            numeric_only_bool = self._resolve_numeric_only("cummax", numeric_only, axis)
+            obj = self._selected_obj
+            if numeric_only_bool:
+                obj = obj._get_numeric_data()
+            return self._python_apply_general(f, obj, is_transform=True)
 
-        return self._cython_transform("cummax", numeric_only=False, skipna=skipna)
+        return self._cython_transform(
+            "cummax", numeric_only=numeric_only, skipna=skipna
+        )
 
     @final
     def _get_cythonized_result(
@@ -3309,7 +3789,8 @@ def _get_cythonized_result(
         -------
         `Series` or `DataFrame`  with filled values
         """
-        numeric_only = self._resolve_numeric_only(numeric_only)
+        how = base_func.__name__
+        numeric_only_bool = self._resolve_numeric_only(how, numeric_only, axis=0)
 
         if post_processing and not callable(post_processing):
             raise ValueError("'post_processing' must be a callable!")
@@ -3320,7 +3801,6 @@ def _get_cythonized_result(
 
         ids, _, ngroups = grouper.group_info
 
-        how = base_func.__name__
         base_func = partial(base_func, labels=ids)
 
         def blk_func(values: ArrayLike) -> ArrayLike:
@@ -3378,15 +3858,16 @@ def blk_func(values: ArrayLike) -> ArrayLike:
         # Operate block-wise instead of column-by-column
         is_ser = obj.ndim == 1
         mgr = self._get_data_to_aggregate()
+        orig_mgr_len = len(mgr)
 
-        if numeric_only:
+        if numeric_only_bool:
             mgr = mgr.get_numeric_data()
 
         res_mgr = mgr.grouped_reduce(blk_func, ignore_failures=True)
 
-        if not is_ser and len(res_mgr.items) != len(mgr.items):
+        if not is_ser and len(res_mgr.items) != orig_mgr_len:
             howstr = how.replace("group_", "")
-            warn_dropping_nuisance_columns_deprecated(type(self), howstr)
+            warn_dropping_nuisance_columns_deprecated(type(self), howstr, numeric_only)
 
             if len(res_mgr.items) == 0:
                 # We re-call grouped_reduce to get the right exception message
@@ -3434,7 +3915,8 @@ def shift(self, periods=1, freq=None, axis=0, fill_value=None):
             if available.
         """
         if freq is not None or axis != 0:
-            return self.apply(lambda x: x.shift(periods, freq, axis, fill_value))
+            f = lambda x: x.shift(periods, freq, axis, fill_value)
+            return self._python_apply_general(f, self._selected_obj, is_transform=True)
 
         ids, _, ngroups = self.grouper.group_info
         res_indexer = np.zeros(len(ids), dtype=np.int64)
@@ -3450,6 +3932,47 @@ def shift(self, periods=1, freq=None, axis=0, fill_value=None):
         )
         return res
 
+    @final
+    @Substitution(name="groupby")
+    @Appender(_common_see_also)
+    def diff(self, periods: int = 1, axis: int = 0) -> NDFrameT:
+        """
+        First discrete difference of element.
+
+        Calculates the difference of each element compared with another
+        element in the group (default is element in previous row).
+
+        Parameters
+        ----------
+        periods : int, default 1
+            Periods to shift for calculating difference, accepts negative values.
+        axis : axis to shift, default 0
+            Take difference over rows (0) or columns (1).
+
+        Returns
+        -------
+        Series or DataFrame
+            First differences.
+        """
+        if axis != 0:
+            return self.apply(lambda x: x.diff(periods=periods, axis=axis))
+
+        obj = self._obj_with_exclusions
+        shifted = self.shift(periods=periods, axis=axis)
+
+        # GH45562 - to retain existing behavior and match behavior of Series.diff(),
+        # int8 and int16 are coerced to float32 rather than float64.
+        dtypes_to_f32 = ["int8", "int16"]
+        if obj.ndim == 1:
+            if obj.dtype in dtypes_to_f32:
+                shifted = shifted.astype("float32")
+        else:
+            to_coerce = [c for c, dtype in obj.dtypes.items() if dtype in dtypes_to_f32]
+            if len(to_coerce):
+                shifted = shifted.astype({c: "float32" for c in to_coerce})
+
+        return obj - shifted
+
     @final
     @Substitution(name="groupby")
     @Appender(_common_see_also)
@@ -3465,27 +3988,29 @@ def pct_change(self, periods=1, fill_method="ffill", limit=None, freq=None, axis
         # TODO(GH#23918): Remove this conditional for SeriesGroupBy when
         #  GH#23918 is fixed
         if freq is not None or axis != 0:
-            return self.apply(
-                lambda x: x.pct_change(
-                    periods=periods,
-                    fill_method=fill_method,
-                    limit=limit,
-                    freq=freq,
-                    axis=axis,
-                )
+            f = lambda x: x.pct_change(
+                periods=periods,
+                fill_method=fill_method,
+                limit=limit,
+                freq=freq,
+                axis=axis,
             )
+            return self._python_apply_general(f, self._selected_obj, is_transform=True)
+
         if fill_method is None:  # GH30463
             fill_method = "ffill"
             limit = 0
         filled = getattr(self, fill_method)(limit=limit)
-        fill_grp = filled.groupby(self.grouper.codes, axis=self.axis)
+        fill_grp = filled.groupby(
+            self.grouper.codes, axis=self.axis, group_keys=self.group_keys
+        )
         shifted = fill_grp.shift(periods=periods, freq=freq, axis=self.axis)
         return (filled / shifted) - 1
 
     @final
     @Substitution(name="groupby")
     @Substitution(see_also=_common_see_also)
-    def head(self, n=5):
+    def head(self, n: int = 5) -> NDFrameT:
         """
         Return first n rows of each group.
 
@@ -3524,7 +4049,7 @@ def head(self, n=5):
     @final
     @Substitution(name="groupby")
     @Substitution(see_also=_common_see_also)
-    def tail(self, n=5):
+    def tail(self, n: int = 5) -> NDFrameT:
         """
         Return last n rows of each group.
 
@@ -3566,13 +4091,13 @@ def tail(self, n=5):
         return self._mask_selected_obj(mask)
 
     @final
-    def _mask_selected_obj(self, mask: np.ndarray) -> NDFrameT:
+    def _mask_selected_obj(self, mask: npt.NDArray[np.bool_]) -> NDFrameT:
         """
         Return _selected_obj with mask applied to the correct axis.
 
         Parameters
         ----------
-        mask : np.ndarray
+        mask : np.ndarray[bool]
             Boolean mask to apply.
 
         Returns
@@ -3646,6 +4171,7 @@ def _reindex_output(
         index, _ = MultiIndex.from_product(levels_list, names=names).sortlevel()
 
         if self.as_index:
+            # Always holds for SeriesGroupBy unless GH#36507 is implemented
             d = {
                 self.obj._get_axis_name(self.axis): index,
                 "copy": False,
@@ -3822,7 +4348,7 @@ def get_groupby(
     selection=None,
     as_index: bool = True,
     sort: bool = True,
-    group_keys: bool = True,
+    group_keys: bool | lib.NoDefault = True,
     squeeze: bool = False,
     observed: bool = False,
     mutated: bool = False,
@@ -3887,13 +4413,25 @@ def _insert_quantile_level(idx: Index, qs: npt.NDArray[np.float64]) -> MultiInde
     return mi
 
 
-def warn_dropping_nuisance_columns_deprecated(cls, how: str) -> None:
-    warnings.warn(
-        "Dropping invalid columns in "
-        f"{cls.__name__}.{how} is deprecated. "
-        "In a future version, a TypeError will be raised. "
-        f"Before calling .{how}, select only columns which "
-        "should be valid for the function.",
-        FutureWarning,
-        stacklevel=find_stack_level(),
-    )
+def warn_dropping_nuisance_columns_deprecated(cls, how: str, numeric_only) -> None:
+    if numeric_only is not lib.no_default and not numeric_only:
+        # numeric_only was specified and falsey but still dropped nuisance columns
+        warnings.warn(
+            "Dropping invalid columns in "
+            f"{cls.__name__}.{how} is deprecated. "
+            "In a future version, a TypeError will be raised. "
+            f"Before calling .{how}, select only columns which "
+            "should be valid for the function.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+    elif numeric_only is lib.no_default:
+        warnings.warn(
+            "The default value of numeric_only in "
+            f"{cls.__name__}.{how} is deprecated. "
+            "In a future version, numeric_only will default to False. "
+            f"Either specify numeric_only or select only columns which "
+            "should be valid for the function.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 3cf56af18c076..52377f4bf967c 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -263,7 +263,7 @@ class Grouper:
     _gpr_index: Index | None
     _grouper: Index | None
 
-    _attributes: tuple[str, ...] = ("key", "level", "freq", "axis", "sort")
+    _attributes: tuple[str, ...] = ("key", "level", "freq", "axis", "sort", "dropna")
 
     def __new__(cls, *args, **kwargs):
         if kwargs.get("freq") is not None:
@@ -281,12 +281,13 @@ def __init__(
         axis: int = 0,
         sort: bool = False,
         dropna: bool = True,
-    ):
+    ) -> None:
         self.key = key
         self.level = level
         self.freq = freq
         self.axis = axis
         self.sort = sort
+        self.dropna = dropna
 
         self.grouper = None
         self._gpr_index = None
@@ -295,7 +296,6 @@ def __init__(
         self.binner = None
         self._grouper = None
         self._indexer = None
-        self.dropna = dropna
 
     @final
     @property
@@ -339,7 +339,7 @@ def _get_grouper(
         return self.binner, self.grouper, self.obj  # type: ignore[return-value]
 
     @final
-    def _set_grouper(self, obj: NDFrame, sort: bool = False):
+    def _set_grouper(self, obj: NDFrame, sort: bool = False) -> None:
         """
         given an object and the specifications, setup the internal grouper
         for this particular specification
@@ -400,7 +400,7 @@ def _set_grouper(self, obj: NDFrame, sort: bool = False):
                         raise ValueError(f"The level {level} is not valid")
 
         # possibly sort
-        if (self.sort or sort) and not ax.is_monotonic:
+        if (self.sort or sort) and not ax.is_monotonic_increasing:
             # use stable sort to support first, last, nth
             # TODO: why does putting na_position="first" fix datetimelike cases?
             indexer = self.indexer = ax.array.argsort(
@@ -413,7 +413,6 @@ def _set_grouper(self, obj: NDFrame, sort: bool = False):
         # "NDFrameT", variable has type "None")
         self.obj = obj  # type: ignore[assignment]
         self._gpr_index = ax
-        return self._gpr_index
 
     @final
     @property
@@ -459,7 +458,7 @@ class Grouping:
       * groups : dict of {group -> label_list}
     """
 
-    _codes: np.ndarray | None = None
+    _codes: npt.NDArray[np.signedinteger] | None = None
     _group_index: Index | None = None
     _passed_categorical: bool
     _all_grouper: Categorical | None
@@ -475,7 +474,7 @@ def __init__(
         observed: bool = False,
         in_axis: bool = False,
         dropna: bool = True,
-    ):
+    ) -> None:
         self.level = level
         self._orig_grouper = grouper
         self.grouping_vector = _convert_grouper(index, grouper)
@@ -502,7 +501,7 @@ def __init__(
                 self.grouping_vector,  # Index
                 self._codes,
                 self._group_index,
-            ) = index._get_grouper_for_level(mapper, level=ilevel)
+            ) = index._get_grouper_for_level(mapper, level=ilevel, dropna=dropna)
 
         # a passed Grouper like, directly get the grouper in the same way
         # as single grouper groupby, use the group_info to get codes
@@ -614,7 +613,7 @@ def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
         return values._reverse_indexer()
 
     @property
-    def codes(self) -> np.ndarray:
+    def codes(self) -> npt.NDArray[np.signedinteger]:
         if self._codes is not None:
             # _codes is set in __init__ for MultiIndex cases
             return self._codes
@@ -657,10 +656,11 @@ def group_index(self) -> Index:
         return Index._with_infer(uniques, name=self.name)
 
     @cache_readonly
-    def _codes_and_uniques(self) -> tuple[np.ndarray, ArrayLike]:
+    def _codes_and_uniques(self) -> tuple[npt.NDArray[np.signedinteger], ArrayLike]:
         if self._passed_categorical:
             # we make a CategoricalIndex out of the cat grouper
-            # preserving the categories / ordered attributes
+            # preserving the categories / ordered attributes;
+            # doesn't (yet - GH#46909) handle dropna=False
             cat = self.grouping_vector
             categories = cat.categories
 
@@ -680,15 +680,17 @@ def _codes_and_uniques(self) -> tuple[np.ndarray, ArrayLike]:
         elif isinstance(self.grouping_vector, ops.BaseGrouper):
             # we have a list of groupers
             codes = self.grouping_vector.codes_info
-            uniques = self.grouping_vector.result_arraylike
+            # error: Incompatible types in assignment (expression has type "Union
+            # [ExtensionArray, ndarray[Any, Any]]", variable has type "Categorical")
+            uniques = (
+                self.grouping_vector.result_index._values  # type: ignore[assignment]
+            )
         else:
-            # GH35667, replace dropna=False with na_sentinel=None
-            if not self._dropna:
-                na_sentinel = None
-            else:
-                na_sentinel = -1
-            codes, uniques = algorithms.factorize(
-                self.grouping_vector, sort=self._sort, na_sentinel=na_sentinel
+            # GH35667, replace dropna=False with use_na_sentinel=False
+            # error: Incompatible types in assignment (expression has type "Union[
+            # ndarray[Any, Any], Index]", variable has type "Categorical")
+            codes, uniques = algorithms.factorize(  # type: ignore[assignment]
+                self.grouping_vector, sort=self._sort, use_na_sentinel=self._dropna
             )
         return codes, uniques
 
@@ -836,7 +838,11 @@ def get_grouper(
 
     # if the actual grouper should be obj[key]
     def is_in_axis(key) -> bool:
+
         if not _is_label_like(key):
+            if obj.ndim == 1:
+                return False
+
             # items -> .columns for DataFrame, .index for Series
             items = obj.axes[-1]
             try:
diff --git a/pandas/core/groupby/indexing.py b/pandas/core/groupby/indexing.py
index f98bdf4b8be29..750097b403f26 100644
--- a/pandas/core/groupby/indexing.py
+++ b/pandas/core/groupby/indexing.py
@@ -245,7 +245,7 @@ def _descending_count(self) -> np.ndarray:
 
 @doc(GroupByIndexingMixin._positional_selector)
 class GroupByPositionalSelector:
-    def __init__(self, groupby_object: groupby.GroupBy):
+    def __init__(self, groupby_object: groupby.GroupBy) -> None:
         self.groupby_object = groupby_object
 
     def __getitem__(self, arg: PositionalIndexer | tuple) -> DataFrame | Series:
@@ -289,7 +289,7 @@ class GroupByNthSelector:
     Dynamically substituted for GroupBy.nth to enable both call and index
     """
 
-    def __init__(self, groupby_object: groupby.GroupBy):
+    def __init__(self, groupby_object: groupby.GroupBy) -> None:
         self.groupby_object = groupby_object
 
     def __call__(
@@ -297,7 +297,7 @@ def __call__(
         n: PositionalIndexer | tuple,
         dropna: Literal["any", "all", None] = None,
     ) -> DataFrame | Series:
-        return self.groupby_object.nth_actual(n, dropna)
+        return self.groupby_object._nth(n, dropna)
 
     def __getitem__(self, n: PositionalIndexer | tuple) -> DataFrame | Series:
-        return self.groupby_object.nth_actual(n)
+        return self.groupby_object._nth(n)
diff --git a/pandas/core/groupby/numba_.py b/pandas/core/groupby/numba_.py
index 24d66725caa70..acfc690ab3fdb 100644
--- a/pandas/core/groupby/numba_.py
+++ b/pandas/core/groupby/numba_.py
@@ -1,6 +1,7 @@
 """Common utilities for Numba operations with groupby ops"""
 from __future__ import annotations
 
+import functools
 import inspect
 from typing import (
     TYPE_CHECKING,
@@ -14,9 +15,7 @@
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
     NumbaUtilError,
-    get_jit_arguments,
     jit_user_function,
 )
 
@@ -43,6 +42,10 @@ def f(values, index, ...):
     ------
     NumbaUtilError
     """
+    if not callable(func):
+        raise NotImplementedError(
+            "Numba engine can only be used with a single function."
+        )
     udf_signature = list(inspect.signature(func).parameters.keys())
     expected_args = ["values", "index"]
     min_number_args = len(expected_args)
@@ -56,10 +59,12 @@ def f(values, index, ...):
         )
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_agg_func(
-    kwargs: dict[str, Any],
     func: Callable[..., Scalar],
-    engine_kwargs: dict[str, bool] | None,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
 ) -> Callable[[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int, Any], np.ndarray]:
     """
     Generate a numba jitted agg function specified by values from engine_kwargs.
@@ -72,24 +77,19 @@ def generate_numba_agg_func(
 
     Parameters
     ----------
-    kwargs : dict
-        **kwargs to be passed into the function
     func : function
-        function to be applied to each window and will be JITed
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
+        function to be applied to each group and will be JITed
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs, kwargs)
-
-    validate_udf(func)
-    cache_key = (func, "groupby_agg")
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     numba_func = jit_user_function(func, nopython, nogil, parallel)
     if TYPE_CHECKING:
         import numba
@@ -120,10 +120,12 @@ def group_agg(
     return group_agg
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_transform_func(
-    kwargs: dict[str, Any],
     func: Callable[..., np.ndarray],
-    engine_kwargs: dict[str, bool] | None,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
 ) -> Callable[[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int, Any], np.ndarray]:
     """
     Generate a numba jitted transform function specified by values from engine_kwargs.
@@ -136,24 +138,19 @@ def generate_numba_transform_func(
 
     Parameters
     ----------
-    kwargs : dict
-        **kwargs to be passed into the function
     func : function
         function to be applied to each window and will be JITed
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs, kwargs)
-
-    validate_udf(func)
-    cache_key = (func, "groupby_transform")
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     numba_func = jit_user_function(func, nopython, nogil, parallel)
     if TYPE_CHECKING:
         import numba
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 5e7882b8b4a1e..00de92d1732ae 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -10,13 +10,14 @@
 import collections
 import functools
 from typing import (
+    TYPE_CHECKING,
     Callable,
     Generic,
     Hashable,
     Iterator,
+    NoReturn,
     Sequence,
     final,
-    overload,
 )
 
 import numpy as np
@@ -45,9 +46,9 @@
     ensure_float64,
     ensure_int64,
     ensure_platform_int,
-    is_1d_only_ea_obj,
+    ensure_uint64,
+    is_1d_only_ea_dtype,
     is_bool_dtype,
-    is_categorical_dtype,
     is_complex_dtype,
     is_datetime64_any_dtype,
     is_float_dtype,
@@ -57,34 +58,28 @@
     is_timedelta64_dtype,
     needs_i8_conversion,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.dtypes import CategoricalDtype
 from pandas.core.dtypes.missing import (
     isna,
     maybe_fill,
 )
 
 from pandas.core.arrays import (
+    Categorical,
     DatetimeArray,
     ExtensionArray,
     PeriodArray,
     TimedeltaArray,
 )
 from pandas.core.arrays.boolean import BooleanDtype
-from pandas.core.arrays.floating import (
-    Float64Dtype,
-    FloatingDtype,
-)
-from pandas.core.arrays.integer import (
-    Int64Dtype,
-    _IntegerDtype,
-)
+from pandas.core.arrays.floating import FloatingDtype
+from pandas.core.arrays.integer import IntegerDtype
 from pandas.core.arrays.masked import (
     BaseMaskedArray,
     BaseMaskedDtype,
 )
 from pandas.core.arrays.string_ import StringDtype
 from pandas.core.frame import DataFrame
-from pandas.core.generic import NDFrame
 from pandas.core.groupby import grouper
 from pandas.core.indexes.api import (
     CategoricalIndex,
@@ -102,35 +97,48 @@
     get_indexer_dict,
 )
 
+if TYPE_CHECKING:
+    from pandas.core.generic import NDFrame
+
 
 class WrappedCythonOp:
     """
     Dispatch logic for functions defined in _libs.groupby
+
+    Parameters
+    ----------
+    kind: str
+        Whether the operation is an aggregate or transform.
+    how: str
+        Operation name, e.g. "mean".
+    has_dropped_na: bool
+        True precisely when dropna=True and the grouper contains a null value.
     """
 
     # Functions for which we do _not_ attempt to cast the cython result
     #  back to the original dtype.
     cast_blocklist = frozenset(["rank", "count", "size", "idxmin", "idxmax"])
 
-    def __init__(self, kind: str, how: str):
+    def __init__(self, kind: str, how: str, has_dropped_na: bool) -> None:
         self.kind = kind
         self.how = how
+        self.has_dropped_na = has_dropped_na
 
     _CYTHON_FUNCTIONS = {
         "aggregate": {
-            "add": "group_add",
+            "sum": "group_sum",
             "prod": "group_prod",
             "min": "group_min",
             "max": "group_max",
             "mean": "group_mean",
-            "median": "group_median",
+            "median": "group_median_float64",
             "var": "group_var",
             "first": "group_nth",
             "last": "group_last",
             "ohlc": "group_ohlc",
         },
         "transform": {
-            "cumprod": "group_cumprod",
+            "cumprod": "group_cumprod_float64",
             "cumsum": "group_cumsum",
             "cummin": "group_cummin",
             "cummax": "group_cummax",
@@ -138,7 +146,21 @@ def __init__(self, kind: str, how: str):
         },
     }
 
-    _MASKED_CYTHON_FUNCTIONS = {"cummin", "cummax", "min", "max"}
+    # "group_any" and "group_all" are also support masks, but don't go
+    #  through WrappedCythonOp
+    _MASKED_CYTHON_FUNCTIONS = {
+        "cummin",
+        "cummax",
+        "min",
+        "max",
+        "last",
+        "first",
+        "rank",
+        "sum",
+        "ohlc",
+        "cumsum",
+        "prod",
+    }
 
     _cython_arity = {"ohlc": 4}  # OHLC
 
@@ -158,55 +180,64 @@ def _get_cython_function(
         f = getattr(libgroupby, ftype)
         if is_numeric:
             return f
-        # error: Non-overlapping equality check (left operand type: "dtype[Any]", right
-        # operand type: "Literal['object']")
-        elif dtype == object:  # type: ignore[comparison-overlap]
-            if "object" not in f.__signatures__:
+        elif dtype == np.dtype(object):
+            if how in ["median", "cumprod"]:
+                # no fused types -> no __signatures__
+                raise NotImplementedError(
+                    f"function is not implemented for this dtype: "
+                    f"[how->{how},dtype->{dtype_str}]"
+                )
+            elif "object" not in f.__signatures__:
                 # raise NotImplementedError here rather than TypeError later
                 raise NotImplementedError(
                     f"function is not implemented for this dtype: "
                     f"[how->{how},dtype->{dtype_str}]"
                 )
             return f
+        else:
+            raise NotImplementedError(
+                "This should not be reached. Please report a bug at "
+                "github.com/pandas-dev/pandas/",
+                dtype,
+            )
 
-    def get_cython_func_and_vals(self, values: np.ndarray, is_numeric: bool):
+    def _get_cython_vals(self, values: np.ndarray) -> np.ndarray:
         """
-        Find the appropriate cython function, casting if necessary.
+        Cast numeric dtypes to float64 for functions that only support that.
 
         Parameters
         ----------
         values : np.ndarray
-        is_numeric : bool
 
         Returns
         -------
-        func : callable
         values : np.ndarray
         """
         how = self.how
-        kind = self.kind
 
         if how in ["median", "cumprod"]:
             # these two only have float64 implementations
-            if is_numeric:
-                values = ensure_float64(values)
-            else:
-                raise NotImplementedError(
-                    f"function is not implemented for this dtype: "
-                    f"[how->{how},dtype->{values.dtype.name}]"
-                )
-            func = getattr(libgroupby, f"group_{how}_float64")
-            return func, values
-
-        func = self._get_cython_function(kind, how, values.dtype, is_numeric)
-
-        if values.dtype.kind in ["i", "u"]:
-            if how in ["add", "var", "prod", "mean", "ohlc"]:
+            # We should only get here with is_numeric, as non-numeric cases
+            #  should raise in _get_cython_function
+            values = ensure_float64(values)
+
+        elif values.dtype.kind in ["i", "u"]:
+            if how in ["var", "mean"] or (
+                self.kind == "transform" and self.has_dropped_na
+            ):
                 # result may still include NaN, so we have to cast
                 values = ensure_float64(values)
 
-        return func, values
+            elif how in ["sum", "ohlc", "prod", "cumsum"]:
+                # Avoid overflow during group op
+                if values.dtype.kind == "i":
+                    values = ensure_int64(values)
+                else:
+                    values = ensure_uint64(values)
 
+        return values
+
+    # TODO: general case implementation overridable by EAs.
     def _disallow_invalid_ops(self, dtype: DtypeObj, is_numeric: bool = False):
         """
         Check if we can do this operation with our cython functions.
@@ -223,21 +254,27 @@ def _disallow_invalid_ops(self, dtype: DtypeObj, is_numeric: bool = False):
             # never an invalid op for those dtypes, so return early as fastpath
             return
 
-        if is_categorical_dtype(dtype):
+        if isinstance(dtype, CategoricalDtype):
             # NotImplementedError for methods that can fall back to a
             #  non-cython implementation.
-            if how in ["add", "prod", "cumsum", "cumprod"]:
+            if how in ["sum", "prod", "cumsum", "cumprod"]:
                 raise TypeError(f"{dtype} type does not support {how} operations")
-            raise NotImplementedError(f"{dtype} dtype not supported")
+            elif how not in ["rank"]:
+                # only "rank" is implemented in cython
+                raise NotImplementedError(f"{dtype} dtype not supported")
+            elif not dtype.ordered:
+                # TODO: TypeError?
+                raise NotImplementedError(f"{dtype} dtype not supported")
 
         elif is_sparse(dtype):
             # categoricals are only 1d, so we
             #  are not setup for dim transforming
             raise NotImplementedError(f"{dtype} dtype not supported")
         elif is_datetime64_any_dtype(dtype):
+            # TODO: same for period_dtype?  no for these methods with Period
             # we raise NotImplemented if this is an invalid operation
             #  entirely, e.g. adding datetimes
-            if how in ["add", "prod", "cumsum", "cumprod"]:
+            if how in ["sum", "prod", "cumsum", "cumprod"]:
                 raise TypeError(f"datetime64 type does not support {how} operations")
         elif is_timedelta64_dtype(dtype):
             if how in ["prod", "cumprod"]:
@@ -262,7 +299,7 @@ def _get_output_shape(self, ngroups: int, values: np.ndarray) -> Shape:
             out_shape = (ngroups,) + values.shape[1:]
         return out_shape
 
-    def get_out_dtype(self, dtype: np.dtype) -> np.dtype:
+    def _get_out_dtype(self, dtype: np.dtype) -> np.dtype:
         how = self.how
 
         if how == "rank":
@@ -274,40 +311,27 @@ def get_out_dtype(self, dtype: np.dtype) -> np.dtype:
                 out_dtype = "object"
         return np.dtype(out_dtype)
 
-    @overload
     def _get_result_dtype(self, dtype: np.dtype) -> np.dtype:
-        ...  # pragma: no cover
-
-    @overload
-    def _get_result_dtype(self, dtype: ExtensionDtype) -> ExtensionDtype:
-        ...  # pragma: no cover
-
-    def _get_result_dtype(self, dtype: DtypeObj) -> DtypeObj:
         """
         Get the desired dtype of a result based on the
         input dtype and how it was computed.
 
         Parameters
         ----------
-        dtype : np.dtype or ExtensionDtype
-            Input dtype.
+        dtype : np.dtype
 
         Returns
         -------
-        np.dtype or ExtensionDtype
+        np.dtype
             The desired dtype of the result.
         """
         how = self.how
 
-        if how in ["add", "cumsum", "sum", "prod"]:
+        if how in ["sum", "cumsum", "sum", "prod"]:
             if dtype == np.dtype(bool):
                 return np.dtype(np.int64)
-            elif isinstance(dtype, (BooleanDtype, _IntegerDtype)):
-                return Int64Dtype()
         elif how in ["mean", "median", "var"]:
-            if isinstance(dtype, (BooleanDtype, _IntegerDtype)):
-                return Float64Dtype()
-            elif is_float_dtype(dtype) or is_complex_dtype(dtype):
+            if is_float_dtype(dtype) or is_complex_dtype(dtype):
                 return dtype
             elif is_numeric_dtype(dtype):
                 return np.dtype(np.float64)
@@ -329,7 +353,6 @@ def _ea_wrap_cython_operation(
         If we have an ExtensionArray, unwrap, call _cython_operation, and
         re-wrap if appropriate.
         """
-        # TODO: general case implementation overridable by EAs.
         if isinstance(values, BaseMaskedArray) and self.uses_mask():
             return self._masked_ea_wrap_cython_operation(
                 values,
@@ -339,11 +362,51 @@ def _ea_wrap_cython_operation(
                 **kwargs,
             )
 
+        elif isinstance(values, Categorical) and self.uses_mask():
+            assert self.how == "rank"  # the only one implemented ATM
+            assert values.ordered  # checked earlier
+            mask = values.isna()
+            npvalues = values._ndarray
+
+            res_values = self._cython_op_ndim_compat(
+                npvalues,
+                min_count=min_count,
+                ngroups=ngroups,
+                comp_ids=comp_ids,
+                mask=mask,
+                **kwargs,
+            )
+
+            # If we ever have more than just "rank" here, we'll need to do
+            #  `if self.how in self.cast_blocklist` like we do for other dtypes.
+            return res_values
+
+        npvalues = self._ea_to_cython_values(values)
+
+        res_values = self._cython_op_ndim_compat(
+            npvalues,
+            min_count=min_count,
+            ngroups=ngroups,
+            comp_ids=comp_ids,
+            mask=None,
+            **kwargs,
+        )
+
+        if self.how in self.cast_blocklist:
+            # i.e. how in ["rank"], since other cast_blocklist methods dont go
+            #  through cython_operation
+            return res_values
+
+        return self._reconstruct_ea_result(values, res_values)
+
+    # TODO: general case implementation overridable by EAs.
+    def _ea_to_cython_values(self, values: ExtensionArray) -> np.ndarray:
+        # GH#43682
         if isinstance(values, (DatetimeArray, PeriodArray, TimedeltaArray)):
             # All of the functions implemented here are ordinal, so we can
             #  operate on the tz-naive equivalents
             npvalues = values._ndarray.view("M8[ns]")
-        elif isinstance(values.dtype, (BooleanDtype, _IntegerDtype)):
+        elif isinstance(values.dtype, (BooleanDtype, IntegerDtype)):
             # IntegerArray or BooleanArray
             npvalues = values.to_numpy("float64", na_value=np.nan)
         elif isinstance(values.dtype, FloatingDtype):
@@ -356,39 +419,33 @@ def _ea_wrap_cython_operation(
             raise NotImplementedError(
                 f"function is not implemented for this dtype: {values.dtype}"
             )
+        return npvalues
 
-        res_values = self._cython_op_ndim_compat(
-            npvalues,
-            min_count=min_count,
-            ngroups=ngroups,
-            comp_ids=comp_ids,
-            mask=None,
-            **kwargs,
-        )
-
-        if self.how in ["rank"]:
-            # i.e. how in WrappedCythonOp.cast_blocklist, since
-            #  other cast_blocklist methods dont go through cython_operation
-            return res_values
-
-        return self._reconstruct_ea_result(values, res_values)
-
-    def _reconstruct_ea_result(self, values, res_values):
+    # TODO: general case implementation overridable by EAs.
+    def _reconstruct_ea_result(
+        self, values: ExtensionArray, res_values: np.ndarray
+    ) -> ExtensionArray:
         """
         Construct an ExtensionArray result from an ndarray result.
         """
-        # TODO: allow EAs to override this logic
+        dtype: BaseMaskedDtype | StringDtype
 
-        if isinstance(
-            values.dtype, (BooleanDtype, _IntegerDtype, FloatingDtype, StringDtype)
-        ):
-            dtype = self._get_result_dtype(values.dtype)
-            cls = dtype.construct_array_type()
-            return cls._from_sequence(res_values, dtype=dtype)
+        if isinstance(values.dtype, StringDtype):
+            dtype = values.dtype
+            string_array_cls = dtype.construct_array_type()
+            return string_array_cls._from_sequence(res_values, dtype=dtype)
 
-        elif needs_i8_conversion(values.dtype):
-            i8values = res_values.view("i8")
-            return type(values)(i8values, dtype=values.dtype)
+        elif isinstance(values.dtype, BaseMaskedDtype):
+            new_dtype = self._get_result_dtype(values.dtype.numpy_dtype)
+            dtype = BaseMaskedDtype.from_numpy_dtype(new_dtype)
+            masked_array_cls = dtype.construct_array_type()
+            return masked_array_cls._from_sequence(res_values, dtype=dtype)
+
+        elif isinstance(values, (DatetimeArray, TimedeltaArray, PeriodArray)):
+            # In to_cython_values we took a view as M8[ns]
+            assert res_values.dtype == "M8[ns]"
+            res_values = res_values.view(values._ndarray.dtype)
+            return values._from_backing_data(res_values)
 
         raise NotImplementedError
 
@@ -407,9 +464,13 @@ def _masked_ea_wrap_cython_operation(
         """
         orig_values = values
 
-        # Copy to ensure input and result masks don't end up shared
-        mask = values._mask.copy()
-        result_mask = np.zeros(ngroups, dtype=bool)
+        # libgroupby functions are responsible for NOT altering mask
+        mask = values._mask
+        if self.kind != "aggregate":
+            result_mask = mask.copy()
+        else:
+            result_mask = np.zeros(ngroups, dtype=bool)
+
         arr = values._data
 
         res_values = self._cython_op_ndim_compat(
@@ -422,14 +483,12 @@ def _masked_ea_wrap_cython_operation(
             **kwargs,
         )
 
-        dtype = self._get_result_dtype(orig_values.dtype)
-        assert isinstance(dtype, BaseMaskedDtype)
-        cls = dtype.construct_array_type()
+        if self.how == "ohlc":
+            result_mask = np.tile(result_mask, (4, 1)).T
 
-        if self.kind != "aggregate":
-            return cls(res_values.astype(dtype.type, copy=False), mask)
-        else:
-            return cls(res_values.astype(dtype.type, copy=False), result_mask)
+        # res_values should already have the correct dtype, we just need to
+        #  wrap in a MaskedArray
+        return orig_values._maybe_mask_result(res_values, result_mask)
 
     @final
     def _cython_op_ndim_compat(
@@ -439,8 +498,8 @@ def _cython_op_ndim_compat(
         min_count: int,
         ngroups: int,
         comp_ids: np.ndarray,
-        mask: np.ndarray | None = None,
-        result_mask: np.ndarray | None = None,
+        mask: npt.NDArray[np.bool_] | None = None,
+        result_mask: npt.NDArray[np.bool_] | None = None,
         **kwargs,
     ) -> np.ndarray:
         if values.ndim == 1:
@@ -483,8 +542,8 @@ def _call_cython_op(
         min_count: int,
         ngroups: int,
         comp_ids: np.ndarray,
-        mask: np.ndarray | None,
-        result_mask: np.ndarray | None,
+        mask: npt.NDArray[np.bool_] | None,
+        result_mask: npt.NDArray[np.bool_] | None,
         **kwargs,
     ) -> np.ndarray:  # np.ndarray[ndim=2]
         orig_values = values
@@ -498,15 +557,9 @@ def _call_cython_op(
             values = values.view("int64")
             is_numeric = True
         elif is_bool_dtype(dtype):
-            values = values.astype("int64")
-        elif is_integer_dtype(dtype):
-            # GH#43329 If the dtype is explicitly of type uint64 the type is not
-            # changed to prevent overflow.
-            if dtype != np.uint64:
-                values = values.astype(np.int64, copy=False)
-        elif is_numeric:
-            if not is_complex_dtype(dtype):
-                values = ensure_float64(values)
+            values = values.view("uint8")
+        if values.dtype == "float16":
+            values = values.astype(np.float32)
 
         values = values.T
         if mask is not None:
@@ -515,75 +568,102 @@ def _call_cython_op(
                 result_mask = result_mask.T
 
         out_shape = self._get_output_shape(ngroups, values)
-        func, values = self.get_cython_func_and_vals(values, is_numeric)
-        out_dtype = self.get_out_dtype(values.dtype)
+        func = self._get_cython_function(self.kind, self.how, values.dtype, is_numeric)
+        values = self._get_cython_vals(values)
+        out_dtype = self._get_out_dtype(values.dtype)
 
         result = maybe_fill(np.empty(out_shape, dtype=out_dtype))
         if self.kind == "aggregate":
             counts = np.zeros(ngroups, dtype=np.int64)
-            if self.how in ["min", "max", "mean"]:
+            if self.how in ["min", "max", "mean", "last", "first"]:
                 func(
-                    result,
-                    counts,
-                    values,
-                    comp_ids,
-                    min_count,
+                    out=result,
+                    counts=counts,
+                    values=values,
+                    labels=comp_ids,
+                    min_count=min_count,
                     mask=mask,
                     result_mask=result_mask,
                     is_datetimelike=is_datetimelike,
                 )
-            elif self.how in ["add"]:
+            elif self.how in ["sum"]:
                 # We support datetimelike
+                func(
+                    out=result,
+                    counts=counts,
+                    values=values,
+                    labels=comp_ids,
+                    mask=mask,
+                    result_mask=result_mask,
+                    min_count=min_count,
+                    is_datetimelike=is_datetimelike,
+                )
+            elif self.how in ["ohlc", "prod"]:
                 func(
                     result,
                     counts,
                     values,
                     comp_ids,
-                    min_count,
-                    datetimelike=is_datetimelike,
+                    min_count=min_count,
+                    mask=mask,
+                    result_mask=result_mask,
                 )
             else:
-                func(result, counts, values, comp_ids, min_count)
+                func(result, counts, values, comp_ids, min_count, **kwargs)
         else:
             # TODO: min_count
             if self.uses_mask():
+                if self.how != "rank":
+                    # TODO: should rank take result_mask?
+                    kwargs["result_mask"] = result_mask
                 func(
-                    result,
-                    values,
-                    comp_ids,
-                    ngroups,
-                    is_datetimelike,
+                    out=result,
+                    values=values,
+                    labels=comp_ids,
+                    ngroups=ngroups,
+                    is_datetimelike=is_datetimelike,
                     mask=mask,
                     **kwargs,
                 )
             else:
-                func(result, values, comp_ids, ngroups, is_datetimelike, **kwargs)
+                func(
+                    out=result,
+                    values=values,
+                    labels=comp_ids,
+                    ngroups=ngroups,
+                    is_datetimelike=is_datetimelike,
+                    **kwargs,
+                )
 
         if self.kind == "aggregate":
             # i.e. counts is defined.  Locations where count<min_count
             # need to have the result set to np.nan, which may require casting,
             # see GH#40767
             if is_integer_dtype(result.dtype) and not is_datetimelike:
-                cutoff = max(1, min_count)
+                # if the op keeps the int dtypes, we have to use 0
+                cutoff = max(0 if self.how in ["sum", "prod"] else 1, min_count)
                 empty_groups = counts < cutoff
                 if empty_groups.any():
-                    # Note: this conversion could be lossy, see GH#40767
-                    result = result.astype("float64")
-                    result[empty_groups] = np.nan
+                    if result_mask is not None and self.uses_mask():
+                        assert result_mask[empty_groups].all()
+                    else:
+                        # Note: this conversion could be lossy, see GH#40767
+                        result = result.astype("float64")
+                        result[empty_groups] = np.nan
 
         result = result.T
 
         if self.how not in self.cast_blocklist:
             # e.g. if we are int64 and need to restore to datetime64/timedelta64
             # "rank" is the only member of cast_blocklist we get here
+            # Casting only needed for float16, bool, datetimelike,
+            #  and self.how in ["sum", "prod", "ohlc", "cumprod"]
             res_dtype = self._get_result_dtype(orig_values.dtype)
             op_result = maybe_downcast_to_dtype(result, res_dtype)
         else:
             op_result = result
 
-        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
-        # expected "ndarray")
-        return op_result  # type: ignore[return-value]
+        return op_result
 
     @final
     def cython_operation(
@@ -603,7 +683,7 @@ def cython_operation(
             raise NotImplementedError("number of dimensions is currently limited to 2")
         elif values.ndim == 2:
             assert axis == 1, axis
-        elif not is_1d_only_ea_obj(values):
+        elif not is_1d_only_ea_dtype(values.dtype):
             # Note: it is *not* the case that axis is always 0 for 1-dim values,
             #  as we can have 1D ExtensionArrays that we need to treat as 2D
             assert axis == 0
@@ -668,7 +748,7 @@ def __init__(
         mutated: bool = False,
         indexer: npt.NDArray[np.intp] | None = None,
         dropna: bool = True,
-    ):
+    ) -> None:
         assert isinstance(axis, Index), axis
 
         self.axis = axis
@@ -687,7 +767,7 @@ def groupings(self) -> list[grouper.Grouping]:
     def shape(self) -> Shape:
         return tuple(ping.ngroups for ping in self.groupings)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Hashable]:
         return iter(self.indices)
 
     @property
@@ -707,8 +787,7 @@ def get_iterator(
         """
         splitter = self._get_splitter(data, axis=axis)
         keys = self.group_keys_seq
-        for key, group in zip(keys, splitter):
-            yield key, group.__finalize__(data, method="groupby")
+        yield from zip(keys, splitter)
 
     @final
     def _get_splitter(self, data: NDFrame, axis: int = 0) -> DataSplitter:
@@ -716,8 +795,6 @@ def _get_splitter(self, data: NDFrame, axis: int = 0) -> DataSplitter:
         Returns
         -------
         Generator yielding subsetted objects
-
-        __finalize__ has not been called for the subsetted objects returned.
         """
         ids, _, ngroups = self.group_info
         return get_splitter(data, ids, ngroups, axis=axis)
@@ -763,15 +840,14 @@ def apply(
             if not mutated and not _is_indexed_like(res, group_axes, axis):
                 mutated = True
             result_values.append(res)
-
         # getattr pattern for __name__ is needed for functools.partial objects
-        if len(group_keys) == 0 and getattr(f, "__name__", None) not in [
-            "idxmin",
-            "idxmax",
-            "nanargmin",
-            "nanargmax",
+        if len(group_keys) == 0 and getattr(f, "__name__", None) in [
+            "mad",
+            "skew",
+            "sum",
+            "prod",
         ]:
-            # If group_keys is empty, then no function calls have been made,
+            #  If group_keys is empty, then no function calls have been made,
             #  so we will not have raised even if this is an invalid dtype.
             #  So do one dummy call here to raise appropriate TypeError.
             f(data.iloc[:0])
@@ -788,9 +864,36 @@ def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
         keys = [ping.group_index for ping in self.groupings]
         return get_indexer_dict(codes_list, keys)
 
+    @final
+    def result_ilocs(self) -> npt.NDArray[np.intp]:
+        """
+        Get the original integer locations of result_index in the input.
+        """
+        # Original indices are where group_index would go via sorting.
+        # But when dropna is true, we need to remove null values while accounting for
+        # any gaps that then occur because of them.
+        group_index = get_group_index(
+            self.codes, self.shape, sort=self._sort, xnull=True
+        )
+        group_index, _ = compress_group_index(group_index, sort=self._sort)
+
+        if self.has_dropped_na:
+            mask = np.where(group_index >= 0)
+            # Count how many gaps are caused by previous null values for each position
+            null_gaps = np.cumsum(group_index == -1)[mask]
+            group_index = group_index[mask]
+
+        result = get_group_index_sorter(group_index, self.ngroups)
+
+        if self.has_dropped_na:
+            # Shift by the number of prior null gaps
+            result += np.take(null_gaps, result)
+
+        return result
+
     @final
     @property
-    def codes(self) -> list[np.ndarray]:
+    def codes(self) -> list[npt.NDArray[np.signedinteger]]:
         return [ping.codes for ping in self.groupings]
 
     @property
@@ -807,6 +910,7 @@ def size(self) -> Series:
         Compute group sizes.
         """
         ids, _, ngroups = self.group_info
+        out: np.ndarray | list
         if ngroups:
             out = np.bincount(ids[ids != -1], minlength=ngroups)
         else:
@@ -827,7 +931,15 @@ def groups(self) -> dict[Hashable, np.ndarray]:
     @cache_readonly
     def is_monotonic(self) -> bool:
         # return if my group orderings are monotonic
-        return Index(self.group_info[0]).is_monotonic
+        return Index(self.group_info[0]).is_monotonic_increasing
+
+    @final
+    @cache_readonly
+    def has_dropped_na(self) -> bool:
+        """
+        Whether grouper has null value(s) that are dropped.
+        """
+        return bool((self.group_info[0] < 0).any())
 
     @cache_readonly
     def group_info(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp], int]:
@@ -852,11 +964,14 @@ def codes_info(self) -> npt.NDArray[np.intp]:
         return ids
 
     @final
-    def _get_compressed_codes(self) -> tuple[np.ndarray, npt.NDArray[np.intp]]:
+    def _get_compressed_codes(
+        self,
+    ) -> tuple[npt.NDArray[np.signedinteger], npt.NDArray[np.intp]]:
         # The first returned ndarray may have any signed integer dtype
         if len(self.groupings) > 1:
             group_index = get_group_index(self.codes, self.shape, sort=True, xnull=True)
             return compress_group_index(group_index, sort=self._sort)
+            # FIXME: compress_group_index's second return value is int64, not intp
 
         ping = self.groupings[0]
         return ping.codes, np.arange(len(ping.group_index), dtype=np.intp)
@@ -867,26 +982,11 @@ def ngroups(self) -> int:
         return len(self.result_index)
 
     @property
-    def reconstructed_codes(self) -> list[np.ndarray]:
+    def reconstructed_codes(self) -> list[npt.NDArray[np.intp]]:
         codes = self.codes
         ids, obs_ids, _ = self.group_info
         return decons_obs_group_ids(ids, obs_ids, self.shape, codes, xnull=True)
 
-    @final
-    @cache_readonly
-    def result_arraylike(self) -> ArrayLike:
-        """
-        Analogous to result_index, but returning an ndarray/ExtensionArray
-        allowing us to retain ExtensionDtypes not supported by Index.
-        """
-        # TODO(ExtensionIndex): once Index supports arbitrary EAs, this can
-        #  be removed in favor of result_index
-        if len(self.groupings) == 1:
-            return self.groupings[0].group_arraylike
-
-        # result_index is MultiIndex
-        return self.result_index._values
-
     @cache_readonly
     def result_index(self) -> Index:
         if len(self.groupings) == 1:
@@ -932,7 +1032,7 @@ def _cython_operation(
         """
         assert kind in ["transform", "aggregate"]
 
-        cy_op = WrappedCythonOp(kind=kind, how=how)
+        cy_op = WrappedCythonOp(kind=kind, how=how, has_dropped_na=self.has_dropped_na)
 
         ids, _, _ = self.group_info
         ngroups = self.ngroups
@@ -1054,7 +1154,7 @@ def __init__(
         binlabels,
         mutated: bool = False,
         indexer=None,
-    ):
+    ) -> None:
         self.bins = ensure_int64(bins)
         self.binlabels = ensure_index(binlabels)
         self.mutated = mutated
@@ -1151,7 +1251,7 @@ def reconstructed_codes(self) -> list[np.ndarray]:
         return [np.r_[0, np.flatnonzero(self.bins[1:] != self.bins[:-1]) + 1]]
 
     @cache_readonly
-    def result_index(self):
+    def result_index(self) -> Index:
         if len(self.binlabels) != 0 and isna(self.binlabels[0]):
             return self.binlabels[1:]
 
@@ -1171,7 +1271,7 @@ def groupings(self) -> list[grouper.Grouping]:
         ping = grouper.Grouping(lev, lev, in_axis=False, level=None)
         return [ping]
 
-    def _aggregate_series_fast(self, obj: Series, func: Callable) -> np.ndarray:
+    def _aggregate_series_fast(self, obj: Series, func: Callable) -> NoReturn:
         # -> np.ndarray[object]
         raise NotImplementedError(
             "This should not be reached; use _aggregate_series_pure_python"
@@ -1200,7 +1300,7 @@ def __init__(
         labels: npt.NDArray[np.intp],
         ngroups: int,
         axis: int = 0,
-    ):
+    ) -> None:
         self.data = data
         self.labels = ensure_platform_int(labels)  # _should_ already be np.intp
         self.ngroups = ngroups
@@ -1243,14 +1343,8 @@ class SeriesSplitter(DataSplitter):
     def _chop(self, sdata: Series, slice_obj: slice) -> Series:
         # fastpath equivalent to `sdata.iloc[slice_obj]`
         mgr = sdata._mgr.get_slice(slice_obj)
-        # __finalize__ not called here, must be applied by caller if applicable
-
-        # fastpath equivalent to:
-        # `return sdata._constructor(mgr, name=sdata.name, fastpath=True)`
-        obj = type(sdata)._from_mgr(mgr)
-        object.__setattr__(obj, "_flags", sdata._flags)
-        object.__setattr__(obj, "_name", sdata._name)
-        return obj
+        ser = sdata._constructor(mgr, name=sdata.name, fastpath=True)
+        return ser.__finalize__(sdata, method="groupby")
 
 
 class FrameSplitter(DataSplitter):
@@ -1261,12 +1355,8 @@ def _chop(self, sdata: DataFrame, slice_obj: slice) -> DataFrame:
         # else:
         #     return sdata.iloc[:, slice_obj]
         mgr = sdata._mgr.get_slice(slice_obj, axis=1 - self.axis)
-        # __finalize__ not called here, must be applied by caller if applicable
-
-        # fastpath equivalent to `return sdata._constructor(mgr)`
-        obj = type(sdata)._from_mgr(mgr)
-        object.__setattr__(obj, "_flags", sdata._flags)
-        return obj
+        df = sdata._constructor(mgr)
+        return df.__finalize__(sdata, method="groupby")
 
 
 def get_splitter(
diff --git a/pandas/core/index.py b/pandas/core/index.py
index 00ca6f9048a40..19e9c6b27e4e7 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -1,3 +1,6 @@
+# pyright: reportUnusedImport = false
+from __future__ import annotations
+
 import warnings
 
 from pandas.util._exceptions import find_stack_level
@@ -30,3 +33,5 @@
     FutureWarning,
     stacklevel=find_stack_level(),
 )
+
+__all__: list[str] = []
diff --git a/pandas/core/indexers/__init__.py b/pandas/core/indexers/__init__.py
index 86ec36144b134..6431f12a08dc8 100644
--- a/pandas/core/indexers/__init__.py
+++ b/pandas/core/indexers/__init__.py
@@ -4,7 +4,6 @@
     check_setitem_lengths,
     deprecate_ndim_indexing,
     is_empty_indexer,
-    is_exact_shape_match,
     is_list_like_indexer,
     is_scalar_indexer,
     is_valid_positional_slice,
@@ -23,7 +22,6 @@
     "check_setitem_lengths",
     "validate_indices",
     "maybe_convert_indices",
-    "is_exact_shape_match",
     "length_of_indexer",
     "deprecate_ndim_indexing",
     "unpack_1tuple",
diff --git a/pandas/core/indexers/objects.py b/pandas/core/indexers/objects.py
index 4d5e4bbe6bd36..c15cbf368c159 100644
--- a/pandas/core/indexers/objects.py
+++ b/pandas/core/indexers/objects.py
@@ -27,6 +27,9 @@
     center passed from the top level rolling API
 closed : str, default None
     closed passed from the top level rolling API
+step : int, default None
+    step passed from the top level rolling API
+    .. versionadded:: 1.5
 win_type : str, default None
     win_type passed from the top level rolling API
 
@@ -42,7 +45,7 @@ class BaseIndexer:
 
     def __init__(
         self, index_array: np.ndarray | None = None, window_size: int = 0, **kwargs
-    ):
+    ) -> None:
         """
         Parameters
         ----------
@@ -62,6 +65,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         raise NotImplementedError
@@ -77,6 +81,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         if center:
@@ -84,7 +89,7 @@ def get_window_bounds(
         else:
             offset = 0
 
-        end = np.arange(1 + offset, num_values + 1 + offset, dtype="int64")
+        end = np.arange(1 + offset, num_values + 1 + offset, step, dtype="int64")
         start = end - self.window_size
         if closed in ["left", "both"]:
             start -= 1
@@ -107,6 +112,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         # error: Argument 4 to "calculate_variable_window_bounds" has incompatible
@@ -133,7 +139,7 @@ def __init__(
         index=None,
         offset=None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(index_array, window_size, **kwargs)
         self.index = index
         self.offset = offset
@@ -145,8 +151,14 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
+        if step is not None:
+            raise NotImplementedError("step not implemented for variable offset window")
+        if num_values <= 0:
+            return np.empty(0, dtype="int64"), np.empty(0, dtype="int64")
+
         # if windows is variable, default is 'right', otherwise default is 'both'
         if closed is None:
             closed = "right" if self.index is not None else "both"
@@ -215,6 +227,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         return (
@@ -225,8 +238,7 @@ def get_window_bounds(
 
 class FixedForwardWindowIndexer(BaseIndexer):
     """
-    Creates window boundaries for fixed-length windows that include the
-    current row.
+    Creates window boundaries for fixed-length windows that include the current row.
 
     Examples
     --------
@@ -256,6 +268,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         if center:
@@ -264,11 +277,13 @@ def get_window_bounds(
             raise ValueError(
                 "Forward-looking windows don't support setting the closed argument"
             )
+        if step is None:
+            step = 1
 
-        start = np.arange(num_values, dtype="int64")
+        start = np.arange(0, num_values, step, dtype="int64")
         end = start + self.window_size
         if self.window_size:
-            end[-self.window_size :] = num_values
+            end = np.clip(end, 0, num_values)
 
         return start, end
 
@@ -284,7 +299,7 @@ def __init__(
         window_indexer: type[BaseIndexer] = BaseIndexer,
         indexer_kwargs: dict | None = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Parameters
         ----------
@@ -319,7 +334,9 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
+
         # 1) For each group, get the indices that belong to the group
         # 2) Use the indices to calculate the start & end bounds of the window
         # 3) Append the window bounds in group order
@@ -339,7 +356,7 @@ def get_window_bounds(
                 **self.indexer_kwargs,
             )
             start, end = indexer.get_window_bounds(
-                len(indices), min_periods, center, closed
+                len(indices), min_periods, center, closed, step
             )
             start = start.astype(np.int64)
             end = end.astype(np.int64)
@@ -358,6 +375,8 @@ def get_window_bounds(
             )
             start_arrays.append(window_indices.take(ensure_platform_int(start)))
             end_arrays.append(window_indices.take(ensure_platform_int(end)))
+        if len(start_arrays) == 0:
+            return np.array([], dtype=np.int64), np.array([], dtype=np.int64)
         start = np.concatenate(start_arrays)
         end = np.concatenate(end_arrays)
         return start, end
@@ -373,6 +392,7 @@ def get_window_bounds(
         min_periods: int | None = None,
         center: bool | None = None,
         closed: str | None = None,
+        step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         return np.array([0], dtype=np.int64), np.array([num_values], dtype=np.int64)
diff --git a/pandas/core/indexers/utils.py b/pandas/core/indexers/utils.py
index 41920727c50fd..0f3cdc4195c85 100644
--- a/pandas/core/indexers/utils.py
+++ b/pandas/core/indexers/utils.py
@@ -11,10 +11,7 @@
 
 import numpy as np
 
-from pandas._typing import (
-    AnyArrayLike,
-    ArrayLike,
-)
+from pandas._typing import AnyArrayLike
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
@@ -104,14 +101,13 @@ def is_scalar_indexer(indexer, ndim: int) -> bool:
     return False
 
 
-def is_empty_indexer(indexer, arr_value: ArrayLike) -> bool:
+def is_empty_indexer(indexer) -> bool:
     """
     Check if we have an empty indexer.
 
     Parameters
     ----------
     indexer : object
-    arr_value : np.ndarray or ExtensionArray
 
     Returns
     -------
@@ -119,11 +115,9 @@ def is_empty_indexer(indexer, arr_value: ArrayLike) -> bool:
     """
     if is_list_like(indexer) and not len(indexer):
         return True
-    if arr_value.ndim == 1:
-        if not isinstance(indexer, tuple):
-            indexer = (indexer,)
-        return any(isinstance(idx, np.ndarray) and len(idx) == 0 for idx in indexer)
-    return False
+    if not isinstance(indexer, tuple):
+        indexer = (indexer,)
+    return any(isinstance(idx, np.ndarray) and len(idx) == 0 for idx in indexer)
 
 
 # -----------------------------------------------------------
@@ -246,7 +240,7 @@ def validate_indices(indices: np.ndarray, n: int) -> None:
 # Indexer Conversion
 
 
-def maybe_convert_indices(indices, n: int, verify: bool = True):
+def maybe_convert_indices(indices, n: int, verify: bool = True) -> np.ndarray:
     """
     Attempt to convert indices into valid, positive indices.
 
@@ -297,27 +291,6 @@ def maybe_convert_indices(indices, n: int, verify: bool = True):
 # Unsorted
 
 
-def is_exact_shape_match(target: ArrayLike, value: ArrayLike) -> bool:
-    """
-    Is setting this value into this target overwriting the entire column?
-
-    Parameters
-    ----------
-    target : np.ndarray or ExtensionArray
-    value : np.ndarray or ExtensionArray
-
-    Returns
-    -------
-    bool
-    """
-    return (
-        len(value.shape) > 0
-        and len(target.shape) > 0
-        and value.shape[0] == target.shape[0]
-        and value.size == target.size
-    )
-
-
 def length_of_indexer(indexer, target=None) -> int:
     """
     Return the expected length of target[indexer]
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index 3aad1140294e5..46959aa5cd3e2 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -38,7 +38,10 @@
 from pandas.core.indexes.timedeltas import TimedeltaIndex
 
 if TYPE_CHECKING:
-    from pandas import Series
+    from pandas import (
+        DataFrame,
+        Series,
+    )
 
 
 class Properties(PandasDelegate, PandasObject, NoNewAttributesMixin):
@@ -47,7 +50,7 @@ class Properties(PandasDelegate, PandasObject, NoNewAttributesMixin):
         "name",
     }
 
-    def __init__(self, data: Series, orig):
+    def __init__(self, data: Series, orig) -> None:
         if not isinstance(data, ABCSeries):
             raise TypeError(
                 f"cannot convert an object of type {type(data)} to a datetimelike index"
@@ -193,7 +196,7 @@ class DatetimeProperties(Properties):
 
     def to_pydatetime(self) -> np.ndarray:
         """
-        Return the data as an array of native Python datetime objects.
+        Return the data as an array of :class:`datetime.datetime` objects.
 
         Timezone information is retained if present.
 
@@ -241,17 +244,16 @@ def to_pydatetime(self) -> np.ndarray:
     def freq(self):
         return self._get_values().inferred_freq
 
-    def isocalendar(self):
+    def isocalendar(self) -> DataFrame:
         """
-        Returns a DataFrame with the year, week, and day calculated according to
-        the ISO 8601 standard.
+        Calculate year, week, and day according to the ISO 8601 standard.
 
         .. versionadded:: 1.1.0
 
         Returns
         -------
         DataFrame
-            with columns year, week and day
+            With columns year, week and day.
 
         See Also
         --------
@@ -277,12 +279,13 @@ def isocalendar(self):
     @property
     def weekofyear(self):
         """
-        The week ordinal of the year.
+        The week ordinal of the year according to the ISO 8601 standard.
 
         .. deprecated:: 1.1.0
 
-        Series.dt.weekofyear and Series.dt.week have been deprecated.
-        Please use Series.dt.isocalendar().week instead.
+        Series.dt.weekofyear and Series.dt.week have been deprecated.  Please
+        call :func:`Series.dt.isocalendar` and access the ``week`` column
+        instead.
         """
         warnings.warn(
             "Series.dt.weekofyear and Series.dt.week have been deprecated. "
@@ -333,7 +336,7 @@ class TimedeltaProperties(Properties):
 
     def to_pytimedelta(self) -> np.ndarray:
         """
-        Return an array of native `datetime.timedelta` objects.
+        Return an array of native :class:`datetime.timedelta` objects.
 
         Python's standard `datetime` library uses a different representation
         timedelta's. This method converts a Series of pandas Timedeltas
diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 922c344510375..b041e6a64541a 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 import textwrap
+from typing import cast
+
+import numpy as np
 
 from pandas._libs import (
     NaT,
@@ -8,8 +11,10 @@
 )
 from pandas.errors import InvalidIndexError
 
+from pandas.core.dtypes.cast import find_common_type
 from pandas.core.dtypes.common import is_dtype_equal
 
+from pandas.core.algorithms import safe_sort
 from pandas.core.indexes.base import (
     Index,
     _new_Index,
@@ -66,6 +71,7 @@
     "get_unanimous_names",
     "all_indexes_same",
     "default_index",
+    "safe_sort_index",
 ]
 
 
@@ -153,11 +159,7 @@ def _get_combined_index(
         index = ensure_index(index)
 
     if sort:
-        try:
-            index = index.sort_values()
-        except TypeError:
-            pass
-
+        index = safe_sort_index(index)
     # GH 29879
     if copy:
         index = index.copy()
@@ -165,6 +167,40 @@ def _get_combined_index(
     return index
 
 
+def safe_sort_index(index: Index) -> Index:
+    """
+    Returns the sorted index
+
+    We keep the dtypes and the name attributes.
+
+    Parameters
+    ----------
+    index : an Index
+
+    Returns
+    -------
+    Index
+    """
+    if index.is_monotonic_increasing:
+        return index
+
+    try:
+        array_sorted = safe_sort(index)
+    except TypeError:
+        pass
+    else:
+        if isinstance(array_sorted, MultiIndex):
+            return array_sorted
+
+        array_sorted = cast(np.ndarray, array_sorted)
+        if isinstance(index, MultiIndex):
+            index = MultiIndex.from_tuples(array_sorted, names=index.names)
+        else:
+            index = Index(array_sorted, name=index.name, dtype=index.dtype)
+
+    return index
+
+
 def union_indexes(indexes, sort: bool | None = True) -> Index:
     """
     Return the union of indexes.
@@ -191,7 +227,7 @@ def union_indexes(indexes, sort: bool | None = True) -> Index:
 
     indexes, kind = _sanitize_and_check(indexes)
 
-    def _unique_indices(inds) -> Index:
+    def _unique_indices(inds, dtype) -> Index:
         """
         Convert indexes to lists and concatenate them, removing duplicates.
 
@@ -200,6 +236,7 @@ def _unique_indices(inds) -> Index:
         Parameters
         ----------
         inds : list of Index or list objects
+        dtype : dtype to set for the resulting Index
 
         Returns
         -------
@@ -211,7 +248,30 @@ def conv(i):
                 i = i.tolist()
             return i
 
-        return Index(lib.fast_unique_multiple_list([conv(i) for i in inds], sort=sort))
+        return Index(
+            lib.fast_unique_multiple_list([conv(i) for i in inds], sort=sort),
+            dtype=dtype,
+        )
+
+    def _find_common_index_dtype(inds):
+        """
+        Finds a common type for the indexes to pass through to resulting index.
+
+        Parameters
+        ----------
+        inds: list of Index or list objects
+
+        Returns
+        -------
+        The common type or None if no indexes were given
+        """
+        dtypes = [idx.dtype for idx in indexes if isinstance(idx, Index)]
+        if dtypes:
+            dtype = find_common_type(dtypes)
+        else:
+            dtype = None
+
+        return dtype
 
     if kind == "special":
         result = indexes[0]
@@ -251,16 +311,18 @@ def conv(i):
         return result
 
     elif kind == "array":
+        dtype = _find_common_index_dtype(indexes)
         index = indexes[0]
         if not all(index.equals(other) for other in indexes[1:]):
-            index = _unique_indices(indexes)
+            index = _unique_indices(indexes, dtype)
 
         name = get_unanimous_names(*indexes)[0]
         if name != index.name:
             index = index.rename(name)
         return index
     else:  # kind='list'
-        return _unique_indices(indexes)
+        dtype = _find_common_index_dtype(indexes)
+        return _unique_indices(indexes, dtype)
 
 
 def _sanitize_and_check(indexes):
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 6c7499a575fca..447ba8d70c73e 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -8,8 +8,11 @@
     TYPE_CHECKING,
     Any,
     Callable,
+    ClassVar,
     Hashable,
+    Iterable,
     Literal,
+    NoReturn,
     Sequence,
     TypeVar,
     cast,
@@ -33,24 +36,29 @@
     is_datetime_array,
     no_default,
 )
+from pandas._libs.missing import is_float_nan
 from pandas._libs.tslibs import (
     IncompatibleFrequency,
     OutOfBoundsDatetime,
     Timestamp,
+    is_unitless,
     tz_compare,
 )
 from pandas._typing import (
-    AnyArrayLike,
     ArrayLike,
+    Axes,
     Dtype,
     DtypeObj,
     F,
+    IgnoreRaise,
+    Level,
     Shape,
     npt,
 )
 from pandas.compat.numpy import function as nv
 from pandas.errors import (
     DuplicateLabelError,
+    IntCastingNaNError,
     InvalidIndexError,
 )
 from pandas.util._decorators import (
@@ -64,11 +72,16 @@
     rewrite_exception,
 )
 
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.cast import (
+    LossySetitemError,
     can_hold_element,
+    common_dtype_categorical_compat,
+    ensure_dtype_can_hold_na,
     find_common_type,
     infer_dtype_from,
     maybe_cast_pointwise_result,
+    np_can_hold_element,
 )
 from pandas.core.dtypes.common import (
     ensure_int64,
@@ -90,6 +103,7 @@
     is_object_dtype,
     is_scalar,
     is_signed_integer_dtype,
+    is_string_dtype,
     is_unsigned_integer_dtype,
     needs_i8_conversion,
     pandas_dtype,
@@ -138,8 +152,8 @@
     tz_to_dtype,
     validate_tz_from_dtype,
 )
-from pandas.core.arrays.masked import BaseMaskedArray
 from pandas.core.arrays.sparse import SparseDtype
+from pandas.core.arrays.string_ import StringArray
 from pandas.core.base import (
     IndexOpsMixin,
     PandasObject,
@@ -172,7 +186,6 @@
     from pandas import (
         CategoricalIndex,
         DataFrame,
-        IntervalIndex,
         MultiIndex,
         Series,
     )
@@ -195,7 +208,7 @@
 str_t = str
 
 
-_o_dtype = np.dtype("object")
+_dtype_obj = np.dtype("object")
 
 
 def _maybe_return_indexers(meth: F) -> F:
@@ -247,6 +260,10 @@ def _new_Index(cls, d):
             # GH#23752 "labels" kwarg has been replaced with "codes"
             d["codes"] = d.pop("labels")
 
+        # Since this was a valid MultiIndex at pickle-time, we don't need to
+        #  check validty at un-pickle time.
+        d["verify_integrity"] = False
+
     elif "dtype" not in d and "data" in d:
         # Prevent Index.__new__ from conducting inference;
         #  "data" key not in RangeIndex
@@ -259,8 +276,9 @@ def _new_Index(cls, d):
 
 class Index(IndexOpsMixin, PandasObject):
     """
-    Immutable sequence used for indexing and alignment. The basic object
-    storing axis labels for all pandas objects.
+    Immutable sequence used for indexing and alignment.
+
+    The basic object storing axis labels for all pandas objects.
 
     Parameters
     ----------
@@ -323,6 +341,9 @@ def _left_indexer_unique(self: _IndexT, other: _IndexT) -> npt.NDArray[np.intp]:
         # Caller is responsible for ensuring other.dtype == self.dtype
         sv = self._get_engine_target()
         ov = other._get_engine_target()
+        # can_use_libjoin assures sv and ov are ndarrays
+        sv = cast(np.ndarray, sv)
+        ov = cast(np.ndarray, ov)
         return libjoin.left_join_indexer_unique(sv, ov)
 
     @final
@@ -332,6 +353,9 @@ def _left_indexer(
         # Caller is responsible for ensuring other.dtype == self.dtype
         sv = self._get_engine_target()
         ov = other._get_engine_target()
+        # can_use_libjoin assures sv and ov are ndarrays
+        sv = cast(np.ndarray, sv)
+        ov = cast(np.ndarray, ov)
         joined_ndarray, lidx, ridx = libjoin.left_join_indexer(sv, ov)
         joined = self._from_join_target(joined_ndarray)
         return joined, lidx, ridx
@@ -343,6 +367,9 @@ def _inner_indexer(
         # Caller is responsible for ensuring other.dtype == self.dtype
         sv = self._get_engine_target()
         ov = other._get_engine_target()
+        # can_use_libjoin assures sv and ov are ndarrays
+        sv = cast(np.ndarray, sv)
+        ov = cast(np.ndarray, ov)
         joined_ndarray, lidx, ridx = libjoin.inner_join_indexer(sv, ov)
         joined = self._from_join_target(joined_ndarray)
         return joined, lidx, ridx
@@ -354,6 +381,9 @@ def _outer_indexer(
         # Caller is responsible for ensuring other.dtype == self.dtype
         sv = self._get_engine_target()
         ov = other._get_engine_target()
+        # can_use_libjoin assures sv and ov are ndarrays
+        sv = cast(np.ndarray, sv)
+        ov = cast(np.ndarray, ov)
         joined_ndarray, lidx, ridx = libjoin.outer_join_indexer(sv, ov)
         joined = self._from_join_target(joined_ndarray)
         return joined, lidx, ridx
@@ -373,7 +403,6 @@ def _outer_indexer(
     _comparables: list[str] = ["name"]
     _attributes: list[str] = ["name"]
     _is_numeric_dtype: bool = False
-    _can_hold_na: bool = True
     _can_hold_strings: bool = True
 
     # Whether this index is a NumericIndex, but not a Int64Index, Float64Index,
@@ -381,7 +410,12 @@ def _outer_indexer(
     # associated code in pandas 2.0.
     _is_backward_compat_public_numeric_index: bool = False
 
-    _engine_type: type[libindex.IndexEngine] = libindex.ObjectEngine
+    @property
+    def _engine_type(
+        self,
+    ) -> type[libindex.IndexEngine] | type[libindex.ExtensionEngine]:
+        return libindex.ObjectEngine
+
     # whether we support partial string indexing. Overridden
     # in DatetimeIndex and PeriodIndex
     _supports_partial_string_indexing = False
@@ -453,6 +487,9 @@ def __new__(
                 if dtype is not None:
                     return result.astype(dtype, copy=False)
                 return result
+            elif dtype is not None:
+                # GH#45206
+                data = data.astype(dtype, copy=False)
 
             disallow_kwargs(kwargs)
             data = extract_array(data, extract_numpy=True)
@@ -483,8 +520,12 @@ def __new__(
             if data.dtype.kind in ["i", "u", "f"]:
                 # maybe coerce to a sub-class
                 arr = data
+            elif data.dtype.kind in ["b", "c"]:
+                # No special subclass, and Index._ensure_array won't do this
+                #  for us.
+                arr = np.asarray(data)
             else:
-                arr = com.asarray_tuplesafe(data, dtype=np.dtype("object"))
+                arr = com.asarray_tuplesafe(data, dtype=_dtype_obj)
 
                 if dtype is None:
                     arr = _maybe_cast_data_without_dtype(
@@ -521,13 +562,10 @@ def __new__(
                     )
             # other iterable of some kind
 
-            subarr = com.asarray_tuplesafe(data, dtype=np.dtype("object"))
+            subarr = com.asarray_tuplesafe(data, dtype=_dtype_obj)
             if dtype is None:
                 # with e.g. a list [1, 2, 3] casting to numeric is _not_ deprecated
-                # error: Incompatible types in assignment (expression has type
-                # "Union[ExtensionArray, ndarray[Any, Any]]", variable has type
-                # "ndarray[Any, Any]")
-                subarr = _maybe_cast_data_without_dtype(  # type: ignore[assignment]
+                subarr = _maybe_cast_data_without_dtype(
                     subarr, cast_numeric_deprecated=False
                 )
                 dtype = subarr.dtype
@@ -606,13 +644,13 @@ def _dtype_to_subclass(cls, dtype: DtypeObj):
 
             return Int64Index
 
-        # error: Non-overlapping equality check (left operand type: "dtype[Any]", right
-        # operand type: "Type[object]")
-        elif dtype == object:  # type: ignore[comparison-overlap]
+        elif dtype == _dtype_obj:
             # NB: assuming away MultiIndex
             return Index
 
-        elif issubclass(dtype.type, (str, bool, np.bool_)):
+        elif issubclass(
+            dtype.type, (str, bool, np.bool_, complex, np.complex64, np.complex128)
+        ):
             return Index
 
         raise NotImplementedError(dtype)
@@ -677,12 +715,12 @@ def _with_infer(cls, *args, **kwargs):
             warnings.filterwarnings("ignore", ".*the Index constructor", FutureWarning)
             result = cls(*args, **kwargs)
 
-        if result.dtype == object and not result._is_multi:
+        if result.dtype == _dtype_obj and not result._is_multi:
             # error: Argument 1 to "maybe_convert_objects" has incompatible type
             # "Union[ExtensionArray, ndarray[Any, Any]]"; expected
             # "ndarray[Any, Any]"
             values = lib.maybe_convert_objects(result._values)  # type: ignore[arg-type]
-            if values.dtype.kind in ["i", "u", "f"]:
+            if values.dtype.kind in ["i", "u", "f", "b"]:
                 return Index(values, name=result.name)
 
         return result
@@ -843,23 +881,28 @@ def _cleanup(self) -> None:
     @cache_readonly
     def _engine(
         self,
-    ) -> libindex.IndexEngine:
+    ) -> libindex.IndexEngine | libindex.ExtensionEngine:
         # For base class (object dtype) we get ObjectEngine
-
-        if isinstance(self._values, BaseMaskedArray):
-            # TODO(ExtensionIndex): use libindex.NullableEngine(self._values)
-            return libindex.ObjectEngine(self._get_engine_target())
-        elif (
-            isinstance(self._values, ExtensionArray)
+        target_values = self._get_engine_target()
+        if (
+            isinstance(target_values, ExtensionArray)
             and self._engine_type is libindex.ObjectEngine
         ):
-            # TODO(ExtensionIndex): use libindex.ExtensionEngine(self._values)
-            return libindex.ObjectEngine(self._get_engine_target())
+            return libindex.ExtensionEngine(target_values)
 
+        target_values = cast(np.ndarray, target_values)
         # to avoid a reference cycle, bind `target_values` to a local variable, so
         # `self` is not passed into the lambda.
-        target_values = self._get_engine_target()
-        return self._engine_type(target_values)
+        if target_values.dtype == bool:
+            return libindex.BoolEngine(target_values)
+        elif target_values.dtype == np.complex64:
+            return libindex.Complex64Engine(target_values)
+        elif target_values.dtype == np.complex128:
+            return libindex.Complex128Engine(target_values)
+
+        # error: Argument 1 to "ExtensionEngine" has incompatible type
+        # "ndarray[Any, Any]"; expected "ExtensionArray"
+        return self._engine_type(target_values)  # type: ignore[arg-type]
 
     @final
     @cache_readonly
@@ -895,11 +938,19 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str_t, *inputs, **kwargs):
         if any(isinstance(other, (ABCSeries, ABCDataFrame)) for other in inputs):
             return NotImplemented
 
-        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
-            self, ufunc, method, *inputs, **kwargs
-        )
-        if result is not NotImplemented:
-            return result
+        # TODO(2.0) the 'and', 'or' and 'xor' dunder methods are currently set
+        # operations and not logical operations, so don't dispatch
+        # This is deprecated, so this full 'if' clause can be removed once
+        # deprecation is enforced in 2.0
+        if not (
+            method == "__call__"
+            and ufunc in (np.bitwise_and, np.bitwise_or, np.bitwise_xor)
+        ):
+            result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
+                self, ufunc, method, *inputs, **kwargs
+            )
+            if result is not NotImplemented:
+                return result
 
         if "out" in kwargs:
             # e.g. test_dti_isub_tdi
@@ -1031,21 +1082,24 @@ def astype(self, dtype, copy: bool = True):
             # Ensure that self.astype(self.dtype) is self
             return self.copy() if copy else self
 
-        if (
-            self.dtype == np.dtype("M8[ns]")
-            and isinstance(dtype, np.dtype)
-            and dtype.kind == "M"
-            and dtype != np.dtype("M8[ns]")
-        ):
-            # For now DatetimeArray supports this by unwrapping ndarray,
-            #  but DatetimeIndex doesn't
-            raise TypeError(f"Cannot cast {type(self).__name__} to dtype")
-
         values = self._data
         if isinstance(values, ExtensionArray):
+            if isinstance(dtype, np.dtype) and dtype.kind == "M" and is_unitless(dtype):
+                # TODO(2.0): remove this special-casing once this is enforced
+                #  in DTA.astype
+                raise TypeError(f"Cannot cast {type(self).__name__} to dtype")
+
             with rewrite_exception(type(values).__name__, type(self).__name__):
                 new_values = values.astype(dtype, copy=copy)
 
+        elif is_float_dtype(self.dtype) and needs_i8_conversion(dtype):
+            # NB: this must come before the ExtensionDtype check below
+            # TODO: this differs from Series behavior; can/should we align them?
+            raise TypeError(
+                f"Cannot convert Float64Index to dtype {dtype}; integer "
+                "values are required for conversion"
+            )
+
         elif isinstance(dtype, ExtensionDtype):
             cls = dtype.construct_array_type()
             # Note: for RangeIndex and CategoricalDtype self vs self._values
@@ -1054,13 +1108,31 @@ def astype(self, dtype, copy: bool = True):
 
         else:
             try:
-                new_values = values.astype(dtype, copy=copy)
+                if dtype == str:
+                    # GH#38607
+                    new_values = values.astype(dtype, copy=copy)
+                else:
+                    # GH#13149 specifically use astype_nansafe instead of astype
+                    new_values = astype_nansafe(values, dtype=dtype, copy=copy)
+            except IntCastingNaNError:
+                raise
             except (TypeError, ValueError) as err:
+                if dtype.kind == "u" and "losslessly" in str(err):
+                    # keep the message from _astype_float_to_int_nansafe
+                    raise
                 raise TypeError(
                     f"Cannot cast {type(self).__name__} to dtype {dtype}"
                 ) from err
 
         # pass copy=False because any copying will be done in the astype above
+        if self._is_backward_compat_public_numeric_index:
+            # this block is needed so e.g. NumericIndex[int8].astype("int32") returns
+            # NumericIndex[int32] and not Int64Index with dtype int64.
+            # When Int64Index etc. are removed from the code base, removed this also.
+            if isinstance(dtype, np.dtype) and is_numeric_dtype(dtype):
+                return self._constructor(
+                    new_values, name=self.name, dtype=dtype, copy=False
+                )
         return Index(new_values, name=self.name, dtype=new_values.dtype, copy=False)
 
     _index_shared_docs[
@@ -1349,6 +1421,18 @@ def _format_attrs(self) -> list[tuple[str_t, str_t | int | bool | None]]:
             attrs.append(("length", len(self)))
         return attrs
 
+    @final
+    def _get_level_names(self) -> Hashable | Sequence[Hashable]:
+        """
+        Return a name or list of names with None replaced by the level number.
+        """
+        if self._is_multi:
+            return [
+                level if name is None else name for level, name in enumerate(self.names)
+            ]
+        else:
+            return 0 if self.name is None else self.name
+
     @final
     def _mpl_repr(self) -> np.ndarray:
         # how to represent ourselves to matplotlib
@@ -1390,7 +1474,7 @@ def _format_with_header(self, header: list[str_t], na_rep: str_t) -> list[str_t]
             result = [pprint_thing(x, escape_chars=("\t", "\r", "\n")) for x in values]
 
             # could have nans
-            mask = isna(values)
+            mask = is_float_nan(values)
             if mask.any():
                 result_arr = np.array(result)
                 result_arr[mask] = na_rep
@@ -1438,7 +1522,9 @@ def to_native_types(self, slicer=None, **kwargs) -> np.ndarray:
             values = values[slicer]
         return values._format_native_types(**kwargs)
 
-    def _format_native_types(self, *, na_rep="", quoting=None, **kwargs):
+    def _format_native_types(
+        self, *, na_rep="", quoting=None, **kwargs
+    ) -> npt.NDArray[np.object_]:
         """
         Actually format specific types of the index.
         """
@@ -1489,7 +1575,7 @@ def _summary(self, name=None) -> str_t:
     # --------------------------------------------------------------------
     # Conversion Methods
 
-    def to_flat_index(self):
+    def to_flat_index(self: _IndexT) -> _IndexT:
         """
         Identity method.
 
@@ -1623,8 +1709,19 @@ def to_frame(
         """
         from pandas import DataFrame
 
+        if name is None:
+            warnings.warn(
+                "Explicitly passing `name=None` currently preserves the Index's name "
+                "or uses a default name of 0. This behaviour is deprecated, and in "
+                "the future `None` will be used as the name of the resulting "
+                "DataFrame column.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            name = lib.no_default
+
         if name is lib.no_default:
-            name = self.name or 0
+            name = self._get_level_names()
         result = DataFrame({name: self._values.copy()})
 
         if index:
@@ -1635,14 +1732,14 @@ def to_frame(
     # Name-Centric Methods
 
     @property
-    def name(self):
+    def name(self) -> Hashable:
         """
         Return Index or MultiIndex name.
         """
         return self._name
 
     @name.setter
-    def name(self, value: Hashable):
+    def name(self, value: Hashable) -> None:
         if self._no_setting_name:
             # Used in MultiIndex.levels to avoid silently ignoring name updates.
             raise RuntimeError(
@@ -1685,6 +1782,41 @@ def _validate_names(
 
         return new_names
 
+    def _get_default_index_names(
+        self, names: Hashable | Sequence[Hashable] | None = None, default=None
+    ) -> list[Hashable]:
+        """
+        Get names of index.
+
+        Parameters
+        ----------
+        names : int, str or 1-dimensional list, default None
+            Index names to set.
+        default : str
+            Default name of index.
+
+        Raises
+        ------
+        TypeError
+            if names not str or list-like
+        """
+        from pandas.core.indexes.multi import MultiIndex
+
+        if names is not None:
+            if isinstance(names, str) or isinstance(names, int):
+                names = [names]
+
+        if not isinstance(names, list) and names is not None:
+            raise ValueError("Index names must be str or 1-dimensional list")
+
+        if not names:
+            if isinstance(self, MultiIndex):
+                names = com.fill_missing_names(self.names)
+            else:
+                names = [default] if self.name is None else [self.name]
+
+        return names
+
     def _get_names(self) -> FrozenList:
         return FrozenList((self.name,))
 
@@ -2079,8 +2211,14 @@ def _drop_level_numbers(self, levnums: list[int]):
 
             if len(lev) == 0:
                 # If lev is empty, lev.take will fail GH#42055
-                res_values = algos.take(lev._values, new_codes[0], allow_fill=True)
-                result = type(lev)._simple_new(res_values, name=new_names[0])
+                if len(new_codes[0]) == 0:
+                    # GH#45230 preserve RangeIndex here
+                    #  see test_reset_index_empty_rangeindex
+                    result = lev[:0]
+                else:
+                    res_values = algos.take(lev._values, new_codes[0], allow_fill=True)
+                    # _constructor instead of type(lev) for RangeIndex compat GH#35230
+                    result = lev._constructor._simple_new(res_values, name=new_names[0])
             else:
                 # set nan if needed
                 mask = new_codes[0] == -1
@@ -2101,7 +2239,13 @@ def _drop_level_numbers(self, levnums: list[int]):
                 verify_integrity=False,
             )
 
-    def _get_grouper_for_level(self, mapper, *, level=None):
+    def _get_grouper_for_level(
+        self,
+        mapper,
+        *,
+        level=None,
+        dropna: bool = True,
+    ) -> tuple[Index, npt.NDArray[np.signedinteger] | None, Index | None]:
         """
         Get index grouper corresponding to an index level
 
@@ -2111,6 +2255,8 @@ def _get_grouper_for_level(self, mapper, *, level=None):
             Function mapping index values to groups
         level : int or None
             Index level, positional
+        dropna : bool
+            dropna from groupby
 
         Returns
         -------
@@ -2132,19 +2278,42 @@ def _get_grouper_for_level(self, mapper, *, level=None):
     # --------------------------------------------------------------------
     # Introspection Methods
 
+    @cache_readonly
+    @final
+    def _can_hold_na(self) -> bool:
+        if isinstance(self.dtype, ExtensionDtype):
+            if isinstance(self.dtype, IntervalDtype):
+                # FIXME(GH#45720): this is inaccurate for integer-backed
+                #  IntervalArray, but without it other.categories.take raises
+                #  in IntervalArray._cmp_method
+                return True
+            return self.dtype._can_hold_na
+        if self.dtype.kind in ["i", "u", "b"]:
+            return False
+        return True
+
     @final
     @property
     def is_monotonic(self) -> bool:
         """
         Alias for is_monotonic_increasing.
+
+        .. deprecated:: 1.5.0
+            is_monotonic is deprecated and will be removed in a future version.
+            Use is_monotonic_increasing instead.
         """
+        warnings.warn(
+            "is_monotonic is deprecated and will be removed in a future version. "
+            "Use is_monotonic_increasing instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
         return self.is_monotonic_increasing
 
     @property
     def is_monotonic_increasing(self) -> bool:
         """
-        Return if the index is monotonic increasing (only equal or
-        increasing) values.
+        Return a boolean if the values are equal or increasing.
 
         Examples
         --------
@@ -2160,8 +2329,7 @@ def is_monotonic_increasing(self) -> bool:
     @property
     def is_monotonic_decreasing(self) -> bool:
         """
-        Return if the index is monotonic decreasing (only equal or
-        decreasing) values.
+        Return a boolean if the values are equal or decreasing.
 
         Examples
         --------
@@ -2582,10 +2750,20 @@ def inferred_type(self) -> str_t:
         return lib.infer_dtype(self._values, skipna=False)
 
     @cache_readonly
+    @final
     def _is_all_dates(self) -> bool:
         """
         Whether or not the index values only consist of dates.
         """
+        if needs_i8_conversion(self.dtype):
+            return True
+        elif self.dtype != _dtype_obj:
+            # TODO(ExtensionIndex): 3rd party EA might override?
+            # Note: this includes IntervalIndex, even when the left/right
+            #  contain datetime-like objects.
+            return False
+        elif self._is_multi:
+            return False
         return is_datetime_array(ensure_object(self._values))
 
     @cache_readonly
@@ -2646,7 +2824,9 @@ def _isnan(self) -> npt.NDArray[np.bool_]:
     @cache_readonly
     def hasnans(self) -> bool:
         """
-        Return if I have any nans; enables various perf speedups.
+        Return True if there are any NaNs.
+
+        Enables various performance speedups.
         """
         if self._can_hold_na:
             return bool(self._isnan.any())
@@ -3004,7 +3184,7 @@ def __xor__(self, other):
         return self.symmetric_difference(other)
 
     @final
-    def __nonzero__(self):
+    def __nonzero__(self) -> NoReturn:
         raise ValueError(
             f"The truth value of a {type(self).__name__} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
@@ -3034,6 +3214,30 @@ def _validate_sort_keyword(self, sort):
                 f"None or False; {sort} was passed."
             )
 
+    @final
+    def _deprecate_dti_setop(self, other: Index, setop: str_t):
+        """
+        Deprecate setop behavior between timezone-aware DatetimeIndexes with
+        mismatched timezones.
+        """
+        # Caller is responsibelf or checking
+        #  `not is_dtype_equal(self.dtype, other.dtype)`
+        if (
+            isinstance(self, ABCDatetimeIndex)
+            and isinstance(other, ABCDatetimeIndex)
+            and self.tz is not None
+            and other.tz is not None
+        ):
+            # GH#39328, GH#45357
+            warnings.warn(
+                f"In a future version, the {setop} of DatetimeIndex objects "
+                "with mismatched timezones will cast both to UTC instead of "
+                "object dtype. To retain the old behavior, "
+                f"use `index.astype(object).{setop}(other)`",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
     @final
     def union(self, other, sort=None):
         """
@@ -3132,21 +3336,7 @@ def union(self, other, sort=None):
                     "Can only union MultiIndex with MultiIndex or Index of tuples, "
                     "try mi.to_flat_index().union(other) instead."
                 )
-            if (
-                isinstance(self, ABCDatetimeIndex)
-                and isinstance(other, ABCDatetimeIndex)
-                and self.tz is not None
-                and other.tz is not None
-            ):
-                # GH#39328
-                warnings.warn(
-                    "In a future version, the union of DatetimeIndex objects "
-                    "with mismatched timezones will cast both to UTC instead of "
-                    "object dtype. To retain the old behavior, "
-                    "use `index.astype(object).union(other)`",
-                    FutureWarning,
-                    stacklevel=find_stack_level(),
-                )
+            self._deprecate_dti_setop(other, "union")
 
             dtype = self._find_common_type_compat(other)
             left = self.astype(dtype, copy=False)
@@ -3189,8 +3379,8 @@ def _union(self, other: Index, sort):
 
         if (
             sort is None
-            and self.is_monotonic
-            and other.is_monotonic
+            and self.is_monotonic_increasing
+            and other.is_monotonic_increasing
             and not (self.has_duplicates and other.has_duplicates)
             and self._can_use_libjoin
         ):
@@ -3228,7 +3418,7 @@ def _union(self, other: Index, sort):
         else:
             result = lvals
 
-        if not self.is_monotonic or not other.is_monotonic:
+        if not self.is_monotonic_increasing or not other.is_monotonic_increasing:
             # if both are monotonic then result should already be sorted
             result = _maybe_try_sort(result, sort)
 
@@ -3242,12 +3432,6 @@ def _wrap_setop_result(self, other: Index, result) -> Index:
                 result = result.rename(name)
         else:
             result = self._shallow_copy(result, name=name)
-
-        if type(self) is Index and self.dtype != object:
-            # i.e. ExtensionArray-backed
-            # TODO(ExtensionIndex): revert this astype; it is a kludge to make
-            #  it possible to split ExtensionEngine from ExtensionIndex PR.
-            return result.astype(self.dtype, copy=False)
         return result
 
     @final
@@ -3282,6 +3466,9 @@ def intersection(self, other, sort=False):
         self._assert_can_do_setop(other)
         other, result_name = self._convert_can_do_setop(other)
 
+        if not is_dtype_equal(self.dtype, other.dtype):
+            self._deprecate_dti_setop(other, "intersection")
+
         if self.equals(other):
             if self.has_duplicates:
                 return self.unique()._get_reconciled_name_object(other)
@@ -3330,7 +3517,11 @@ def _intersection(self, other: Index, sort=False):
         """
         intersection specialized to the case with matching dtypes.
         """
-        if self.is_monotonic and other.is_monotonic and self._can_use_libjoin:
+        if (
+            self.is_monotonic_increasing
+            and other.is_monotonic_increasing
+            and self._can_use_libjoin
+        ):
             try:
                 result = self._inner_indexer(other)[0]
             except TypeError:
@@ -3412,6 +3603,10 @@ def difference(self, other, sort=None):
         self._assert_can_do_setop(other)
         other, result_name = self._convert_can_do_setop(other)
 
+        # Note: we do NOT call _deprecate_dti_setop here, as there
+        #  is no requirement that .difference be commutative, so it does
+        #  not cast to object.
+
         if self.equals(other):
             # Note: we do not (yet) sort even if sort=None GH#24959
             return self[:0].rename(result_name)
@@ -3486,6 +3681,9 @@ def symmetric_difference(self, other, result_name=None, sort=None):
         if result_name is None:
             result_name = result_name_update
 
+        if not is_dtype_equal(self.dtype, other.dtype):
+            self._deprecate_dti_setop(other, "symmetric_difference")
+
         if not self._should_compare(other):
             return self.union(other, sort=sort).rename(result_name)
 
@@ -3566,6 +3764,10 @@ def get_loc(self, key, method=None, tolerance=None):
             * backfill / bfill: use NEXT index value if no exact match
             * nearest: use the NEAREST index value if no exact match. Tied
               distances are broken by preferring the larger index value.
+
+            .. deprecated:: 1.4
+                Use index.get_indexer([item], method=...) instead.
+
         tolerance : int or float, optional
             Maximum distance from index value for inexact matches. The value of
             the index at the matching location must satisfy the equation
@@ -3633,8 +3835,9 @@ def get_loc(self, key, method=None, tolerance=None):
     _index_shared_docs[
         "get_indexer"
     ] = """
-        Compute indexer and mask for new index given the current index. The
-        indexer should be then used as an input to ndarray.take to align the
+        Compute indexer and mask for new index given the current index.
+
+        The indexer should be then used as an input to ndarray.take to align the
         current data to the new index.
 
         Parameters
@@ -3692,6 +3895,7 @@ def get_indexer(
         tolerance=None,
     ) -> npt.NDArray[np.intp]:
         method = missing.clean_reindex_fill_method(method)
+        orig_target = target
         target = self._maybe_cast_listlike_indexer(target)
 
         self._check_indexing_method(method, limit, tolerance)
@@ -3714,9 +3918,15 @@ def get_indexer(
 
             indexer = self._engine.get_indexer(target.codes)
             if self.hasnans and target.hasnans:
+                # After _maybe_cast_listlike_indexer, target elements which do not
+                # belong to some category are changed to NaNs
+                # Mask to track actual NaN values compared to inserted NaN values
+                # GH#45361
+                target_nans = isna(orig_target)
                 loc = self.get_loc(np.nan)
                 mask = target.isna()
-                indexer[mask] = loc
+                indexer[target_nans] = loc
+                indexer[mask & ~target_nans] = -1
             return indexer
 
         if is_categorical_dtype(target.dtype):
@@ -3777,13 +3987,15 @@ def _get_indexer(
         elif method == "nearest":
             indexer = self._get_nearest_indexer(target, limit, tolerance)
         else:
-            tgt_values = target._get_engine_target()
             if target._is_multi and self._is_multi:
                 engine = self._engine
-                # error: "IndexEngine" has no attribute "_extract_level_codes"
-                tgt_values = engine._extract_level_codes(  # type: ignore[attr-defined]
+                # error: Item "IndexEngine" of "Union[IndexEngine, ExtensionEngine]"
+                # has no attribute "_extract_level_codes"
+                tgt_values = engine._extract_level_codes(  # type: ignore[union-attr]
                     target
                 )
+            else:
+                tgt_values = target._get_engine_target()
 
             indexer = self._engine.get_indexer(tgt_values)
 
@@ -3795,8 +4007,14 @@ def _should_partial_index(self, target: Index) -> bool:
         Should we attempt partial-matching indexing?
         """
         if is_interval_dtype(self.dtype):
+            if is_interval_dtype(target.dtype):
+                return False
+            # See https://github.com/pandas-dev/pandas/issues/47772 the commented
+            # out code can be restored (instead of hardcoding `return True`)
+            # once that issue if fixed
             # "Index" has no attribute "left"
-            return self.left._should_compare(target)  # type: ignore[attr-defined]
+            # return self.left._should_compare(target)  # type: ignore[attr-defined]
+            return True
         return False
 
     @final
@@ -3861,13 +4079,18 @@ def _get_fill_indexer(
             # TODO: get_indexer_with_fill docstring says values must be _sorted_
             #  but that doesn't appear to be enforced
             # error: "IndexEngine" has no attribute "get_indexer_with_fill"
-            return self._engine.get_indexer_with_fill(  # type: ignore[attr-defined]
+            engine = self._engine
+            return engine.get_indexer_with_fill(  # type: ignore[union-attr]
                 target=target._values, values=self._values, method=method, limit=limit
             )
 
         if self.is_monotonic_increasing and target.is_monotonic_increasing:
             target_values = target._get_engine_target()
             own_values = self._get_engine_target()
+            if not isinstance(target_values, np.ndarray) or not isinstance(
+                own_values, np.ndarray
+            ):
+                raise NotImplementedError
 
             if method == "pad":
                 indexer = libalgos.pad(own_values, target_values, limit=limit)
@@ -3934,7 +4157,11 @@ def _get_nearest_indexer(
 
         op = operator.lt if self.is_monotonic_increasing else operator.le
         indexer = np.where(
-            op(left_distances, right_distances) | (right_indexer == -1),
+            # error: Argument 1&2 has incompatible type "Union[ExtensionArray,
+            # ndarray[Any, Any]]"; expected "Union[SupportsDunderLE,
+            # SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+            op(left_distances, right_distances)  # type: ignore[arg-type]
+            | (right_indexer == -1),
             left_indexer,
             right_indexer,
         )
@@ -4007,16 +4234,19 @@ def is_int(v):
             return v is None or is_integer(v)
 
         is_index_slice = is_int(start) and is_int(stop) and is_int(step)
-        is_positional = is_index_slice and not (
-            self.is_integer() or self.is_categorical()
+
+        # special case for interval_dtype bc we do not do partial-indexing
+        #  on integer Intervals when slicing
+        # TODO: write this in terms of e.g. should_partial_index?
+        ints_are_positional = self._should_fallback_to_positional or is_interval_dtype(
+            self.dtype
         )
+        is_positional = is_index_slice and ints_are_positional
 
         if kind == "getitem":
-            """
-            called from the getitem slicers, validate that we are in fact
-            integers
-            """
+            # called from the getitem slicers, validate that we are in fact integers
             if self.is_integer() or is_index_slice:
+                # Note: these checks are redundant if we know is_index_slice
                 self._validate_indexer("slice", key.start, "getitem")
                 self._validate_indexer("slice", key.stop, "getitem")
                 self._validate_indexer("slice", key.step, "getitem")
@@ -4134,8 +4364,8 @@ def reindex(
 
         See Also
         --------
-        Series.reindex
-        DataFrame.reindex
+        Series.reindex : Conform Series to new index with optional filling logic.
+        DataFrame.reindex : Conform DataFrame to new index with optional filling logic.
 
         Examples
         --------
@@ -4162,7 +4392,9 @@ def reindex(
         else:
             target = ensure_index(target)
 
-        if level is not None:
+        if level is not None and (
+            isinstance(self, ABCMultiIndex) or isinstance(target, ABCMultiIndex)
+        ):
             if method is not None:
                 raise TypeError("Fill method not supported if level passed")
 
@@ -4290,19 +4522,55 @@ def _reindex_non_unique(
     # --------------------------------------------------------------------
     # Join Methods
 
+    @overload
+    def join(
+        self,
+        other: Index,
+        *,
+        how: str_t = ...,
+        level: Level = ...,
+        return_indexers: Literal[True],
+        sort: bool = ...,
+    ) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        ...
+
+    @overload
+    def join(
+        self,
+        other: Index,
+        *,
+        how: str_t = ...,
+        level: Level = ...,
+        return_indexers: Literal[False] = ...,
+        sort: bool = ...,
+    ) -> Index:
+        ...
+
+    @overload
+    def join(
+        self,
+        other: Index,
+        *,
+        how: str_t = ...,
+        level: Level = ...,
+        return_indexers: bool = ...,
+        sort: bool = ...,
+    ) -> Index | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        ...
+
     @final
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "other"])
     @_maybe_return_indexers
     def join(
         self,
-        other,
+        other: Index,
         how: str_t = "left",
-        level=None,
+        level: Level = None,
         return_indexers: bool = False,
         sort: bool = False,
-    ):
+    ) -> Index | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
         """
-        Compute join_index and indexers to conform data
-        structures to the new index.
+        Compute join_index and indexers to conform data structures to the new index.
 
         Parameters
         ----------
@@ -4350,15 +4618,25 @@ def join(
         if level is not None and (self._is_multi or other._is_multi):
             return self._join_level(other, level, how=how)
 
-        if len(other) == 0 and how in ("left", "outer"):
-            join_index = self._view()
-            rindexer = np.repeat(np.intp(-1), len(join_index))
-            return join_index, None, rindexer
-
-        if len(self) == 0 and how in ("right", "outer"):
-            join_index = other._view()
-            lindexer = np.repeat(np.intp(-1), len(join_index))
-            return join_index, lindexer, None
+        if len(other) == 0:
+            if how in ("left", "outer"):
+                join_index = self._view()
+                rindexer = np.broadcast_to(np.intp(-1), len(join_index))
+                return join_index, None, rindexer
+            elif how in ("right", "inner", "cross"):
+                join_index = other._view()
+                lindexer = np.array([])
+                return join_index, lindexer, None
+
+        if len(self) == 0:
+            if how in ("right", "outer"):
+                join_index = other._view()
+                lindexer = np.broadcast_to(np.intp(-1), len(join_index))
+                return join_index, lindexer, None
+            elif how in ("left", "inner", "cross"):
+                join_index = self._view()
+                rindexer = np.array([])
+                return join_index, None, rindexer
 
         if self._join_precedence < other._join_precedence:
             how = {"right": "left", "left": "right"}.get(how, how)
@@ -4379,20 +4657,23 @@ def join(
         if not self.is_unique and not other.is_unique:
             return self._join_non_unique(other, how=how)
         elif not self.is_unique or not other.is_unique:
-            if self.is_monotonic and other.is_monotonic:
-                if self._can_use_libjoin:
+            if self.is_monotonic_increasing and other.is_monotonic_increasing:
+                if not is_interval_dtype(self.dtype):
                     # otherwise we will fall through to _join_via_get_indexer
+                    # GH#39133
+                    # go through object dtype for ea till engine is supported properly
                     return self._join_monotonic(other, how=how)
             else:
                 return self._join_non_unique(other, how=how)
         elif (
-            self.is_monotonic
-            and other.is_monotonic
+            self.is_monotonic_increasing
+            and other.is_monotonic_increasing
             and self._can_use_libjoin
             and (
                 not isinstance(self, ABCMultiIndex)
                 or not any(is_categorical_dtype(dtype) for dtype in self.dtypes)
             )
+            and not is_categorical_dtype(self.dtype)
         ):
             # Categorical is monotonic if data are ordered as categories, but join can
             #  not handle this in case of not lexicographically monotonic GH#38502
@@ -4432,11 +4713,11 @@ def _join_via_get_indexer(
         if join_index is self:
             lindexer = None
         else:
-            lindexer = self.get_indexer(join_index)
+            lindexer = self.get_indexer_for(join_index)
         if join_index is other:
             rindexer = None
         else:
-            rindexer = other.get_indexer(join_index)
+            rindexer = other.get_indexer_for(join_index)
         return join_index, lindexer, rindexer
 
     @final
@@ -4474,7 +4755,7 @@ def _join_multi(self, other: Index, how: str_t):
             # Join left and right
             # Join on same leveled multi-index frames is supported
             join_idx, lidx, ridx = self_jnlevels.join(
-                other_jnlevels, how, return_indexers=True
+                other_jnlevels, how=how, return_indexers=True
             )
 
             # Restore the dropped levels
@@ -4482,8 +4763,16 @@ def _join_multi(self, other: Index, how: str_t):
             # common levels, ldrop_names, rdrop_names
             dropped_names = ldrop_names + rdrop_names
 
+            # error: Argument 5/6 to "restore_dropped_levels_multijoin" has
+            # incompatible type "Optional[ndarray[Any, dtype[signedinteger[Any
+            # ]]]]"; expected "ndarray[Any, dtype[signedinteger[Any]]]"
             levels, codes, names = restore_dropped_levels_multijoin(
-                self, other, dropped_names, join_idx, lidx, ridx
+                self,
+                other,
+                dropped_names,
+                join_idx,
+                lidx,  # type: ignore[arg-type]
+                ridx,  # type: ignore[arg-type]
             )
 
             # Re-create the multi-index
@@ -4531,7 +4820,13 @@ def _join_non_unique(
         right = other._values.take(right_idx)
 
         if isinstance(join_array, np.ndarray):
-            np.putmask(join_array, mask, right)
+            # error: Argument 3 to "putmask" has incompatible type
+            # "Union[ExtensionArray, ndarray[Any, Any]]"; expected
+            # "Union[_SupportsArray[dtype[Any]], _NestedSequence[
+            # _SupportsArray[dtype[Any]]], bool, int, float, complex,
+            # str, bytes, _NestedSequence[Union[bool, int, float,
+            # complex, str, bytes]]]"
+            np.putmask(join_array, mask, right)  # type: ignore[arg-type]
         else:
             join_array._putmask(mask, right)
 
@@ -4743,15 +5038,16 @@ def _wrap_joined_index(self: _IndexT, joined: ArrayLike, other: _IndexT) -> _Ind
             return self._constructor(joined, name=name)  # type: ignore[return-value]
         else:
             name = get_op_result_name(self, other)
-            return self._constructor._with_infer(joined, name=name)
+            return self._constructor._with_infer(joined, name=name, dtype=self.dtype)
 
     @cache_readonly
     def _can_use_libjoin(self) -> bool:
         """
         Whether we can use the fastpaths implement in _libs.join
         """
-        # Note: this will need to be updated when e.g. Nullable dtypes
-        #  are supported in Indexes.
+        if type(self) is Index:
+            # excludes EAs
+            return isinstance(self.dtype, np.dtype)
         return not is_interval_dtype(self.dtype)
 
     # --------------------------------------------------------------------
@@ -4817,16 +5113,19 @@ def _values(self) -> ExtensionArray | np.ndarray:
         """
         return self._data
 
-    def _get_engine_target(self) -> np.ndarray:
+    def _get_engine_target(self) -> ArrayLike:
         """
-        Get the ndarray that we can pass to the IndexEngine constructor.
+        Get the ndarray or ExtensionArray that we can pass to the IndexEngine
+        constructor.
         """
-        # error: Incompatible return value type (got "Union[ExtensionArray,
-        # ndarray]", expected "ndarray")
+        vals = self._values
+        if isinstance(vals, StringArray):
+            # GH#45652 much more performant than ExtensionEngine
+            return vals._ndarray
         if type(self) is Index and isinstance(self._values, ExtensionArray):
             # TODO(ExtensionIndex): remove special-case, just use self._values
             return self._values.astype(object)
-        return self._values  # type: ignore[return-value]
+        return vals
 
     def _from_join_target(self, result: np.ndarray) -> ArrayLike:
         """
@@ -4912,7 +5211,15 @@ def _validate_fill_value(self, value):
         TypeError
             If the value cannot be inserted into an array of this dtype.
         """
-        if not can_hold_element(self._values, value):
+        dtype = self.dtype
+        if isinstance(dtype, np.dtype) and dtype.kind not in ["m", "M"]:
+            # return np_can_hold_element(dtype, value)
+            try:
+                return np_can_hold_element(dtype, value)
+            except LossySetitemError as err:
+                # re-raise as TypeError for consistency
+                raise TypeError from err
+        elif not can_hold_element(self._values, value):
             raise TypeError
         return value
 
@@ -4988,7 +5295,7 @@ def __contains__(self, key: Any) -> bool:
     # https://github.com/python/typeshed/issues/2148#issuecomment-520783318
     # Incompatible types in assignment (expression has type "None", base class
     # "object" defined the type as "Callable[[object], int]")
-    __hash__: None  # type: ignore[assignment]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
     @final
     def __setitem__(self, key, value):
@@ -5024,7 +5331,10 @@ def __getitem__(self, key):
             #  takes 166 µs + 2.1 ms and cuts the ndarray.__getitem__
             #  time below from 3.8 ms to 496 µs
             # if we already have ndarray[bool], the overhead is 1.4 µs or .25%
-            key = np.asarray(key, dtype=bool)
+            if is_extension_array_dtype(getattr(key, "dtype", None)):
+                key = key.to_numpy(dtype=bool, na_value=False)
+            else:
+                key = np.asarray(key, dtype=bool)
 
         result = getitem(key)
         # Because we ruled out integer above, we always get an arraylike here
@@ -5033,7 +5343,10 @@ def __getitem__(self, key):
             if hasattr(result, "_ndarray"):
                 # i.e. NDArrayBackedExtensionArray
                 # Unpack to ndarray for MPL compat
-                return result._ndarray
+                # error: Item "ndarray[Any, Any]" of
+                # "Union[ExtensionArray, ndarray[Any, Any]]"
+                # has no attribute "_ndarray"
+                return result._ndarray  # type: ignore[union-attr]
             return result
 
         # NB: Using _constructor._simple_new would break if MultiIndex
@@ -5057,7 +5370,7 @@ def _can_hold_identifiers_and_holds_name(self, name) -> bool:
 
         https://github.com/pandas-dev/pandas/issues/19764
         """
-        if self.is_object() or self.is_categorical():
+        if self.is_object() or is_string_dtype(self.dtype) or self.is_categorical():
             return name in self
         return False
 
@@ -5123,11 +5436,12 @@ def putmask(self, mask, value) -> Index:
         if noop:
             return self.copy()
 
-        if value is None and (self._is_numeric_dtype or self.dtype == object):
+        if self.dtype != object and is_valid_na_for_dtype(value, self.dtype):
+            # e.g. None -> np.nan, see also Block._standardize_fill_value
             value = self._na_value
         try:
             converted = self._validate_fill_value(value)
-        except (ValueError, TypeError) as err:
+        except (LossySetitemError, ValueError, TypeError) as err:
             if is_object_dtype(self):  # pragma: no cover
                 raise err
 
@@ -5197,10 +5511,10 @@ def equals(self, other: Any) -> bool:
 
         The dtype is *not* compared
 
-        >>> int64_idx = pd.Int64Index([1, 2, 3])
+        >>> int64_idx = pd.Index([1, 2, 3], dtype='int64')
         >>> int64_idx
         Int64Index([1, 2, 3], dtype='int64')
-        >>> uint64_idx = pd.UInt64Index([1, 2, 3])
+        >>> uint64_idx = pd.Index([1, 2, 3], dtype='uint64')
         >>> uint64_idx
         UInt64Index([1, 2, 3], dtype='uint64')
         >>> int64_idx.equals(uint64_idx)
@@ -5330,7 +5644,9 @@ def asof(self, label):
 
         return self[loc]
 
-    def asof_locs(self, where: Index, mask: np.ndarray) -> npt.NDArray[np.intp]:
+    def asof_locs(
+        self, where: Index, mask: npt.NDArray[np.bool_]
+    ) -> npt.NDArray[np.intp]:
         """
         Return the locations (indices) of labels in the index.
 
@@ -5613,7 +5929,7 @@ def _should_fallback_to_positional(self) -> bool:
         """
         Should an integer key be treated as positional?
         """
-        return not self.holds_integer() and not self.is_boolean()
+        return not self.holds_integer()
 
     def _get_values_for_loc(self, series: Series, loc, key):
         """
@@ -5630,7 +5946,7 @@ def _get_values_for_loc(self, series: Series, loc, key):
         return series.iloc[loc]
 
     @final
-    def set_value(self, arr, key, value):
+    def set_value(self, arr, key, value) -> None:
         """
         Fast lookup of value from 1-dimensional ndarray.
 
@@ -5656,8 +5972,9 @@ def set_value(self, arr, key, value):
     _index_shared_docs[
         "get_indexer_non_unique"
     ] = """
-        Compute indexer and mask for new index given the current index. The
-        indexer should be then used as an input to ndarray.take to align the
+        Compute indexer and mask for new index given the current index.
+
+        The indexer should be then used as an input to ndarray.take to align the
         current data to the new index.
 
         Parameters
@@ -5705,10 +6022,9 @@ def get_indexer_non_unique(
         tgt_values = target._get_engine_target()
         if self._is_multi and target._is_multi:
             engine = self._engine
-            # error: "IndexEngine" has no attribute "_extract_level_codes"
-            tgt_values = engine._extract_level_codes(  # type: ignore[attr-defined]
-                target
-            )
+            # Item "IndexEngine" of "Union[IndexEngine, ExtensionEngine]" has
+            # no attribute "_extract_level_codes"
+            tgt_values = engine._extract_level_codes(target)  # type: ignore[union-attr]
 
         indexer, missing = self._engine.get_indexer_non_unique(tgt_values)
         return ensure_platform_int(indexer), ensure_platform_int(missing)
@@ -5938,10 +6254,15 @@ def _find_common_type_compat(self, target) -> DtypeObj:
         Implementation of find_common_type that adjusts for Index-specific
         special cases.
         """
-        if is_interval_dtype(self.dtype) and is_valid_na_for_dtype(target, self.dtype):
+        if is_valid_na_for_dtype(target, self.dtype):
             # e.g. setting NA value into IntervalArray[int64]
-            self = cast("IntervalIndex", self)
-            return IntervalDtype(np.float64, closed=self.closed)
+            dtype = ensure_dtype_can_hold_na(self.dtype)
+            if is_dtype_equal(self.dtype, dtype):
+                raise NotImplementedError(
+                    "This should not be reached. Please report a bug at "
+                    "github.com/pandas-dev/pandas"
+                )
+            return dtype
 
         target_dtype, _ = infer_dtype_from(target, pandas_dtype=True)
 
@@ -5955,22 +6276,10 @@ def _find_common_type_compat(self, target) -> DtypeObj:
             if is_signed_integer_dtype(self.dtype) or is_signed_integer_dtype(
                 target_dtype
             ):
-                return np.dtype("object")
+                return _dtype_obj
 
         dtype = find_common_type([self.dtype, target_dtype])
-
-        if dtype.kind in ["i", "u"]:
-            # TODO: what about reversed with self being categorical?
-            if (
-                isinstance(target, Index)
-                and is_categorical_dtype(target.dtype)
-                and target.hasnans
-            ):
-                # FIXME: find_common_type incorrect with Categorical GH#38240
-                # FIXME: some cases where float64 cast can be lossy?
-                dtype = np.dtype(np.float64)
-        if dtype.kind == "c":
-            dtype = np.dtype(object)
+        dtype = common_dtype_categorical_compat([self, target], dtype)
         return dtype
 
     @final
@@ -5995,6 +6304,10 @@ def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
         """
         Can we compare values of the given dtype to our own?
         """
+        if self.dtype.kind == "b":
+            return dtype.kind == "b"
+        elif is_numeric_dtype(self.dtype):
+            return is_numeric_dtype(dtype)
         return True
 
     @final
@@ -6026,7 +6339,7 @@ def groupby(self, values) -> PrettyDict[Hashable, np.ndarray]:
 
     def map(self, mapper, na_action=None):
         """
-        Map values using input correspondence (a dict, Series, or function).
+        Map values using an input mapping or function.
 
         Parameters
         ----------
@@ -6103,7 +6416,7 @@ def _transform_index(self, func, *, level=None) -> Index:
             items = [func(x) for x in self]
             return Index(items, name=self.name, tupleize_cols=False)
 
-    def isin(self, values, level=None) -> np.ndarray:
+    def isin(self, values, level=None) -> npt.NDArray[np.bool_]:
         """
         Return a boolean array where the index values are in `values`.
 
@@ -6258,8 +6571,6 @@ def _maybe_cast_indexer(self, key):
         If we have a float key and are not a floating index, then try to cast
         to an int if equivalent.
         """
-        if not self.is_floating():
-            return com.cast_scalar_indexer(key)
         return key
 
     def _maybe_cast_listlike_indexer(self, target) -> Index:
@@ -6520,6 +6831,7 @@ def delete(self: _IndexT, loc) -> _IndexT:
         Index(['b'], dtype='object')
         """
         values = self._values
+        res_values: ArrayLike
         if isinstance(values, np.ndarray):
             # TODO(__array_function__): special casing will be unnecessary
             res_values = np.delete(values, loc)
@@ -6556,7 +6868,7 @@ def insert(self, loc: int, item) -> Index:
                 return type(self)._simple_new(res_values, name=self.name)
             else:
                 item = self._validate_fill_value(item)
-        except (TypeError, ValueError):
+        except (TypeError, ValueError, LossySetitemError):
             # e.g. trying to insert an integer into a DatetimeIndex
             #  We cannot keep the same dtype, so cast to the (often object)
             #  minimal shared dtype before doing the insert.
@@ -6573,15 +6885,24 @@ def insert(self, loc: int, item) -> Index:
             new_values = np.insert(arr, loc, casted)
 
         else:
-            new_values = np.insert(arr, loc, None)
+            # error: No overload variant of "insert" matches argument types
+            # "ndarray[Any, Any]", "int", "None"
+            new_values = np.insert(arr, loc, None)  # type: ignore[call-overload]
             loc = loc if loc >= 0 else loc - 1
             new_values[loc] = item
 
-        # Use self._constructor instead of Index to retain NumericIndex GH#43921
-        # TODO(2.0) can use Index instead of self._constructor
-        return self._constructor._with_infer(new_values, name=self.name)
+        if self._typ == "numericindex":
+            # Use self._constructor instead of Index to retain NumericIndex GH#43921
+            # TODO(2.0) can use Index instead of self._constructor
+            return self._constructor._with_infer(new_values, name=self.name)
+        else:
+            return Index._with_infer(new_values, name=self.name)
 
-    def drop(self, labels, errors: str_t = "raise") -> Index:
+    def drop(
+        self,
+        labels: Index | np.ndarray | Iterable[Hashable],
+        errors: IgnoreRaise = "raise",
+    ) -> Index:
         """
         Make new Index with passed list of labels deleted.
 
@@ -6629,7 +6950,7 @@ def _cmp_method(self, other, op):
                     # TODO: should set MultiIndex._can_hold_na = False?
                     arr[self.isna()] = False
                 return arr
-            elif op in {operator.ne, operator.lt, operator.gt}:
+            elif op is operator.ne:
                 arr = np.zeros(len(self), dtype=bool)
                 if self._can_hold_na and not isinstance(self, ABCMultiIndex):
                     arr[self.isna()] = True
@@ -6690,16 +7011,16 @@ def _unary_method(self, op):
         result = op(self._values)
         return Index(result, name=self.name)
 
-    def __abs__(self):
+    def __abs__(self) -> Index:
         return self._unary_method(operator.abs)
 
-    def __neg__(self):
+    def __neg__(self) -> Index:
         return self._unary_method(operator.neg)
 
-    def __pos__(self):
+    def __pos__(self) -> Index:
         return self._unary_method(operator.pos)
 
-    def __invert__(self):
+    def __invert__(self) -> Index:
         # GH#8875
         return self._unary_method(operator.inv)
 
@@ -6813,7 +7134,7 @@ def _maybe_disable_logical_methods(self, opname: str_t) -> None:
             make_invalid_op(opname)(self)
 
     @Appender(IndexOpsMixin.argmin.__doc__)
-    def argmin(self, axis=None, skipna=True, *args, **kwargs):
+    def argmin(self, axis=None, skipna=True, *args, **kwargs) -> int:
         nv.validate_argmin(args, kwargs)
         nv.validate_minmax_axis(axis)
 
@@ -6825,7 +7146,7 @@ def argmin(self, axis=None, skipna=True, *args, **kwargs):
         return super().argmin(skipna=skipna)
 
     @Appender(IndexOpsMixin.argmax.__doc__)
-    def argmax(self, axis=None, skipna=True, *args, **kwargs):
+    def argmax(self, axis=None, skipna=True, *args, **kwargs) -> int:
         nv.validate_argmax(args, kwargs)
         nv.validate_minmax_axis(axis)
 
@@ -6948,12 +7269,12 @@ def ensure_index_from_sequences(sequences, names=None) -> Index:
     if len(sequences) == 1:
         if names is not None:
             names = names[0]
-        return Index(sequences[0], name=names)
+        return Index._with_infer(sequences[0], name=names)
     else:
         return MultiIndex.from_arrays(sequences, names=names)
 
 
-def ensure_index(index_like: AnyArrayLike | Sequence, copy: bool = False) -> Index:
+def ensure_index(index_like: Axes, copy: bool = False) -> Index:
     """
     Ensure that we have an index from some index-like object.
 
@@ -7107,10 +7428,8 @@ def _maybe_cast_data_without_dtype(
             "In a future version, the Index constructor will not infer numeric "
             "dtypes when passed object-dtype sequences (matching Series behavior)",
             FutureWarning,
-            stacklevel=3,
+            stacklevel=find_stack_level(),
         )
-    if result.dtype.kind in ["b", "c"]:
-        return subarr
     result = ensure_wrapped_if_datetimelike(result)
     return result
 
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 2c615e96c22e0..a39a8105bed71 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -8,8 +8,6 @@
 
 import numpy as np
 
-from pandas._config import get_option
-
 from pandas._libs import index as libindex
 from pandas._typing import (
     Dtype,
@@ -194,7 +192,7 @@ def _should_fallback_to_positional(self) -> bool:
     _values: Categorical
 
     @property
-    def _engine_type(self):
+    def _engine_type(self) -> type[libindex.IndexEngine]:
         # self.codes can have dtype int8, int16, int32 or int64, so we need
         # to return the corresponding engine type (libindex.Int8Engine, etc.).
         return {
@@ -347,16 +345,12 @@ def _format_attrs(self):
         """
         Return a list of tuples of the (attr,formatted_value)
         """
-        max_categories = (
-            10
-            if get_option("display.max_categories") == 0
-            else get_option("display.max_categories")
-        )
         attrs: list[tuple[str, str | int | bool | None]]
+
         attrs = [
             (
                 "categories",
-                ibase.default_pprint(self.categories, max_seq_items=max_categories),
+                "[" + ", ".join(self._data._repr_categories()) + "]",
             ),
             ("ordered", self.ordered),
         ]
@@ -428,6 +422,7 @@ def reindex(
                     stacklevel=find_stack_level(),
                 )
 
+        new_target: Index
         if len(self) and indexer is not None:
             new_target = self.take(indexer)
         else:
@@ -440,8 +435,8 @@ def reindex(
             if not isinstance(target, CategoricalIndex) or (cats == -1).any():
                 new_target, indexer, _ = super()._reindex_non_unique(target)
             else:
-
-                codes = new_target.codes.copy()
+                # error: "Index" has no attribute "codes"
+                codes = new_target.codes.copy()  # type: ignore[attr-defined]
                 codes[indexer == -1] = cats[missing]
                 cat = self._data._from_backing_data(codes)
                 new_target = type(self)._simple_new(cat, name=self.name)
@@ -456,8 +451,8 @@ def reindex(
             new_target = type(self)._simple_new(cat, name=self.name)
         else:
             # e.g. test_reindex_with_categoricalindex, test_reindex_duplicate_target
-            new_target = np.asarray(new_target)
-            new_target = Index._with_infer(new_target, name=self.name)
+            new_target_array = np.asarray(new_target)
+            new_target = Index._with_infer(new_target_array, name=self.name)
 
         return new_target, indexer
 
@@ -494,7 +489,7 @@ def _maybe_cast_listlike_indexer(self, values) -> CategoricalIndex:
     def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
         return self.categories._is_comparable_dtype(dtype)
 
-    def take_nd(self, *args, **kwargs):
+    def take_nd(self, *args, **kwargs) -> CategoricalIndex:
         """Alias for `take`"""
         warnings.warn(
             "CategoricalIndex.take_nd is deprecated, use CategoricalIndex.take "
@@ -506,7 +501,7 @@ def take_nd(self, *args, **kwargs):
 
     def map(self, mapper):
         """
-        Map values using input correspondence (a dict, Series, or function).
+        Map values using input an input mapping or function.
 
         Maps the values (their categories, not the codes) of the index to new
         categories. If the mapping correspondence is one-to-one the result is a
@@ -577,13 +572,14 @@ def map(self, mapper):
     def _concat(self, to_concat: list[Index], name: Hashable) -> Index:
         # if calling index is category, don't check dtype of others
         try:
-            codes = np.concatenate([self._is_dtype_compat(c).codes for c in to_concat])
+            cat = Categorical._concat_same_type(
+                [self._is_dtype_compat(c) for c in to_concat]
+            )
         except TypeError:
             # not all to_concat elements are among our categories (or NA)
             from pandas.core.dtypes.concat import concat_compat
 
-            res = concat_compat(to_concat)
+            res = concat_compat([x._values for x in to_concat])
             return Index(res, name=name)
         else:
-            cat = self._data._from_backing_data(codes)
             return type(self)._simple_new(cat, name=name)
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 589b92f392ca8..1a13cddd99b95 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -92,20 +92,12 @@ class DatetimeIndexOpsMixin(NDArrayBackedExtensionIndex):
     freqstr: str | None
     _resolution_obj: Resolution
 
-    # error: "Callable[[Any], Any]" has no attribute "fget"
-    hasnans = cast(
-        bool,
-        cache_readonly(
-            DatetimeLikeArrayMixin._hasnans.fget  # type: ignore[attr-defined]
-        ),
-    )
-
-    @property
-    def _is_all_dates(self) -> bool:
-        return True
-
     # ------------------------------------------------------------------------
 
+    @cache_readonly
+    def hasnans(self) -> bool:
+        return self._data._hasna
+
     def equals(self, other: Any) -> bool:
         """
         Determines if two Index objects contain the same elements.
@@ -151,8 +143,6 @@ def __contains__(self, key: Any) -> bool:
             return False
         return True
 
-    _can_hold_na = True
-
     def _convert_tolerance(self, tolerance, target):
         tolerance = np.asarray(to_timedelta(tolerance).to_numpy())
         return super()._convert_tolerance(tolerance, target)
@@ -220,19 +210,29 @@ def _summary(self, name=None) -> str:
     # --------------------------------------------------------------------
     # Indexing Methods
 
+    @final
     def _can_partial_date_slice(self, reso: Resolution) -> bool:
-        raise NotImplementedError
+        # e.g. test_getitem_setitem_periodindex
+        # History of conversation GH#3452, GH#3931, GH#2369, GH#14826
+        return reso > self._resolution_obj
+        # NB: for DTI/PI, not TDI
 
     def _parsed_string_to_bounds(self, reso: Resolution, parsed):
         raise NotImplementedError
 
     def _parse_with_reso(self, label: str):
         # overridden by TimedeltaIndex
-        parsed, reso_str = parsing.parse_time_string(label, self.freq)
+        try:
+            if self.freq is None or hasattr(self.freq, "rule_code"):
+                freq = self.freq
+        except NotImplementedError:
+            freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
+        parsed, reso_str = parsing.parse_time_string(label, freq)
         reso = Resolution.from_attrname(reso_str)
         return parsed, reso
 
     def _get_string_slice(self, key: str):
+        # overridden by TimedeltaIndex
         parsed, reso = self._parse_with_reso(key)
         try:
             return self._partial_date_slice(reso, parsed)
@@ -677,7 +677,7 @@ def _get_insert_freq(self, loc: int, item):
         return freq
 
     @doc(NDArrayBackedExtensionIndex.delete)
-    def delete(self, loc):
+    def delete(self, loc) -> DatetimeTimedeltaMixin:
         result = super().delete(loc)
         result._data._freq = self._get_delete_freq(loc)
         return result
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 5a3da9b65d03b..33cc39cc26060 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -25,14 +25,19 @@
     lib,
 )
 from pandas._libs.tslibs import (
+    BaseOffset,
     Resolution,
+    periods_per_day,
     timezones,
     to_offset,
 )
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 from pandas._libs.tslibs.offsets import prefix_mapping
 from pandas._typing import (
     Dtype,
     DtypeObj,
+    IntervalClosedType,
+    IntervalLeftRight,
     npt,
 )
 from pandas.util._decorators import (
@@ -42,9 +47,9 @@
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
-    DT64NS_DTYPE,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
+    is_dtype_equal,
     is_scalar,
 )
 from pandas.core.dtypes.missing import is_valid_na_for_dtype
@@ -110,7 +115,7 @@ def _new_DatetimeIndex(cls, d):
     + [
         method
         for method in DatetimeArray._datetimelike_methods
-        if method not in ("tz_localize", "tz_convert")
+        if method not in ("tz_localize", "tz_convert", "strftime")
     ],
     DatetimeArray,
     wrap=True,
@@ -140,8 +145,8 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
 
     Parameters
     ----------
-    data : array-like (1-dimensional), optional
-        Optional datetime-like data to construct index with.
+    data : array-like (1-dimensional)
+        Datetime-like data to construct index with.
     freq : str or pandas offset object, optional
         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
@@ -248,9 +253,12 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
     _typ = "datetimeindex"
 
     _data_cls = DatetimeArray
-    _engine_type = libindex.DatetimeEngine
     _supports_partial_string_indexing = True
 
+    @property
+    def _engine_type(self) -> type[libindex.DatetimeEngine]:
+        return libindex.DatetimeEngine
+
     _data: DatetimeArray
     inferred_freq: str | None
     tz: tzinfo | None
@@ -261,7 +269,7 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
     @doc(DatetimeArray.strftime)
     def strftime(self, date_format) -> Index:
         arr = self._data.strftime(date_format)
-        return Index(arr, name=self.name)
+        return Index(arr, name=self.name, dtype=object)
 
     @doc(DatetimeArray.tz_convert)
     def tz_convert(self, tz) -> DatetimeIndex:
@@ -305,7 +313,7 @@ def isocalendar(self) -> DataFrame:
     def __new__(
         cls,
         data=None,
-        freq=lib.no_default,
+        freq: str | BaseOffset | lib.NoDefault = lib.no_default,
         tz=None,
         normalize: bool = False,
         closed=None,
@@ -324,6 +332,30 @@ def __new__(
 
         name = maybe_extract_name(name, data, cls)
 
+        if (
+            isinstance(data, DatetimeArray)
+            and freq is lib.no_default
+            and tz is None
+            and dtype is None
+        ):
+            # fastpath, similar logic in TimedeltaIndex.__new__;
+            # Note in this particular case we retain non-nano.
+            if copy:
+                data = data.copy()
+            return cls._simple_new(data, name=name)
+        elif (
+            isinstance(data, DatetimeArray)
+            and freq is lib.no_default
+            and tz is None
+            and is_dtype_equal(data.dtype, dtype)
+        ):
+            # Reached via Index.__new__ when we call .astype
+            # TODO(2.0): special casing can be removed once _from_sequence_not_strict
+            #  no longer chokes on non-nano
+            if copy:
+                data = data.copy()
+            return cls._simple_new(data, name=name)
+
         dtarr = DatetimeArray._from_sequence_not_strict(
             data,
             dtype=dtype,
@@ -383,6 +415,23 @@ def _formatter_func(self):
     # --------------------------------------------------------------------
     # Set Operation Methods
 
+    def _can_range_setop(self, other) -> bool:
+        # GH 46702: If self or other have non-UTC tzs, DST transitions prevent
+        # range representation due to no singular step
+        if (
+            self.tz is not None
+            and not timezones.is_utc(self.tz)
+            and not timezones.is_fixed_offset(self.tz)
+        ):
+            return False
+        if (
+            other.tz is not None
+            and not timezones.is_utc(other.tz)
+            and not timezones.is_fixed_offset(other.tz)
+        ):
+            return False
+        return super()._can_range_setop(other)
+
     def union_many(self, others):
         """
         A bit of a hack to accelerate unioning a collection of indexes.
@@ -434,7 +483,7 @@ def _maybe_utc_convert(self, other: Index) -> tuple[DatetimeIndex, Index]:
 
     # --------------------------------------------------------------------
 
-    def _get_time_micros(self) -> np.ndarray:
+    def _get_time_micros(self) -> npt.NDArray[np.int64]:
         """
         Return the number of microseconds since midnight.
 
@@ -444,16 +493,29 @@ def _get_time_micros(self) -> np.ndarray:
         """
         values = self._data._local_timestamps()
 
-        nanos = values % (24 * 3600 * 1_000_000_000)
-        micros = nanos // 1000
+        reso = self._data._reso
+        ppd = periods_per_day(reso)
+
+        frac = values % ppd
+        if reso == NpyDatetimeUnit.NPY_FR_ns.value:
+            micros = frac // 1000
+        elif reso == NpyDatetimeUnit.NPY_FR_us.value:
+            micros = frac
+        elif reso == NpyDatetimeUnit.NPY_FR_ms.value:
+            micros = frac * 1000
+        elif reso == NpyDatetimeUnit.NPY_FR_s.value:
+            micros = frac * 1_000_000
+        else:  # pragma: no cover
+            raise NotImplementedError(reso)
 
         micros[self._isnan] = -1
         return micros
 
     def to_series(self, keep_tz=lib.no_default, index=None, name=None):
         """
-        Create a Series with both index and values equal to the index keys
-        useful with map for returning an indexer based on an index.
+        Create a Series with both index and values equal to the index keys.
+
+        Useful with map for returning an indexer based on an index.
 
         Parameters
         ----------
@@ -538,7 +600,7 @@ def snap(self, freq="S") -> DatetimeIndex:
         # Superdumb, punting on any optimizing
         freq = to_offset(freq)
 
-        snapped = np.empty(len(self), dtype=DT64NS_DTYPE)
+        dta = self._data.copy()
 
         for i, v in enumerate(self):
             s = v
@@ -549,9 +611,8 @@ def snap(self, freq="S") -> DatetimeIndex:
                     s = t0
                 else:
                     s = t1
-            snapped[i] = s
+            dta[i] = s
 
-        dta = DatetimeArray(snapped, dtype=self.dtype)
         return DatetimeIndex._simple_new(dta, name=self.name)
 
     # --------------------------------------------------------------------
@@ -572,8 +633,7 @@ def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
         -------
         lower, upper: pd.Timestamp
         """
-        grp = reso.freq_group
-        per = Period(parsed, freq=grp.value)
+        per = Period(parsed, freq=reso.attr_abbrev)
         start, end = per.start_time, per.end_time
 
         # GH 24076
@@ -593,11 +653,7 @@ def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
         end = self._maybe_cast_for_get_loc(end)
         return start, end
 
-    def _can_partial_date_slice(self, reso: Resolution) -> bool:
-        # History of conversation GH#3452, GH#3931, GH#2369, GH#14826
-        return reso > self._resolution_obj
-
-    def _deprecate_mismatched_indexing(self, key) -> None:
+    def _deprecate_mismatched_indexing(self, key, one_way: bool = False) -> None:
         # GH#36148
         # we get here with isinstance(key, self._data._recognized_scalars)
         try:
@@ -610,6 +666,10 @@ def _deprecate_mismatched_indexing(self, key) -> None:
                     "raise KeyError in a future version.  "
                     "Use a timezone-naive object instead."
                 )
+            elif one_way:
+                # we special-case timezone-naive strings and timezone-aware
+                #  DatetimeIndex
+                return
             else:
                 msg = (
                     "Indexing a timezone-aware DatetimeIndex with a "
@@ -644,6 +704,7 @@ def get_loc(self, key, method=None, tolerance=None):
                 parsed, reso = self._parse_with_reso(key)
             except ValueError as err:
                 raise KeyError(key) from err
+            self._deprecate_mismatched_indexing(parsed, one_way=True)
 
             if self._can_partial_date_slice(reso):
                 try:
@@ -651,12 +712,8 @@ def get_loc(self, key, method=None, tolerance=None):
                 except KeyError as err:
                     if method is None:
                         raise KeyError(key) from err
-            try:
-                key = self._maybe_cast_for_get_loc(key)
-            except ValueError as err:
-                # FIXME(dateutil#1180): we get here because parse_with_reso
-                #  doesn't raise on "t2m"
-                raise KeyError(key) from err
+
+            key = self._maybe_cast_for_get_loc(key)
 
         elif isinstance(key, timedelta):
             # GH#20464
@@ -682,7 +739,16 @@ def get_loc(self, key, method=None, tolerance=None):
 
     def _maybe_cast_for_get_loc(self, key) -> Timestamp:
         # needed to localize naive datetimes or dates (GH 35690)
-        key = Timestamp(key)
+        try:
+            key = Timestamp(key)
+        except ValueError as err:
+            # FIXME(dateutil#1180): we get here because parse_with_reso
+            #  doesn't raise on "t2m"
+            if not isinstance(key, str):
+                # Not expected to be reached, but check to be sure
+                raise  # pragma: no cover
+            raise KeyError(key) from err
+
         if key.tzinfo is None:
             key = key.tz_localize(self.tz)
         else:
@@ -691,6 +757,13 @@ def _maybe_cast_for_get_loc(self, key) -> Timestamp:
 
     @doc(DatetimeTimedeltaMixin._maybe_cast_slice_bound)
     def _maybe_cast_slice_bound(self, label, side: str, kind=lib.no_default):
+
+        # GH#42855 handle date here instead of get_slice_bound
+        if isinstance(label, date) and not isinstance(label, datetime):
+            # Pandas supports slicing with dates, treated as datetimes at midnight.
+            # https://github.com/pandas-dev/pandas/issues/31501
+            label = Timestamp(label).to_pydatetime()
+
         label = super()._maybe_cast_slice_bound(label, side, kind=kind)
         self._deprecate_mismatched_indexing(label)
         return self._maybe_cast_for_get_loc(label)
@@ -722,13 +795,6 @@ def slice_indexer(self, start=None, end=None, step=None, kind=lib.no_default):
         if isinstance(start, time) or isinstance(end, time):
             raise KeyError("Cannot mix time and non-time slice keys")
 
-        # Pandas supports slicing with dates, treated as datetimes at midnight.
-        # https://github.com/pandas-dev/pandas/issues/31501
-        if isinstance(start, date) and not isinstance(start, datetime):
-            start = datetime.combine(start, time(0, 0))
-        if isinstance(end, date) and not isinstance(end, datetime):
-            end = datetime.combine(end, time(0, 0))
-
         def check_str_or_none(point):
             return point is not None and not isinstance(point, str)
 
@@ -768,15 +834,6 @@ def check_str_or_none(point):
         else:
             return indexer
 
-    @doc(Index.get_slice_bound)
-    def get_slice_bound(
-        self, label, side: Literal["left", "right"], kind=lib.no_default
-    ) -> int:
-        # GH#42855 handle date here instead of _maybe_cast_slice_bound
-        if isinstance(label, date) and not isinstance(label, datetime):
-            label = Timestamp(label).to_pydatetime()
-        return super().get_slice_bound(label, side=side, kind=kind)
-
     # --------------------------------------------------------------------
 
     @property
@@ -787,8 +844,7 @@ def inferred_type(self) -> str:
 
     def indexer_at_time(self, time, asof: bool = False) -> npt.NDArray[np.intp]:
         """
-        Return index locations of values at particular time of day
-        (e.g. 9:30AM).
+        Return index locations of values at particular time of day.
 
         Parameters
         ----------
@@ -828,8 +884,7 @@ def indexer_between_time(
         self, start_time, end_time, include_start: bool = True, include_end: bool = True
     ) -> npt.NDArray[np.intp]:
         """
-        Return index locations of values between particular times of day
-        (e.g., 9:00-9:30AM).
+        Return index locations of values between particular times of day.
 
         Parameters
         ----------
@@ -884,8 +939,8 @@ def date_range(
     tz=None,
     normalize: bool = False,
     name: Hashable = None,
-    closed: str | None | lib.NoDefault = lib.no_default,
-    inclusive: str | None = None,
+    closed: Literal["left", "right"] | None | lib.NoDefault = lib.no_default,
+    inclusive: IntervalClosedType | None = None,
     **kwargs,
 ) -> DatetimeIndex:
     """
@@ -1022,31 +1077,32 @@ def date_range(
                    '2018-01-05 00:00:00+09:00'],
                   dtype='datetime64[ns, Asia/Tokyo]', freq='D')
 
-    `closed` controls whether to include `start` and `end` that are on the
-    boundary. The default includes boundary points on either end.
+    `inclusive` controls whether to include `start` and `end` that are on the
+    boundary. The default, "both", includes boundary points on either end.
 
-    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed=None)
+    >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive="both")
     DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
                   dtype='datetime64[ns]', freq='D')
 
-    Use ``closed='left'`` to exclude `end` if it falls on the boundary.
+    Use ``inclusive='left'`` to exclude `end` if it falls on the boundary.
 
-    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='left')
+    >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='left')
     DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
                   dtype='datetime64[ns]', freq='D')
 
-    Use ``closed='right'`` to exclude `start` if it falls on the boundary.
+    Use ``inclusive='right'`` to exclude `start` if it falls on the boundary, and
+    similarly ``inclusive='neither'`` will exclude both `start` and `end`.
 
-    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='right')
+    >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='right')
     DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
                   dtype='datetime64[ns]', freq='D')
     """
-    if inclusive is not None and not isinstance(closed, lib.NoDefault):
+    if inclusive is not None and closed is not lib.no_default:
         raise ValueError(
             "Deprecated argument `closed` cannot be passed"
             "if argument `inclusive` is not None"
         )
-    elif not isinstance(closed, lib.NoDefault):
+    elif closed is not lib.no_default:
         warnings.warn(
             "Argument `closed` is deprecated in favor of `inclusive`.",
             FutureWarning,
@@ -1089,13 +1145,12 @@ def bdate_range(
     name: Hashable = None,
     weekmask=None,
     holidays=None,
-    closed: lib.NoDefault = lib.no_default,
-    inclusive: str | None = None,
+    closed: IntervalLeftRight | lib.NoDefault | None = lib.no_default,
+    inclusive: IntervalClosedType | None = None,
     **kwargs,
 ) -> DatetimeIndex:
     """
-    Return a fixed frequency DatetimeIndex, with business day as the default
-    frequency.
+    Return a fixed frequency DatetimeIndex with business day as the default.
 
     Parameters
     ----------
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index 28a0b43d5b02b..5bf30dde33ba4 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 from typing import (
+    TYPE_CHECKING,
     Callable,
     TypeVar,
 )
@@ -21,10 +22,12 @@
 
 from pandas.core.dtypes.generic import ABCDataFrame
 
-from pandas.core.arrays import IntervalArray
-from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 from pandas.core.indexes.base import Index
 
+if TYPE_CHECKING:
+    from pandas.core.arrays import IntervalArray
+    from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+
 _T = TypeVar("_T", bound="NDArrayBackedExtensionIndex")
 _ExtensionIndexT = TypeVar("_ExtensionIndexT", bound="ExtensionIndex")
 
diff --git a/pandas/core/indexes/frozen.py b/pandas/core/indexes/frozen.py
index ed5cf047ab59f..043fd07b28025 100644
--- a/pandas/core/indexes/frozen.py
+++ b/pandas/core/indexes/frozen.py
@@ -8,7 +8,10 @@
 """
 from __future__ import annotations
 
-from typing import Any
+from typing import (
+    Any,
+    NoReturn,
+)
 
 from pandas.core.base import PandasObject
 
@@ -18,7 +21,7 @@
 class FrozenList(PandasObject, list):
     """
     Container that doesn't allow setting item *but*
-    because it's technically non-hashable, will be used
+    because it's technically hashable, will be used
     for lookups, appropriately, etc.
     """
 
@@ -89,10 +92,11 @@ def __mul__(self, other):
     def __reduce__(self):
         return type(self), (list(self),)
 
-    def __hash__(self):
+    # error: Signature of "__hash__" incompatible with supertype "list"
+    def __hash__(self) -> int:  # type: ignore[override]
         return hash(tuple(self))
 
-    def _disabled(self, *args, **kwargs):
+    def _disabled(self, *args, **kwargs) -> NoReturn:
         """
         This method will not function because object is immutable.
         """
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index a378fd95b9c03..b993af5621923 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -9,6 +9,7 @@
 from typing import (
     Any,
     Hashable,
+    Literal,
 )
 
 import numpy as np
@@ -28,6 +29,7 @@
 from pandas._typing import (
     Dtype,
     DtypeObj,
+    IntervalClosedType,
     npt,
 )
 from pandas.errors import InvalidIndexError
@@ -191,10 +193,12 @@ class IntervalIndex(ExtensionIndex):
     _typ = "intervalindex"
 
     # annotate properties pinned via inherit_names
-    closed: str
+    closed: IntervalClosedType
     is_non_overlapping_monotonic: bool
     closed_left: bool
     closed_right: bool
+    open_left: bool
+    open_right: bool
 
     _data: IntervalArray
     _values: IntervalArray
@@ -232,6 +236,11 @@ def __new__(
         _interval_shared_docs["from_breaks"]
         % {
             "klass": "IntervalIndex",
+            "name": textwrap.dedent(
+                """
+             name : str, optional
+                  Name of the resulting IntervalIndex."""
+            ),
             "examples": textwrap.dedent(
                 """\
         Examples
@@ -246,7 +255,7 @@ def __new__(
     def from_breaks(
         cls,
         breaks,
-        closed: str = "right",
+        closed: IntervalClosedType | None = "right",
         name: Hashable = None,
         copy: bool = False,
         dtype: Dtype | None = None,
@@ -262,6 +271,11 @@ def from_breaks(
         _interval_shared_docs["from_arrays"]
         % {
             "klass": "IntervalIndex",
+            "name": textwrap.dedent(
+                """
+             name : str, optional
+                  Name of the resulting IntervalIndex."""
+            ),
             "examples": textwrap.dedent(
                 """\
         Examples
@@ -277,7 +291,7 @@ def from_arrays(
         cls,
         left,
         right,
-        closed: str = "right",
+        closed: IntervalClosedType = "right",
         name: Hashable = None,
         copy: bool = False,
         dtype: Dtype | None = None,
@@ -293,6 +307,11 @@ def from_arrays(
         _interval_shared_docs["from_tuples"]
         % {
             "klass": "IntervalIndex",
+            "name": textwrap.dedent(
+                """
+             name : str, optional
+                  Name of the resulting IntervalIndex."""
+            ),
             "examples": textwrap.dedent(
                 """\
         Examples
@@ -317,9 +336,10 @@ def from_tuples(
         return cls._simple_new(arr, name=name)
 
     # --------------------------------------------------------------------
-
+    # error: Return type "IntervalTree" of "_engine" incompatible with return type
+    # "Union[IndexEngine, ExtensionEngine]" in supertype "Index"
     @cache_readonly
-    def _engine(self) -> IntervalTree:
+    def _engine(self) -> IntervalTree:  # type: ignore[override]
         left = self._maybe_convert_i8(self.left)
         right = self._maybe_convert_i8(self.right)
         return IntervalTree(left, right, closed=self.closed)
@@ -511,7 +531,10 @@ def _maybe_convert_i8(self, key):
             left = self._maybe_convert_i8(key.left)
             right = self._maybe_convert_i8(key.right)
             constructor = Interval if scalar else IntervalIndex.from_arrays
-            return constructor(left, right, closed=self.closed)
+            # error: "object" not callable
+            return constructor(
+                left, right, closed=self.closed
+            )  # type: ignore[operator]
 
         if scalar:
             # Timestamp/Timedelta
@@ -543,7 +566,7 @@ def _maybe_convert_i8(self, key):
 
         return key_i8
 
-    def _searchsorted_monotonic(self, label, side: str = "left"):
+    def _searchsorted_monotonic(self, label, side: Literal["left", "right"] = "left"):
         if not self.is_non_overlapping_monotonic:
             raise KeyError(
                 "can only get slices from an IntervalIndex if bounds are "
@@ -584,6 +607,8 @@ def get_loc(
         method : {None}, optional
             * default: matches where the label is within an interval only.
 
+            .. deprecated:: 1.4
+
         Returns
         -------
         int if unique index, slice if monotonic index, else mask
@@ -812,7 +837,9 @@ def _format_with_header(self, header: list[str], na_rep: str) -> list[str]:
         # matches base class except for whitespace padding
         return header + list(self._format_native_types(na_rep=na_rep))
 
-    def _format_native_types(self, *, na_rep="NaN", quoting=None, **kwargs):
+    def _format_native_types(
+        self, *, na_rep="NaN", quoting=None, **kwargs
+    ) -> npt.NDArray[np.object_]:
         # GH 28210: use base method but with different default na_rep
         return super()._format_native_types(na_rep=na_rep, quoting=quoting, **kwargs)
 
@@ -897,14 +924,6 @@ def _intersection_non_unique(self, other: IntervalIndex) -> IntervalIndex:
 
     # --------------------------------------------------------------------
 
-    @property
-    def _is_all_dates(self) -> bool:
-        """
-        This is False even when left/right contain datetime-like objects,
-        as the check is done on the Interval itself
-        """
-        return False
-
     def _get_engine_target(self) -> np.ndarray:
         # Note: we _could_ use libjoin functions by either casting to object
         #  dtype or constructing tuples (faster than constructing Intervals)
@@ -949,7 +968,12 @@ def _is_type_compatible(a, b) -> bool:
 
 
 def interval_range(
-    start=None, end=None, periods=None, freq=None, name: Hashable = None, closed="right"
+    start=None,
+    end=None,
+    periods=None,
+    freq=None,
+    name: Hashable = None,
+    closed: IntervalClosedType = "right",
 ) -> IntervalIndex:
     """
     Return a fixed frequency IntervalIndex.
@@ -1101,10 +1125,12 @@ def interval_range(
         if all(is_integer(x) for x in com.not_none(start, end, freq)):
             # np.linspace always produces float output
 
-            # error: Incompatible types in assignment (expression has type
-            # "Union[ExtensionArray, ndarray]", variable has type "ndarray")
-            breaks = maybe_downcast_numeric(  # type: ignore[assignment]
-                breaks, np.dtype("int64")
+            # error: Argument 1 to "maybe_downcast_numeric" has incompatible type
+            # "Union[ndarray[Any, Any], TimedeltaIndex, DatetimeIndex]";
+            # expected "ndarray[Any, Any]"  [
+            breaks = maybe_downcast_numeric(
+                breaks,  # type: ignore[arg-type]
+                np.dtype("int64"),
             )
     else:
         # delegate to the appropriate range function
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 45c386510cc38..e717f928740ff 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -10,6 +10,7 @@
     Hashable,
     Iterable,
     List,
+    Literal,
     Sequence,
     Tuple,
     cast,
@@ -53,6 +54,7 @@
     ensure_int64,
     ensure_platform_int,
     is_categorical_dtype,
+    is_extension_array_dtype,
     is_hashable,
     is_integer,
     is_iterator,
@@ -84,7 +86,6 @@
     get_unanimous_names,
 )
 from pandas.core.indexes.frozen import FrozenList
-from pandas.core.indexes.numeric import Int64Index
 from pandas.core.ops.invalid import make_invalid_op
 from pandas.core.sorting import (
     get_group_index,
@@ -288,7 +289,7 @@ class MultiIndex(Index):
 
     # initialize to zero-length tuples to make everything work
     _typ = "multiindex"
-    _names = FrozenList()
+    _names: list[Hashable | None] = []
     _levels = FrozenList()
     _codes = FrozenList()
     _comparables = ["names"]
@@ -308,7 +309,7 @@ def __new__(
         copy=False,
         name=None,
         verify_integrity: bool = True,
-    ):
+    ) -> MultiIndex:
 
         # compat with Index
         if name is not None:
@@ -327,9 +328,7 @@ def __new__(
         result._set_levels(levels, copy=copy, validate=False)
         result._set_codes(codes, copy=copy, validate=False)
 
-        # Incompatible types in assignment (expression has type "List[None]",
-        # variable has type "FrozenList")  [assignment]
-        result._names = [None] * len(levels)  # type: ignore[assignment]
+        result._names = [None] * len(levels)
         if names is not None:
             # handles name validation
             result._set_names(names)
@@ -365,7 +364,10 @@ def _validate_codes(self, level: list, code: list):
         """
         null_mask = isna(level)
         if np.any(null_mask):
-            code = np.where(null_mask[code], -1, code)
+            # error: Incompatible types in assignment
+            # (expression has type "ndarray[Any, dtype[Any]]",
+            # variable has type "List[Any]")
+            code = np.where(null_mask[code], -1, code)  # type: ignore[assignment]
         return code
 
     def _verify_integrity(self, codes: list | None = None, levels: list | None = None):
@@ -502,7 +504,7 @@ def from_tuples(
         cls,
         tuples: Iterable[tuple[Hashable, ...]],
         sortorder: int | None = None,
-        names: Sequence[Hashable] | None = None,
+        names: Sequence[Hashable] | Hashable | None = None,
     ) -> MultiIndex:
         """
         Convert list of tuples to MultiIndex.
@@ -545,11 +547,25 @@ def from_tuples(
             tuples = list(tuples)
         tuples = cast(Collection[Tuple[Hashable, ...]], tuples)
 
+        # handling the empty tuple cases
+        if len(tuples) and all(isinstance(e, tuple) and not e for e in tuples):
+            codes = [np.zeros(len(tuples))]
+            levels = [Index(com.asarray_tuplesafe(tuples, dtype=np.dtype("object")))]
+            return cls(
+                levels=levels,
+                codes=codes,
+                sortorder=sortorder,
+                names=names,
+                verify_integrity=False,
+            )
+
         arrays: list[Sequence[Hashable]]
         if len(tuples) == 0:
             if names is None:
                 raise TypeError("Cannot infer number of levels from empty list")
-            arrays = [[]] * len(names)
+            # error: Argument 1 to "len" has incompatible type "Hashable";
+            # expected "Sized"
+            arrays = [[]] * len(names)  # type: ignore[arg-type]
         elif isinstance(tuples, (np.ndarray, Index)):
             if isinstance(tuples, Index):
                 tuples = np.asarray(tuples._values)
@@ -565,7 +581,10 @@ def from_tuples(
 
     @classmethod
     def from_product(
-        cls, iterables, sortorder=None, names=lib.no_default
+        cls,
+        iterables: Sequence[Iterable[Hashable]],
+        sortorder: int | None = None,
+        names: Sequence[Hashable] | lib.NoDefault = lib.no_default,
     ) -> MultiIndex:
         """
         Make a MultiIndex from the cartesian product of multiple iterables.
@@ -696,17 +715,31 @@ def _values(self) -> np.ndarray:
         values = []
 
         for i in range(self.nlevels):
-            vals = self._get_level_values(i)
+            index = self.levels[i]
+            codes = self.codes[i]
+
+            vals = index
             if is_categorical_dtype(vals.dtype):
                 vals = cast("CategoricalIndex", vals)
                 vals = vals._data._internal_get_values()
+
+            is_dti = isinstance(vals, ABCDatetimeIndex)
+
+            if is_dti:
+                # TODO: this can be removed after Timestamp.freq is removed
+                # The astype(object) below does not remove the freq from
+                # the underlying Timestamps so we remove it here to match
+                # the behavior of self._get_level_values
+                vals = algos.take_nd(vals, codes, fill_value=index._na_value)
+
             if isinstance(vals.dtype, ExtensionDtype) or isinstance(
                 vals, (ABCDatetimeIndex, ABCTimedeltaIndex)
             ):
                 vals = vals.astype(object)
-            # error: Incompatible types in assignment (expression has type "ndarray",
-            # variable has type "Index")
-            vals = np.array(vals, copy=False)  # type: ignore[assignment]
+
+            vals = np.array(vals, copy=False)
+            if not is_dti:
+                vals = algos.take_nd(vals, codes, fill_value=index._na_value)
             values.append(vals)
 
         arr = lib.fast_zip(values)
@@ -739,7 +772,7 @@ def dtypes(self) -> Series:
         from pandas import Series
 
         names = com.fill_missing_names([level.name for level in self.levels])
-        return Series([level.dtype for level in self.levels], index=names)
+        return Series([level.dtype for level in self.levels], index=Index(names))
 
     def __len__(self) -> int:
         return len(self.codes[0])
@@ -1160,6 +1193,7 @@ def copy(
         This could be potentially expensive on large MultiIndex objects.
         """
         names = self._validate_names(name=name, names=names, deep=deep)
+        keep_id = not deep
         if levels is not None:
             warnings.warn(
                 "parameter levels is deprecated and will be removed in a future "
@@ -1167,6 +1201,7 @@ def copy(
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
+            keep_id = False
         if codes is not None:
             warnings.warn(
                 "parameter codes is deprecated and will be removed in a future "
@@ -1174,6 +1209,7 @@ def copy(
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
+            keep_id = False
 
         if deep:
             from copy import deepcopy
@@ -1195,6 +1231,8 @@ def copy(
         )
         new_index._cache = self._cache.copy()
         new_index._cache.pop("levels", None)  # GH32669
+        if keep_id:
+            new_index._id = self._id
 
         if dtype:
             warnings.warn(
@@ -1281,7 +1319,9 @@ def _formatter_func(self, tup):
         formatter_funcs = [level._formatter_func for level in self.levels]
         return tuple(func(val) for func, val in zip(formatter_funcs, tup))
 
-    def _format_native_types(self, *, na_rep="nan", **kwargs):
+    def _format_native_types(
+        self, *, na_rep="nan", **kwargs
+    ) -> npt.NDArray[np.object_]:
         new_levels = []
         new_codes = []
 
@@ -1333,7 +1373,7 @@ def format(
 
         stringified_levels = []
         for lev, level_codes in zip(self.levels, self.codes):
-            na = na_rep if na_rep is not None else _get_na_rep(lev.dtype.type)
+            na = na_rep if na_rep is not None else _get_na_rep(lev.dtype)
 
             if len(lev) > 0:
 
@@ -1372,7 +1412,7 @@ def format(
             sparsify = get_option("display.multi_sparse")
 
         if sparsify:
-            sentinel = ""
+            sentinel: Literal[""] | bool | lib.NoDefault = ""
             # GH3547 use value of sparsify as sentinel if it's "Falsey"
             assert isinstance(sparsify, bool) or sparsify is lib.no_default
             if sparsify in [False, lib.no_default]:
@@ -1449,8 +1489,7 @@ def _set_names(self, names, *, level=None, validate: bool = True):
                     raise TypeError(
                         f"{type(self).__name__}.name must be a hashable type"
                     )
-            # error: Cannot determine type of '__setitem__'
-            self._names[lev] = name  # type: ignore[has-type]
+            self._names[lev] = name
 
         # If .levels has been accessed, the names in our cache will be stale.
         self._reset_cache()
@@ -1477,41 +1516,30 @@ def _set_names(self, names, *, level=None, validate: bool = True):
     # --------------------------------------------------------------------
 
     @doc(Index._get_grouper_for_level)
-    def _get_grouper_for_level(self, mapper, *, level):
-        indexer = self.codes[level]
-        level_index = self.levels[level]
-
+    def _get_grouper_for_level(
+        self,
+        mapper,
+        *,
+        level=None,
+        dropna: bool = True,
+    ) -> tuple[Index, npt.NDArray[np.signedinteger] | None, Index | None]:
         if mapper is not None:
+            indexer = self.codes[level]
             # Handle group mapping function and return
             level_values = self.levels[level].take(indexer)
             grouper = level_values.map(mapper)
             return grouper, None, None
 
-        codes, uniques = algos.factorize(indexer, sort=True)
-
-        if len(uniques) > 0 and uniques[0] == -1:
-            # Handle NAs
-            mask = indexer != -1
-            ok_codes, uniques = algos.factorize(indexer[mask], sort=True)
-
-            codes = np.empty(len(indexer), dtype=indexer.dtype)
-            codes[mask] = ok_codes
-            codes[~mask] = -1
-
-        if len(uniques) < len(level_index):
-            # Remove unobserved levels from level_index
-            level_index = level_index.take(uniques)
-        else:
-            # break references back to us so that setting the name
-            # on the output of a groupby doesn't reflect back here.
-            level_index = level_index.copy()
+        values = self.get_level_values(level)
+        codes, uniques = algos.factorize(values, sort=True, use_na_sentinel=dropna)
+        assert isinstance(uniques, Index)
 
-        if level_index._can_hold_na:
-            grouper = level_index.take(codes, fill_value=True)
+        if self.levels[level]._can_hold_na:
+            grouper = uniques.take(codes, fill_value=True)
         else:
-            grouper = level_index.take(codes)
+            grouper = uniques.take(codes)
 
-        return grouper, codes, level_index
+        return grouper, codes, uniques
 
     @cache_readonly
     def inferred_type(self) -> str:
@@ -1547,13 +1575,12 @@ def _get_level_number(self, level) -> int:
     @cache_readonly
     def is_monotonic_increasing(self) -> bool:
         """
-        return if the index is monotonic increasing (only equal or
-        increasing) values.
+        Return a boolean if the values are equal or increasing.
         """
         if any(-1 in code for code in self.codes):
             return False
 
-        if all(level.is_monotonic for level in self.levels):
+        if all(level.is_monotonic_increasing for level in self.levels):
             # If each level is sorted, we can operate on the codes directly. GH27495
             return libalgos.is_lexsorted(
                 [x.astype("int64", copy=False) for x in self.codes]
@@ -1564,18 +1591,23 @@ def is_monotonic_increasing(self) -> bool:
             self._get_level_values(i)._values for i in reversed(range(len(self.levels)))
         ]
         try:
-            sort_order = np.lexsort(values)
-            return Index(sort_order).is_monotonic
+            # error: Argument 1 to "lexsort" has incompatible type
+            # "List[Union[ExtensionArray, ndarray[Any, Any]]]";
+            # expected "Union[_SupportsArray[dtype[Any]],
+            # _NestedSequence[_SupportsArray[dtype[Any]]], bool,
+            # int, float, complex, str, bytes, _NestedSequence[Union
+            # [bool, int, float, complex, str, bytes]]]"
+            sort_order = np.lexsort(values)  # type: ignore[arg-type]
+            return Index(sort_order).is_monotonic_increasing
         except TypeError:
 
             # we have mixed types and np.lexsort is not happy
-            return Index(self._values).is_monotonic
+            return Index(self._values).is_monotonic_increasing
 
     @cache_readonly
     def is_monotonic_decreasing(self) -> bool:
         """
-        return if the index is monotonic decreasing (only equal or
-        decreasing) values.
+        Return a boolean if the values are equal or decreasing.
         """
         # monotonic decreasing if and only if reverse is monotonic increasing
         return self[::-1].is_monotonic_increasing
@@ -1658,6 +1690,12 @@ def get_level_values(self, level):
             Values is a level of this MultiIndex converted to
             a single :class:`Index` (or subclass thereof).
 
+        Notes
+        -----
+        If the level contains missing values, the result may be casted to
+        ``float`` with missing values specified as ``NaN``. This is because
+        the level is converted to a regular ``Index``.
+
         Examples
         --------
         Create a MultiIndex:
@@ -1671,6 +1709,16 @@ def get_level_values(self, level):
         Index(['a', 'b', 'c'], dtype='object', name='level_1')
         >>> mi.get_level_values('level_2')
         Index(['d', 'e', 'f'], dtype='object', name='level_2')
+
+        If a level contains missing values, the return type of the level
+        maybe casted to ``float``.
+
+        >>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).dtypes
+        level_0    int64
+        level_1    int64
+        dtype: object
+        >>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).get_level_values(0)
+        Float64Index([1.0, nan, 2.0], dtype='float64')
         """
         level = self._get_level_number(level)
         values = self._get_level_values(level)
@@ -1685,7 +1733,12 @@ def unique(self, level=None):
             level = self._get_level_number(level)
             return self._get_level_values(level=level, unique=True)
 
-    def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
+    def to_frame(
+        self,
+        index: bool = True,
+        name=lib.no_default,
+        allow_duplicates: bool = False,
+    ) -> DataFrame:
         """
         Create a DataFrame with the levels of the MultiIndex as columns.
 
@@ -1700,6 +1753,11 @@ def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
         name : list / sequence of str, optional
             The passed names should substitute index level names.
 
+        allow_duplicates : bool, optional default False
+            Allow duplicate column labels to be created.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         DataFrame : a DataFrame containing the original MultiIndex data.
@@ -1737,6 +1795,17 @@ def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
         """
         from pandas import DataFrame
 
+        if name is None:
+            warnings.warn(
+                "Explicitly passing `name=None` currently preserves the Index's name "
+                "or uses a default name of 0. This behaviour is deprecated, and in "
+                "the future `None` will be used as the name of the resulting "
+                "DataFrame column.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            name = lib.no_default
+
         if name is not lib.no_default:
             if not is_list_like(name):
                 raise TypeError("'name' must be a list / sequence of column names.")
@@ -1747,22 +1816,27 @@ def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
                 )
             idx_names = name
         else:
-            idx_names = self.names
+            idx_names = self._get_level_names()
+
+        if not allow_duplicates and len(set(idx_names)) != len(idx_names):
+            raise ValueError(
+                "Cannot create duplicate column labels if allow_duplicates is False"
+            )
 
         # Guarantee resulting column order - PY36+ dict maintains insertion order
         result = DataFrame(
-            {
-                (level if lvlname is None else lvlname): self._get_level_values(level)
-                for lvlname, level in zip(idx_names, range(len(self.levels)))
-            },
+            {level: self._get_level_values(level) for level in range(len(self.levels))},
             copy=False,
         )
+        result.columns = idx_names
 
         if index:
             result.index = self
         return result
 
-    def to_flat_index(self) -> Index:
+    # error: Return type "Index" of "to_flat_index" incompatible with return type
+    # "MultiIndex" in supertype "Index"
+    def to_flat_index(self) -> Index:  # type: ignore[override]
         """
         Convert a MultiIndex to an Index of Tuples containing the level values.
 
@@ -1792,10 +1866,6 @@ def to_flat_index(self) -> Index:
         """
         return Index(self._values, tupleize_cols=False)
 
-    @property
-    def _is_all_dates(self) -> bool:
-        return False
-
     def is_lexsorted(self) -> bool:
         warnings.warn(
             "MultiIndex.is_lexsorted is deprecated as a public function, "
@@ -1842,7 +1912,7 @@ def _is_lexsorted(self) -> bool:
     @property
     def lexsort_depth(self) -> int:
         warnings.warn(
-            "MultiIndex.is_lexsorted is deprecated as a public function, "
+            "MultiIndex.lexsort_depth is deprecated as a public function, "
             "users should use MultiIndex.is_monotonic_increasing instead.",
             FutureWarning,
             stacklevel=find_stack_level(),
@@ -1897,7 +1967,7 @@ def _sort_levels_monotonic(self) -> MultiIndex:
                     ('b', 'bb')],
                    )
         """
-        if self._is_lexsorted() and self.is_monotonic:
+        if self._is_lexsorted() and self.is_monotonic_increasing:
             return self
 
         new_levels = []
@@ -1905,7 +1975,7 @@ def _sort_levels_monotonic(self) -> MultiIndex:
 
         for lev, level_codes in zip(self.levels, self.codes):
 
-            if not lev.is_monotonic:
+            if not lev.is_monotonic_increasing:
                 try:
                     # indexer to reorder the levels
                     indexer = lev.argsort()
@@ -2266,7 +2336,7 @@ def swaplevel(self, i=-2, j=-1) -> MultiIndex:
         See Also
         --------
         Series.swaplevel : Swap levels i and j in a MultiIndex.
-        Dataframe.swaplevel : Swap levels i and j in a MultiIndex on a
+        DataFrame.swaplevel : Swap levels i and j in a MultiIndex on a
             particular axis.
 
         Examples
@@ -2586,7 +2656,10 @@ def _get_indexer_level_0(self, target) -> npt.NDArray[np.intp]:
         return ci.get_indexer_for(target)
 
     def get_slice_bound(
-        self, label: Hashable | Sequence[Hashable], side: str, kind=lib.no_default
+        self,
+        label: Hashable | Sequence[Hashable],
+        side: Literal["left", "right"],
+        kind=lib.no_default,
     ) -> int:
         """
         For an ordered MultiIndex, compute slice bound
@@ -2701,7 +2774,7 @@ def slice_locs(
         # happens in get_slice_bound method), but it adds meaningful doc.
         return super().slice_locs(start, end, step)
 
-    def _partial_tup_index(self, tup: tuple, side="left"):
+    def _partial_tup_index(self, tup: tuple, side: Literal["left", "right"] = "left"):
         if len(tup) > self._lexsort_depth:
             raise UnsortedIndexError(
                 f"Key length ({len(tup)}) was greater than MultiIndex lexsort depth "
@@ -2717,7 +2790,7 @@ def _partial_tup_index(self, tup: tuple, side="left"):
             if lab not in lev and not isna(lab):
                 # short circuit
                 try:
-                    loc = lev.searchsorted(lab, side=side)
+                    loc = algos.searchsorted(lev, lab, side=side)
                 except TypeError as err:
                     # non-comparable e.g. test_slice_locs_with_type_mismatch
                     raise TypeError(f"Level type mismatch: {lab}") from err
@@ -2726,7 +2799,7 @@ def _partial_tup_index(self, tup: tuple, side="left"):
                     raise TypeError(f"Level type mismatch: {lab}")
                 if side == "right" and loc >= 0:
                     loc -= 1
-                return start + section.searchsorted(loc, side=side)
+                return start + algos.searchsorted(section, loc, side=side)
 
             idx = self._get_loc_single_level_index(lev, lab)
             if isinstance(idx, slice) and k < n - 1:
@@ -2735,13 +2808,21 @@ def _partial_tup_index(self, tup: tuple, side="left"):
                 start = idx.start
                 end = idx.stop
             elif k < n - 1:
-                end = start + section.searchsorted(idx, side="right")
-                start = start + section.searchsorted(idx, side="left")
+                # error: Incompatible types in assignment (expression has type
+                # "Union[ndarray[Any, dtype[signedinteger[Any]]]
+                end = start + algos.searchsorted(  # type: ignore[assignment]
+                    section, idx, side="right"
+                )
+                # error: Incompatible types in assignment (expression has type
+                # "Union[ndarray[Any, dtype[signedinteger[Any]]]
+                start = start + algos.searchsorted(  # type: ignore[assignment]
+                    section, idx, side="left"
+                )
             elif isinstance(idx, slice):
                 idx = idx.start
-                return start + section.searchsorted(idx, side=side)
+                return start + algos.searchsorted(section, idx, side=side)
             else:
-                return start + section.searchsorted(idx, side=side)
+                return start + algos.searchsorted(section, idx, side=side)
 
     def _get_loc_single_level_index(self, level_index: Index, key: Hashable) -> int:
         """
@@ -2950,6 +3031,10 @@ def _get_loc_level(self, key, level: int | list[int] = 0):
 
         # different name to distinguish from maybe_droplevels
         def maybe_mi_droplevels(indexer, levels):
+            """
+            If level does not exist or all levels were dropped, the exception
+            has to be handled outside.
+            """
             new_index = self[indexer]
 
             for i in sorted(levels, reverse=True):
@@ -3083,13 +3168,18 @@ def maybe_mi_droplevels(indexer, levels):
                     # e.g. test_partial_string_timestamp_multiindex
                     return indexer, self[indexer]
 
-            return indexer, maybe_mi_droplevels(indexer, [level])
+            try:
+                result_index = maybe_mi_droplevels(indexer, [level])
+            except ValueError:
+                result_index = self[indexer]
+
+            return indexer, result_index
 
     def _get_level_indexer(
-        self, key, level: int = 0, indexer: Int64Index | None = None
+        self, key, level: int = 0, indexer: npt.NDArray[np.bool_] | None = None
     ):
         # `level` kwarg is _always_ positional, never name
-        # return an indexer, boolean array or a slice showing where the key is
+        # return a boolean array or slice showing where the key is
         # in the totality of values
         # if the indexer is provided, then use this
 
@@ -3097,56 +3187,49 @@ def _get_level_indexer(
         level_codes = self.codes[level]
 
         def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
-            # given the inputs and the codes/indexer, compute an indexer set
-            # if we have a provided indexer, then this need not consider
-            # the entire labels set
-            if step is not None and step < 0:
-                # Switch elements for negative step size
-                start, stop = stop - 1, start - 1
-            r = np.arange(start, stop, step)
-
-            if indexer is not None and len(indexer) != len(codes):
-
-                # we have an indexer which maps the locations in the labels
-                # that we have already selected (and is not an indexer for the
-                # entire set) otherwise this is wasteful so we only need to
-                # examine locations that are in this set the only magic here is
-                # that the result are the mappings to the set that we have
-                # selected
-                from pandas import Series
-
-                mapper = Series(indexer)
-                indexer = codes.take(ensure_platform_int(indexer))
-                result = Series(Index(indexer).isin(r).nonzero()[0])
-                m = result.map(mapper)
-                # error: Incompatible types in assignment (expression has type
-                # "ndarray", variable has type "Series")
-                m = np.asarray(m)  # type: ignore[assignment]
-
+            # Compute a bool indexer to identify the positions to take.
+            # If we have an existing indexer, we only need to examine the
+            # subset of positions where the existing indexer is True.
+            if indexer is not None:
+                # we only need to look at the subset of codes where the
+                # existing indexer equals True
+                codes = codes[indexer]
+
+            if step is None or step == 1:
+                new_indexer = (codes >= start) & (codes < stop)
             else:
-                # error: Incompatible types in assignment (expression has type
-                # "ndarray", variable has type "Series")
-                m = np.zeros(len(codes), dtype=bool)  # type: ignore[assignment]
-                m[np.in1d(codes, r, assume_unique=Index(codes).is_unique)] = True
+                r = np.arange(start, stop, step, dtype=codes.dtype)
+                new_indexer = algos.isin(codes, r)
 
-            return m
+            if indexer is None:
+                return new_indexer
+
+            indexer = indexer.copy()
+            indexer[indexer] = new_indexer
+            return indexer
 
         if isinstance(key, slice):
             # handle a slice, returning a slice if we can
             # otherwise a boolean indexer
+            step = key.step
+            is_negative_step = step is not None and step < 0
 
             try:
                 if key.start is not None:
                     start = level_index.get_loc(key.start)
+                elif is_negative_step:
+                    start = len(level_index) - 1
                 else:
                     start = 0
+
                 if key.stop is not None:
                     stop = level_index.get_loc(key.stop)
+                elif is_negative_step:
+                    stop = 0
                 elif isinstance(start, slice):
                     stop = len(level_index)
                 else:
                     stop = len(level_index) - 1
-                step = key.step
             except KeyError:
 
                 # we have a partial slice (like looking up a partial date
@@ -3166,12 +3249,13 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
             elif level > 0 or self._lexsort_depth == 0 or step is not None:
                 # need to have like semantics here to right
                 # searching as when we are using a slice
-                # so include the stop+1 (so we include stop)
-                return convert_indexer(start, stop + 1, step)
+                # so adjust the stop by 1 (so we include stop)
+                stop = (stop - 1) if is_negative_step else (stop + 1)
+                return convert_indexer(start, stop, step)
             else:
                 # sorted, so can return slice object -> view
-                i = level_codes.searchsorted(start, side="left")
-                j = level_codes.searchsorted(stop, side="right")
+                i = algos.searchsorted(level_codes, start, side="left")
+                j = algos.searchsorted(level_codes, stop, side="right")
                 return slice(i, j, step)
 
         else:
@@ -3194,12 +3278,12 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
 
             if isinstance(idx, slice):
                 # e.g. test_partial_string_timestamp_multiindex
-                start = level_codes.searchsorted(idx.start, side="left")
+                start = algos.searchsorted(level_codes, idx.start, side="left")
                 # NB: "left" here bc of slice semantics
-                end = level_codes.searchsorted(idx.stop, side="left")
+                end = algos.searchsorted(level_codes, idx.stop, side="left")
             else:
-                start = level_codes.searchsorted(idx, side="left")
-                end = level_codes.searchsorted(idx, side="right")
+                start = algos.searchsorted(level_codes, idx, side="left")
+                end = algos.searchsorted(level_codes, idx, side="right")
 
             if start == end:
                 # The label is present in self.levels[level] but unused:
@@ -3249,60 +3333,41 @@ def get_locs(self, seq):
                 f"on levels {true_slices}, lexsort depth {self._lexsort_depth}"
             )
 
-        n = len(self)
-        # indexer is the list of all positions that we want to take; we
-        #  start with it being everything and narrow it down as we look at each
-        #  entry in `seq`
-        indexer = Index(np.arange(n))
-
         if any(x is Ellipsis for x in seq):
             raise NotImplementedError(
                 "MultiIndex does not support indexing with Ellipsis"
             )
 
-        def _convert_to_indexer(r) -> Int64Index:
-            # return an indexer
-            if isinstance(r, slice):
-                m = np.zeros(n, dtype=bool)
-                m[r] = True
-                r = m.nonzero()[0]
-            elif com.is_bool_indexer(r):
-                if len(r) != n:
-                    raise ValueError(
-                        "cannot index with a boolean indexer "
-                        "that is not the same length as the "
-                        "index"
-                    )
-                r = r.nonzero()[0]
-            return Int64Index(r)
+        n = len(self)
 
-        def _update_indexer(idxr: Index, indexer: Index) -> Index:
-            indexer_intersection = indexer.intersection(idxr)
-            if indexer_intersection.empty and not idxr.empty and not indexer.empty:
-                raise KeyError(seq)
-            return indexer_intersection
+        def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
+            if isinstance(indexer, slice):
+                new_indexer = np.zeros(n, dtype=np.bool_)
+                new_indexer[indexer] = True
+                return new_indexer
+            return indexer
+
+        # a bool indexer for the positions we want to take
+        indexer: npt.NDArray[np.bool_] | None = None
 
         for i, k in enumerate(seq):
 
+            lvl_indexer: npt.NDArray[np.bool_] | slice | None = None
+
             if com.is_bool_indexer(k):
-                # a boolean indexer, must be the same length!
-                k = np.asarray(k)
-                lvl_indexer = _convert_to_indexer(k)
-                indexer = _update_indexer(lvl_indexer, indexer=indexer)
+                if len(k) != n:
+                    raise ValueError(
+                        "cannot index with a boolean indexer that "
+                        "is not the same length as the index"
+                    )
+                lvl_indexer = np.asarray(k)
 
             elif is_list_like(k):
-                # a collection of labels to include from this level (these
-                # are or'd)
-
-                indexers: Int64Index | None = None
+                # a collection of labels to include from this level (these are or'd)
 
                 # GH#27591 check if this is a single tuple key in the level
                 try:
-                    # Argument "indexer" to "_get_level_indexer" of "MultiIndex"
-                    # has incompatible type "Index"; expected "Optional[Int64Index]"
-                    lev_loc = self._get_level_indexer(
-                        k, level=i, indexer=indexer  # type: ignore[arg-type]
-                    )
+                    lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
                 except (InvalidIndexError, TypeError, KeyError) as err:
                     # InvalidIndexError e.g. non-hashable, fall back to treating
                     #  this as a sequence of labels
@@ -3314,11 +3379,8 @@ def _update_indexer(idxr: Index, indexer: Index) -> Index:
                             # e.g. slice
                             raise err
                         try:
-                            # Argument "indexer" to "_get_level_indexer" of "MultiIndex"
-                            # has incompatible type "Index"; expected
-                            # "Optional[Int64Index]"
-                            item_lvl_indexer = self._get_level_indexer(
-                                x, level=i, indexer=indexer  # type: ignore[arg-type]
+                            item_indexer = self._get_level_indexer(
+                                x, level=i, indexer=indexer
                             )
                         except KeyError:
                             # ignore not founds; see discussion in GH#39424
@@ -3338,81 +3400,63 @@ def _update_indexer(idxr: Index, indexer: Index) -> Index:
                             )
                             continue
                         else:
-                            idxrs = _convert_to_indexer(item_lvl_indexer)
-
-                            if indexers is None:
-                                indexers = idxrs
+                            if lvl_indexer is None:
+                                lvl_indexer = _to_bool_indexer(item_indexer)
+                            elif isinstance(item_indexer, slice):
+                                lvl_indexer[item_indexer] = True  # type: ignore[index]
                             else:
-                                indexers = indexers.union(idxrs, sort=False)
+                                lvl_indexer |= item_indexer
 
-                else:
-                    idxrs = _convert_to_indexer(lev_loc)
-                    if indexers is None:
-                        indexers = idxrs
-                    else:
-                        indexers = indexers.union(idxrs, sort=False)
-
-                if indexers is not None:
-                    indexer = _update_indexer(indexers, indexer=indexer)
-                else:
+                if lvl_indexer is None:
                     # no matches we are done
                     # test_loc_getitem_duplicates_multiindex_empty_indexer
                     return np.array([], dtype=np.intp)
 
             elif com.is_null_slice(k):
                 # empty slice
-                pass
+                if indexer is None and i == len(seq) - 1:
+                    return np.arange(n, dtype=np.intp)
+                continue
 
-            elif isinstance(k, slice):
+            else:
+                # a slice or a single label
+                lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
 
-                # a slice, include BOTH of the labels
-                # Argument "indexer" to "_get_level_indexer" of "MultiIndex" has
-                # incompatible type "Index"; expected "Optional[Int64Index]"
-                lvl_indexer = self._get_level_indexer(
-                    k,
-                    level=i,
-                    indexer=indexer,  # type: ignore[arg-type]
-                )
-                indexer = _update_indexer(
-                    _convert_to_indexer(lvl_indexer),
-                    indexer=indexer,
-                )
+            # update indexer
+            lvl_indexer = _to_bool_indexer(lvl_indexer)
+            if indexer is None:
+                indexer = lvl_indexer
             else:
-                # a single label
-                lvl_indexer = self._get_loc_level(k, level=i)[0]
-                indexer = _update_indexer(
-                    _convert_to_indexer(lvl_indexer),
-                    indexer=indexer,
-                )
+                indexer &= lvl_indexer
+                if not np.any(indexer) and np.any(lvl_indexer):
+                    raise KeyError(seq)
 
         # empty indexer
         if indexer is None:
             return np.array([], dtype=np.intp)
 
-        assert isinstance(indexer, Int64Index), type(indexer)
-        indexer = self._reorder_indexer(seq, indexer)
-
-        return indexer._values.astype(np.intp, copy=False)
+        pos_indexer = indexer.nonzero()[0]
+        return self._reorder_indexer(seq, pos_indexer)
 
     # --------------------------------------------------------------------
 
     def _reorder_indexer(
         self,
         seq: tuple[Scalar | Iterable | AnyArrayLike, ...],
-        indexer: Int64Index,
-    ) -> Int64Index:
+        indexer: npt.NDArray[np.intp],
+    ) -> npt.NDArray[np.intp]:
         """
-        Reorder an indexer of a MultiIndex (self) so that the label are in the
+        Reorder an indexer of a MultiIndex (self) so that the labels are in the
         same order as given in seq
 
         Parameters
         ----------
         seq : label/slice/list/mask or a sequence of such
-        indexer: an Int64Index indexer of self
+        indexer: a position indexer of self
 
         Returns
         -------
-        indexer : a sorted Int64Index indexer of self ordered as seq
+        indexer : a sorted position indexer of self ordered as seq
         """
         # If the index is lexsorted and the list_like label in seq are sorted
         # then we do not need to sort
@@ -3455,7 +3499,8 @@ def _reorder_indexer(
 
                 new_order = key_order_map[self.codes[i][indexer]]
             elif isinstance(k, slice) and k.step is not None and k.step < 0:
-                new_order = np.arange(n)[k][indexer]
+                # flip order for negative step
+                new_order = np.arange(n)[::-1][indexer]
             elif isinstance(k, slice) and k.start is None and k.stop is None:
                 # slice(None) should not determine order GH#31330
                 new_order = np.ones((n,))[indexer]
@@ -3554,6 +3599,10 @@ def equals(self, other: object) -> bool:
                 # i.e. ExtensionArray
                 if not self_values.equals(other_values):
                     return False
+            elif not isinstance(other_values, np.ndarray):
+                # i.e. other is ExtensionArray
+                if not other_values.equals(self_values):
+                    return False
             else:
                 if not array_equivalent(self_values, other_values):
                     return False
@@ -3843,6 +3892,11 @@ def sparsify_labels(label_list, start: int = 0, sentinel=""):
 
 
 def _get_na_rep(dtype) -> str:
+    if is_extension_array_dtype(dtype):
+        return f"{dtype.na_value}"
+    else:
+        dtype = dtype.type
+
     return {np.datetime64: "NaT", np.timedelta64: "NaT"}.get(dtype, "NaN")
 
 
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 5cd4cc9dfaec2..fe11a02eccb3c 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -14,7 +14,6 @@
 )
 from pandas._typing import (
     Dtype,
-    DtypeObj,
     npt,
 )
 from pandas.util._decorators import (
@@ -23,18 +22,14 @@
 )
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.dtypes.cast import astype_nansafe
 from pandas.core.dtypes.common import (
     is_dtype_equal,
-    is_extension_array_dtype,
-    is_float,
     is_float_dtype,
     is_integer_dtype,
     is_numeric_dtype,
     is_scalar,
     is_signed_integer_dtype,
     is_unsigned_integer_dtype,
-    needs_i8_conversion,
     pandas_dtype,
 )
 from pandas.core.dtypes.generic import ABCSeries
@@ -47,9 +42,10 @@
 
 class NumericIndex(Index):
     """
-    Immutable sequence used for indexing and alignment. The basic object
-    storing axis labels for all pandas objects. NumericIndex is a special case
-    of `Index` with purely numpy int/uint/float labels.
+    Immutable numeric sequence used for indexing and alignment.
+
+    The basic object storing axis labels for all pandas objects.
+    NumericIndex is a special case of `Index` with purely numpy int/uint/float labels.
 
     .. versionadded:: 1.4.0
 
@@ -67,7 +63,7 @@ class NumericIndex(Index):
     None
 
     Methods
-    ----------
+    -------
     None
 
     See Also
@@ -95,14 +91,6 @@ class NumericIndex(Index):
     _can_hold_strings = False
     _is_backward_compat_public_numeric_index: bool = True
 
-    # error: Signature of "_can_hold_na" incompatible with supertype "Index"
-    @cache_readonly
-    def _can_hold_na(self) -> bool:  # type: ignore[override]
-        if is_float_dtype(self.dtype):
-            return True
-        else:
-            return False
-
     _engine_types: dict[np.dtype, type[libindex.IndexEngine]] = {
         np.dtype(np.int8): libindex.Int8Engine,
         np.dtype(np.int16): libindex.Int16Engine,
@@ -114,10 +102,12 @@ def _can_hold_na(self) -> bool:  # type: ignore[override]
         np.dtype(np.uint64): libindex.UInt64Engine,
         np.dtype(np.float32): libindex.Float32Engine,
         np.dtype(np.float64): libindex.Float64Engine,
+        np.dtype(np.complex64): libindex.Complex64Engine,
+        np.dtype(np.complex128): libindex.Complex128Engine,
     }
 
     @property
-    def _engine_type(self):
+    def _engine_type(self) -> type[libindex.IndexEngine]:
         # error: Invalid index type "Union[dtype[Any], ExtensionDtype]" for
         # "Dict[dtype[Any], Type[IndexEngine]]"; expected type "dtype[Any]"
         return self._engine_types[self.dtype]  # type: ignore[index]
@@ -128,9 +118,12 @@ def inferred_type(self) -> str:
             "i": "integer",
             "u": "integer",
             "f": "floating",
+            "c": "complex",
         }[self.dtype.kind]
 
-    def __new__(cls, data=None, dtype: Dtype | None = None, copy=False, name=None):
+    def __new__(
+        cls, data=None, dtype: Dtype | None = None, copy=False, name=None
+    ) -> NumericIndex:
         name = maybe_extract_name(name, data, cls)
 
         subarr = cls._ensure_array(data, dtype, copy)
@@ -216,48 +209,6 @@ def _ensure_dtype(cls, dtype: Dtype | None) -> np.dtype | None:
             # dtype for Int64Index, UInt64Index etc. Needed for backwards compat.
             return cls._default_dtype
 
-    def __contains__(self, key) -> bool:
-        """
-        Check if key is a float and has a decimal. If it has, return False.
-        """
-        if not is_integer_dtype(self.dtype):
-            return super().__contains__(key)
-
-        hash(key)
-        try:
-            if is_float(key) and int(key) != key:
-                # otherwise the `key in self._engine` check casts e.g. 1.1 -> 1
-                return False
-            return key in self._engine
-        except (OverflowError, TypeError, ValueError):
-            return False
-
-    @doc(Index.astype)
-    def astype(self, dtype, copy: bool = True):
-        dtype = pandas_dtype(dtype)
-        if is_float_dtype(self.dtype):
-            if needs_i8_conversion(dtype):
-                raise TypeError(
-                    f"Cannot convert Float64Index to dtype {dtype}; integer "
-                    "values are required for conversion"
-                )
-            elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
-                # TODO(ExtensionIndex); this can change once we have an EA Index type
-                # GH 13149
-                arr = astype_nansafe(self._values, dtype=dtype)
-                if isinstance(self, Float64Index):
-                    return Int64Index(arr, name=self.name)
-                else:
-                    return NumericIndex(arr, name=self.name, dtype=dtype)
-        elif self._is_backward_compat_public_numeric_index:
-            # this block is needed so e.g. NumericIndex[int8].astype("int32") returns
-            # NumericIndex[int32] and not Int64Index with dtype int64.
-            # When Int64Index etc. are removed from the code base, removed this also.
-            if not is_extension_array_dtype(dtype) and is_numeric_dtype(dtype):
-                return self._constructor(self, dtype=dtype, copy=copy)
-
-        return super().astype(dtype, copy=copy)
-
     # ----------------------------------------------------------------
     # Indexing Methods
 
@@ -269,9 +220,13 @@ def _should_fallback_to_positional(self) -> bool:
 
     @doc(Index._convert_slice_indexer)
     def _convert_slice_indexer(self, key: slice, kind: str):
+        # TODO(2.0): once #45324 deprecation is enforced we should be able
+        #  to simplify this.
         if is_float_dtype(self.dtype):
             assert kind in ["loc", "getitem"]
 
+            # TODO: can we write this as a condition based on
+            #  e.g. _should_fallback_to_positional?
             # We always treat __getitem__ slicing as label-based
             # translate to locations
             return self.slice_indexer(key.start, key.stop, key.step)
@@ -312,10 +267,6 @@ def _convert_tolerance(self, tolerance, target):
                 )
         return tolerance
 
-    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
-        # If we ever have BoolIndex or ComplexIndex, this may need to be tightened
-        return is_numeric_dtype(dtype)
-
     @classmethod
     def _assert_safe_casting(cls, data: np.ndarray, subarr: np.ndarray) -> None:
         """
@@ -328,16 +279,9 @@ def _assert_safe_casting(cls, data: np.ndarray, subarr: np.ndarray) -> None:
             if not np.array_equal(data, subarr):
                 raise TypeError("Unsafe NumPy casting, you must explicitly cast")
 
-    @property
-    def _is_all_dates(self) -> bool:
-        """
-        Checks that all the labels are datetime objects.
-        """
-        return False
-
     def _format_native_types(
         self, *, na_rep="", float_format=None, decimal=".", quoting=None, **kwargs
-    ):
+    ) -> npt.NDArray[np.object_]:
         from pandas.io.formats.format import FloatArrayFormatter
 
         if is_float_dtype(self.dtype):
@@ -366,14 +310,15 @@ def _format_native_types(
 _num_index_shared_docs[
     "class_descr"
 ] = """
-    Immutable sequence used for indexing and alignment. The basic object
-    storing axis labels for all pandas objects. %(klass)s is a special case
-    of `Index` with purely %(ltype)s labels. %(extra)s.
+    Immutable sequence used for indexing and alignment.
 
     .. deprecated:: 1.4.0
         In pandas v2.0 %(klass)s will be removed and :class:`NumericIndex` used instead.
         %(klass)s will remain fully functional for the duration of pandas 1.x.
 
+    The basic object storing axis labels for all pandas objects.
+    %(klass)s is a special case of `Index` with purely %(ltype)s labels. %(extra)s.
+
     Parameters
     ----------
     data : array-like (1-dimensional)
@@ -388,7 +333,7 @@ def _format_native_types(
     None
 
     Methods
-    ----------
+    -------
     None
 
     See Also
@@ -419,18 +364,6 @@ def asi8(self) -> npt.NDArray[np.int64]:
         )
         return self._values.view(self._default_dtype)
 
-    def _validate_fill_value(self, value):
-        # e.g. np.array([1.0]) we want np.array([1], dtype=self.dtype)
-        #  see TestSetitemFloatNDarrayIntoIntegerSeries
-        super()._validate_fill_value(value)
-        if hasattr(value, "dtype") and is_float_dtype(value.dtype):
-            converted = value.astype(self.dtype)
-            if (converted == value).all():
-                # See also: can_hold_element
-                return converted
-            raise TypeError
-        return value
-
 
 class Int64Index(IntegerIndex):
     _index_descr_args = {
@@ -442,10 +375,13 @@ class Int64Index(IntegerIndex):
     __doc__ = _num_index_shared_docs["class_descr"] % _index_descr_args
 
     _typ = "int64index"
-    _engine_type = libindex.Int64Engine
     _default_dtype = np.dtype(np.int64)
     _dtype_validation_metadata = (is_signed_integer_dtype, "signed integer")
 
+    @property
+    def _engine_type(self) -> type[libindex.Int64Engine]:
+        return libindex.Int64Engine
+
 
 class UInt64Index(IntegerIndex):
     _index_descr_args = {
@@ -457,19 +393,12 @@ class UInt64Index(IntegerIndex):
     __doc__ = _num_index_shared_docs["class_descr"] % _index_descr_args
 
     _typ = "uint64index"
-    _engine_type = libindex.UInt64Engine
     _default_dtype = np.dtype(np.uint64)
     _dtype_validation_metadata = (is_unsigned_integer_dtype, "unsigned integer")
 
-    def _validate_fill_value(self, value):
-        # e.g. np.array([1]) we want np.array([1], dtype=np.uint64)
-        #  see test_where_uin64
-        super()._validate_fill_value(value)
-        if hasattr(value, "dtype") and is_signed_integer_dtype(value.dtype):
-            if (value >= 0).all():
-                return value.astype(self.dtype)
-            raise TypeError
-        return value
+    @property
+    def _engine_type(self) -> type[libindex.UInt64Engine]:
+        return libindex.UInt64Engine
 
 
 class Float64Index(NumericIndex):
@@ -482,7 +411,10 @@ class Float64Index(NumericIndex):
     __doc__ = _num_index_shared_docs["class_descr"] % _index_descr_args
 
     _typ = "float64index"
-    _engine_type = libindex.Float64Engine
     _default_dtype = np.dtype(np.float64)
     _dtype_validation_metadata = (is_float_dtype, "float")
     _is_backward_compat_public_numeric_index: bool = False
+
+    @property
+    def _engine_type(self) -> type[libindex.Float64Engine]:
+        return libindex.Float64Engine
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index aba834a47ffef..c034d9416eae7 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -23,8 +23,12 @@
 from pandas._typing import (
     Dtype,
     DtypeObj,
+    npt,
+)
+from pandas.util._decorators import (
+    cache_readonly,
+    doc,
 )
-from pandas.util._decorators import doc
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
@@ -155,9 +159,18 @@ class PeriodIndex(DatetimeIndexOpsMixin):
     dtype: PeriodDtype
 
     _data_cls = PeriodArray
-    _engine_type = libindex.PeriodEngine
     _supports_partial_string_indexing = True
 
+    @property
+    def _engine_type(self) -> type[libindex.PeriodEngine]:
+        return libindex.PeriodEngine
+
+    @cache_readonly
+    # Signature of "_resolution_obj" incompatible with supertype "DatetimeIndexOpsMixin"
+    def _resolution_obj(self) -> Resolution:  # type: ignore[override]
+        # for compat with DatetimeIndex
+        return self.dtype._resolution_obj
+
     # --------------------------------------------------------------------
     # methods that dispatch to array and wrap result in Index
     # These are defined here instead of via inherit_names for mypy
@@ -173,27 +186,27 @@ def asfreq(self, freq=None, how: str = "E") -> PeriodIndex:
         return type(self)._simple_new(arr, name=self.name)
 
     @doc(PeriodArray.to_timestamp)
-    def to_timestamp(self, freq=None, how="start") -> DatetimeIndex:
+    def to_timestamp(self, freq=None, how: str = "start") -> DatetimeIndex:
         arr = self._data.to_timestamp(freq, how)
         return DatetimeIndex._simple_new(arr, name=self.name)
 
     # https://github.com/python/mypy/issues/1362
     # error: Decorated property not supported
-    @property  # type:ignore[misc]
+    @property  # type: ignore[misc]
     @doc(PeriodArray.hour.fget)
     def hour(self) -> Int64Index:
         return Int64Index(self._data.hour, name=self.name)
 
     # https://github.com/python/mypy/issues/1362
     # error: Decorated property not supported
-    @property  # type:ignore[misc]
+    @property  # type: ignore[misc]
     @doc(PeriodArray.minute.fget)
     def minute(self) -> Int64Index:
         return Int64Index(self._data.minute, name=self.name)
 
     # https://github.com/python/mypy/issues/1362
     # error: Decorated property not supported
-    @property  # type:ignore[misc]
+    @property  # type: ignore[misc]
     @doc(PeriodArray.second.fget)
     def second(self) -> Int64Index:
         return Int64Index(self._data.second, name=self.name)
@@ -271,7 +284,7 @@ def __new__(
     def values(self) -> np.ndarray:
         return np.asarray(self, dtype=object)
 
-    def _maybe_convert_timedelta(self, other):
+    def _maybe_convert_timedelta(self, other) -> int | npt.NDArray[np.int64]:
         """
         Convert timedelta-like input to an integer multiple of self.freq
 
@@ -320,14 +333,16 @@ def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
         freq = dtype.freq
         own_freq = self.freq
         return (
-            freq._period_dtype_code == own_freq._period_dtype_code
+            freq._period_dtype_code
+            # error: "BaseOffset" has no attribute "_period_dtype_code"
+            == own_freq._period_dtype_code  # type: ignore[attr-defined]
             and freq.n == own_freq.n
         )
 
     # ------------------------------------------------------------------------
     # Index Methods
 
-    def asof_locs(self, where: Index, mask: np.ndarray) -> np.ndarray:
+    def asof_locs(self, where: Index, mask: npt.NDArray[np.bool_]) -> np.ndarray:
         """
         where : array of timestamps
         mask : np.ndarray[bool]
@@ -443,9 +458,10 @@ def get_loc(self, key, method=None, tolerance=None):
                     # TODO: pass if method is not None, like DTI does?
                     raise KeyError(key) from err
 
-            if reso == self.dtype.resolution:
-                # the reso < self.dtype.resolution case goes through _get_string_slice
-                key = Period(parsed, freq=self.freq)
+            if reso == self._resolution_obj:
+                # the reso < self._resolution_obj case goes
+                #  through _get_string_slice
+                key = self._cast_partial_indexing_scalar(key)
                 loc = self.get_loc(key, method=method, tolerance=tolerance)
                 # Recursing instead of falling through matters for the exception
                 #  message in test_get_loc3 (though not clear if that really matters)
@@ -453,25 +469,14 @@ def get_loc(self, key, method=None, tolerance=None):
             elif method is None:
                 raise KeyError(key)
             else:
-                key = Period(parsed, freq=self.freq)
+                key = self._cast_partial_indexing_scalar(parsed)
 
         elif isinstance(key, Period):
-            sfreq = self.freq
-            kfreq = key.freq
-            if not (
-                sfreq.n == kfreq.n
-                and sfreq._period_dtype_code == kfreq._period_dtype_code
-            ):
-                # GH#42247 For the subset of DateOffsets that can be Period freqs,
-                #  checking these two attributes is sufficient to check equality,
-                #  and much more performant than `self.freq == key.freq`
-                raise KeyError(key)
+            key = self._maybe_cast_for_get_loc(key)
+
         elif isinstance(key, datetime):
-            try:
-                key = Period(key, freq=self.freq)
-            except ValueError as err:
-                # we cannot construct the Period
-                raise KeyError(orig_key) from err
+            key = self._cast_partial_indexing_scalar(key)
+
         else:
             # in particular integer, which Period constructor would cast to string
             raise KeyError(key)
@@ -481,23 +486,42 @@ def get_loc(self, key, method=None, tolerance=None):
         except KeyError as err:
             raise KeyError(orig_key) from err
 
+    def _maybe_cast_for_get_loc(self, key: Period) -> Period:
+        # name is a misnomer, chosen for compat with DatetimeIndex
+        sfreq = self.freq
+        kfreq = key.freq
+        if not (
+            sfreq.n == kfreq.n
+            # error: "BaseOffset" has no attribute "_period_dtype_code"
+            and sfreq._period_dtype_code  # type: ignore[attr-defined]
+            # error: "BaseOffset" has no attribute "_period_dtype_code"
+            == kfreq._period_dtype_code  # type: ignore[attr-defined]
+        ):
+            # GH#42247 For the subset of DateOffsets that can be Period freqs,
+            #  checking these two attributes is sufficient to check equality,
+            #  and much more performant than `self.freq == key.freq`
+            raise KeyError(key)
+        return key
+
+    def _cast_partial_indexing_scalar(self, label):
+        try:
+            key = Period(label, freq=self.freq)
+        except ValueError as err:
+            # we cannot construct the Period
+            raise KeyError(label) from err
+        return key
+
     @doc(DatetimeIndexOpsMixin._maybe_cast_slice_bound)
     def _maybe_cast_slice_bound(self, label, side: str, kind=lib.no_default):
         if isinstance(label, datetime):
-            label = Period(label, freq=self.freq)
+            label = self._cast_partial_indexing_scalar(label)
 
         return super()._maybe_cast_slice_bound(label, side, kind=kind)
 
     def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
-        grp = reso.freq_group
-        iv = Period(parsed, freq=grp.value)
+        iv = Period(parsed, freq=reso.attr_abbrev)
         return (iv.asfreq(self.freq, how="start"), iv.asfreq(self.freq, how="end"))
 
-    def _can_partial_date_slice(self, reso: Resolution) -> bool:
-        assert isinstance(reso, Resolution), (type(reso), reso)
-        # e.g. test_getitem_setitem_periodindex
-        return reso > self.dtype.resolution
-
 
 def period_range(
     start=None, end=None, periods: int | None = None, freq=None, name=None
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index fdb1ee754a7e6..376c98b6e176f 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -8,6 +8,7 @@
     Any,
     Callable,
     Hashable,
+    Iterator,
     List,
     cast,
 )
@@ -19,6 +20,7 @@
     index as libindex,
     lib,
 )
+from pandas._libs.algos import unique_deltas
 from pandas._libs.lib import no_default
 from pandas._typing import (
     Dtype,
@@ -43,6 +45,7 @@
 from pandas.core.dtypes.generic import ABCTimedeltaIndex
 
 from pandas.core import ops
+from pandas.core.algorithms import resolve_na_sentinel
 import pandas.core.common as com
 from pandas.core.construction import extract_array
 import pandas.core.indexes.base as ibase
@@ -101,11 +104,14 @@ class RangeIndex(NumericIndex):
     """
 
     _typ = "rangeindex"
-    _engine_type = libindex.Int64Engine
     _dtype_validation_metadata = (is_signed_integer_dtype, "signed integer")
     _range: range
     _is_backward_compat_public_numeric_index: bool = False
 
+    @property
+    def _engine_type(self) -> type[libindex.Int64Engine]:
+        return libindex.Int64Engine
+
     # --------------------------------------------------------------------
     # Constructors
 
@@ -425,7 +431,7 @@ def tolist(self) -> list[int]:
         return list(self._range)
 
     @doc(Int64Index.__iter__)
-    def __iter__(self):
+    def __iter__(self) -> Iterator[int]:
         yield from self._range
 
     @doc(Int64Index._shallow_copy)
@@ -434,7 +440,15 @@ def _shallow_copy(self, values, name: Hashable = no_default):
 
         if values.dtype.kind == "f":
             return Float64Index(values, name=name)
-        return Int64Index._simple_new(values, name=name)
+        # GH 46675 & 43885: If values is equally spaced, return a
+        # more memory-compact RangeIndex instead of Int64Index
+        unique_diffs = unique_deltas(values)
+        if len(unique_diffs) == 1 and unique_diffs[0] != 0:
+            diff = unique_diffs[0]
+            new_range = range(values[0], values[-1] + diff, diff)
+            return type(self)._simple_new(new_range, name=name)
+        else:
+            return Int64Index._simple_new(values, name=name)
 
     def _view(self: RangeIndex) -> RangeIndex:
         result = type(self)._simple_new(self._range, name=self._name)
@@ -510,8 +524,13 @@ def argsort(self, *args, **kwargs) -> npt.NDArray[np.intp]:
         return result
 
     def factorize(
-        self, sort: bool = False, na_sentinel: int | None = -1
+        self,
+        sort: bool = False,
+        na_sentinel: int | lib.NoDefault = lib.no_default,
+        use_na_sentinel: bool | lib.NoDefault = lib.no_default,
     ) -> tuple[npt.NDArray[np.intp], RangeIndex]:
+        # resolve to emit warning if appropriate
+        resolve_na_sentinel(na_sentinel, use_na_sentinel)
         codes = np.arange(len(self), dtype=np.intp)
         uniques = self
         if sort and self.step < 0:
@@ -631,6 +650,17 @@ def _extended_gcd(self, a: int, b: int) -> tuple[int, int, int]:
             old_t, t = t, old_t - quotient * t
         return old_r, old_s, old_t
 
+    def _range_in_self(self, other: range) -> bool:
+        """Check if other range is contained in self"""
+        # https://stackoverflow.com/a/32481015
+        if not other:
+            return True
+        if not self._range:
+            return False
+        if len(other) > 1 and other.step % self._range.step:
+            return False
+        return other.start in self._range and other[-1] in self._range
+
     def _union(self, other: Index, sort):
         """
         Form the union of two Index objects and sorts if possible
@@ -640,10 +670,12 @@ def _union(self, other: Index, sort):
         other : Index or array-like
 
         sort : False or None, default None
-            Whether to sort resulting index. ``sort=None`` returns a
-            monotonically increasing ``RangeIndex`` if possible or a sorted
-            ``Int64Index`` if not. ``sort=False`` always returns an
-            unsorted ``Int64Index``
+            Whether to sort (monotonically increasing) the resulting index.
+            ``sort=None`` returns a ``RangeIndex`` if possible or a sorted
+            ``Int64Index`` if not.
+            ``sort=False`` can return a ``RangeIndex`` if self is monotonically
+            increasing and other is fully contained in self. Otherwise, returns
+            an unsorted ``Int64Index``
 
             .. versionadded:: 0.25.0
 
@@ -651,53 +683,58 @@ def _union(self, other: Index, sort):
         -------
         union : Index
         """
-        if isinstance(other, RangeIndex) and sort is None:
-            start_s, step_s = self.start, self.step
-            end_s = self.start + self.step * (len(self) - 1)
-            start_o, step_o = other.start, other.step
-            end_o = other.start + other.step * (len(other) - 1)
-            if self.step < 0:
-                start_s, step_s, end_s = end_s, -step_s, start_s
-            if other.step < 0:
-                start_o, step_o, end_o = end_o, -step_o, start_o
-            if len(self) == 1 and len(other) == 1:
-                step_s = step_o = abs(self.start - other.start)
-            elif len(self) == 1:
-                step_s = step_o
-            elif len(other) == 1:
-                step_o = step_s
-            start_r = min(start_s, start_o)
-            end_r = max(end_s, end_o)
-            if step_o == step_s:
-                if (
-                    (start_s - start_o) % step_s == 0
-                    and (start_s - end_o) <= step_s
-                    and (start_o - end_s) <= step_s
-                ):
-                    return type(self)(start_r, end_r + step_s, step_s)
-                if (
-                    (step_s % 2 == 0)
-                    and (abs(start_s - start_o) == step_s / 2)
-                    and (abs(end_s - end_o) == step_s / 2)
-                ):
-                    # e.g. range(0, 10, 2) and range(1, 11, 2)
-                    #  but not range(0, 20, 4) and range(1, 21, 4) GH#44019
-                    return type(self)(start_r, end_r + step_s / 2, step_s / 2)
-
-            elif step_o % step_s == 0:
-                if (
-                    (start_o - start_s) % step_s == 0
-                    and (start_o + step_s >= start_s)
-                    and (end_o - step_s <= end_s)
-                ):
-                    return type(self)(start_r, end_r + step_s, step_s)
-            elif step_s % step_o == 0:
-                if (
-                    (start_s - start_o) % step_o == 0
-                    and (start_s + step_o >= start_o)
-                    and (end_s - step_o <= end_o)
-                ):
-                    return type(self)(start_r, end_r + step_o, step_o)
+        if isinstance(other, RangeIndex):
+            if sort is None or (
+                sort is False and self.step > 0 and self._range_in_self(other._range)
+            ):
+                # GH 47557: Can still return a RangeIndex
+                # if other range in self and sort=False
+                start_s, step_s = self.start, self.step
+                end_s = self.start + self.step * (len(self) - 1)
+                start_o, step_o = other.start, other.step
+                end_o = other.start + other.step * (len(other) - 1)
+                if self.step < 0:
+                    start_s, step_s, end_s = end_s, -step_s, start_s
+                if other.step < 0:
+                    start_o, step_o, end_o = end_o, -step_o, start_o
+                if len(self) == 1 and len(other) == 1:
+                    step_s = step_o = abs(self.start - other.start)
+                elif len(self) == 1:
+                    step_s = step_o
+                elif len(other) == 1:
+                    step_o = step_s
+                start_r = min(start_s, start_o)
+                end_r = max(end_s, end_o)
+                if step_o == step_s:
+                    if (
+                        (start_s - start_o) % step_s == 0
+                        and (start_s - end_o) <= step_s
+                        and (start_o - end_s) <= step_s
+                    ):
+                        return type(self)(start_r, end_r + step_s, step_s)
+                    if (
+                        (step_s % 2 == 0)
+                        and (abs(start_s - start_o) == step_s / 2)
+                        and (abs(end_s - end_o) == step_s / 2)
+                    ):
+                        # e.g. range(0, 10, 2) and range(1, 11, 2)
+                        #  but not range(0, 20, 4) and range(1, 21, 4) GH#44019
+                        return type(self)(start_r, end_r + step_s / 2, step_s / 2)
+
+                elif step_o % step_s == 0:
+                    if (
+                        (start_o - start_s) % step_s == 0
+                        and (start_o + step_s >= start_s)
+                        and (end_o - step_s <= end_s)
+                    ):
+                        return type(self)(start_r, end_r + step_s, step_s)
+                elif step_s % step_o == 0:
+                    if (
+                        (start_s - start_o) % step_o == 0
+                        and (start_s + step_o >= start_o)
+                        and (end_s - step_o <= end_o)
+                    ):
+                        return type(self)(start_r, end_r + step_o, step_o)
 
         return super()._union(other, sort=sort)
 
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 0249bf51f71b7..12a8f2c0d5a9d 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -47,8 +47,9 @@
 )
 class TimedeltaIndex(DatetimeTimedeltaMixin):
     """
-    Immutable ndarray of timedelta64 data, represented internally as int64, and
-    which can be boxed to timedelta objects.
+    Immutable Index of timedelta64 data.
+
+    Represented internally as int64, and scalars returned Timedelta objects.
 
     Parameters
     ----------
@@ -101,7 +102,10 @@ class TimedeltaIndex(DatetimeTimedeltaMixin):
     _typ = "timedeltaindex"
 
     _data_cls = TimedeltaArray
-    _engine_type = libindex.TimedeltaEngine
+
+    @property
+    def _engine_type(self) -> type[libindex.TimedeltaEngine]:
+        return libindex.TimedeltaEngine
 
     _data: TimedeltaArray
 
@@ -132,6 +136,7 @@ def __new__(
                 "represent unambiguous timedelta values durations."
             )
 
+        # FIXME: need to check for dtype/data match
         if isinstance(data, TimedeltaArray) and freq is lib.no_default:
             if copy:
                 data = data.copy()
@@ -205,8 +210,7 @@ def timedelta_range(
     closed=None,
 ) -> TimedeltaIndex:
     """
-    Return a fixed frequency TimedeltaIndex, with day as the default
-    frequency.
+    Return a fixed frequency TimedeltaIndex with day as the default.
 
     Parameters
     ----------
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 0ac44ba53ae05..dd06d9bee4428 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -4,6 +4,10 @@
 from typing import (
     TYPE_CHECKING,
     Hashable,
+    Sequence,
+    TypeVar,
+    cast,
+    final,
 )
 import warnings
 
@@ -13,14 +17,20 @@
 from pandas._libs.lib import item_from_zerodim
 from pandas.errors import (
     AbstractMethodError,
+    IndexingError,
     InvalidIndexError,
 )
 from pandas.util._decorators import doc
 from pandas.util._exceptions import find_stack_level
 
+from pandas.core.dtypes.cast import (
+    can_hold_element,
+    maybe_promote,
+)
 from pandas.core.dtypes.common import (
     is_array_like,
     is_bool_dtype,
+    is_extension_array_dtype,
     is_hashable,
     is_integer,
     is_iterator,
@@ -37,7 +47,9 @@
 )
 from pandas.core.dtypes.missing import (
     infer_fill_value,
+    is_valid_na_for_dtype,
     isna,
+    na_value_for_dtype,
 )
 
 from pandas.core import algorithms as algos
@@ -49,8 +61,8 @@
 from pandas.core.indexers import (
     check_array_indexer,
     is_empty_indexer,
-    is_exact_shape_match,
     is_list_like_indexer,
+    is_scalar_indexer,
     length_of_indexer,
 )
 from pandas.core.indexes.api import (
@@ -64,6 +76,8 @@
         Series,
     )
 
+_LocationIndexerT = TypeVar("_LocationIndexerT", bound="_LocationIndexer")
+
 # "null slice"
 _NS = slice(None, None)
 _one_ellipsis_message = "indexer may only contain one '...' entry"
@@ -117,10 +131,6 @@ def __getitem__(self, arg):
 IndexSlice = _IndexSlice()
 
 
-class IndexingError(Exception):
-    pass
-
-
 class IndexingMixin:
     """
     Mixin for adding .loc/.iloc/.at/.iat to Dataframes and Series.
@@ -145,6 +155,8 @@ def iloc(self) -> _iLocIndexer:
           DataFrame) and that returns valid output for indexing (one of the above).
           This is useful in method chains, when you don't have a reference to the
           calling object, but would like to base your selection on some value.
+        - A tuple of row and column indexes. The tuple elements consist of one of the
+          above inputs, e.g. ``(0, 1)``.
 
         ``.iloc`` will raise ``IndexError`` if a requested indexer is
         out-of-bounds, except *slice* indexers which allow out-of-bounds
@@ -520,6 +532,9 @@ def loc(self) -> _LocIndexer:
         sidewinder mark i          10      20
                    mark ii          1       4
         viper      mark ii          7       1
+
+        Please see the :ref:`user guide<advanced.advanced_hierarchical>`
+        for more details and explanations of advanced indexing.
         """
         return _LocIndexer("loc", self)
 
@@ -535,14 +550,30 @@ def at(self) -> _AtIndexer:
         Raises
         ------
         KeyError
-            If 'label' does not exist in DataFrame.
+            * If getting a value and 'label' does not exist in a DataFrame or
+                Series.
+        ValueError
+            * If row/column label pair is not a tuple or if any label from
+                the pair is not a scalar for DataFrame.
+            * If label is list-like (*excluding* NamedTuple) for Series.
 
         See Also
         --------
+        DataFrame.at : Access a single value for a row/column pair by label.
         DataFrame.iat : Access a single value for a row/column pair by integer
             position.
         DataFrame.loc : Access a group of rows and columns by label(s).
-        Series.at : Access a single value using a label.
+        DataFrame.iloc : Access a group of rows and columns by integer
+            position(s).
+        Series.at : Access a single value by label.
+        Series.iat : Access a single value by integer position.
+        Series.loc : Access a group of rows by label(s).
+        Series.iloc : Access a group of rows by integer position(s).
+
+        Notes
+        -----
+        See :ref:`Fast scalar value getting and setting <indexing.basics.get_value>`
+        for more details.
 
         Examples
         --------
@@ -623,9 +654,13 @@ def iat(self) -> _iAtIndexer:
 
 class _LocationIndexer(NDFrameIndexerBase):
     _valid_types: str
-    axis = None
+    axis: int | None = None
 
-    def __call__(self, axis=None):
+    # sub-classes need to set _takeable
+    _takeable: bool
+
+    @final
+    def __call__(self: _LocationIndexerT, axis=None) -> _LocationIndexerT:
         # we need to return a copy of ourselves
         new_self = type(self)(self.name, self.obj)
 
@@ -639,6 +674,7 @@ def _get_setitem_indexer(self, key):
         Convert a potentially-label-based key into a positional indexer.
         """
         if self.name == "loc":
+            # always holds here bc iloc overrides _get_setitem_indexer
             self._ensure_listlike_indexer(key)
 
         if isinstance(key, tuple):
@@ -646,7 +682,7 @@ def _get_setitem_indexer(self, key):
                 check_deprecated_indexers(x)
 
         if self.axis is not None:
-            return self._convert_tuple(key)
+            key = _tupleize_axis_indexer(self.ndim, self.axis, key)
 
         ax = self.obj._get_axis(0)
 
@@ -657,13 +693,81 @@ def _get_setitem_indexer(self, key):
 
         if isinstance(key, tuple):
             with suppress(IndexingError):
+                # suppress "Too many indexers"
                 return self._convert_tuple(key)
 
         if isinstance(key, range):
-            return list(key)
+            # GH#45479 test_loc_setitem_range_key
+            key = list(key)
 
         return self._convert_to_indexer(key, axis=0)
 
+    @final
+    def _maybe_mask_setitem_value(self, indexer, value):
+        """
+        If we have obj.iloc[mask] = series_or_frame and series_or_frame has the
+        same length as obj, we treat this as obj.iloc[mask] = series_or_frame[mask],
+        similar to Series.__setitem__.
+
+        Note this is only for loc, not iloc.
+        """
+
+        if (
+            isinstance(indexer, tuple)
+            and len(indexer) == 2
+            and isinstance(value, (ABCSeries, ABCDataFrame))
+        ):
+            pi, icols = indexer
+            ndim = value.ndim
+            if com.is_bool_indexer(pi) and len(value) == len(pi):
+                newkey = pi.nonzero()[0]
+
+                if is_scalar_indexer(icols, self.ndim - 1) and ndim == 1:
+                    # e.g. test_loc_setitem_boolean_mask_allfalse
+                    if len(newkey) == 0:
+                        # FIXME: kludge for test_loc_setitem_boolean_mask_allfalse
+                        # TODO(GH#45333): may be fixed when deprecation is enforced
+
+                        value = value.iloc[:0]
+                    else:
+                        # test_loc_setitem_ndframe_values_alignment
+                        value = self.obj.iloc._align_series(indexer, value)
+                    indexer = (newkey, icols)
+
+                elif (
+                    isinstance(icols, np.ndarray)
+                    and icols.dtype.kind == "i"
+                    and len(icols) == 1
+                ):
+                    if ndim == 1:
+                        # We implicitly broadcast, though numpy does not, see
+                        # github.com/pandas-dev/pandas/pull/45501#discussion_r789071825
+                        if len(newkey) == 0:
+                            # FIXME: kludge for
+                            #  test_setitem_loc_only_false_indexer_dtype_changed
+                            #  TODO(GH#45333): may be fixed when deprecation is enforced
+                            value = value.iloc[:0]
+                        else:
+                            # test_loc_setitem_ndframe_values_alignment
+                            value = self.obj.iloc._align_series(indexer, value)
+                        indexer = (newkey, icols)
+
+                    elif ndim == 2 and value.shape[1] == 1:
+                        if len(newkey) == 0:
+                            # FIXME: kludge for
+                            #  test_loc_setitem_all_false_boolean_two_blocks
+                            #  TODO(GH#45333): may be fixed when deprecation is enforced
+                            value = value.iloc[:0]
+                        else:
+                            # test_loc_setitem_ndframe_values_alignment
+                            value = self.obj.iloc._align_frame(indexer, value)
+                        indexer = (newkey, icols)
+        elif com.is_bool_indexer(indexer):
+            indexer = indexer.nonzero()[0]
+
+        return indexer, value
+
+    @final
     def _ensure_listlike_indexer(self, key, axis=None, value=None):
         """
         Ensure that a list-like of column labels are all present by adding them if
@@ -697,11 +801,10 @@ def _ensure_listlike_indexer(self, key, axis=None, value=None):
             # GH#38148
             keys = self.obj.columns.union(key, sort=False)
 
-            self.obj._mgr = self.obj._mgr.reindex_axis(
-                keys, axis=0, consolidate=False, only_slice=True
-            )
+            self.obj._mgr = self.obj._mgr.reindex_axis(keys, axis=0, only_slice=True)
 
-    def __setitem__(self, key, value):
+    @final
+    def __setitem__(self, key, value) -> None:
         check_deprecated_indexers(key)
         if isinstance(key, tuple):
             key = tuple(list(x) if is_iterator(x) else x for x in key)
@@ -736,6 +839,7 @@ def _validate_key(self, key, axis: int):
         """
         raise AbstractMethodError(self)
 
+    @final
     def _expand_ellipsis(self, tup: tuple) -> tuple:
         """
         If a tuple key includes an Ellipsis, replace it with an appropriate
@@ -757,6 +861,7 @@ def _expand_ellipsis(self, tup: tuple) -> tuple:
             #  by _validate_key_length
         return tup
 
+    @final
     def _validate_tuple_indexer(self, key: tuple) -> tuple:
         """
         Check the key for valid keys across my indexer.
@@ -773,6 +878,7 @@ def _validate_tuple_indexer(self, key: tuple) -> tuple:
                 ) from err
         return key
 
+    @final
     def _is_nested_tuple_indexer(self, tup: tuple) -> bool:
         """
         Returns
@@ -783,23 +889,14 @@ def _is_nested_tuple_indexer(self, tup: tuple) -> bool:
             return any(is_nested_tuple(tup, ax) for ax in self.obj.axes)
         return False
 
-    def _convert_tuple(self, key):
-        keyidx = []
-        if self.axis is not None:
-            axis = self.obj._get_axis_number(self.axis)
-            for i in range(self.ndim):
-                if i == axis:
-                    keyidx.append(self._convert_to_indexer(key, axis=axis))
-                else:
-                    keyidx.append(slice(None))
-        else:
-            self._validate_key_length(key)
-            for i, k in enumerate(key):
-                idx = self._convert_to_indexer(k, axis=i)
-                keyidx.append(idx)
-
+    @final
+    def _convert_tuple(self, key: tuple) -> tuple:
+        # Note: we assume _tupleize_axis_indexer has been called, if necessary.
+        self._validate_key_length(key)
+        keyidx = [self._convert_to_indexer(k, axis=i) for i, k in enumerate(key)]
         return tuple(keyidx)
 
+    @final
     def _validate_key_length(self, key: tuple) -> tuple:
         if len(key) > self.ndim:
             if key[0] is Ellipsis:
@@ -811,6 +908,7 @@ def _validate_key_length(self, key: tuple) -> tuple:
             raise IndexingError("Too many indexers")
         return key
 
+    @final
     def _getitem_tuple_same_dim(self, tup: tuple):
         """
         Index with indexers that should return an object of the same dimension
@@ -830,6 +928,7 @@ def _getitem_tuple_same_dim(self, tup: tuple):
 
         return retval
 
+    @final
     def _getitem_lowerdim(self, tup: tuple):
 
         # we can directly get the axis result since the axis is specified
@@ -855,7 +954,9 @@ def _getitem_lowerdim(self, tup: tuple):
             #  is equivalent.
             #  (see the other place where we call _handle_lowerdim_multi_index_axis0)
             with suppress(IndexingError):
-                return self._handle_lowerdim_multi_index_axis0(tup)
+                # error "_LocationIndexer" has no attribute
+                # "_handle_lowerdim_multi_index_axis0"
+                return cast(_LocIndexer, self)._handle_lowerdim_multi_index_axis0(tup)
 
         tup = self._validate_key_length(tup)
 
@@ -891,6 +992,7 @@ def _getitem_lowerdim(self, tup: tuple):
 
         raise IndexingError("not applicable")
 
+    @final
     def _getitem_nested_tuple(self, tup: tuple):
         # we have a nested tuple so have at least 1 multi-index level
         # we should be able to match up the dimensionality here
@@ -910,7 +1012,11 @@ def _getitem_nested_tuple(self, tup: tuple):
                 #  DataFrame, IndexingError is not raised when slice(None,None,None)
                 #  with one row.
                 with suppress(IndexingError):
-                    return self._handle_lowerdim_multi_index_axis0(tup)
+                    # error "_LocationIndexer" has no attribute
+                    # "_handle_lowerdim_multi_index_axis0"
+                    return cast(_LocIndexer, self)._handle_lowerdim_multi_index_axis0(
+                        tup
+                    )
             elif isinstance(self.obj, ABCSeries) and any(
                 isinstance(k, tuple) for k in tup
             ):
@@ -919,7 +1025,7 @@ def _getitem_nested_tuple(self, tup: tuple):
                 #  we are only getting non-hashable tuples, in particular ones
                 #  that themselves contain a slice entry
                 # See test_loc_series_getitem_too_many_dimensions
-                raise ValueError("Too many indices")
+                raise IndexingError("Too many indexers")
 
             # this is a series with a multi-index specified a tuple of
             # selectors
@@ -950,6 +1056,7 @@ def _getitem_nested_tuple(self, tup: tuple):
     def _convert_to_indexer(self, key, axis: int):
         raise AbstractMethodError(self)
 
+    @final
     def __getitem__(self, key):
         check_deprecated_indexers(key)
         if type(key) is tuple:
@@ -977,6 +1084,7 @@ def _getitem_axis(self, key, axis: int):
     def _has_valid_setitem_indexer(self, indexer) -> bool:
         raise AbstractMethodError(self)
 
+    @final
     def _getbool_axis(self, key, axis: int):
         # caller is responsible for ensuring non-None axis
         labels = self.obj._get_axis(axis)
@@ -1148,7 +1256,7 @@ def _getitem_tuple(self, tup: tuple):
         return self._getitem_tuple_same_dim(tup)
 
     def _get_label(self, label, axis: int):
-        # GH#5667 this will fail if the label is not present in the axis.
+        # GH#5567 this will fail if the label is not present in the axis.
         return self.obj.xs(label, axis=axis)
 
     def _handle_lowerdim_multi_index_axis0(self, tup: tuple):
@@ -1174,6 +1282,9 @@ def _getitem_axis(self, key, axis: int):
 
         labels = self.obj._get_axis(axis)
 
+        if isinstance(key, tuple) and isinstance(labels, MultiIndex):
+            key = tuple(key)
+
         if isinstance(key, slice):
             self._validate_key(key, axis)
             return self._get_slice_axis(key, axis=axis)
@@ -1239,9 +1350,13 @@ def _convert_to_indexer(self, key, axis: int):
         if isinstance(key, slice):
             return labels._convert_slice_indexer(key, kind="loc")
 
-        # see if we are positional in nature
-        is_int_index = labels.is_integer()
-        is_int_positional = is_integer(key) and not is_int_index
+        if (
+            isinstance(key, tuple)
+            and not isinstance(labels, MultiIndex)
+            and self.ndim < 2
+            and len(key) > 1
+        ):
+            raise IndexingError("Too many indexers")
 
         if is_scalar(key) or (isinstance(labels, MultiIndex) and is_hashable(key)):
             # Otherwise get_loc will raise InvalidIndexError
@@ -1259,22 +1374,14 @@ def _convert_to_indexer(self, key, axis: int):
                 if not isinstance(labels, MultiIndex):
                     raise
             except ValueError:
-                if not is_int_positional:
+                if not is_integer(key):
                     raise
-
-        # a positional
-        if is_int_positional:
-
-            # if we are setting and its not a valid location
-            # its an insert which fails by definition
-
-            # always valid
-            return {"key": key}
+                return {"key": key}
 
         if is_nested_tuple(key, labels):
             if self.ndim == 1 and any(isinstance(k, tuple) for k in key):
                 # GH#35349 Raise if tuple in tuple for series
-                raise ValueError("Too many indices")
+                raise IndexingError("Too many indexers")
             return labels.get_locs(key)
 
         elif is_list_like_indexer(key):
@@ -1284,8 +1391,7 @@ def _convert_to_indexer(self, key, axis: int):
 
             if com.is_bool_indexer(key):
                 key = check_bool_indexer(labels, key)
-                (inds,) = key.nonzero()
-                return inds
+                return key
             else:
                 return self._get_listlike_indexer(key, axis)[1]
         else:
@@ -1543,7 +1649,7 @@ def _get_setitem_indexer(self, key):
             key = list(key)
 
         if self.axis is not None:
-            return self._convert_tuple(key)
+            key = _tupleize_axis_indexer(self.ndim, self.axis, key)
 
         return key
 
@@ -1568,15 +1674,13 @@ def _setitem_with_indexer(self, indexer, value, name="iloc"):
 
         # if there is only one block/type, still have to take split path
         # unless the block is one-dimensional or it can hold the value
-        if (
-            not take_split_path
-            and getattr(self.obj._mgr, "blocks", False)
-            and self.ndim > 1
-        ):
+        if not take_split_path and len(self.obj._mgr.arrays) and self.ndim > 1:
             # in case of dict, keys are indices
             val = list(value.values()) if isinstance(value, dict) else value
-            blk = self.obj._mgr.blocks[0]
-            take_split_path = not blk._can_hold_element(val)
+            arr = self.obj._mgr.arrays[0]
+            take_split_path = not can_hold_element(
+                arr, extract_array(val, extract_numpy=True)
+            )
 
         # if we have any multi-indexes that have non-trivial slices
         # (not null slices) then we must take the split path, xref
@@ -1681,6 +1785,10 @@ def _setitem_with_indexer(self, indexer, value, name="iloc"):
                 self._setitem_with_indexer_missing(indexer, value)
                 return
 
+        if name == "loc":
+            # must come after setting of missing
+            indexer, value = self._maybe_mask_setitem_value(indexer, value)
+
         # align and set the values
         if take_split_path:
             # We have to operate column-wise
@@ -1748,8 +1856,10 @@ def _setitem_with_indexer_split_path(self, indexer, value, name: str):
                 # We get here in one case via .loc with a all-False mask
                 pass
 
-            elif self._is_scalar_access(indexer):
-                # We are setting nested data
+            elif self._is_scalar_access(indexer) and is_object_dtype(
+                self.obj.dtypes[ilocs[0]]
+            ):
+                # We are setting nested data, only possible for object dtype data
                 self._setitem_single_column(indexer[1], value, pi)
 
             elif len(ilocs) == len(value):
@@ -1856,7 +1966,7 @@ def _setitem_single_column(self, loc: int, value, plane_indexer):
         """
         pi = plane_indexer
 
-        ser = self.obj._ixs(loc, axis=1)
+        orig_values = self.obj._get_column_array(loc)
 
         # perform the equivalent of a setitem on the info axis
         # as we have a null slice or a slice with full bounds
@@ -1864,34 +1974,64 @@ def _setitem_single_column(self, loc: int, value, plane_indexer):
         # multi-dim object
         # GH#6149 (null slice), GH#10408 (full bounds)
         if com.is_null_slice(pi) or com.is_full_slice(pi, len(self.obj)):
-            ser = value
+            pass
         elif (
             is_array_like(value)
-            and is_exact_shape_match(ser, value)
-            and not is_empty_indexer(pi, value)
+            and len(value.shape) > 0
+            and self.obj.shape[0] == value.shape[0]
+            and not is_empty_indexer(pi)
         ):
-            if is_list_like(pi):
-                ser = value[np.argsort(pi)]
+            if is_list_like(pi) and not is_bool_dtype(pi):
+                value = value[np.argsort(pi)]
             else:
                 # in case of slice
-                ser = value[pi]
+                value = value[pi]
         else:
-            # set the item, first attempting to operate inplace, then
-            #  falling back to casting if necessary; see
-            #  _whatsnew_130.notable_bug_fixes.setitem_column_try_inplace
+            # set value into the column (first attempting to operate inplace, then
+            #  falling back to casting if necessary)
+            self.obj._mgr.column_setitem(loc, plane_indexer, value)
+            self.obj._clear_item_cache()
+            return
 
-            orig_values = ser._values
-            ser._mgr = ser._mgr.setitem((pi,), value)
+        self.obj._iset_item(loc, value)
 
-            if ser._values is orig_values:
-                # The setitem happened inplace, so the DataFrame's values
-                #  were modified inplace.
-                return
-            self.obj._iset_item(loc, ser)
-            return
+        # We will not operate in-place, but will attempt to in the future.
+        #  To determine whether we need to issue a FutureWarning, see if the
+        #  setting in-place would work, i.e. behavior will change.
+
+        new_values = self.obj._get_column_array(loc)
 
-        # reset the sliced object if unique
-        self.obj._iset_item(loc, ser)
+        if can_hold_element(orig_values, new_values) and not len(new_values) == 0:
+            # Don't issue the warning yet, as we can still trim a few cases where
+            #  behavior will not change.
+
+            if (
+                isinstance(new_values, np.ndarray)
+                and isinstance(orig_values, np.ndarray)
+                and (
+                    np.shares_memory(new_values, orig_values)
+                    or new_values.shape != orig_values.shape
+                )
+            ):
+                # TODO: get something like tm.shares_memory working?
+                # The values were set inplace after all, no need to warn,
+                #  e.g. test_rename_nocopy
+                # In case of enlarging we can not set inplace, so need to
+                # warn either
+                pass
+            else:
+                warnings.warn(
+                    "In a future version, `df.iloc[:, i] = newvals` will attempt "
+                    "to set the values inplace instead of always setting a new "
+                    "array. To retain the old behavior, use either "
+                    "`df[df.columns[i]] = newvals` or, if columns are non-unique, "
+                    "`df.isetitem(i, newvals)`",
+                    DeprecationWarning,
+                    stacklevel=find_stack_level(),
+                )
+                # TODO: how to get future behavior?
+                # TODO: what if we got here indirectly via loc?
+        return
 
     def _setitem_single_block(self, indexer, value, name: str):
         """
@@ -1901,7 +2041,6 @@ def _setitem_single_block(self, indexer, value, name: str):
 
         info_axis = self.obj._info_axis_number
         item_labels = self.obj._get_axis(info_axis)
-
         if isinstance(indexer, tuple):
 
             # if we are setting on the info axis ONLY
@@ -1916,7 +2055,9 @@ def _setitem_single_block(self, indexer, value, name: str):
                 if len(item_labels.get_indexer_for([col])) == 1:
                     # e.g. test_loc_setitem_empty_append_expands_rows
                     loc = item_labels.get_loc(col)
-                    self.obj._iset_item(loc, value)
+                    # Go through _setitem_single_column to get
+                    #  FutureWarning if relevant.
+                    self._setitem_single_column(loc, value, indexer[0])
                     return
 
             indexer = maybe_convert_ix(*indexer)  # e.g. test_setitem_frame_align
@@ -1963,8 +2104,30 @@ def _setitem_with_indexer_missing(self, indexer, value):
                     # We get only here with loc, so can hard code
                     return self._setitem_with_indexer(new_indexer, value, "loc")
 
-            # this preserves dtype of the value
-            new_values = Series([value])._values
+            # this preserves dtype of the value and of the object
+            if not is_scalar(value):
+                new_dtype = None
+
+            elif is_valid_na_for_dtype(value, self.obj.dtype):
+                if not is_object_dtype(self.obj.dtype):
+                    # Every NA value is suitable for object, no conversion needed
+                    value = na_value_for_dtype(self.obj.dtype, compat=False)
+
+                new_dtype = maybe_promote(self.obj.dtype, value)[0]
+
+            elif isna(value):
+                new_dtype = None
+            elif not self.obj.empty and not is_object_dtype(self.obj.dtype):
+                # We should not cast, if we have object dtype because we can
+                # set timedeltas into object series
+                curr_dtype = self.obj.dtype
+                curr_dtype = getattr(curr_dtype, "numpy_dtype", curr_dtype)
+                new_dtype = maybe_promote(curr_dtype, value)[0]
+            else:
+                new_dtype = None
+
+            new_values = Series([value], dtype=new_dtype)._values
+
             if len(self.obj._values):
                 # GH#22717 handle casting compatibility that np.concatenate
                 #  does incorrectly
@@ -2002,7 +2165,14 @@ def _setitem_with_indexer_missing(self, indexer, value):
                 # We will ignore the existing dtypes instead of using
                 #  internals.concat logic
                 df = value.to_frame().T
-                df.index = [indexer]
+
+                idx = self.obj.index
+                if isinstance(idx, MultiIndex):
+                    name = idx.names
+                else:
+                    name = idx.name
+
+                df.index = Index([indexer], name=name)
                 if not has_dtype:
                     # i.e. if we already had a Series or ndarray, keep that
                     #  dtype.  But if we had a list or dict, then do inference
@@ -2016,6 +2186,7 @@ def _ensure_iterable_column_indexer(self, column_indexer):
         """
         Ensure that our column indexer is something that can be iterated over.
         """
+        ilocs: Sequence[int] | np.ndarray
         if is_integer(column_indexer):
             ilocs = [column_indexer]
         elif isinstance(column_indexer, slice):
@@ -2074,16 +2245,19 @@ def ravel(i):
             # we have a frame, with multiple indexers on both axes; and a
             # series, so need to broadcast (see GH5206)
             if sum_aligners == self.ndim and all(is_sequence(_) for _ in indexer):
-                if is_empty_indexer(indexer[0], ser._values):
+                # TODO: This is hacky, align Series and DataFrame behavior GH#45778
+                if obj.ndim == 2 and is_empty_indexer(indexer[0]):
                     return ser._values.copy()
-                ser = ser.reindex(obj.axes[0][indexer[0]], copy=True)._values
+                ser_values = ser.reindex(obj.axes[0][indexer[0]], copy=True)._values
 
                 # single indexer
                 if len(indexer) > 1 and not multiindex_indexer:
                     len_indexer = len(indexer[1])
-                    ser = np.tile(ser, len_indexer).reshape(len_indexer, -1).T
+                    ser_values = (
+                        np.tile(ser_values, len_indexer).reshape(len_indexer, -1).T
+                    )
 
-                return ser
+                return ser_values
 
             for i, idx in enumerate(indexer):
                 ax = obj.axes[i]
@@ -2189,6 +2363,9 @@ class _ScalarAccessIndexer(NDFrameIndexerBase):
     Access scalars quickly.
     """
 
+    # sub-classes need to set _takeable
+    _takeable: bool
+
     def _convert_key(self, key):
         raise AbstractMethodError(self)
 
@@ -2204,7 +2381,7 @@ def __getitem__(self, key):
         key = self._convert_key(key)
         return self.obj._get_value(*key, takeable=self._takeable)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         if isinstance(key, tuple):
             key = tuple(com.apply_if_callable(x, self.obj) for x in key)
         else:
@@ -2299,6 +2476,15 @@ def _tuplify(ndim: int, loc: Hashable) -> tuple[Hashable | slice, ...]:
     return tuple(_tup)
 
 
+def _tupleize_axis_indexer(ndim: int, axis: int, key) -> tuple:
+    """
+    If we have an axis, adapt the given key to be axis-independent.
+    """
+    new_key = [slice(None)] * ndim
+    new_key[axis] = key
+    return tuple(new_key)
+
+
 def convert_to_index_sliceable(obj: DataFrame, key):
     """
     If we are index sliceable, then return my slicer, otherwise return None.
@@ -2361,15 +2547,20 @@ def check_bool_indexer(index: Index, key) -> np.ndarray:
     """
     result = key
     if isinstance(key, ABCSeries) and not key.index.equals(index):
-        result = result.reindex(index)
-        mask = isna(result._values)
-        if mask.any():
+        indexer = result.index.get_indexer_for(index)
+        if -1 in indexer:
             raise IndexingError(
                 "Unalignable boolean Series provided as "
                 "indexer (index of the boolean Series and of "
                 "the indexed object do not match)."
             )
-        return result.astype(bool)._values
+
+        result = result.take(indexer)
+
+        # fall through for boolean
+        if not is_extension_array_dtype(result.dtype):
+            return result.astype(bool)._values
+
     if is_object_dtype(key):
         # key might be object-dtype bool, check_array_indexer needs bool array
         result = np.asarray(result, dtype=bool)
diff --git a/pandas/core/interchange/__init__.py b/pandas/core/interchange/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/core/interchange/buffer.py b/pandas/core/interchange/buffer.py
new file mode 100644
index 0000000000000..0f62dd00a0f41
--- /dev/null
+++ b/pandas/core/interchange/buffer.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import numpy as np
+
+from pandas.core.interchange.dataframe_protocol import (
+    Buffer,
+    DlpackDeviceType,
+)
+from pandas.util.version import Version
+
+_NUMPY_HAS_DLPACK = Version(np.__version__) >= Version("1.22.0")
+
+
+class PandasBuffer(Buffer):
+    """
+    Data in the buffer is guaranteed to be contiguous in memory.
+    """
+
+    def __init__(self, x: np.ndarray, allow_copy: bool = True) -> None:
+        """
+        Handle only regular columns (= numpy arrays) for now.
+        """
+        if not x.strides == (x.dtype.itemsize,):
+            # The protocol does not support strided buffers, so a copy is
+            # necessary. If that's not allowed, we need to raise an exception.
+            if allow_copy:
+                x = x.copy()
+            else:
+                raise RuntimeError(
+                    "Exports cannot be zero-copy in the case "
+                    "of a non-contiguous buffer"
+                )
+
+        # Store the numpy array in which the data resides as a private
+        # attribute, so we can use it to retrieve the public attributes
+        self._x = x
+
+    @property
+    def bufsize(self) -> int:
+        """
+        Buffer size in bytes.
+        """
+        return self._x.size * self._x.dtype.itemsize
+
+    @property
+    def ptr(self) -> int:
+        """
+        Pointer to start of the buffer as an integer.
+        """
+        return self._x.__array_interface__["data"][0]
+
+    def __dlpack__(self):
+        """
+        Represent this structure as DLPack interface.
+        """
+        if _NUMPY_HAS_DLPACK:
+            return self._x.__dlpack__()
+        raise NotImplementedError("__dlpack__")
+
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+        """
+        Device type and device ID for where the data in the buffer resides.
+        """
+        return (DlpackDeviceType.CPU, None)
+
+    def __repr__(self) -> str:
+        return (
+            "PandasBuffer("
+            + str(
+                {
+                    "bufsize": self.bufsize,
+                    "ptr": self.ptr,
+                    "device": self.__dlpack_device__()[0].name,
+                }
+            )
+            + ")"
+        )
diff --git a/pandas/core/interchange/column.py b/pandas/core/interchange/column.py
new file mode 100644
index 0000000000000..359e2fa0b7ab2
--- /dev/null
+++ b/pandas/core/interchange/column.py
@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from pandas._libs.lib import infer_dtype
+from pandas._libs.tslibs import iNaT
+from pandas.util._decorators import cache_readonly
+
+import pandas as pd
+from pandas.api.types import (
+    is_categorical_dtype,
+    is_string_dtype,
+)
+from pandas.core.interchange.buffer import PandasBuffer
+from pandas.core.interchange.dataframe_protocol import (
+    Column,
+    ColumnBuffers,
+    ColumnNullType,
+    DtypeKind,
+)
+from pandas.core.interchange.utils import (
+    ArrowCTypes,
+    Endianness,
+    NoBufferPresent,
+    dtype_to_arrow_c_fmt,
+)
+
+_NP_KINDS = {
+    "i": DtypeKind.INT,
+    "u": DtypeKind.UINT,
+    "f": DtypeKind.FLOAT,
+    "b": DtypeKind.BOOL,
+    "U": DtypeKind.STRING,
+    "M": DtypeKind.DATETIME,
+    "m": DtypeKind.DATETIME,
+}
+
+_NULL_DESCRIPTION = {
+    DtypeKind.FLOAT: (ColumnNullType.USE_NAN, None),
+    DtypeKind.DATETIME: (ColumnNullType.USE_SENTINEL, iNaT),
+    DtypeKind.INT: (ColumnNullType.NON_NULLABLE, None),
+    DtypeKind.UINT: (ColumnNullType.NON_NULLABLE, None),
+    DtypeKind.BOOL: (ColumnNullType.NON_NULLABLE, None),
+    # Null values for categoricals are stored as `-1` sentinel values
+    # in the category date (e.g., `col.values.codes` is int8 np.ndarray)
+    DtypeKind.CATEGORICAL: (ColumnNullType.USE_SENTINEL, -1),
+    # follow Arrow in using 1 as valid value and 0 for missing/null value
+    DtypeKind.STRING: (ColumnNullType.USE_BYTEMASK, 0),
+}
+
+_NO_VALIDITY_BUFFER = {
+    ColumnNullType.NON_NULLABLE: "This column is non-nullable",
+    ColumnNullType.USE_NAN: "This column uses NaN as null",
+    ColumnNullType.USE_SENTINEL: "This column uses a sentinel value",
+}
+
+
+class PandasColumn(Column):
+    """
+    A column object, with only the methods and properties required by the
+    interchange protocol defined.
+    A column can contain one or more chunks. Each chunk can contain up to three
+    buffers - a data buffer, a mask buffer (depending on null representation),
+    and an offsets buffer (if variable-size binary; e.g., variable-length
+    strings).
+    Note: this Column object can only be produced by ``__dataframe__``, so
+          doesn't need its own version or ``__column__`` protocol.
+    """
+
+    def __init__(self, column: pd.Series, allow_copy: bool = True) -> None:
+        """
+        Note: doesn't deal with extension arrays yet, just assume a regular
+        Series/ndarray for now.
+        """
+        if not isinstance(column, pd.Series):
+            raise NotImplementedError(f"Columns of type {type(column)} not handled yet")
+
+        # Store the column as a private attribute
+        self._col = column
+        self._allow_copy = allow_copy
+
+    def size(self) -> int:
+        """
+        Size of the column, in elements.
+        """
+        return self._col.size
+
+    @property
+    def offset(self) -> int:
+        """
+        Offset of first element. Always zero.
+        """
+        # TODO: chunks are implemented now, probably this should return something
+        return 0
+
+    @cache_readonly
+    def dtype(self) -> tuple[DtypeKind, int, str, str]:
+        dtype = self._col.dtype
+
+        if is_categorical_dtype(dtype):
+            codes = self._col.values.codes
+            (
+                _,
+                bitwidth,
+                c_arrow_dtype_f_str,
+                _,
+            ) = self._dtype_from_pandasdtype(codes.dtype)
+            return (
+                DtypeKind.CATEGORICAL,
+                bitwidth,
+                c_arrow_dtype_f_str,
+                Endianness.NATIVE,
+            )
+        elif is_string_dtype(dtype):
+            if infer_dtype(self._col) == "string":
+                return (
+                    DtypeKind.STRING,
+                    8,
+                    dtype_to_arrow_c_fmt(dtype),
+                    Endianness.NATIVE,
+                )
+            raise NotImplementedError("Non-string object dtypes are not supported yet")
+        else:
+            return self._dtype_from_pandasdtype(dtype)
+
+    def _dtype_from_pandasdtype(self, dtype) -> tuple[DtypeKind, int, str, str]:
+        """
+        See `self.dtype` for details.
+        """
+        # Note: 'c' (complex) not handled yet (not in array spec v1).
+        #       'b', 'B' (bytes), 'S', 'a', (old-style string) 'V' (void) not handled
+        #       datetime and timedelta both map to datetime (is timedelta handled?)
+
+        kind = _NP_KINDS.get(dtype.kind, None)
+        if kind is None:
+            # Not a NumPy dtype. Check if it's a categorical maybe
+            raise ValueError(f"Data type {dtype} not supported by interchange protocol")
+
+        return kind, dtype.itemsize * 8, dtype_to_arrow_c_fmt(dtype), dtype.byteorder
+
+    @property
+    def describe_categorical(self):
+        """
+        If the dtype is categorical, there are two options:
+        - There are only values in the data buffer.
+        - There is a separate non-categorical Column encoding for categorical values.
+
+        Raises TypeError if the dtype is not categorical
+
+        Content of returned dict:
+            - "is_ordered" : bool, whether the ordering of dictionary indices is
+                             semantically meaningful.
+            - "is_dictionary" : bool, whether a dictionary-style mapping of
+                                categorical values to other objects exists
+            - "categories" : Column representing the (implicit) mapping of indices to
+                             category values (e.g. an array of cat1, cat2, ...).
+                             None if not a dictionary-style categorical.
+        """
+        if not self.dtype[0] == DtypeKind.CATEGORICAL:
+            raise TypeError(
+                "describe_categorical only works on a column with categorical dtype!"
+            )
+
+        return {
+            "is_ordered": self._col.cat.ordered,
+            "is_dictionary": True,
+            "categories": PandasColumn(pd.Series(self._col.cat.categories)),
+        }
+
+    @property
+    def describe_null(self):
+        kind = self.dtype[0]
+        try:
+            null, value = _NULL_DESCRIPTION[kind]
+        except KeyError:
+            raise NotImplementedError(f"Data type {kind} not yet supported")
+
+        return null, value
+
+    @cache_readonly
+    def null_count(self) -> int:
+        """
+        Number of null elements. Should always be known.
+        """
+        return self._col.isna().sum().item()
+
+    @property
+    def metadata(self) -> dict[str, pd.Index]:
+        """
+        Store specific metadata of the column.
+        """
+        return {"pandas.index": self._col.index}
+
+    def num_chunks(self) -> int:
+        """
+        Return the number of chunks the column consists of.
+        """
+        return 1
+
+    def get_chunks(self, n_chunks: int | None = None):
+        """
+        Return an iterator yielding the chunks.
+        See `DataFrame.get_chunks` for details on ``n_chunks``.
+        """
+        if n_chunks and n_chunks > 1:
+            size = len(self._col)
+            step = size // n_chunks
+            if size % n_chunks != 0:
+                step += 1
+            for start in range(0, step * n_chunks, step):
+                yield PandasColumn(
+                    self._col.iloc[start : start + step], self._allow_copy
+                )
+        else:
+            yield self
+
+    def get_buffers(self) -> ColumnBuffers:
+        """
+        Return a dictionary containing the underlying buffers.
+        The returned dictionary has the following contents:
+            - "data": a two-element tuple whose first element is a buffer
+                      containing the data and whose second element is the data
+                      buffer's associated dtype.
+            - "validity": a two-element tuple whose first element is a buffer
+                          containing mask values indicating missing data and
+                          whose second element is the mask value buffer's
+                          associated dtype. None if the null representation is
+                          not a bit or byte mask.
+            - "offsets": a two-element tuple whose first element is a buffer
+                         containing the offset values for variable-size binary
+                         data (e.g., variable-length strings) and whose second
+                         element is the offsets buffer's associated dtype. None
+                         if the data buffer does not have an associated offsets
+                         buffer.
+        """
+        buffers: ColumnBuffers = {
+            "data": self._get_data_buffer(),
+            "validity": None,
+            "offsets": None,
+        }
+
+        try:
+            buffers["validity"] = self._get_validity_buffer()
+        except NoBufferPresent:
+            pass
+
+        try:
+            buffers["offsets"] = self._get_offsets_buffer()
+        except NoBufferPresent:
+            pass
+
+        return buffers
+
+    def _get_data_buffer(
+        self,
+    ) -> tuple[PandasBuffer, Any]:  # Any is for self.dtype tuple
+        """
+        Return the buffer containing the data and the buffer's associated dtype.
+        """
+        if self.dtype[0] in (
+            DtypeKind.INT,
+            DtypeKind.UINT,
+            DtypeKind.FLOAT,
+            DtypeKind.BOOL,
+            DtypeKind.DATETIME,
+        ):
+            buffer = PandasBuffer(self._col.to_numpy(), allow_copy=self._allow_copy)
+            dtype = self.dtype
+        elif self.dtype[0] == DtypeKind.CATEGORICAL:
+            codes = self._col.values._codes
+            buffer = PandasBuffer(codes, allow_copy=self._allow_copy)
+            dtype = self._dtype_from_pandasdtype(codes.dtype)
+        elif self.dtype[0] == DtypeKind.STRING:
+            # Marshal the strings from a NumPy object array into a byte array
+            buf = self._col.to_numpy()
+            b = bytearray()
+
+            # TODO: this for-loop is slow; can be implemented in Cython/C/C++ later
+            for obj in buf:
+                if isinstance(obj, str):
+                    b.extend(obj.encode(encoding="utf-8"))
+
+            # Convert the byte array to a Pandas "buffer" using
+            # a NumPy array as the backing store
+            buffer = PandasBuffer(np.frombuffer(b, dtype="uint8"))
+
+            # Define the dtype for the returned buffer
+            dtype = (
+                DtypeKind.STRING,
+                8,
+                ArrowCTypes.STRING,
+                Endianness.NATIVE,
+            )  # note: currently only support native endianness
+        else:
+            raise NotImplementedError(f"Data type {self._col.dtype} not handled yet")
+
+        return buffer, dtype
+
+    def _get_validity_buffer(self) -> tuple[PandasBuffer, Any]:
+        """
+        Return the buffer containing the mask values indicating missing data and
+        the buffer's associated dtype.
+        Raises NoBufferPresent if null representation is not a bit or byte mask.
+        """
+        null, invalid = self.describe_null
+
+        if self.dtype[0] == DtypeKind.STRING:
+            # For now, use byte array as the mask.
+            # TODO: maybe store as bit array to save space?..
+            buf = self._col.to_numpy()
+
+            # Determine the encoding for valid values
+            valid = invalid == 0
+            invalid = not valid
+
+            mask = np.zeros(shape=(len(buf),), dtype=np.bool_)
+            for i, obj in enumerate(buf):
+                mask[i] = valid if isinstance(obj, str) else invalid
+
+            # Convert the mask array to a Pandas "buffer" using
+            # a NumPy array as the backing store
+            buffer = PandasBuffer(mask)
+
+            # Define the dtype of the returned buffer
+            dtype = (DtypeKind.BOOL, 8, ArrowCTypes.BOOL, Endianness.NATIVE)
+
+            return buffer, dtype
+
+        try:
+            msg = _NO_VALIDITY_BUFFER[null] + " so does not have a separate mask"
+        except KeyError:
+            # TODO: implement for other bit/byte masks?
+            raise NotImplementedError("See self.describe_null")
+
+        raise NoBufferPresent(msg)
+
+    def _get_offsets_buffer(self) -> tuple[PandasBuffer, Any]:
+        """
+        Return the buffer containing the offset values for variable-size binary
+        data (e.g., variable-length strings) and the buffer's associated dtype.
+        Raises NoBufferPresent if the data buffer does not have an associated
+        offsets buffer.
+        """
+        if self.dtype[0] == DtypeKind.STRING:
+            # For each string, we need to manually determine the next offset
+            values = self._col.to_numpy()
+            ptr = 0
+            offsets = np.zeros(shape=(len(values) + 1,), dtype=np.int64)
+            for i, v in enumerate(values):
+                # For missing values (in this case, `np.nan` values)
+                # we don't increment the pointer
+                if isinstance(v, str):
+                    b = v.encode(encoding="utf-8")
+                    ptr += len(b)
+
+                offsets[i + 1] = ptr
+
+            # Convert the offsets to a Pandas "buffer" using
+            # the NumPy array as the backing store
+            buffer = PandasBuffer(offsets)
+
+            # Assemble the buffer dtype info
+            dtype = (
+                DtypeKind.INT,
+                64,
+                ArrowCTypes.INT64,
+                Endianness.NATIVE,
+            )  # note: currently only support native endianness
+        else:
+            raise NoBufferPresent(
+                "This column has a fixed-length dtype so "
+                "it does not have an offsets buffer"
+            )
+
+        return buffer, dtype
diff --git a/pandas/core/interchange/dataframe.py b/pandas/core/interchange/dataframe.py
new file mode 100644
index 0000000000000..9139cb41e3af7
--- /dev/null
+++ b/pandas/core/interchange/dataframe.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections import abc
+from typing import TYPE_CHECKING
+
+from pandas.core.interchange.column import PandasColumn
+from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from pandas import Index
+
+
+class PandasDataFrameXchg(DataFrameXchg):
+    """
+    A data frame class, with only the methods required by the interchange
+    protocol defined.
+    Instances of this (private) class are returned from
+    ``pd.DataFrame.__dataframe__`` as objects with the methods and
+    attributes defined on this class.
+    """
+
+    def __init__(
+        self, df: pd.DataFrame, nan_as_null: bool = False, allow_copy: bool = True
+    ) -> None:
+        """
+        Constructor - an instance of this (private) class is returned from
+        `pd.DataFrame.__dataframe__`.
+        """
+        self._df = df
+        # ``nan_as_null`` is a keyword intended for the consumer to tell the
+        # producer to overwrite null values in the data with ``NaN`` (or ``NaT``).
+        # This currently has no effect; once support for nullable extension
+        # dtypes is added, this value should be propagated to columns.
+        self._nan_as_null = nan_as_null
+        self._allow_copy = allow_copy
+
+    def __dataframe__(
+        self, nan_as_null: bool = False, allow_copy: bool = True
+    ) -> PandasDataFrameXchg:
+        return PandasDataFrameXchg(self._df, nan_as_null, allow_copy)
+
+    @property
+    def metadata(self) -> dict[str, Index]:
+        # `index` isn't a regular column, and the protocol doesn't support row
+        # labels - so we export it as Pandas-specific metadata here.
+        return {"pandas.index": self._df.index}
+
+    def num_columns(self) -> int:
+        return len(self._df.columns)
+
+    def num_rows(self) -> int:
+        return len(self._df)
+
+    def num_chunks(self) -> int:
+        return 1
+
+    def column_names(self) -> Index:
+        return self._df.columns
+
+    def get_column(self, i: int) -> PandasColumn:
+        return PandasColumn(self._df.iloc[:, i], allow_copy=self._allow_copy)
+
+    def get_column_by_name(self, name: str) -> PandasColumn:
+        return PandasColumn(self._df[name], allow_copy=self._allow_copy)
+
+    def get_columns(self) -> list[PandasColumn]:
+        return [
+            PandasColumn(self._df[name], allow_copy=self._allow_copy)
+            for name in self._df.columns
+        ]
+
+    def select_columns(self, indices) -> PandasDataFrameXchg:
+        if not isinstance(indices, abc.Sequence):
+            raise ValueError("`indices` is not a sequence")
+        if not isinstance(indices, list):
+            indices = list(indices)
+
+        return PandasDataFrameXchg(
+            self._df.iloc[:, indices], self._nan_as_null, self._allow_copy
+        )
+
+    def select_columns_by_name(self, names) -> PandasDataFrameXchg:
+        if not isinstance(names, abc.Sequence):
+            raise ValueError("`names` is not a sequence")
+        if not isinstance(names, list):
+            names = list(names)
+
+        return PandasDataFrameXchg(
+            self._df.loc[:, names], self._nan_as_null, self._allow_copy
+        )
+
+    def get_chunks(self, n_chunks=None):
+        """
+        Return an iterator yielding the chunks.
+        """
+        if n_chunks and n_chunks > 1:
+            size = len(self._df)
+            step = size // n_chunks
+            if size % n_chunks != 0:
+                step += 1
+            for start in range(0, step * n_chunks, step):
+                yield PandasDataFrameXchg(
+                    self._df.iloc[start : start + step, :],
+                    self._nan_as_null,
+                    self._allow_copy,
+                )
+        else:
+            yield self
diff --git a/pandas/core/interchange/dataframe_protocol.py b/pandas/core/interchange/dataframe_protocol.py
new file mode 100644
index 0000000000000..2cfdee5517ece
--- /dev/null
+++ b/pandas/core/interchange/dataframe_protocol.py
@@ -0,0 +1,485 @@
+"""
+A verbatim copy (vendored) of the spec from https://github.com/data-apis/dataframe-api
+"""
+
+from __future__ import annotations
+
+from abc import (
+    ABC,
+    abstractmethod,
+)
+import enum
+from typing import (
+    Any,
+    Iterable,
+    Sequence,
+    TypedDict,
+)
+
+
+class DlpackDeviceType(enum.IntEnum):
+    """Integer enum for device type codes matching DLPack."""
+
+    CPU = 1
+    CUDA = 2
+    CPU_PINNED = 3
+    OPENCL = 4
+    VULKAN = 7
+    METAL = 8
+    VPI = 9
+    ROCM = 10
+
+
+class DtypeKind(enum.IntEnum):
+    """
+    Integer enum for data types.
+
+    Attributes
+    ----------
+    INT : int
+        Matches to signed integer data type.
+    UINT : int
+        Matches to unsigned integer data type.
+    FLOAT : int
+        Matches to floating point data type.
+    BOOL : int
+        Matches to boolean data type.
+    STRING : int
+        Matches to string data type (UTF-8 encoded).
+    DATETIME : int
+        Matches to datetime data type.
+    CATEGORICAL : int
+        Matches to categorical data type.
+    """
+
+    INT = 0
+    UINT = 1
+    FLOAT = 2
+    BOOL = 20
+    STRING = 21  # UTF-8
+    DATETIME = 22
+    CATEGORICAL = 23
+
+
+class ColumnNullType(enum.IntEnum):
+    """
+    Integer enum for null type representation.
+
+    Attributes
+    ----------
+    NON_NULLABLE : int
+        Non-nullable column.
+    USE_NAN : int
+        Use explicit float NaN value.
+    USE_SENTINEL : int
+        Sentinel value besides NaN/NaT.
+    USE_BITMASK : int
+        The bit is set/unset representing a null on a certain position.
+    USE_BYTEMASK : int
+        The byte is set/unset representing a null on a certain position.
+    """
+
+    NON_NULLABLE = 0
+    USE_NAN = 1
+    USE_SENTINEL = 2
+    USE_BITMASK = 3
+    USE_BYTEMASK = 4
+
+
+class ColumnBuffers(TypedDict):
+    # first element is a buffer containing the column data;
+    # second element is the data buffer's associated dtype
+    data: tuple[Buffer, Any]
+
+    # first element is a buffer containing mask values indicating missing data;
+    # second element is the mask value buffer's associated dtype.
+    # None if the null representation is not a bit or byte mask
+    validity: tuple[Buffer, Any] | None
+
+    # first element is a buffer containing the offset values for
+    # variable-size binary data (e.g., variable-length strings);
+    # second element is the offsets buffer's associated dtype.
+    # None if the data buffer does not have an associated offsets buffer
+    offsets: tuple[Buffer, Any] | None
+
+
+class CategoricalDescription(TypedDict):
+    # whether the ordering of dictionary indices is semantically meaningful
+    is_ordered: bool
+    # whether a dictionary-style mapping of categorical values to other objects exists
+    is_dictionary: bool
+    # Python-level only (e.g. ``{int: str}``).
+    # None if not a dictionary-style categorical.
+    categories: Column | None
+
+
+class Buffer(ABC):
+    """
+    Data in the buffer is guaranteed to be contiguous in memory.
+
+    Note that there is no dtype attribute present, a buffer can be thought of
+    as simply a block of memory. However, if the column that the buffer is
+    attached to has a dtype that's supported by DLPack and ``__dlpack__`` is
+    implemented, then that dtype information will be contained in the return
+    value from ``__dlpack__``.
+
+    This distinction is useful to support both data exchange via DLPack on a
+    buffer and (b) dtypes like variable-length strings which do not have a
+    fixed number of bytes per element.
+    """
+
+    @property
+    @abstractmethod
+    def bufsize(self) -> int:
+        """
+        Buffer size in bytes.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def ptr(self) -> int:
+        """
+        Pointer to start of the buffer as an integer.
+        """
+        pass
+
+    @abstractmethod
+    def __dlpack__(self):
+        """
+        Produce DLPack capsule (see array API standard).
+
+        Raises:
+
+            - TypeError : if the buffer contains unsupported dtypes.
+            - NotImplementedError : if DLPack support is not implemented
+
+        Useful to have to connect to array libraries. Support optional because
+        it's not completely trivial to implement for a Python-only library.
+        """
+        raise NotImplementedError("__dlpack__")
+
+    @abstractmethod
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+        """
+        Device type and device ID for where the data in the buffer resides.
+        Uses device type codes matching DLPack.
+        Note: must be implemented even if ``__dlpack__`` is not.
+        """
+        pass
+
+
+class Column(ABC):
+    """
+    A column object, with only the methods and properties required by the
+    interchange protocol defined.
+
+    A column can contain one or more chunks. Each chunk can contain up to three
+    buffers - a data buffer, a mask buffer (depending on null representation),
+    and an offsets buffer (if variable-size binary; e.g., variable-length
+    strings).
+
+    TBD: Arrow has a separate "null" dtype, and has no separate mask concept.
+         Instead, it seems to use "children" for both columns with a bit mask,
+         and for nested dtypes. Unclear whether this is elegant or confusing.
+         This design requires checking the null representation explicitly.
+
+         The Arrow design requires checking:
+         1. the ARROW_FLAG_NULLABLE (for sentinel values)
+         2. if a column has two children, combined with one of those children
+            having a null dtype.
+
+         Making the mask concept explicit seems useful. One null dtype would
+         not be enough to cover both bit and byte masks, so that would mean
+         even more checking if we did it the Arrow way.
+
+    TBD: there's also the "chunk" concept here, which is implicit in Arrow as
+         multiple buffers per array (= column here). Semantically it may make
+         sense to have both: chunks were meant for example for lazy evaluation
+         of data which doesn't fit in memory, while multiple buffers per column
+         could also come from doing a selection operation on a single
+         contiguous buffer.
+
+         Given these concepts, one would expect chunks to be all of the same
+         size (say a 10,000 row dataframe could have 10 chunks of 1,000 rows),
+         while multiple buffers could have data-dependent lengths. Not an issue
+         in pandas if one column is backed by a single NumPy array, but in
+         Arrow it seems possible.
+         Are multiple chunks *and* multiple buffers per column necessary for
+         the purposes of this interchange protocol, or must producers either
+         reuse the chunk concept for this or copy the data?
+
+    Note: this Column object can only be produced by ``__dataframe__``, so
+          doesn't need its own version or ``__column__`` protocol.
+    """
+
+    @abstractmethod
+    def size(self) -> int:
+        """
+        Size of the column, in elements.
+
+        Corresponds to DataFrame.num_rows() if column is a single chunk;
+        equal to size of this current chunk otherwise.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def offset(self) -> int:
+        """
+        Offset of first element.
+
+        May be > 0 if using chunks; for example for a column with N chunks of
+        equal size M (only the last chunk may be shorter),
+        ``offset = n * M``, ``n = 0 .. N-1``.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def dtype(self) -> tuple[DtypeKind, int, str, str]:
+        """
+        Dtype description as a tuple ``(kind, bit-width, format string, endianness)``.
+
+        Bit-width : the number of bits as an integer
+        Format string : data type description format string in Apache Arrow C
+                        Data Interface format.
+        Endianness : current only native endianness (``=``) is supported
+
+        Notes:
+            - Kind specifiers are aligned with DLPack where possible (hence the
+              jump to 20, leave enough room for future extension)
+            - Masks must be specified as boolean with either bit width 1 (for bit
+              masks) or 8 (for byte masks).
+            - Dtype width in bits was preferred over bytes
+            - Endianness isn't too useful, but included now in case in the future
+              we need to support non-native endianness
+            - Went with Apache Arrow format strings over NumPy format strings
+              because they're more complete from a dataframe perspective
+            - Format strings are mostly useful for datetime specification, and
+              for categoricals.
+            - For categoricals, the format string describes the type of the
+              categorical in the data buffer. In case of a separate encoding of
+              the categorical (e.g. an integer to string mapping), this can
+              be derived from ``self.describe_categorical``.
+            - Data types not included: complex, Arrow-style null, binary, decimal,
+              and nested (list, struct, map, union) dtypes.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def describe_categorical(self) -> CategoricalDescription:
+        """
+        If the dtype is categorical, there are two options:
+        - There are only values in the data buffer.
+        - There is a separate non-categorical Column encoding for categorical values.
+
+        Raises TypeError if the dtype is not categorical
+
+        Returns the dictionary with description on how to interpret the data buffer:
+            - "is_ordered" : bool, whether the ordering of dictionary indices is
+                             semantically meaningful.
+            - "is_dictionary" : bool, whether a mapping of
+                                categorical values to other objects exists
+            - "categories" : Column representing the (implicit) mapping of indices to
+                             category values (e.g. an array of cat1, cat2, ...).
+                             None if not a dictionary-style categorical.
+
+        TBD: are there any other in-memory representations that are needed?
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def describe_null(self) -> tuple[ColumnNullType, Any]:
+        """
+        Return the missing value (or "null") representation the column dtype
+        uses, as a tuple ``(kind, value)``.
+
+        Value : if kind is "sentinel value", the actual value. If kind is a bit
+        mask or a byte mask, the value (0 or 1) indicating a missing value. None
+        otherwise.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def null_count(self) -> int | None:
+        """
+        Number of null elements, if known.
+
+        Note: Arrow uses -1 to indicate "unknown", but None seems cleaner.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def metadata(self) -> dict[str, Any]:
+        """
+        The metadata for the column. See `DataFrame.metadata` for more details.
+        """
+        pass
+
+    @abstractmethod
+    def num_chunks(self) -> int:
+        """
+        Return the number of chunks the column consists of.
+        """
+        pass
+
+    @abstractmethod
+    def get_chunks(self, n_chunks: int | None = None) -> Iterable[Column]:
+        """
+        Return an iterator yielding the chunks.
+
+        See `DataFrame.get_chunks` for details on ``n_chunks``.
+        """
+        pass
+
+    @abstractmethod
+    def get_buffers(self) -> ColumnBuffers:
+        """
+        Return a dictionary containing the underlying buffers.
+
+        The returned dictionary has the following contents:
+
+            - "data": a two-element tuple whose first element is a buffer
+                      containing the data and whose second element is the data
+                      buffer's associated dtype.
+            - "validity": a two-element tuple whose first element is a buffer
+                          containing mask values indicating missing data and
+                          whose second element is the mask value buffer's
+                          associated dtype. None if the null representation is
+                          not a bit or byte mask.
+            - "offsets": a two-element tuple whose first element is a buffer
+                         containing the offset values for variable-size binary
+                         data (e.g., variable-length strings) and whose second
+                         element is the offsets buffer's associated dtype. None
+                         if the data buffer does not have an associated offsets
+                         buffer.
+        """
+        pass
+
+
+#    def get_children(self) -> Iterable[Column]:
+#        """
+#        Children columns underneath the column, each object in this iterator
+#        must adhere to the column specification.
+#        """
+#        pass
+
+
+class DataFrame(ABC):
+    """
+    A data frame class, with only the methods required by the interchange
+    protocol defined.
+
+    A "data frame" represents an ordered collection of named columns.
+    A column's "name" must be a unique string.
+    Columns may be accessed by name or by position.
+
+    This could be a public data frame class, or an object with the methods and
+    attributes defined on this DataFrame class could be returned from the
+    ``__dataframe__`` method of a public data frame class in a library adhering
+    to the dataframe interchange protocol specification.
+    """
+
+    version = 0  # version of the protocol
+
+    @abstractmethod
+    def __dataframe__(self, nan_as_null: bool = False, allow_copy: bool = True):
+        """Construct a new interchange object, potentially changing the parameters."""
+        pass
+
+    @property
+    @abstractmethod
+    def metadata(self) -> dict[str, Any]:
+        """
+        The metadata for the data frame, as a dictionary with string keys. The
+        contents of `metadata` may be anything, they are meant for a library
+        to store information that it needs to, e.g., roundtrip losslessly or
+        for two implementations to share data that is not (yet) part of the
+        interchange protocol specification. For avoiding collisions with other
+        entries, please add name the keys with the name of the library
+        followed by a period and the desired name, e.g, ``pandas.indexcol``.
+        """
+        pass
+
+    @abstractmethod
+    def num_columns(self) -> int:
+        """
+        Return the number of columns in the DataFrame.
+        """
+        pass
+
+    @abstractmethod
+    def num_rows(self) -> int | None:
+        # TODO: not happy with Optional, but need to flag it may be expensive
+        #       why include it if it may be None - what do we expect consumers
+        #       to do here?
+        """
+        Return the number of rows in the DataFrame, if available.
+        """
+        pass
+
+    @abstractmethod
+    def num_chunks(self) -> int:
+        """
+        Return the number of chunks the DataFrame consists of.
+        """
+        pass
+
+    @abstractmethod
+    def column_names(self) -> Iterable[str]:
+        """
+        Return an iterator yielding the column names.
+        """
+        pass
+
+    @abstractmethod
+    def get_column(self, i: int) -> Column:
+        """
+        Return the column at the indicated position.
+        """
+        pass
+
+    @abstractmethod
+    def get_column_by_name(self, name: str) -> Column:
+        """
+        Return the column whose name is the indicated name.
+        """
+        pass
+
+    @abstractmethod
+    def get_columns(self) -> Iterable[Column]:
+        """
+        Return an iterator yielding the columns.
+        """
+        pass
+
+    @abstractmethod
+    def select_columns(self, indices: Sequence[int]) -> DataFrame:
+        """
+        Create a new DataFrame by selecting a subset of columns by index.
+        """
+        pass
+
+    @abstractmethod
+    def select_columns_by_name(self, names: Sequence[str]) -> DataFrame:
+        """
+        Create a new DataFrame by selecting a subset of columns by name.
+        """
+        pass
+
+    @abstractmethod
+    def get_chunks(self, n_chunks: int | None = None) -> Iterable[DataFrame]:
+        """
+        Return an iterator yielding the chunks.
+
+        By default (None), yields the chunks that the data is stored as by the
+        producer. If given, ``n_chunks`` must be a multiple of
+        ``self.num_chunks()``, meaning the producer must subdivide each chunk
+        before yielding it.
+        """
+        pass
diff --git a/pandas/core/interchange/from_dataframe.py b/pandas/core/interchange/from_dataframe.py
new file mode 100644
index 0000000000000..bec66e414875c
--- /dev/null
+++ b/pandas/core/interchange/from_dataframe.py
@@ -0,0 +1,524 @@
+from __future__ import annotations
+
+import ctypes
+import re
+from typing import Any
+
+import numpy as np
+
+import pandas as pd
+from pandas.core.interchange.column import PandasColumn
+from pandas.core.interchange.dataframe_protocol import (
+    Buffer,
+    Column,
+    ColumnNullType,
+    DataFrame as DataFrameXchg,
+    DtypeKind,
+)
+from pandas.core.interchange.utils import (
+    ArrowCTypes,
+    Endianness,
+)
+
+_NP_DTYPES: dict[DtypeKind, dict[int, Any]] = {
+    DtypeKind.INT: {8: np.int8, 16: np.int16, 32: np.int32, 64: np.int64},
+    DtypeKind.UINT: {8: np.uint8, 16: np.uint16, 32: np.uint32, 64: np.uint64},
+    DtypeKind.FLOAT: {32: np.float32, 64: np.float64},
+    DtypeKind.BOOL: {8: bool},
+}
+
+
+def from_dataframe(df, allow_copy=True) -> pd.DataFrame:
+    """
+    Build a ``pd.DataFrame`` from any DataFrame supporting the interchange protocol.
+
+    Parameters
+    ----------
+    df : DataFrameXchg
+        Object supporting the interchange protocol, i.e. `__dataframe__` method.
+    allow_copy : bool, default: True
+        Whether to allow copying the memory to perform the conversion
+        (if false then zero-copy approach is requested).
+
+    Returns
+    -------
+    pd.DataFrame
+    """
+    if isinstance(df, pd.DataFrame):
+        return df
+
+    if not hasattr(df, "__dataframe__"):
+        raise ValueError("`df` does not support __dataframe__")
+
+    return _from_dataframe(df.__dataframe__(allow_copy=allow_copy))
+
+
+def _from_dataframe(df: DataFrameXchg, allow_copy=True):
+    """
+    Build a ``pd.DataFrame`` from the DataFrame interchange object.
+
+    Parameters
+    ----------
+    df : DataFrameXchg
+        Object supporting the interchange protocol, i.e. `__dataframe__` method.
+    allow_copy : bool, default: True
+        Whether to allow copying the memory to perform the conversion
+        (if false then zero-copy approach is requested).
+
+    Returns
+    -------
+    pd.DataFrame
+    """
+    pandas_dfs = []
+    for chunk in df.get_chunks():
+        pandas_df = protocol_df_chunk_to_pandas(chunk)
+        pandas_dfs.append(pandas_df)
+
+    if not allow_copy and len(pandas_dfs) > 1:
+        raise RuntimeError(
+            "To join chunks a copy is required which is forbidden by allow_copy=False"
+        )
+    if len(pandas_dfs) == 1:
+        pandas_df = pandas_dfs[0]
+    else:
+        pandas_df = pd.concat(pandas_dfs, axis=0, ignore_index=True, copy=False)
+
+    index_obj = df.metadata.get("pandas.index", None)
+    if index_obj is not None:
+        pandas_df.index = index_obj
+
+    return pandas_df
+
+
+def protocol_df_chunk_to_pandas(df: DataFrameXchg) -> pd.DataFrame:
+    """
+    Convert interchange protocol chunk to ``pd.DataFrame``.
+
+    Parameters
+    ----------
+    df : DataFrameXchg
+
+    Returns
+    -------
+    pd.DataFrame
+    """
+    # We need a dict of columns here, with each column being a NumPy array (at
+    # least for now, deal with non-NumPy dtypes later).
+    columns: dict[str, Any] = {}
+    buffers = []  # hold on to buffers, keeps memory alive
+    for name in df.column_names():
+        if not isinstance(name, str):
+            raise ValueError(f"Column {name} is not a string")
+        if name in columns:
+            raise ValueError(f"Column {name} is not unique")
+        col = df.get_column_by_name(name)
+        dtype = col.dtype[0]
+        if dtype in (
+            DtypeKind.INT,
+            DtypeKind.UINT,
+            DtypeKind.FLOAT,
+            DtypeKind.BOOL,
+        ):
+            columns[name], buf = primitive_column_to_ndarray(col)
+        elif dtype == DtypeKind.CATEGORICAL:
+            columns[name], buf = categorical_column_to_series(col)
+        elif dtype == DtypeKind.STRING:
+            columns[name], buf = string_column_to_ndarray(col)
+        elif dtype == DtypeKind.DATETIME:
+            columns[name], buf = datetime_column_to_ndarray(col)
+        else:
+            raise NotImplementedError(f"Data type {dtype} not handled yet")
+
+        buffers.append(buf)
+
+    pandas_df = pd.DataFrame(columns)
+    pandas_df.attrs["_INTERCHANGE_PROTOCOL_BUFFERS"] = buffers
+    return pandas_df
+
+
+def primitive_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
+    """
+    Convert a column holding one of the primitive dtypes to a NumPy array.
+
+    A primitive type is one of: int, uint, float, bool.
+
+    Parameters
+    ----------
+    col : Column
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarray holding the data and the memory owner object
+        that keeps the memory alive.
+    """
+    buffers = col.get_buffers()
+
+    data_buff, data_dtype = buffers["data"]
+    data = buffer_to_ndarray(data_buff, data_dtype, col.offset, col.size())
+
+    data = set_nulls(data, col, buffers["validity"])
+    return data, buffers
+
+
+def categorical_column_to_series(col: Column) -> tuple[pd.Series, Any]:
+    """
+    Convert a column holding categorical data to a pandas Series.
+
+    Parameters
+    ----------
+    col : Column
+
+    Returns
+    -------
+    tuple
+        Tuple of pd.Series holding the data and the memory owner object
+        that keeps the memory alive.
+    """
+    categorical = col.describe_categorical
+
+    if not categorical["is_dictionary"]:
+        raise NotImplementedError("Non-dictionary categoricals not supported yet")
+
+    cat_column = categorical["categories"]
+    # for mypy/pyright
+    assert isinstance(cat_column, PandasColumn), "categories must be a PandasColumn"
+    categories = np.array(cat_column._col)
+    buffers = col.get_buffers()
+
+    codes_buff, codes_dtype = buffers["data"]
+    codes = buffer_to_ndarray(codes_buff, codes_dtype, col.offset, col.size())
+
+    # Doing module in order to not get ``IndexError`` for
+    # out-of-bounds sentinel values in `codes`
+    values = categories[codes % len(categories)]
+
+    cat = pd.Categorical(
+        values, categories=categories, ordered=categorical["is_ordered"]
+    )
+    data = pd.Series(cat)
+
+    data = set_nulls(data, col, buffers["validity"])
+    return data, buffers
+
+
+def string_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
+    """
+    Convert a column holding string data to a NumPy array.
+
+    Parameters
+    ----------
+    col : Column
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarray holding the data and the memory owner object
+        that keeps the memory alive.
+    """
+    null_kind, sentinel_val = col.describe_null
+
+    if null_kind not in (
+        ColumnNullType.NON_NULLABLE,
+        ColumnNullType.USE_BITMASK,
+        ColumnNullType.USE_BYTEMASK,
+    ):
+        raise NotImplementedError(
+            f"{null_kind} null kind is not yet supported for string columns."
+        )
+
+    buffers = col.get_buffers()
+
+    assert buffers["offsets"], "String buffers must contain offsets"
+    # Retrieve the data buffer containing the UTF-8 code units
+    data_buff, protocol_data_dtype = buffers["data"]
+    # We're going to reinterpret the buffer as uint8, so make sure we can do it safely
+    assert protocol_data_dtype[1] == 8  # bitwidth == 8
+    assert protocol_data_dtype[2] == ArrowCTypes.STRING  # format_str == utf-8
+    # Convert the buffers to NumPy arrays. In order to go from STRING to
+    # an equivalent ndarray, we claim that the buffer is uint8 (i.e., a byte array)
+    data_dtype = (
+        DtypeKind.UINT,
+        8,
+        ArrowCTypes.UINT8,
+        Endianness.NATIVE,
+    )
+    # Specify zero offset as we don't want to chunk the string data
+    data = buffer_to_ndarray(data_buff, data_dtype, offset=0, length=col.size())
+
+    # Retrieve the offsets buffer containing the index offsets demarcating
+    # the beginning and the ending of each string
+    offset_buff, offset_dtype = buffers["offsets"]
+    # Offsets buffer contains start-stop positions of strings in the data buffer,
+    # meaning that it has more elements than in the data buffer, do `col.size() + 1`
+    # here to pass a proper offsets buffer size
+    offsets = buffer_to_ndarray(
+        offset_buff, offset_dtype, col.offset, length=col.size() + 1
+    )
+
+    null_pos = None
+    if null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
+        assert buffers["validity"], "Validity buffers cannot be empty for masks"
+        valid_buff, valid_dtype = buffers["validity"]
+        null_pos = buffer_to_ndarray(valid_buff, valid_dtype, col.offset, col.size())
+        if sentinel_val == 0:
+            null_pos = ~null_pos
+
+    # Assemble the strings from the code units
+    str_list: list[None | float | str] = [None] * col.size()
+    for i in range(col.size()):
+        # Check for missing values
+        if null_pos is not None and null_pos[i]:
+            str_list[i] = np.nan
+            continue
+
+        # Extract a range of code units
+        units = data[offsets[i] : offsets[i + 1]]
+
+        # Convert the list of code units to bytes
+        str_bytes = bytes(units)
+
+        # Create the string
+        string = str_bytes.decode(encoding="utf-8")
+
+        # Add to our list of strings
+        str_list[i] = string
+
+    # Convert the string list to a NumPy array
+    return np.asarray(str_list, dtype="object"), buffers
+
+
+def parse_datetime_format_str(format_str, data):
+    """Parse datetime `format_str` to interpret the `data`."""
+    # timestamp 'ts{unit}:tz'
+    timestamp_meta = re.match(r"ts([smun]):(.*)", format_str)
+    if timestamp_meta:
+        unit, tz = timestamp_meta.group(1), timestamp_meta.group(2)
+        if tz != "":
+            raise NotImplementedError("Timezones are not supported yet")
+        if unit != "s":
+            # the format string describes only a first letter of the unit, so
+            # add one extra letter to convert the unit to numpy-style:
+            # 'm' -> 'ms', 'u' -> 'us', 'n' -> 'ns'
+            unit += "s"
+        data = data.astype(f"datetime64[{unit}]")
+        return data
+
+    # date 'td{Days/Ms}'
+    date_meta = re.match(r"td([Dm])", format_str)
+    if date_meta:
+        unit = date_meta.group(1)
+        if unit == "D":
+            # NumPy doesn't support DAY unit, so converting days to seconds
+            # (converting to uint64 to avoid overflow)
+            data = (data.astype(np.uint64) * (24 * 60 * 60)).astype("datetime64[s]")
+        elif unit == "m":
+            data = data.astype("datetime64[ms]")
+        else:
+            raise NotImplementedError(f"Date unit is not supported: {unit}")
+        return data
+
+    raise NotImplementedError(f"DateTime kind is not supported: {format_str}")
+
+
+def datetime_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
+    """
+    Convert a column holding DateTime data to a NumPy array.
+
+    Parameters
+    ----------
+    col : Column
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarray holding the data and the memory owner object
+        that keeps the memory alive.
+    """
+    buffers = col.get_buffers()
+
+    _, _, format_str, _ = col.dtype
+    dbuf, dtype = buffers["data"]
+    # Consider dtype being `uint` to get number of units passed since the 01.01.1970
+    data = buffer_to_ndarray(
+        dbuf,
+        (
+            DtypeKind.UINT,
+            dtype[1],
+            getattr(ArrowCTypes, f"UINT{dtype[1]}"),
+            Endianness.NATIVE,
+        ),
+        col.offset,
+        col.size(),
+    )
+
+    data = parse_datetime_format_str(format_str, data)
+    data = set_nulls(data, col, buffers["validity"])
+    return data, buffers
+
+
+def buffer_to_ndarray(
+    buffer: Buffer,
+    dtype: tuple[DtypeKind, int, str, str],
+    offset: int = 0,
+    length: int | None = None,
+) -> np.ndarray:
+    """
+    Build a NumPy array from the passed buffer.
+
+    Parameters
+    ----------
+    buffer : Buffer
+        Buffer to build a NumPy array from.
+    dtype : tuple
+        Data type of the buffer conforming protocol dtypes format.
+    offset : int, default: 0
+        Number of elements to offset from the start of the buffer.
+    length : int, optional
+        If the buffer is a bit-mask, specifies a number of bits to read
+        from the buffer. Has no effect otherwise.
+
+    Returns
+    -------
+    np.ndarray
+
+    Notes
+    -----
+    The returned array doesn't own the memory. The caller of this function is
+    responsible for keeping the memory owner object alive as long as
+    the returned NumPy array is being used.
+    """
+    kind, bit_width, _, _ = dtype
+
+    column_dtype = _NP_DTYPES.get(kind, {}).get(bit_width, None)
+    if column_dtype is None:
+        raise NotImplementedError(f"Conversion for {dtype} is not yet supported.")
+
+    # TODO: No DLPack yet, so need to construct a new ndarray from the data pointer
+    # and size in the buffer plus the dtype on the column. Use DLPack as NumPy supports
+    # it since https://github.com/numpy/numpy/pull/19083
+    ctypes_type = np.ctypeslib.as_ctypes_type(column_dtype)
+    data_pointer = ctypes.cast(
+        buffer.ptr + (offset * bit_width // 8), ctypes.POINTER(ctypes_type)
+    )
+
+    if bit_width == 1:
+        assert length is not None, "`length` must be specified for a bit-mask buffer."
+        arr = np.ctypeslib.as_array(data_pointer, shape=(buffer.bufsize,))
+        return bitmask_to_bool_ndarray(arr, length, first_byte_offset=offset % 8)
+    else:
+        return np.ctypeslib.as_array(
+            data_pointer, shape=(buffer.bufsize // (bit_width // 8),)
+        )
+
+
+def bitmask_to_bool_ndarray(
+    bitmask: np.ndarray, mask_length: int, first_byte_offset: int = 0
+) -> np.ndarray:
+    """
+    Convert bit-mask to a boolean NumPy array.
+
+    Parameters
+    ----------
+    bitmask : np.ndarray[uint8]
+        NumPy array of uint8 dtype representing the bitmask.
+    mask_length : int
+        Number of elements in the mask to interpret.
+    first_byte_offset : int, default: 0
+        Number of elements to offset from the start of the first byte.
+
+    Returns
+    -------
+    np.ndarray[bool]
+    """
+    bytes_to_skip = first_byte_offset // 8
+    bitmask = bitmask[bytes_to_skip:]
+    first_byte_offset %= 8
+
+    bool_mask = np.zeros(mask_length, dtype=bool)
+
+    # Processing the first byte separately as it has its own offset
+    val = bitmask[0]
+    mask_idx = 0
+    bits_in_first_byte = min(8 - first_byte_offset, mask_length)
+    for j in range(bits_in_first_byte):
+        if val & (1 << (j + first_byte_offset)):
+            bool_mask[mask_idx] = True
+        mask_idx += 1
+
+    # `mask_length // 8` describes how many full bytes to process
+    for i in range((mask_length - bits_in_first_byte) // 8):
+        # doing `+ 1` as we already processed the first byte
+        val = bitmask[i + 1]
+        for j in range(8):
+            if val & (1 << j):
+                bool_mask[mask_idx] = True
+            mask_idx += 1
+
+    if len(bitmask) > 1:
+        # Processing reminder of last byte
+        val = bitmask[-1]
+        for j in range(len(bool_mask) - mask_idx):
+            if val & (1 << j):
+                bool_mask[mask_idx] = True
+            mask_idx += 1
+
+    return bool_mask
+
+
+def set_nulls(
+    data: np.ndarray | pd.Series,
+    col: Column,
+    validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None,
+    allow_modify_inplace: bool = True,
+):
+    """
+    Set null values for the data according to the column null kind.
+
+    Parameters
+    ----------
+    data : np.ndarray or pd.Series
+        Data to set nulls in.
+    col : Column
+        Column object that describes the `data`.
+    validity : tuple(Buffer, dtype) or None
+        The return value of ``col.buffers()``. We do not access the ``col.buffers()``
+        here to not take the ownership of the memory of buffer objects.
+    allow_modify_inplace : bool, default: True
+        Whether to modify the `data` inplace when zero-copy is possible (True) or always
+        modify a copy of the `data` (False).
+
+    Returns
+    -------
+    np.ndarray or pd.Series
+        Data with the nulls being set.
+    """
+    null_kind, sentinel_val = col.describe_null
+    null_pos = None
+
+    if null_kind == ColumnNullType.USE_SENTINEL:
+        null_pos = pd.Series(data) == sentinel_val
+    elif null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
+        assert validity, "Expected to have a validity buffer for the mask"
+        valid_buff, valid_dtype = validity
+        null_pos = buffer_to_ndarray(valid_buff, valid_dtype, col.offset, col.size())
+        if sentinel_val == 0:
+            null_pos = ~null_pos
+    elif null_kind in (ColumnNullType.NON_NULLABLE, ColumnNullType.USE_NAN):
+        pass
+    else:
+        raise NotImplementedError(f"Null kind {null_kind} is not yet supported.")
+
+    if null_pos is not None and np.any(null_pos):
+        if not allow_modify_inplace:
+            data = data.copy()
+        try:
+            data[null_pos] = None
+        except TypeError:
+            # TypeError happens if the `data` dtype appears to be non-nullable
+            # in numpy notation (bool, int, uint). If this happens,
+            # cast the `data` to nullable float dtype.
+            data = data.astype(float)
+            data[null_pos] = None
+
+    return data
diff --git a/pandas/core/interchange/utils.py b/pandas/core/interchange/utils.py
new file mode 100644
index 0000000000000..1d56af94b2629
--- /dev/null
+++ b/pandas/core/interchange/utils.py
@@ -0,0 +1,95 @@
+"""
+Utility functions and objects for implementing the interchange API.
+"""
+
+from __future__ import annotations
+
+import re
+import typing
+
+import numpy as np
+
+from pandas._typing import DtypeObj
+
+import pandas as pd
+from pandas.api.types import is_datetime64_dtype
+
+
+class ArrowCTypes:
+    """
+    Enum for Apache Arrow C type format strings.
+
+    The Arrow C data interface:
+    https://arrow.apache.org/docs/format/CDataInterface.html#data-type-description-format-strings
+    """
+
+    NULL = "n"
+    BOOL = "b"
+    INT8 = "c"
+    UINT8 = "C"
+    INT16 = "s"
+    UINT16 = "S"
+    INT32 = "i"
+    UINT32 = "I"
+    INT64 = "l"
+    UINT64 = "L"
+    FLOAT16 = "e"
+    FLOAT32 = "f"
+    FLOAT64 = "g"
+    STRING = "u"  # utf-8
+    DATE32 = "tdD"
+    DATE64 = "tdm"
+    # Resoulution:
+    #   - seconds -> 's'
+    #   - milliseconds -> 'm'
+    #   - microseconds -> 'u'
+    #   - nanoseconds -> 'n'
+    TIMESTAMP = "ts{resolution}:{tz}"
+    TIME = "tt{resolution}"
+
+
+class Endianness:
+    """Enum indicating the byte-order of a data-type."""
+
+    LITTLE = "<"
+    BIG = ">"
+    NATIVE = "="
+    NA = "|"
+
+
+def dtype_to_arrow_c_fmt(dtype: DtypeObj) -> str:
+    """
+    Represent pandas `dtype` as a format string in Apache Arrow C notation.
+
+    Parameters
+    ----------
+    dtype : np.dtype
+        Datatype of pandas DataFrame to represent.
+
+    Returns
+    -------
+    str
+        Format string in Apache Arrow C notation of the given `dtype`.
+    """
+    if isinstance(dtype, pd.CategoricalDtype):
+        return ArrowCTypes.INT64
+    elif dtype == np.dtype("O"):
+        return ArrowCTypes.STRING
+
+    format_str = getattr(ArrowCTypes, dtype.name.upper(), None)
+    if format_str is not None:
+        return format_str
+
+    if is_datetime64_dtype(dtype):
+        # Selecting the first char of resolution string:
+        # dtype.str -> '<M8[ns]'
+        resolution = re.findall(r"\[(.*)\]", typing.cast(np.dtype, dtype).str)[0][:1]
+        return ArrowCTypes.TIMESTAMP.format(resolution=resolution, tz="")
+
+    raise NotImplementedError(
+        f"Conversion of {dtype} to Arrow C format string is not implemented."
+    )
+
+
+class NoBufferPresent(Exception):
+    """Exception to signal that there is no requested buffer."""
diff --git a/pandas/core/internals/__init__.py b/pandas/core/internals/__init__.py
index 75715bdc90003..ea69b567611e4 100644
--- a/pandas/core/internals/__init__.py
+++ b/pandas/core/internals/__init__.py
@@ -23,7 +23,6 @@
 
 __all__ = [
     "Block",
-    "CategoricalBlock",
     "NumericBlock",
     "DatetimeTZBlock",
     "ExtensionBlock",
diff --git a/pandas/core/internals/api.py b/pandas/core/internals/api.py
index 537ae8f2a4320..371f1e2443b36 100644
--- a/pandas/core/internals/api.py
+++ b/pandas/core/internals/api.py
@@ -24,6 +24,7 @@
 from pandas.core.internals.blocks import (
     Block,
     DatetimeTZBlock,
+    ExtensionBlock,
     check_ndim,
     ensure_block_shape,
     extract_pandas_array,
@@ -51,6 +52,12 @@ def make_block(
 
     values, dtype = extract_pandas_array(values, dtype, ndim)
 
+    if klass is ExtensionBlock and is_period_dtype(values.dtype):
+        # GH-44681 changed PeriodArray to be stored in the 2D
+        # NDArrayBackedExtensionBlock instead of ExtensionBlock
+        # -> still allow ExtensionBlock to be passed in this case for back compat
+        klass = None
+
     if klass is None:
         dtype = dtype or values.dtype
         klass = get_block_type(dtype)
diff --git a/pandas/core/internals/array_manager.py b/pandas/core/internals/array_manager.py
index ec3a9e8b493e3..262ed06fdba02 100644
--- a/pandas/core/internals/array_manager.py
+++ b/pandas/core/internals/array_manager.py
@@ -8,6 +8,7 @@
     Any,
     Callable,
     Hashable,
+    Literal,
     TypeVar,
 )
 
@@ -15,16 +16,18 @@
 
 from pandas._libs import (
     NaT,
+    algos as libalgos,
     lib,
 )
 from pandas._typing import (
     ArrayLike,
     DtypeObj,
+    npt,
 )
 from pandas.util._validators import validate_bool_kwarg
 
+from pandas.core.dtypes.astype import astype_array_safe
 from pandas.core.dtypes.cast import (
-    astype_array_safe,
     ensure_dtype_can_hold_na,
     infer_dtype_from_scalar,
     soft_convert_objects,
@@ -34,6 +37,7 @@
     is_datetime64_ns_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
+    is_integer,
     is_numeric_dtype,
     is_object_dtype,
     is_timedelta64_ns_dtype,
@@ -127,7 +131,7 @@ def __init__(
         arrays: list[np.ndarray | ExtensionArray],
         axes: list[Index],
         verify_integrity: bool = True,
-    ):
+    ) -> None:
         raise NotImplementedError
 
     def make_empty(self: T, axes=None) -> T:
@@ -167,13 +171,13 @@ def set_axis(self, axis: int, new_labels: Index) -> None:
         axis = self._normalize_axis(axis)
         self._axes[axis] = new_labels
 
-    def get_dtypes(self):
+    def get_dtypes(self) -> np.ndarray:
         return np.array([arr.dtype for arr in self.arrays], dtype="object")
 
     def __getstate__(self):
         return self.arrays, self._axes
 
-    def __setstate__(self, state):
+    def __setstate__(self, state) -> None:
         self.arrays = state[0]
         self._axes = state[1]
 
@@ -293,19 +297,10 @@ def apply_with_block(self: T, f, align_keys=None, swap_axis=True, **kwargs) -> T
                         if obj.ndim == 2:
                             kwargs[k] = obj[[i]]
 
-            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
-            # attribute "tz"
-            if hasattr(arr, "tz") and arr.tz is None:  # type: ignore[union-attr]
-                # DatetimeArray needs to be converted to ndarray for DatetimeLikeBlock
-
-                # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
-                # attribute "_data"
-                arr = arr._data  # type: ignore[union-attr]
-            elif arr.dtype.kind == "m" and not isinstance(arr, np.ndarray):
-                # TimedeltaArray needs to be converted to ndarray for TimedeltaBlock
-
-                # error: "ExtensionArray" has no attribute "_data"
-                arr = arr._data  # type: ignore[attr-defined]
+            if isinstance(arr.dtype, np.dtype) and not isinstance(arr, np.ndarray):
+                # i.e. TimedeltaArray, DatetimeArray with tz=None. Need to
+                #  convert for the Block constructors.
+                arr = np.asarray(arr)
 
             if self.ndim == 2:
                 arr = ensure_block_shape(arr, 2)
@@ -341,11 +336,10 @@ def where(self: T, other, cond, align: bool) -> T:
             cond=cond,
         )
 
-    # TODO what is this used for?
-    # def setitem(self, indexer, value) -> ArrayManager:
-    #     return self.apply_with_block("setitem", indexer=indexer, value=value)
+    def setitem(self: T, indexer, value) -> T:
+        return self.apply_with_block("setitem", indexer=indexer, value=value)
 
-    def putmask(self, mask, new, align: bool = True):
+    def putmask(self: T, mask, new, align: bool = True) -> T:
         if align:
             align_keys = ["new", "mask"]
         else:
@@ -383,6 +377,11 @@ def shift(self: T, periods: int, axis: int, fill_value) -> T:
         )
 
     def fillna(self: T, value, limit, inplace: bool, downcast) -> T:
+
+        if limit is not None:
+            # Do this validation even if we go through one of the no-op paths
+            limit = libalgos.validate_limit(None, limit=limit)
+
         return self.apply_with_block(
             "fillna", value=value, limit=limit, inplace=inplace, downcast=downcast
         )
@@ -443,7 +442,7 @@ def replace_list(
             regex=regex,
         )
 
-    def to_native_types(self, **kwargs):
+    def to_native_types(self: T, **kwargs) -> T:
         return self.apply(to_native_types, **kwargs)
 
     @property
@@ -467,7 +466,7 @@ def is_view(self) -> bool:
 
     @property
     def is_single_block(self) -> bool:
-        return False
+        return len(self.arrays) == 1
 
     def _get_data_subset(self: T, predicate: Callable) -> T:
         indices = [i for i, arr in enumerate(self.arrays) if predicate(arr)]
@@ -519,6 +518,11 @@ def copy(self: T, deep=True) -> T:
         -------
         BlockManager
         """
+        if deep is None:
+            # ArrayManager does not yet support CoW, so deep=None always means
+            # deep=True for now
+            deep = True
+
         # this preserves the notion of view copying of axes
         if deep:
             # hit in e.g. tests.io.json.test_pandas
@@ -545,7 +549,6 @@ def reindex_indexer(
         allow_dups: bool = False,
         copy: bool = True,
         # ignored keywords
-        consolidate: bool = True,
         only_slice: bool = False,
         # ArrayManager specific keywords
         use_na_proxy: bool = False,
@@ -564,7 +567,7 @@ def reindex_indexer(
     def _reindex_indexer(
         self: T,
         new_axis,
-        indexer,
+        indexer: npt.NDArray[np.intp] | None,
         axis: int,
         fill_value=None,
         allow_dups: bool = False,
@@ -575,7 +578,7 @@ def _reindex_indexer(
         Parameters
         ----------
         new_axis : Index
-        indexer : ndarray of int64 or None
+        indexer : ndarray[intp] or None
         axis : int
         fill_value : object, default None
         allow_dups : bool, default False
@@ -584,6 +587,11 @@ def _reindex_indexer(
 
         pandas-indexer with -1's only.
         """
+        if copy is None:
+            # ArrayManager does not yet support CoW, so deep=None always means
+            # deep=True for now
+            copy = True
+
         if indexer is None:
             if new_axis is self._axes[axis] and not copy:
                 return self
@@ -635,7 +643,13 @@ def _reindex_indexer(
 
         return type(self)(new_arrays, new_axes, verify_integrity=False)
 
-    def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
+    def take(
+        self: T,
+        indexer,
+        axis: int = 1,
+        verify: bool = True,
+        convert_indices: bool = True,
+    ) -> T:
         """
         Take items along any axis.
         """
@@ -651,7 +665,8 @@ def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
             raise ValueError("indexer should be 1-dimensional")
 
         n = self.shape_proper[axis]
-        indexer = maybe_convert_indices(indexer, n, verify=verify)
+        if convert_indices:
+            indexer = maybe_convert_indices(indexer, n, verify=verify)
 
         new_labels = self._axes[axis].take(indexer)
         return self._reindex_indexer(
@@ -691,14 +706,16 @@ def _equal_values(self, other) -> bool:
 
 
 class ArrayManager(BaseArrayManager):
-    ndim = 2
+    @property
+    def ndim(self) -> Literal[2]:
+        return 2
 
     def __init__(
         self,
         arrays: list[np.ndarray | ExtensionArray],
         axes: list[Index],
         verify_integrity: bool = True,
-    ):
+    ) -> None:
         # Note: we are storing the axes in "_axes" in the (row, columns) order
         # which contrasts the order how it is stored in BlockManager
         self._axes = axes
@@ -737,7 +754,7 @@ def _verify_integrity(self) -> None:
     # --------------------------------------------------------------------
     # Indexing
 
-    def fast_xs(self, loc: int) -> ArrayLike:
+    def fast_xs(self, loc: int) -> SingleArrayManager:
         """
         Return the array corresponding to `frame.iloc[loc]`.
 
@@ -761,7 +778,7 @@ def fast_xs(self, loc: int) -> ArrayLike:
             result = TimedeltaArray._from_sequence(values, dtype=dtype)._data
         else:
             result = np.array(values, dtype=dtype)
-        return result
+        return SingleArrayManager([result], [self._axes[1]])
 
     def get_slice(self, slobj: slice, axis: int = 0) -> ArrayManager:
         axis = self._normalize_axis(axis)
@@ -799,7 +816,7 @@ def column_arrays(self) -> list[ArrayLike]:
 
     def iset(
         self, loc: int | slice | np.ndarray, value: ArrayLike, inplace: bool = False
-    ):
+    ) -> None:
         """
         Set new column(s).
 
@@ -857,6 +874,26 @@ def iset(
             self.arrays[mgr_idx] = value_arr
         return
 
+    def column_setitem(
+        self, loc: int, idx: int | slice | np.ndarray, value, inplace: bool = False
+    ) -> None:
+        """
+        Set values ("setitem") into a single column (not setting the full column).
+
+        This is a method on the ArrayManager level, to avoid creating an
+        intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`)
+        """
+        if not is_integer(loc):
+            raise TypeError("The column index should be an integer")
+        arr = self.arrays[loc]
+        mgr = SingleArrayManager([arr], [self._axes[0]])
+        if inplace:
+            mgr.setitem_inplace(idx, value)
+        else:
+            new_mgr = mgr.setitem((idx,), value)
+            # update existing ArrayManager in-place
+            self.arrays[loc] = new_mgr.arrays[0]
+
     def insert(self, loc: int, item: Hashable, value: ArrayLike) -> None:
         """
         Insert item at selected position.
@@ -892,7 +929,7 @@ def insert(self, loc: int, item: Hashable, value: ArrayLike) -> None:
         self.arrays = arrays
         self._axes[1] = new_axis
 
-    def idelete(self, indexer):
+    def idelete(self, indexer) -> ArrayManager:
         """
         Delete selected locations in-place (new block and array, same BlockManager)
         """
@@ -1101,7 +1138,7 @@ def as_array(
         self,
         dtype=None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Convert the blockmanager data into an numpy array.
@@ -1163,14 +1200,16 @@ class SingleArrayManager(BaseArrayManager, SingleDataManager):
     arrays: list[np.ndarray | ExtensionArray]
     _axes: list[Index]
 
-    ndim = 1
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
 
     def __init__(
         self,
         arrays: list[np.ndarray | ExtensionArray],
         axes: list[Index],
         verify_integrity: bool = True,
-    ):
+    ) -> None:
         self._axes = axes
         self.arrays = arrays
 
@@ -1203,11 +1242,11 @@ def make_empty(self, axes=None) -> SingleArrayManager:
         """Return an empty ArrayManager with index/array of length 0"""
         if axes is None:
             axes = [Index([], dtype=object)]
-        array = np.array([], dtype=self.dtype)
+        array: np.ndarray = np.array([], dtype=self.dtype)
         return type(self)([array], axes)
 
     @classmethod
-    def from_array(cls, array, index):
+    def from_array(cls, array, index) -> SingleArrayManager:
         return cls([array], [index])
 
     @property
@@ -1249,7 +1288,7 @@ def _can_hold_na(self) -> bool:
     def is_single_block(self) -> bool:
         return True
 
-    def fast_xs(self, loc: int) -> ArrayLike:
+    def fast_xs(self, loc: int) -> SingleArrayManager:
         raise NotImplementedError("Use series._values[loc] instead")
 
     def get_slice(self, slobj: slice, axis: int = 0) -> SingleArrayManager:
@@ -1272,7 +1311,7 @@ def apply(self, func, **kwargs):
             new_array = getattr(self.array, func)(**kwargs)
         return type(self)([new_array], self._axes)
 
-    def setitem(self, indexer, value):
+    def setitem(self, indexer, value) -> SingleArrayManager:
         """
         Set values with indexer.
 
@@ -1281,6 +1320,8 @@ def setitem(self, indexer, value):
         See `setitem_inplace` for a version that works inplace and doesn't
         return a new Manager.
         """
+        if isinstance(indexer, np.ndarray) and indexer.ndim > self.ndim:
+            raise ValueError(f"Cannot set values with ndim > {self.ndim}")
         return self.apply_with_block("setitem", indexer=indexer, value=value)
 
     def idelete(self, indexer) -> SingleArrayManager:
@@ -1301,7 +1342,7 @@ def _get_data_subset(self, predicate: Callable) -> SingleArrayManager:
         else:
             return self.make_empty()
 
-    def set_values(self, values: ArrayLike):
+    def set_values(self, values: ArrayLike) -> None:
         """
         Set (replace) the values of the SingleArrayManager in place.
 
@@ -1333,11 +1374,11 @@ class NullArrayProxy:
 
     ndim = 1
 
-    def __init__(self, n: int):
+    def __init__(self, n: int) -> None:
         self.n = n
 
     @property
-    def shape(self):
+    def shape(self) -> tuple[int]:
         return (self.n,)
 
     def to_array(self, dtype: DtypeObj) -> ArrayLike:
diff --git a/pandas/core/internals/base.py b/pandas/core/internals/base.py
index 74d8b20332fff..ddc4495318568 100644
--- a/pandas/core/internals/base.py
+++ b/pandas/core/internals/base.py
@@ -5,10 +5,13 @@
 from __future__ import annotations
 
 from typing import (
+    Literal,
     TypeVar,
     final,
 )
 
+import numpy as np
+
 from pandas._typing import (
     ArrayLike,
     DtypeObj,
@@ -16,7 +19,10 @@
 )
 from pandas.errors import AbstractMethodError
 
-from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.cast import (
+    find_common_type,
+    np_can_hold_element,
+)
 
 from pandas.core.base import PandasObject
 from pandas.core.indexes.api import (
@@ -74,7 +80,6 @@ def reindex_indexer(
         fill_value=None,
         allow_dups: bool = False,
         copy: bool = True,
-        consolidate: bool = True,
         only_slice: bool = False,
     ) -> T:
         raise AbstractMethodError(self)
@@ -85,7 +90,6 @@ def reindex_axis(
         new_index: Index,
         axis: int,
         fill_value=None,
-        consolidate: bool = True,
         only_slice: bool = False,
     ) -> T:
         """
@@ -99,7 +103,6 @@ def reindex_axis(
             axis=axis,
             fill_value=fill_value,
             copy=False,
-            consolidate=consolidate,
             only_slice=only_slice,
         )
 
@@ -153,7 +156,9 @@ def _consolidate_inplace(self) -> None:
 
 
 class SingleDataManager(DataManager):
-    ndim = 1
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
 
     @final
     @property
@@ -174,7 +179,15 @@ def setitem_inplace(self, indexer, value) -> None:
         in place, not returning a new Manager (and Block), and thus never changing
         the dtype.
         """
-        self.array[indexer] = value
+        arr = self.array
+
+        # EAs will do this validation in their own __setitem__ methods.
+        if isinstance(arr, np.ndarray):
+            # Note: checking for ndarray instead of np.dtype means we exclude
+            #  dt64/td64, which do their own validation.
+            value = np_can_hold_element(arr.dtype, value)
+
+        arr[indexer] = value
 
     def grouped_reduce(self, func, ignore_failures: bool = False):
         """
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 9f242226739ec..5e95f83ddfd08 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -17,32 +17,32 @@
 
 from pandas._libs import (
     Timestamp,
-    algos as libalgos,
     internals as libinternals,
     lib,
     writers,
 )
 from pandas._libs.internals import BlockPlacement
+from pandas._libs.tslibs import IncompatibleFrequency
 from pandas._typing import (
     ArrayLike,
     DtypeObj,
     F,
+    IgnoreRaise,
     Shape,
     npt,
 )
-from pandas.compat import np_version_under1p20
+from pandas.errors import AbstractMethodError
 from pandas.util._decorators import cache_readonly
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import validate_bool_kwarg
 
+from pandas.core.dtypes.astype import astype_array_safe
 from pandas.core.dtypes.cast import (
-    astype_array_safe,
+    LossySetitemError,
     can_hold_element,
-    find_common_type,
-    infer_dtype_from,
-    maybe_downcast_numeric,
+    find_result_type,
     maybe_downcast_to_dtype,
-    maybe_upcast,
+    np_can_hold_element,
     soft_convert_objects,
 )
 from pandas.core.dtypes.common import (
@@ -50,9 +50,9 @@
     is_1d_only_ea_dtype,
     is_1d_only_ea_obj,
     is_dtype_equal,
-    is_extension_array_dtype,
     is_interval_dtype,
     is_list_like,
+    is_sparse,
     is_string_dtype,
 )
 from pandas.core.dtypes.dtypes import (
@@ -78,7 +78,6 @@
 from pandas.core.array_algos.putmask import (
     extract_bool_array,
     putmask_inplace,
-    putmask_smart,
     putmask_without_repeat,
     setitem_datetimelike_compat,
     validate_putmask,
@@ -89,7 +88,6 @@
     replace_regex,
     should_use_regex,
 )
-from pandas.core.array_algos.take import take_nd
 from pandas.core.array_algos.transforms import shift
 from pandas.core.arrays import (
     Categorical,
@@ -100,7 +98,6 @@
     PeriodArray,
     TimedeltaArray,
 )
-from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 from pandas.core.arrays.sparse import SparseDtype
 from pandas.core.base import PandasObject
 import pandas.core.common as com
@@ -109,11 +106,7 @@
     ensure_wrapped_if_datetimelike,
     extract_array,
 )
-from pandas.core.indexers import (
-    check_setitem_lengths,
-    is_empty_indexer,
-    is_scalar_indexer,
-)
+from pandas.core.indexers import check_setitem_lengths
 import pandas.core.missing as missing
 
 if TYPE_CHECKING:
@@ -121,6 +114,7 @@
         Float64Index,
         Index,
     )
+    from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 
 # comparison is faster than is_object_dtype
 _dtype_obj = np.dtype("object")
@@ -168,13 +162,6 @@ class Block(PandasObject):
     def _consolidate_key(self):
         return self._can_consolidate, self.dtype.name
 
-    @property
-    def is_view(self) -> bool:
-        """return a boolean if I am possibly a view"""
-        values = self.values
-        values = cast(np.ndarray, values)
-        return values.base is not None
-
     @final
     @cache_readonly
     def _can_hold_na(self) -> bool:
@@ -210,43 +197,25 @@ def is_bool(self) -> bool:
     def external_values(self):
         return external_values(self.values)
 
-    @property
-    def array_values(self) -> ExtensionArray:
-        """
-        The array that Series.array returns. Always an ExtensionArray.
-        """
-        # error: Argument 1 to "PandasArray" has incompatible type "Union[ndarray,
-        # ExtensionArray]"; expected "Union[ndarray, PandasArray]"
-        return PandasArray(self.values)  # type: ignore[arg-type]
-
-    def get_values(self, dtype: DtypeObj | None = None) -> np.ndarray:
-        """
-        return an internal format, currently just the ndarray
-        this is often overridden to handle to_dense like operations
-        """
-        if dtype == _dtype_obj:
-            return self.values.astype(_dtype_obj)
-        # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
-        # expected "ndarray")
-        return self.values  # type: ignore[return-value]
-
-    def values_for_json(self) -> np.ndarray:
-        # Incompatible return value type (got "Union[ndarray[Any, Any],
-        # ExtensionArray]", expected "ndarray[Any, Any]")
-        return self.values  # type: ignore[return-value]
-
     @final
     @cache_readonly
     def fill_value(self):
         # Used in reindex_indexer
         return na_value_for_dtype(self.dtype, compat=False)
 
+    @final
+    def _standardize_fill_value(self, value):
+        # if we are passed a scalar None, convert it here
+        if self.dtype != _dtype_obj and is_valid_na_for_dtype(value, self.dtype):
+            value = self.fill_value
+        return value
+
     @property
     def mgr_locs(self) -> BlockPlacement:
         return self._mgr_locs
 
     @mgr_locs.setter
-    def mgr_locs(self, new_mgr_locs: BlockPlacement):
+    def mgr_locs(self, new_mgr_locs: BlockPlacement) -> None:
         self._mgr_locs = new_mgr_locs
 
     @final
@@ -307,11 +276,6 @@ def __repr__(self) -> str:
     def __len__(self) -> int:
         return len(self.values)
 
-    def _slice(self, slicer) -> ArrayLike:
-        """return a slice of my values"""
-
-        return self.values[slicer]
-
     @final
     def getitem_block(self, slicer: slice | npt.NDArray[np.intp]) -> Block:
         """
@@ -319,8 +283,13 @@ def getitem_block(self, slicer: slice | npt.NDArray[np.intp]) -> Block:
 
         Only supports slices that preserve dimensionality.
         """
-        axis0_slicer = slicer[0] if isinstance(slicer, tuple) else slicer
-        new_mgr_locs = self._mgr_locs[axis0_slicer]
+        # Note: the only place where we are called with ndarray[intp]
+        #  is from internals.concat, and we can verify that never happens
+        #  with 1-column blocks, i.e. never for ExtensionBlock.
+
+        # Invalid index type "Union[slice, ndarray[Any, dtype[signedinteger[Any]]]]"
+        # for "BlockPlacement"; expected type "Union[slice, Sequence[int]]"
+        new_mgr_locs = self._mgr_locs[slicer]  # type: ignore[index]
 
         new_values = self._slice(slicer)
 
@@ -345,41 +314,33 @@ def getitem_block_columns(
 
         return type(self)(new_values, new_mgr_locs, self.ndim)
 
-    # NB: this cannot be made cache_readonly because in libreduction we pin
-    #  new .values that can have different shape GH#42631
-    @property
-    def shape(self) -> Shape:
-        return self.values.shape
-
-    @cache_readonly
-    def dtype(self) -> DtypeObj:
-        return self.values.dtype
-
-    def iget(self, i):
-        return self.values[i]
+    @final
+    def _can_hold_element(self, element: Any) -> bool:
+        """require the same dtype as ourselves"""
+        element = extract_array(element, extract_numpy=True)
+        return can_hold_element(self.values, element)
 
-    def set_inplace(self, locs, values) -> None:
+    @final
+    def should_store(self, value: ArrayLike) -> bool:
         """
-        Modify block values in-place with new item value.
+        Should we set self.values[indexer] = value inplace or do we need to cast?
 
-        Notes
-        -----
-        `set` never creates a new array or new Block, whereas `setitem` _may_
-        create a new array and always creates a new Block.
-        """
-        self.values[locs] = values
+        Parameters
+        ----------
+        value : np.ndarray or ExtensionArray
 
-    def delete(self, loc) -> None:
-        """
-        Delete given loc(-s) from block in-place.
+        Returns
+        -------
+        bool
         """
-        self.values = np.delete(self.values, loc, 0)
-        self.mgr_locs = self._mgr_locs.delete(loc)
+        # faster equivalent to is_dtype_equal(value.dtype, self.dtype)
         try:
-            self._cache.clear()
-        except AttributeError:
-            # _cache not yet initialized
-            pass
+            return value.dtype == self.dtype
+        except TypeError:
+            return False
+
+    # ---------------------------------------------------------------------
+    # Apply/Reduce and Helpers
 
     @final
     def apply(self, func, **kwargs) -> list[Block]:
@@ -433,48 +394,6 @@ def _split_op_result(self, result: ArrayLike) -> list[Block]:
 
         return [nb]
 
-    def fillna(
-        self, value, limit=None, inplace: bool = False, downcast=None
-    ) -> list[Block]:
-        """
-        fillna on the block with the value. If we fail, then convert to
-        ObjectBlock and try again
-        """
-        inplace = validate_bool_kwarg(inplace, "inplace")
-
-        mask = isna(self.values)
-        mask, noop = validate_putmask(self.values, mask)
-
-        if limit is not None:
-            limit = libalgos.validate_limit(None, limit=limit)
-            mask[mask.cumsum(self.ndim - 1) > limit] = False
-
-        if not self._can_hold_na:
-            if inplace:
-                return [self]
-            else:
-                return [self.copy()]
-
-        if self._can_hold_element(value):
-            nb = self if inplace else self.copy()
-            putmask_inplace(nb.values, mask, value)
-            return nb._maybe_downcast([nb], downcast)
-
-        if noop:
-            # we can't process the value, but nothing to do
-            return [self] if inplace else [self.copy()]
-
-        elif self.ndim == 1 or self.shape[0] == 1:
-            blk = self.coerce_to_target_dtype(value)
-            # bc we have already cast, inplace=True may avoid an extra copy
-            return blk.fillna(value, limit=limit, inplace=True, downcast=None)
-
-        else:
-            # operate column-by-column
-            return self.split_and_operate(
-                type(self).fillna, value, limit=limit, inplace=inplace, downcast=None
-            )
-
     @final
     def _split(self) -> list[Block]:
         """
@@ -514,8 +433,26 @@ def split_and_operate(self, func, *args, **kwargs) -> list[Block]:
             res_blocks.extend(rbs)
         return res_blocks
 
+    # ---------------------------------------------------------------------
+    # Up/Down-casting
+
+    @final
+    def coerce_to_target_dtype(self, other) -> Block:
+        """
+        coerce the current block to a dtype compat for other
+        we will return a block, possibly object, and not raise
+
+        we can also safely try to coerce to the same dtype
+        and will receive the same block
+        """
+        new_dtype = find_result_type(self.values, other)
+
+        return self.astype(new_dtype, copy=False)
+
     @final
     def _maybe_downcast(self, blocks: list[Block], downcast=None) -> list[Block]:
+        if downcast is False:
+            return blocks
 
         if self.dtype == _dtype_obj:
             # GH#44241 We downcast regardless of the argument;
@@ -529,10 +466,6 @@ def _maybe_downcast(self, blocks: list[Block], downcast=None) -> list[Block]:
 
         if downcast is None:
             return blocks
-        if downcast is False:
-            # turn if off completely
-            # TODO: not reached, deprecate in favor of downcast=None
-            return blocks
 
         return extend_blocks([b._downcast_2d(downcast) for b in blocks])
 
@@ -547,8 +480,31 @@ def _downcast_2d(self, dtype) -> list[Block]:
         new_values = maybe_downcast_to_dtype(self.values, dtype=dtype)
         return [self.make_block(new_values)]
 
+    def convert(
+        self,
+        copy: bool = True,
+        datetime: bool = True,
+        numeric: bool = True,
+        timedelta: bool = True,
+    ) -> list[Block]:
+        """
+        attempt to coerce any object types to better types return a copy
+        of the block (if copy = True) by definition we are not an ObjectBlock
+        here!
+        """
+        return [self.copy()] if copy else [self]
+
+    # ---------------------------------------------------------------------
+    # Array-Like Methods
+
+    @cache_readonly
+    def dtype(self) -> DtypeObj:
+        return self.values.dtype
+
     @final
-    def astype(self, dtype: DtypeObj, copy: bool = False, errors: str = "raise"):
+    def astype(
+        self, dtype: DtypeObj, copy: bool = False, errors: IgnoreRaise = "raise"
+    ) -> Block:
         """
         Coerce to the new dtype.
 
@@ -579,54 +535,14 @@ def astype(self, dtype: DtypeObj, copy: bool = False, errors: str = "raise"):
             )
         return newb
 
-    def convert(
-        self,
-        copy: bool = True,
-        datetime: bool = True,
-        numeric: bool = True,
-        timedelta: bool = True,
-    ) -> list[Block]:
-        """
-        attempt to coerce any object types to better types return a copy
-        of the block (if copy = True) by definition we are not an ObjectBlock
-        here!
-        """
-        return [self.copy()] if copy else [self]
-
-    @final
-    def _can_hold_element(self, element: Any) -> bool:
-        """require the same dtype as ourselves"""
-        element = extract_array(element, extract_numpy=True)
-        return can_hold_element(self.values, element)
-
-    @final
-    def should_store(self, value: ArrayLike) -> bool:
-        """
-        Should we set self.values[indexer] = value inplace or do we need to cast?
-
-        Parameters
-        ----------
-        value : np.ndarray or ExtensionArray
-
-        Returns
-        -------
-        bool
-        """
-        # faster equivalent to is_dtype_equal(value.dtype, self.dtype)
-        try:
-            return value.dtype == self.dtype
-        except TypeError:
-            return False
-
     @final
-    def to_native_types(self, na_rep="nan", quoting=None, **kwargs):
+    def to_native_types(self, na_rep="nan", quoting=None, **kwargs) -> Block:
         """convert to our native types format"""
         result = to_native_types(self.values, na_rep=na_rep, quoting=quoting, **kwargs)
         return self.make_block(result)
 
-    # block actions #
     @final
-    def copy(self, deep: bool = True):
+    def copy(self, deep: bool = True) -> Block:
         """copy constructor"""
         values = self.values
         if deep:
@@ -653,13 +569,16 @@ def replace(
         # Note: the checks we do in NDFrame.replace ensure we never get
         #  here with listlike to_replace or value, as those cases
         #  go through replace_list
-
         values = self.values
 
         if isinstance(values, Categorical):
             # TODO: avoid special-casing
             blk = self if inplace else self.copy()
-            blk.values._replace(to_replace=to_replace, value=value, inplace=True)
+            # error: Item "ExtensionArray" of "Union[ndarray[Any, Any],
+            # ExtensionArray]" has no attribute "_replace"
+            blk.values._replace(  # type: ignore[union-attr]
+                to_replace=to_replace, value=value, inplace=True
+            )
             return [blk]
 
         if not self._can_hold_element(to_replace):
@@ -688,7 +607,10 @@ def replace(
             return blocks
 
         elif self.ndim == 1 or self.shape[0] == 1:
-            blk = self.coerce_to_target_dtype(value)
+            if value is None:
+                blk = self.astype(np.dtype(object))
+            else:
+                blk = self.coerce_to_target_dtype(value)
             return blk.replace(
                 to_replace=to_replace,
                 value=value,
@@ -698,9 +620,18 @@ def replace(
 
         else:
             # split so that we only upcast where necessary
-            return self.split_and_operate(
-                type(self).replace, to_replace, value, inplace=True
-            )
+            blocks = []
+            for i, nb in enumerate(self._split()):
+                blocks.extend(
+                    type(self).replace(
+                        nb,
+                        to_replace=to_replace,
+                        value=value,
+                        inplace=True,
+                        mask=mask[i : i + 1],
+                    )
+                )
+            return blocks
 
     @final
     def _replace_regex(
@@ -800,10 +731,13 @@ def replace_list(
                     assert not isinstance(mib, bool)
                     m = mib[blk_num : blk_num + 1]
 
+                # error: Argument "mask" to "_replace_coerce" of "Block" has
+                # incompatible type "Union[ExtensionArray, ndarray[Any, Any], bool]";
+                # expected "ndarray[Any, dtype[bool_]]"
                 result = blk._replace_coerce(
                     to_replace=src,
                     value=dest,
-                    mask=m,
+                    mask=m,  # type: ignore[arg-type]
                     inplace=inplace,
                     regex=regex,
                 )
@@ -821,7 +755,7 @@ def _replace_coerce(
         self,
         to_replace,
         value,
-        mask: np.ndarray,
+        mask: npt.NDArray[np.bool_],
         inplace: bool = True,
         regex: bool = False,
     ) -> list[Block]:
@@ -855,11 +789,22 @@ def _replace_coerce(
                 mask=mask,
             )
         else:
+            if value is None:
+                # gh-45601, gh-45836, gh-46634
+                if mask.any():
+                    nb = self.astype(np.dtype(object), copy=False)
+                    if nb is self and not inplace:
+                        nb = nb.copy()
+                    putmask_inplace(nb.values, mask, value)
+                    return [nb]
+                return [self] if inplace else [self.copy()]
             return self.replace(
                 to_replace=to_replace, value=value, inplace=inplace, mask=mask
             )
 
     # ---------------------------------------------------------------------
+    # 2D Methods - Shared by NumpyBlock and NDArrayBackedExtensionBlock
+    #  but not ExtensionBlock
 
     def _maybe_squeeze_arg(self, arg: np.ndarray) -> np.ndarray:
         """
@@ -867,281 +812,244 @@ def _maybe_squeeze_arg(self, arg: np.ndarray) -> np.ndarray:
         """
         return arg
 
-    def setitem(self, indexer, value):
+    def _unwrap_setitem_indexer(self, indexer):
         """
-        Attempt self.values[indexer] = value, possibly creating a new array.
-
-        Parameters
-        ----------
-        indexer : tuple, list-like, array-like, slice, int
-            The subset of self.values to set
-        value : object
-            The value being set
-
-        Returns
-        -------
-        Block
-
-        Notes
-        -----
-        `indexer` is a direct slice/positional indexer. `value` must
-        be a compatible shape.
+        For compatibility with 1D-only ExtensionArrays.
         """
-        transpose = self.ndim == 2
+        return indexer
 
-        if isinstance(indexer, np.ndarray) and indexer.ndim > self.ndim:
-            raise ValueError(f"Cannot set values with ndim > {self.ndim}")
+    # NB: this cannot be made cache_readonly because in mgr.set_values we pin
+    #  new .values that can have different shape GH#42631
+    @property
+    def shape(self) -> Shape:
+        return self.values.shape
 
-        # coerce None values, if appropriate
-        if value is None:
-            if self.is_numeric:
-                value = np.nan
+    def iget(self, i: int | tuple[int, int] | tuple[slice, int]) -> np.ndarray:
+        # In the case where we have a tuple[slice, int], the slice will always
+        #  be slice(None)
+        # Note: only reached with self.ndim == 2
+        # Invalid index type "Union[int, Tuple[int, int], Tuple[slice, int]]"
+        # for "Union[ndarray[Any, Any], ExtensionArray]"; expected type
+        # "Union[int, integer[Any]]"
+        return self.values[i]  # type: ignore[index]
+
+    def _slice(
+        self, slicer: slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]
+    ) -> ArrayLike:
+        """return a slice of my values"""
 
-        # coerce if block dtype can store value
-        values = cast(np.ndarray, self.values)
-        if not self._can_hold_element(value):
-            # current dtype cannot store value, coerce to common dtype
-            return self.coerce_to_target_dtype(value).setitem(indexer, value)
+        return self.values[slicer]
 
-        # value must be storable at this moment
-        if is_extension_array_dtype(getattr(value, "dtype", None)):
-            # We need to be careful not to allow through strings that
-            #  can be parsed to EADtypes
-            arr_value = value
-        else:
-            arr_value = np.asarray(value)
+    def set_inplace(self, locs, values: ArrayLike, copy: bool = False) -> None:
+        """
+        Modify block values in-place with new item value.
 
-        if transpose:
-            values = values.T
+        If copy=True, first copy the underlying values in place before modifying
+        (for Copy-on-Write).
 
-        # length checking
-        check_setitem_lengths(indexer, value, values)
+        Notes
+        -----
+        `set_inplace` never creates a new array or new Block, whereas `setitem`
+        _may_ create a new array and always creates a new Block.
 
-        if is_empty_indexer(indexer, arr_value):
-            # GH#8669 empty indexers, test_loc_setitem_boolean_mask_allfalse
-            pass
+        Caller is responsible for checking values.dtype == self.dtype.
+        """
+        if copy:
+            self.values = self.values.copy()
+        self.values[locs] = values
 
-        elif is_scalar_indexer(indexer, self.ndim):
-            # setting a single element for each dim and with a rhs that could
-            #  be e.g. a list; see GH#6043
-            values[indexer] = value
+    def take_nd(
+        self,
+        indexer: npt.NDArray[np.intp],
+        axis: int,
+        new_mgr_locs: BlockPlacement | None = None,
+        fill_value=lib.no_default,
+    ) -> Block:
+        """
+        Take values according to indexer and return them as a block.
+        """
+        values = self.values
 
+        if fill_value is lib.no_default:
+            fill_value = self.fill_value
+            allow_fill = False
         else:
-            value = setitem_datetimelike_compat(values, len(values[indexer]), value)
-            values[indexer] = value
+            allow_fill = True
 
-        return self
+        # Note: algos.take_nd has upcast logic similar to coerce_to_target_dtype
+        new_values = algos.take_nd(
+            values, indexer, axis=axis, allow_fill=allow_fill, fill_value=fill_value
+        )
 
-    def putmask(self, mask, new) -> list[Block]:
-        """
-        putmask the data to the block; it is possible that we may create a
-        new dtype of block
+        # Called from three places in managers, all of which satisfy
+        #  this assertion
+        assert not (axis == 0 and new_mgr_locs is None)
+        if new_mgr_locs is None:
+            new_mgr_locs = self._mgr_locs
 
-        Return the resulting block(s).
+        if not is_dtype_equal(new_values.dtype, self.dtype):
+            return self.make_block(new_values, new_mgr_locs)
+        else:
+            return self.make_block_same_class(new_values, new_mgr_locs)
 
-        Parameters
-        ----------
-        mask : np.ndarray[bool], SparseArray[bool], or BooleanArray
-        new : a ndarray/object
+    def _unstack(
+        self,
+        unstacker,
+        fill_value,
+        new_placement: npt.NDArray[np.intp],
+        needs_masking: npt.NDArray[np.bool_],
+    ):
+        """
+        Return a list of unstacked blocks of self
+
+        Parameters
+        ----------
+        unstacker : reshape._Unstacker
+        fill_value : int
+            Only used in ExtensionBlock._unstack
+        new_placement : np.ndarray[np.intp]
+        allow_fill : bool
+        needs_masking : np.ndarray[bool]
 
         Returns
         -------
-        List[Block]
+        blocks : list of Block
+            New blocks of unstacked values.
+        mask : array-like of bool
+            The mask of columns of `blocks` we should keep.
         """
-        orig_mask = mask
-        values = cast(np.ndarray, self.values)
-        mask, noop = validate_putmask(values.T, mask)
-        assert not isinstance(new, (ABCIndex, ABCSeries, ABCDataFrame))
-
-        if new is lib.no_default:
-            new = self.fill_value
-
-        # if we are passed a scalar None, convert it here
-        if not self.is_object and is_valid_na_for_dtype(new, self.dtype):
-            new = self.fill_value
-
-        if self._can_hold_element(new):
-            putmask_without_repeat(values.T, mask, new)
-            return [self]
-
-        elif np_version_under1p20 and infer_dtype_from(new)[0].kind in ["m", "M"]:
-            # using putmask with object dtype will incorrectly cast to object
-            # Having excluded self._can_hold_element, we know we cannot operate
-            #  in-place, so we are safe using `where`
-            return self.where(new, ~mask)
-
-        elif noop:
-            return [self]
-
-        elif self.ndim == 1 or self.shape[0] == 1:
-            # no need to split columns
-
-            if not is_list_like(new):
-                # putmask_smart can't save us the need to cast
-                return self.coerce_to_target_dtype(new).putmask(mask, new)
-
-            # This differs from
-            #  `self.coerce_to_target_dtype(new).putmask(mask, new)`
-            # because putmask_smart will check if new[mask] may be held
-            # by our dtype.
-            nv = putmask_smart(values.T, mask, new).T
-            return [self.make_block(nv)]
+        new_values, mask = unstacker.get_new_values(
+            self.values.T, fill_value=fill_value
+        )
 
-        else:
-            is_array = isinstance(new, np.ndarray)
+        mask = mask.any(0)
+        # TODO: in all tests we have mask.all(); can we rely on that?
 
-            res_blocks = []
-            nbs = self._split()
-            for i, nb in enumerate(nbs):
-                n = new
-                if is_array:
-                    # we have a different value per-column
-                    n = new[:, i : i + 1]
+        # Note: these next two lines ensure that
+        #  mask.sum() == sum(len(nb.mgr_locs) for nb in blocks)
+        #  which the calling function needs in order to pass verify_integrity=False
+        #  to the BlockManager constructor
+        new_values = new_values.T[mask]
+        new_placement = new_placement[mask]
 
-                submask = orig_mask[:, i : i + 1]
-                rbs = nb.putmask(submask, n)
-                res_blocks.extend(rbs)
-            return res_blocks
+        bp = BlockPlacement(new_placement)
+        blocks = [new_block_2d(new_values, placement=bp)]
+        return blocks, mask
 
-    @final
-    def coerce_to_target_dtype(self, other) -> Block:
-        """
-        coerce the current block to a dtype compat for other
-        we will return a block, possibly object, and not raise
+    # ---------------------------------------------------------------------
 
-        we can also safely try to coerce to the same dtype
-        and will receive the same block
+    def setitem(self, indexer, value) -> Block:
         """
-        # if we cannot then coerce to object
-        dtype, _ = infer_dtype_from(other, pandas_dtype=True)
+        Attempt self.values[indexer] = value, possibly creating a new array.
 
-        new_dtype = find_common_type([self.dtype, dtype])
+        Parameters
+        ----------
+        indexer : tuple, list-like, array-like, slice, int
+            The subset of self.values to set
+        value : object
+            The value being set
 
-        return self.astype(new_dtype, copy=False)
+        Returns
+        -------
+        Block
 
-    def interpolate(
-        self,
-        method: str = "pad",
-        axis: int = 0,
-        index: Index | None = None,
-        inplace: bool = False,
-        limit: int | None = None,
-        limit_direction: str = "forward",
-        limit_area: str | None = None,
-        fill_value: Any | None = None,
-        coerce: bool = False,
-        downcast: str | None = None,
-        **kwargs,
-    ) -> list[Block]:
+        Notes
+        -----
+        `indexer` is a direct slice/positional indexer. `value` must
+        be a compatible shape.
+        """
 
-        inplace = validate_bool_kwarg(inplace, "inplace")
+        value = self._standardize_fill_value(value)
 
-        if not self._can_hold_na:
-            # If there are no NAs, then interpolate is a no-op
-            return [self] if inplace else [self.copy()]
+        values = cast(np.ndarray, self.values)
+        if self.ndim == 2:
+            values = values.T
 
-        if self.is_object and self.ndim == 2 and self.shape[0] != 1 and axis == 0:
-            # split improves performance in ndarray.copy()
-            return self.split_and_operate(
-                type(self).interpolate,
-                method,
-                axis,
-                index,
-                inplace,
-                limit,
-                limit_direction,
-                limit_area,
-                fill_value,
-                coerce,
-                downcast,
-                **kwargs,
-            )
+        # length checking
+        check_setitem_lengths(indexer, value, values)
 
+        value = extract_array(value, extract_numpy=True)
         try:
-            m = missing.clean_fill_method(method)
-        except ValueError:
-            m = None
-        if m is None and self.dtype.kind != "f":
-            # only deal with floats
-            # bc we already checked that can_hold_na, we dont have int dtype here
-            # TODO: make a copy if not inplace?
-            return [self]
-
-        data = self.values if inplace else self.values.copy()
-        data = cast(np.ndarray, data)  # bc overridden by ExtensionBlock
-
-        missing.interpolate_array_2d(
-            data,
-            method=method,
-            axis=axis,
-            index=index,
-            limit=limit,
-            limit_direction=limit_direction,
-            limit_area=limit_area,
-            fill_value=fill_value,
-            **kwargs,
-        )
-
-        nb = self.make_block_same_class(data)
-        return nb._maybe_downcast([nb], downcast)
+            casted = np_can_hold_element(values.dtype, value)
+        except LossySetitemError:
+            # current dtype cannot store value, coerce to common dtype
+            nb = self.coerce_to_target_dtype(value)
+            return nb.setitem(indexer, value)
+        else:
+            if self.dtype == _dtype_obj:
+                # TODO: avoid having to construct values[indexer]
+                vi = values[indexer]
+                if lib.is_list_like(vi):
+                    # checking lib.is_scalar here fails on
+                    #  test_iloc_setitem_custom_object
+                    casted = setitem_datetimelike_compat(values, len(vi), casted)
+            values[indexer] = casted
+        return self
 
-    def take_nd(
-        self,
-        indexer,
-        axis: int,
-        new_mgr_locs: BlockPlacement | None = None,
-        fill_value=lib.no_default,
-    ) -> Block:
+    def putmask(self, mask, new) -> list[Block]:
         """
-        Take values according to indexer and return them as a block.bb
+        putmask the data to the block; it is possible that we may create a
+        new dtype of block
 
-        """
-        # algos.take_nd dispatches for DatetimeTZBlock, CategoricalBlock
-        # so need to preserve types
-        # sparse is treated like an ndarray, but needs .get_values() shaping
+        Return the resulting block(s).
 
-        values = self.values
+        Parameters
+        ----------
+        mask : np.ndarray[bool], SparseArray[bool], or BooleanArray
+        new : a ndarray/object
 
-        if fill_value is lib.no_default:
-            fill_value = self.fill_value
-            allow_fill = False
-        else:
-            allow_fill = True
+        Returns
+        -------
+        List[Block]
+        """
+        orig_mask = mask
+        values = cast(np.ndarray, self.values)
+        mask, noop = validate_putmask(values.T, mask)
+        assert not isinstance(new, (ABCIndex, ABCSeries, ABCDataFrame))
 
-        new_values = algos.take_nd(
-            values, indexer, axis=axis, allow_fill=allow_fill, fill_value=fill_value
-        )
+        if new is lib.no_default:
+            new = self.fill_value
 
-        # Called from three places in managers, all of which satisfy
-        #  this assertion
-        assert not (axis == 0 and new_mgr_locs is None)
-        if new_mgr_locs is None:
-            new_mgr_locs = self._mgr_locs
+        new = self._standardize_fill_value(new)
+        new = extract_array(new, extract_numpy=True)
 
-        if not is_dtype_equal(new_values.dtype, self.dtype):
-            return self.make_block(new_values, new_mgr_locs)
-        else:
-            return self.make_block_same_class(new_values, new_mgr_locs)
+        if noop:
+            return [self]
 
-    def diff(self, n: int, axis: int = 1) -> list[Block]:
-        """return block for the diff of the values"""
-        new_values = algos.diff(self.values, n, axis=axis)
-        return [self.make_block(values=new_values)]
+        try:
+            casted = np_can_hold_element(values.dtype, new)
+            putmask_without_repeat(values.T, mask, casted)
+            return [self]
+        except LossySetitemError:
 
-    def shift(self, periods: int, axis: int = 0, fill_value: Any = None) -> list[Block]:
-        """shift the block by periods, possibly upcast"""
-        # convert integer to float if necessary. need to do a lot more than
-        # that, handle boolean etc also
+            if self.ndim == 1 or self.shape[0] == 1:
+                # no need to split columns
 
-        values = cast(np.ndarray, self.values)
+                if not is_list_like(new):
+                    # using just new[indexer] can't save us the need to cast
+                    return self.coerce_to_target_dtype(new).putmask(mask, new)
+                else:
+                    indexer = mask.nonzero()[0]
+                    nb = self.setitem(indexer, new[indexer])
+                    return [nb]
 
-        new_values, fill_value = maybe_upcast(values, fill_value)
+            else:
+                is_array = isinstance(new, np.ndarray)
 
-        new_values = shift(new_values, periods, axis, fill_value)
+                res_blocks = []
+                nbs = self._split()
+                for i, nb in enumerate(nbs):
+                    n = new
+                    if is_array:
+                        # we have a different value per-column
+                        n = new[:, i : i + 1]
 
-        return [self.make_block(new_values)]
+                    submask = orig_mask[:, i : i + 1]
+                    rbs = nb.putmask(submask, n)
+                    res_blocks.extend(rbs)
+                return res_blocks
 
-    def where(self, other, cond) -> list[Block]:
+    def where(self, other, cond, _downcast="infer") -> list[Block]:
         """
         evaluate the block; return result block(s) from the result
 
@@ -1149,6 +1057,8 @@ def where(self, other, cond) -> list[Block]:
         ----------
         other : a ndarray/object
         cond : np.ndarray[bool], SparseArray[bool], or BooleanArray
+        _downcast : str or None, default "infer"
+            Private because we only specify it when calling from fillna.
 
         Returns
         -------
@@ -1159,6 +1069,8 @@ def where(self, other, cond) -> list[Block]:
 
         transpose = self.ndim == 2
 
+        cond = extract_bool_array(cond)
+
         # EABlocks override where
         values = cast(np.ndarray, self.values)
         orig_other = other
@@ -1166,25 +1078,51 @@ def where(self, other, cond) -> list[Block]:
             values = values.T
 
         icond, noop = validate_putmask(values, ~cond)
+        if noop:
+            # GH-39595: Always return a copy; short-circuit up/downcasting
+            return [self.copy()]
 
         if other is lib.no_default:
             other = self.fill_value
 
-        if is_valid_na_for_dtype(other, self.dtype) and self.dtype != _dtype_obj:
-            other = self.fill_value
-
-        if noop:
-            # TODO: avoid the downcasting at the end in this case?
-            # GH-39595: Always return a copy
-            result = values.copy()
+        other = self._standardize_fill_value(other)
 
-        elif not self._can_hold_element(other):
+        try:
+            # try/except here is equivalent to a self._can_hold_element check,
+            #  but this gets us back 'casted' which we will re-use below;
+            #  without using 'casted', expressions.where may do unwanted upcasts.
+            casted = np_can_hold_element(values.dtype, other)
+        except (ValueError, TypeError, LossySetitemError):
             # we cannot coerce, return a compat dtype
-            block = self.coerce_to_target_dtype(other)
-            blocks = block.where(orig_other, cond)
-            return self._maybe_downcast(blocks, "infer")
+
+            if self.ndim == 1 or self.shape[0] == 1:
+                # no need to split columns
+
+                block = self.coerce_to_target_dtype(other)
+                blocks = block.where(orig_other, cond)
+                return self._maybe_downcast(blocks, downcast=_downcast)
+
+            else:
+                # since _maybe_downcast would split blocks anyway, we
+                #  can avoid some potential upcast/downcast by splitting
+                #  on the front end.
+                is_array = isinstance(other, (np.ndarray, ExtensionArray))
+
+                res_blocks = []
+                nbs = self._split()
+                for i, nb in enumerate(nbs):
+                    oth = other
+                    if is_array:
+                        # we have a different value per-column
+                        oth = other[:, i : i + 1]
+
+                    submask = cond[:, i : i + 1]
+                    rbs = nb.where(oth, submask, _downcast=_downcast)
+                    res_blocks.extend(rbs)
+                return res_blocks
 
         else:
+            other = casted
             alt = setitem_datetimelike_compat(values, icond.sum(), other)
             if alt is not other:
                 if is_list_like(other) and len(other) < len(values):
@@ -1214,82 +1152,160 @@ def where(self, other, cond) -> list[Block]:
 
                 # Note: expressions.where may upcast.
                 result = expressions.where(~icond, values, other)
+                # The np_can_hold_element check _should_ ensure that we always
+                #  have result.dtype == self.dtype here.
 
-        if self._can_hold_na or self.ndim == 1:
-
-            if transpose:
-                result = result.T
-
-            return [self.make_block(result)]
-
-        # might need to separate out blocks
-        cond = ~icond
-        axis = cond.ndim - 1
-        cond = cond.swapaxes(axis, 0)
-        mask = cond.all(axis=1)
-
-        result_blocks: list[Block] = []
-        for m in [mask, ~mask]:
-            if m.any():
-                taken = result.take(m.nonzero()[0], axis=axis)
-                r = maybe_downcast_numeric(taken, self.dtype)
-                if r.dtype != taken.dtype:
-                    warnings.warn(
-                        "Downcasting integer-dtype results in .where is "
-                        "deprecated and will change in a future version. "
-                        "To retain the old behavior, explicitly cast the results "
-                        "to the desired dtype.",
-                        FutureWarning,
-                        stacklevel=find_stack_level(),
-                    )
-                nb = self.make_block(r.T, placement=self._mgr_locs[m])
-                result_blocks.append(nb)
+        if transpose:
+            result = result.T
+
+        return [self.make_block(result)]
+
+    def fillna(
+        self, value, limit: int | None = None, inplace: bool = False, downcast=None
+    ) -> list[Block]:
+        """
+        fillna on the block with the value. If we fail, then convert to
+        ObjectBlock and try again
+        """
+        # Caller is responsible for validating limit; if int it is strictly positive
+        inplace = validate_bool_kwarg(inplace, "inplace")
+
+        if not self._can_hold_na:
+            # can short-circuit the isna call
+            noop = True
+        else:
+            mask = isna(self.values)
+            mask, noop = validate_putmask(self.values, mask)
+
+        if noop:
+            # we can't process the value, but nothing to do
+            if inplace:
+                # Arbitrarily imposing the convention that we ignore downcast
+                #  on no-op when inplace=True
+                return [self]
+            else:
+                # GH#45423 consistent downcasting on no-ops.
+                nb = self.copy()
+                nbs = nb._maybe_downcast([nb], downcast=downcast)
+                return nbs
+
+        if limit is not None:
+            mask[mask.cumsum(self.ndim - 1) > limit] = False
+
+        if inplace:
+            nbs = self.putmask(mask.T, value)
+        else:
+            # without _downcast, we would break
+            #  test_fillna_dtype_conversion_equiv_replace
+            nbs = self.where(value, ~mask.T, _downcast=False)
+
+        # Note: blk._maybe_downcast vs self._maybe_downcast(nbs)
+        #  makes a difference bc blk may have object dtype, which has
+        #  different behavior in _maybe_downcast.
+        return extend_blocks(
+            [blk._maybe_downcast([blk], downcast=downcast) for blk in nbs]
+        )
+
+    def interpolate(
+        self,
+        method: str = "pad",
+        axis: int = 0,
+        index: Index | None = None,
+        inplace: bool = False,
+        limit: int | None = None,
+        limit_direction: str = "forward",
+        limit_area: str | None = None,
+        fill_value: Any | None = None,
+        downcast: str | None = None,
+        **kwargs,
+    ) -> list[Block]:
+
+        inplace = validate_bool_kwarg(inplace, "inplace")
+
+        if not self._can_hold_na:
+            # If there are no NAs, then interpolate is a no-op
+            return [self] if inplace else [self.copy()]
+
+        try:
+            m = missing.clean_fill_method(method)
+        except ValueError:
+            m = None
+        if m is None and self.dtype.kind != "f":
+            # only deal with floats
+            # bc we already checked that can_hold_na, we dont have int dtype here
+            # test_interp_basic checks that we make a copy here
+            return [self] if inplace else [self.copy()]
+
+        if self.is_object and self.ndim == 2 and self.shape[0] != 1 and axis == 0:
+            # split improves performance in ndarray.copy()
+            return self.split_and_operate(
+                type(self).interpolate,
+                method,
+                axis,
+                index,
+                inplace,
+                limit,
+                limit_direction,
+                limit_area,
+                fill_value,
+                downcast,
+                **kwargs,
+            )
+
+        data = self.values if inplace else self.values.copy()
+        data = cast(np.ndarray, data)  # bc overridden by ExtensionBlock
+
+        missing.interpolate_array_2d(
+            data,
+            method=method,
+            axis=axis,
+            index=index,
+            limit=limit,
+            limit_direction=limit_direction,
+            limit_area=limit_area,
+            fill_value=fill_value,
+            **kwargs,
+        )
+
+        nb = self.make_block_same_class(data)
+        return nb._maybe_downcast([nb], downcast)
 
-        return result_blocks
+    def diff(self, n: int, axis: int = 1) -> list[Block]:
+        """return block for the diff of the values"""
+        new_values = algos.diff(self.values, n, axis=axis)
+        return [self.make_block(values=new_values)]
 
-    def _unstack(
-        self,
-        unstacker,
-        fill_value,
-        new_placement: npt.NDArray[np.intp],
-        needs_masking: npt.NDArray[np.bool_],
-    ):
-        """
-        Return a list of unstacked blocks of self
+    def shift(self, periods: int, axis: int = 0, fill_value: Any = None) -> list[Block]:
+        """shift the block by periods, possibly upcast"""
+        # convert integer to float if necessary. need to do a lot more than
+        # that, handle boolean etc also
 
-        Parameters
-        ----------
-        unstacker : reshape._Unstacker
-        fill_value : int
-            Only used in ExtensionBlock._unstack
-        new_placement : np.ndarray[np.intp]
-        allow_fill : bool
-        needs_masking : np.ndarray[bool]
+        # Note: periods is never 0 here, as that is handled at the top of
+        #  NDFrame.shift.  If that ever changes, we can do a check for periods=0
+        #  and possibly avoid coercing.
 
-        Returns
-        -------
-        blocks : list of Block
-            New blocks of unstacked values.
-        mask : array-like of bool
-            The mask of columns of `blocks` we should keep.
-        """
-        new_values, mask = unstacker.get_new_values(
-            self.values.T, fill_value=fill_value
-        )
+        if not lib.is_scalar(fill_value) and self.dtype != _dtype_obj:
+            # with object dtype there is nothing to promote, and the user can
+            #  pass pretty much any weird fill_value they like
+            # see test_shift_object_non_scalar_fill
+            raise ValueError("fill_value must be a scalar")
 
-        mask = mask.any(0)
-        # TODO: in all tests we have mask.all(); can we rely on that?
+        fill_value = self._standardize_fill_value(fill_value)
 
-        # Note: these next two lines ensure that
-        #  mask.sum() == sum(len(nb.mgr_locs) for nb in blocks)
-        #  which the calling function needs in order to pass verify_integrity=False
-        #  to the BlockManager constructor
-        new_values = new_values.T[mask]
-        new_placement = new_placement[mask]
+        try:
+            # error: Argument 1 to "np_can_hold_element" has incompatible type
+            # "Union[dtype[Any], ExtensionDtype]"; expected "dtype[Any]"
+            casted = np_can_hold_element(
+                self.dtype, fill_value  # type: ignore[arg-type]
+            )
+        except LossySetitemError:
+            nb = self.coerce_to_target_dtype(fill_value)
+            return nb.shift(periods, axis=axis, fill_value=fill_value)
 
-        bp = BlockPlacement(new_placement)
-        blocks = [new_block_2d(new_values, placement=bp)]
-        return blocks, mask
+        else:
+            values = cast(np.ndarray, self.values)
+            new_values = shift(values, periods, axis, casted)
+            return [self.make_block(new_values)]
 
     @final
     def quantile(
@@ -1322,6 +1338,37 @@ def quantile(
         result = ensure_block_shape(result, ndim=2)
         return new_block_2d(result, placement=self._mgr_locs)
 
+    # ---------------------------------------------------------------------
+    # Abstract Methods Overridden By EABackedBlock and NumpyBlock
+
+    def delete(self, loc) -> Block:
+        """
+        Return a new Block with the given loc(s) deleted.
+        """
+        raise AbstractMethodError(self)
+
+    @property
+    def is_view(self) -> bool:
+        """return a boolean if I am possibly a view"""
+        raise AbstractMethodError(self)
+
+    @property
+    def array_values(self) -> ExtensionArray:
+        """
+        The array that Series.array returns. Always an ExtensionArray.
+        """
+        raise AbstractMethodError(self)
+
+    def get_values(self, dtype: DtypeObj | None = None) -> np.ndarray:
+        """
+        return an internal format, currently just the ndarray
+        this is often overridden to handle to_dense like operations
+        """
+        raise AbstractMethodError(self)
+
+    def values_for_json(self) -> np.ndarray:
+        raise AbstractMethodError(self)
+
 
 class EABackedBlock(Block):
     """
@@ -1330,11 +1377,70 @@ class EABackedBlock(Block):
 
     values: ExtensionArray
 
-    def where(self, other, cond) -> list[Block]:
+    def setitem(self, indexer, value):
+        """
+        Attempt self.values[indexer] = value, possibly creating a new array.
+
+        This differs from Block.setitem by not allowing setitem to change
+        the dtype of the Block.
+
+        Parameters
+        ----------
+        indexer : tuple, list-like, array-like, slice, int
+            The subset of self.values to set
+        value : object
+            The value being set
+
+        Returns
+        -------
+        Block
+
+        Notes
+        -----
+        `indexer` is a direct slice/positional indexer. `value` must
+        be a compatible shape.
+        """
+        orig_indexer = indexer
+        orig_value = value
+
+        indexer = self._unwrap_setitem_indexer(indexer)
+        value = self._maybe_squeeze_arg(value)
+
+        values = self.values
+        if values.ndim == 2:
+            # TODO(GH#45419): string[pyarrow] tests break if we transpose
+            #  unconditionally
+            values = values.T
+        check_setitem_lengths(indexer, value, values)
+
+        try:
+            values[indexer] = value
+        except (ValueError, TypeError) as err:
+            _catch_deprecated_value_error(err)
+
+            if is_interval_dtype(self.dtype):
+                # see TestSetitemFloatIntervalWithIntIntervalValues
+                nb = self.coerce_to_target_dtype(orig_value)
+                return nb.setitem(orig_indexer, orig_value)
+
+            elif isinstance(self, NDArrayBackedExtensionBlock):
+                nb = self.coerce_to_target_dtype(orig_value)
+                return nb.setitem(orig_indexer, orig_value)
+
+            else:
+                raise
+
+        else:
+            return self
+
+    def where(self, other, cond, _downcast="infer") -> list[Block]:
+        # _downcast private bc we only specify it when calling from fillna
         arr = self.values.T
 
         cond = extract_bool_array(cond)
 
+        orig_other = other
+        orig_cond = cond
         other = self._maybe_squeeze_arg(other)
         cond = self._maybe_squeeze_arg(cond)
 
@@ -1345,40 +1451,47 @@ def where(self, other, cond) -> list[Block]:
         if noop:
             # GH#44181, GH#45135
             # Avoid a) raising for Interval/PeriodDtype and b) unnecessary object upcast
-            return self.copy()
+            return [self.copy()]
 
         try:
             res_values = arr._where(cond, other).T
         except (ValueError, TypeError) as err:
-            if isinstance(err, ValueError):
-                # TODO(2.0): once DTA._validate_setitem_value deprecation
-                #  is enforced, stop catching ValueError here altogether
-                if "Timezones don't match" not in str(err):
-                    raise
+            _catch_deprecated_value_error(err)
 
-            if is_interval_dtype(self.dtype):
-                # TestSetitemFloatIntervalWithIntIntervalValues
-                blk = self.coerce_to_target_dtype(other)
-                if blk.dtype == _dtype_obj:
-                    # For now at least only support casting e.g.
-                    #  Interval[int64]->Interval[float64]
-                    raise
-                return blk.where(other, cond)
+            if self.ndim == 1 or self.shape[0] == 1:
 
-            elif isinstance(self, NDArrayBackedExtensionBlock):
-                # NB: not (yet) the same as
-                #  isinstance(values, NDArrayBackedExtensionArray)
-                if isinstance(self.dtype, PeriodDtype):
-                    # TODO: don't special-case
-                    # Note: this is the main place where the fallback logic
-                    #  is different from EABackedBlock.putmask.
+                if is_interval_dtype(self.dtype):
+                    # TestSetitemFloatIntervalWithIntIntervalValues
+                    blk = self.coerce_to_target_dtype(orig_other)
+                    nbs = blk.where(orig_other, orig_cond)
+                    return self._maybe_downcast(nbs, downcast=_downcast)
+
+                elif isinstance(self, NDArrayBackedExtensionBlock):
+                    # NB: not (yet) the same as
+                    #  isinstance(values, NDArrayBackedExtensionArray)
+                    blk = self.coerce_to_target_dtype(orig_other)
+                    nbs = blk.where(orig_other, orig_cond)
+                    return self._maybe_downcast(nbs, downcast=_downcast)
+
+                else:
                     raise
-                blk = self.coerce_to_target_dtype(other)
-                nbs = blk.where(other, cond)
-                return self._maybe_downcast(nbs, "infer")
 
             else:
-                raise
+                # Same pattern we use in Block.putmask
+                is_array = isinstance(orig_other, (np.ndarray, ExtensionArray))
+
+                res_blocks = []
+                nbs = self._split()
+                for i, nb in enumerate(nbs):
+                    n = orig_other
+                    if is_array:
+                        # we have a different value per-column
+                        n = orig_other[:, i : i + 1]
+
+                    submask = orig_cond[:, i : i + 1]
+                    rbs = nb.where(n, submask)
+                    res_blocks.extend(rbs)
+                return res_blocks
 
         nb = self.make_block_same_class(res_values)
         return [nb]
@@ -1390,51 +1503,93 @@ def putmask(self, mask, new) -> list[Block]:
         mask = extract_bool_array(mask)
 
         values = self.values
+        if values.ndim == 2:
+            values = values.T
 
+        orig_new = new
+        orig_mask = mask
+        new = self._maybe_squeeze_arg(new)
         mask = self._maybe_squeeze_arg(mask)
 
+        if not mask.any():
+            return [self]
+
         try:
             # Caller is responsible for ensuring matching lengths
             values._putmask(mask, new)
         except (TypeError, ValueError) as err:
-            if isinstance(err, ValueError) and "Timezones don't match" not in str(err):
-                # TODO(2.0): remove catching ValueError at all since
-                #  DTA raising here is deprecated
-                raise
+            _catch_deprecated_value_error(err)
 
-            if is_interval_dtype(self.dtype):
-                # Discussion about what we want to support in the general
-                #  case GH#39584
-                blk = self.coerce_to_target_dtype(new)
-                if blk.dtype == _dtype_obj:
-                    # For now at least, only support casting e.g.
-                    #  Interval[int64]->Interval[float64],
-                    raise
-                return blk.putmask(mask, new)
+            if self.ndim == 1 or self.shape[0] == 1:
 
-            elif isinstance(self, NDArrayBackedExtensionBlock):
-                # NB: not (yet) the same as
-                #  isinstance(values, NDArrayBackedExtensionArray)
-                blk = self.coerce_to_target_dtype(new)
-                return blk.putmask(mask, new)
+                if is_interval_dtype(self.dtype):
+                    # Discussion about what we want to support in the general
+                    #  case GH#39584
+                    blk = self.coerce_to_target_dtype(orig_new)
+                    return blk.putmask(orig_mask, orig_new)
+
+                elif isinstance(self, NDArrayBackedExtensionBlock):
+                    # NB: not (yet) the same as
+                    #  isinstance(values, NDArrayBackedExtensionArray)
+                    blk = self.coerce_to_target_dtype(orig_new)
+                    return blk.putmask(orig_mask, orig_new)
+
+                else:
+                    raise
 
             else:
-                raise
+                # Same pattern we use in Block.putmask
+                is_array = isinstance(orig_new, (np.ndarray, ExtensionArray))
+
+                res_blocks = []
+                nbs = self._split()
+                for i, nb in enumerate(nbs):
+                    n = orig_new
+                    if is_array:
+                        # we have a different value per-column
+                        n = orig_new[:, i : i + 1]
+
+                    submask = orig_mask[:, i : i + 1]
+                    rbs = nb.putmask(submask, n)
+                    res_blocks.extend(rbs)
+                return res_blocks
 
         return [self]
 
-    def delete(self, loc) -> None:
-        """
-        Delete given loc(-s) from block in-place.
-        """
+    def fillna(
+        self, value, limit: int | None = None, inplace: bool = False, downcast=None
+    ) -> list[Block]:
+        # Caller is responsible for validating limit; if int it is strictly positive
+
+        if self.dtype.kind == "m":
+            try:
+                res_values = self.values.fillna(value, limit=limit)
+            except (ValueError, TypeError):
+                # GH#45746
+                warnings.warn(
+                    "The behavior of fillna with timedelta64[ns] dtype and "
+                    f"an incompatible value ({type(value)}) is deprecated. "
+                    "In a future version, this will cast to a common dtype "
+                    "(usually object) instead of raising, matching the "
+                    "behavior of other dtypes.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
+                raise
+            else:
+                res_blk = self.make_block(res_values)
+                return [res_blk]
+
+        # TODO: since this now dispatches to super, which in turn dispatches
+        #  to putmask, it may *actually* respect 'inplace=True'. If so, add
+        #  tests for this.
+        return super().fillna(value, limit=limit, inplace=inplace, downcast=downcast)
+
+    def delete(self, loc) -> Block:
         # This will be unnecessary if/when __array_function__ is implemented
-        self.values = self.values.delete(loc)
-        self.mgr_locs = self._mgr_locs.delete(loc)
-        try:
-            self._cache.clear()
-        except AttributeError:
-            # _cache not yet initialized
-            pass
+        values = self.values.delete(loc)
+        mgr_locs = self._mgr_locs.delete(loc)
+        return type(self)(values, placement=mgr_locs, ndim=self.ndim)
 
     @cache_readonly
     def array_values(self) -> ExtensionArray:
@@ -1490,114 +1645,119 @@ def shape(self) -> Shape:
             return (len(self.values),)
         return len(self._mgr_locs), len(self.values)
 
-    def iget(self, col):
+    def iget(self, i: int | tuple[int, int] | tuple[slice, int]):
+        # In the case where we have a tuple[slice, int], the slice will always
+        #  be slice(None)
+        # We _could_ make the annotation more specific, but mypy would
+        #  complain about override mismatch:
+        #  Literal[0] | tuple[Literal[0], int] | tuple[slice, int]
 
-        if self.ndim == 2 and isinstance(col, tuple):
+        # Note: only reached with self.ndim == 2
+
+        if isinstance(i, tuple):
             # TODO(EA2D): unnecessary with 2D EAs
-            col, loc = col
+            col, loc = i
             if not com.is_null_slice(col) and col != 0:
                 raise IndexError(f"{self} only contains one item")
             elif isinstance(col, slice):
-                if col != slice(None):
-                    raise NotImplementedError(col)
-                return self.values[[loc]]
+                # the is_null_slice check above assures that col is slice(None)
+                #  so what we want is a view on all our columns and row loc
+                if loc < 0:
+                    loc += len(self.values)
+                # Note: loc:loc+1 vs [[loc]] makes a difference when called
+                #  from fast_xs because we want to get a view back.
+                return self.values[loc : loc + 1]
             return self.values[loc]
         else:
-            if col != 0:
+            if i != 0:
                 raise IndexError(f"{self} only contains one item")
             return self.values
 
-    def set_inplace(self, locs, values) -> None:
-        # NB: This is a misnomer, is supposed to be inplace but is not,
-        #  see GH#33457
+    def set_inplace(self, locs, values: ArrayLike, copy: bool = False) -> None:
         # When an ndarray, we should have locs.tolist() == [0]
         # When a BlockPlacement we should have list(locs) == [0]
-        self.values = values
-        try:
-            # TODO(GH33457) this can be removed
-            self._cache.clear()
-        except AttributeError:
-            # _cache not yet initialized
-            pass
+        if copy:
+            self.values = self.values.copy()
+        self.values[:] = values
 
     def _maybe_squeeze_arg(self, arg):
         """
         If necessary, squeeze a (N, 1) ndarray to (N,)
         """
         # e.g. if we are passed a 2D mask for putmask
-        if isinstance(arg, np.ndarray) and arg.ndim == self.values.ndim + 1:
+        if (
+            isinstance(arg, (np.ndarray, ExtensionArray))
+            and arg.ndim == self.values.ndim + 1
+        ):
             # TODO(EA2D): unnecessary with 2D EAs
             assert arg.shape[1] == 1
-            arg = arg[:, 0]
-        return arg
-
-    @property
-    def is_view(self) -> bool:
-        """Extension arrays are never treated as views."""
-        return False
+            # error: No overload variant of "__getitem__" of "ExtensionArray"
+            # matches argument type "Tuple[slice, int]"
+            arg = arg[:, 0]  # type: ignore[call-overload]
+        elif isinstance(arg, ABCDataFrame):
+            # 2022-01-06 only reached for setitem
+            # TODO: should we avoid getting here with DataFrame?
+            assert arg.shape[1] == 1
+            arg = arg._ixs(0, axis=1)._values
 
-    @cache_readonly
-    def is_numeric(self):
-        return self.values.dtype._is_numeric
+        return arg
 
-    def setitem(self, indexer, value):
+    def _unwrap_setitem_indexer(self, indexer):
         """
-        Attempt self.values[indexer] = value, possibly creating a new array.
-
-        This differs from Block.setitem by not allowing setitem to change
-        the dtype of the Block.
+        Adapt a 2D-indexer to our 1D values.
 
-        Parameters
-        ----------
-        indexer : tuple, list-like, array-like, slice, int
-            The subset of self.values to set
-        value : object
-            The value being set
-
-        Returns
-        -------
-        Block
-
-        Notes
-        -----
-        `indexer` is a direct slice/positional indexer. `value` must
-        be a compatible shape.
+        This is intended for 'setitem', not 'iget' or '_slice'.
         """
-        if not self._can_hold_element(value):
-            # see TestSetitemFloatIntervalWithIntIntervalValues
-            return self.coerce_to_target_dtype(value).setitem(indexer, value)
+        # TODO: ATM this doesn't work for iget/_slice, can we change that?
 
         if isinstance(indexer, tuple):
             # TODO(EA2D): not needed with 2D EAs
-            # we are always 1-D
-            indexer = indexer[0]
-            if isinstance(indexer, np.ndarray) and indexer.ndim == 2:
-                # GH#44703
-                if indexer.shape[1] != 1:
+            #  Should never have length > 2.  Caller is responsible for checking.
+            #  Length 1 is reached vis setitem_single_block and setitem_single_column
+            #  each of which pass indexer=(pi,)
+            if len(indexer) == 2:
+
+                if all(isinstance(x, np.ndarray) and x.ndim == 2 for x in indexer):
+                    # GH#44703 went through indexing.maybe_convert_ix
+                    first, second = indexer
+                    if not (
+                        second.size == 1 and (second == 0).all() and first.shape[1] == 1
+                    ):
+                        raise NotImplementedError(
+                            "This should not be reached. Please report a bug at "
+                            "github.com/pandas-dev/pandas/"
+                        )
+                    indexer = first[:, 0]
+
+                elif lib.is_integer(indexer[1]) and indexer[1] == 0:
+                    # reached via setitem_single_block passing the whole indexer
+                    indexer = indexer[0]
+
+                elif com.is_null_slice(indexer[1]):
+                    indexer = indexer[0]
+
+                elif is_list_like(indexer[1]) and indexer[1][0] == 0:
+                    indexer = indexer[0]
+
+                else:
                     raise NotImplementedError(
                         "This should not be reached. Please report a bug at "
                         "github.com/pandas-dev/pandas/"
                     )
-                indexer = indexer[:, 0]
+        return indexer
 
-        # TODO(EA2D): not needed with 2D EAS
-        if isinstance(value, (np.ndarray, ExtensionArray)) and value.ndim == 2:
-            assert value.shape[1] == 1
-            # error: No overload variant of "__getitem__" of "ExtensionArray"
-            # matches argument type "Tuple[slice, int]"
-            value = value[:, 0]  # type: ignore[call-overload]
-        elif isinstance(value, ABCDataFrame):
-            # TODO: should we avoid getting here with DataFrame?
-            assert value.shape[1] == 1
-            value = value._ixs(0, axis=1)._values
+    @property
+    def is_view(self) -> bool:
+        """Extension arrays are never treated as views."""
+        return False
 
-        check_setitem_lengths(indexer, value, self.values)
-        self.values[indexer] = value
-        return self
+    @cache_readonly
+    def is_numeric(self):
+        return self.values.dtype._is_numeric
 
     def take_nd(
         self,
-        indexer,
+        indexer: npt.NDArray[np.intp],
         axis: int = 0,
         new_mgr_locs: BlockPlacement | None = None,
         fill_value=lib.no_default,
@@ -1622,43 +1782,43 @@ def take_nd(
 
         return self.make_block_same_class(new_values, new_mgr_locs)
 
-    def _slice(self, slicer) -> ExtensionArray:
+    def _slice(
+        self, slicer: slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]
+    ) -> ExtensionArray:
         """
         Return a slice of my values.
 
         Parameters
         ----------
-        slicer : slice, ndarray[int], or a tuple of these
+        slicer : slice, ndarray[int], or ndarray[bool]
             Valid (non-reducing) indexer for self.values.
 
         Returns
         -------
         ExtensionArray
         """
+        # Notes: ndarray[bool] is only reachable when via getitem_mgr, which
+        #  is only for Series, i.e. self.ndim == 1.
+
         # return same dims as we currently have
-        if not isinstance(slicer, tuple) and self.ndim == 2:
+        if self.ndim == 2:
             # reached via getitem_block via _slice_take_blocks_ax0
             # TODO(EA2D): won't be necessary with 2D EAs
-            slicer = (slicer, slice(None))
 
-        if isinstance(slicer, tuple) and len(slicer) == 2:
-            first = slicer[0]
-            if not isinstance(first, slice):
+            if not isinstance(slicer, slice):
                 raise AssertionError(
-                    "invalid slicing for a 1-ndim ExtensionArray", first
+                    "invalid slicing for a 1-ndim ExtensionArray", slicer
                 )
             # GH#32959 only full-slicers along fake-dim0 are valid
             # TODO(EA2D): won't be necessary with 2D EAs
             # range(1) instead of self._mgr_locs to avoid exception on [::-1]
             #  see test_iloc_getitem_slice_negative_step_ea_block
-            new_locs = range(1)[first]
-            if len(new_locs):
-                # effectively slice(None)
-                slicer = slicer[1]
-            else:
+            new_locs = range(1)[slicer]
+            if not len(new_locs):
                 raise AssertionError(
                     "invalid slicing for a 1-ndim ExtensionArray", slicer
                 )
+            slicer = slice(None)
 
         return self.values[slicer]
 
@@ -1672,12 +1832,6 @@ def getitem_block_index(self, slicer: slice) -> ExtensionBlock:
         new_values = self.values[slicer]
         return type(self)(new_values, self._mgr_locs, ndim=self.ndim)
 
-    def fillna(
-        self, value, limit=None, inplace: bool = False, downcast=None
-    ) -> list[Block]:
-        values = self.values.fillna(value=value, limit=limit)
-        return [self.make_block_same_class(values=values)]
-
     def diff(self, n: int, axis: int = 1) -> list[Block]:
         if axis == 0 and n != 0:
             # n==0 case will be a no-op so let is fall through
@@ -1746,6 +1900,28 @@ def _unstack(
 class NumpyBlock(libinternals.NumpyBlock, Block):
     values: np.ndarray
 
+    @property
+    def is_view(self) -> bool:
+        """return a boolean if I am possibly a view"""
+        return self.values.base is not None
+
+    @property
+    def array_values(self) -> ExtensionArray:
+        return PandasArray(self.values)
+
+    def get_values(self, dtype: DtypeObj | None = None) -> np.ndarray:
+        if dtype == _dtype_obj:
+            return self.values.astype(_dtype_obj)
+        return self.values
+
+    def values_for_json(self) -> np.ndarray:
+        return self.values
+
+    def delete(self, loc) -> Block:
+        values = np.delete(self.values, loc, 0)
+        mgr_locs = self._mgr_locs.delete(loc)
+        return type(self)(values, placement=mgr_locs, ndim=self.ndim)
+
 
 class NumericBlock(NumpyBlock):
     __slots__ = ()
@@ -1771,18 +1947,6 @@ def is_view(self) -> bool:
         # check the ndarray values of the DatetimeIndex values
         return self.values._ndarray.base is not None
 
-    def setitem(self, indexer, value):
-        if not self._can_hold_element(value):
-            return self.coerce_to_target_dtype(value).setitem(indexer, value)
-
-        values = self.values
-        if self.ndim > 1:
-            # Dont transpose with ndim=1 bc we would fail to invalidate
-            #  arr.freq
-            values = values.T
-        values[indexer] = value
-        return self
-
     def diff(self, n: int, axis: int = 0) -> list[Block]:
         """
         1st discrete difference.
@@ -1813,20 +1977,22 @@ def shift(self, periods: int, axis: int = 0, fill_value: Any = None) -> list[Blo
         new_values = values.shift(periods, fill_value=fill_value, axis=axis)
         return [self.make_block_same_class(new_values)]
 
-    def fillna(
-        self, value, limit=None, inplace: bool = False, downcast=None
-    ) -> list[Block]:
-
-        if not self._can_hold_element(value) and self.dtype.kind != "m":
-            # We support filling a DatetimeTZ with a `value` whose timezone
-            #  is different by coercing to object.
-            # TODO: don't special-case td64
-            return self.coerce_to_target_dtype(value).fillna(
-                value, limit, inplace, downcast
-            )
 
-        new_values = self.values.fillna(value=value, limit=limit)
-        return [self.make_block_same_class(values=new_values)]
+def _catch_deprecated_value_error(err: Exception) -> None:
+    """
+    We catch ValueError for now, but only a specific one raised by DatetimeArray
+    which will no longer be raised in version.2.0.
+    """
+    if isinstance(err, ValueError):
+        # TODO(2.0): once DTA._validate_setitem_value deprecation
+        #  is enforced, stop catching ValueError here altogether
+        if isinstance(err, IncompatibleFrequency):
+            pass
+        elif "'value.closed' is" in str(err):
+            # IntervalDtype mismatched 'closed'
+            pass
+        elif "Timezones don't match" not in str(err):
+            raise
 
 
 class DatetimeLikeBlock(NDArrayBackedExtensionBlock):
@@ -1837,8 +2003,6 @@ class DatetimeLikeBlock(NDArrayBackedExtensionBlock):
     values: DatetimeArray | TimedeltaArray
 
     def values_for_json(self) -> np.ndarray:
-        # special casing datetimetz to avoid conversion through
-        #  object dtype
         return self.values._ndarray
 
 
@@ -1852,6 +2016,10 @@ class DatetimeTZBlock(DatetimeLikeBlock):
     _validate_ndim = True
     _can_consolidate = False
 
+    # Don't use values_for_json from DatetimeLikeBlock since it is
+    # an invalid optimization here(drop the tz)
+    values_for_json = NDArrayBackedExtensionBlock.values_for_json
+
 
 class ObjectBlock(NumpyBlock):
     __slots__ = ()
@@ -2015,7 +2183,7 @@ def new_block(values, placement, *, ndim: int) -> Block:
     return klass(values, ndim=ndim, placement=placement)
 
 
-def check_ndim(values, placement: BlockPlacement, ndim: int):
+def check_ndim(values, placement: BlockPlacement, ndim: int) -> None:
     """
     ndim inference and validation.
 
@@ -2121,9 +2289,9 @@ def to_native_types(
     **kwargs,
 ) -> np.ndarray:
     """convert to our native types format"""
-    if isinstance(values, Categorical):
+    if isinstance(values, Categorical) and values.categories.dtype.kind in "Mm":
         # GH#40754 Convert categorical datetimes to datetime array
-        values = take_nd(
+        values = algos.take_nd(
             values.categories._values,
             ensure_platform_int(values._codes),
             fill_value=na_rep,
@@ -2144,14 +2312,7 @@ def to_native_types(
             results_converted.append(result.astype(object, copy=False))
         return np.vstack(results_converted)
 
-    elif isinstance(values, ExtensionArray):
-        mask = isna(values)
-
-        new_values = np.asarray(values.astype(object))
-        new_values[mask] = na_rep
-        return new_values
-
-    elif values.dtype.kind == "f":
+    elif values.dtype.kind == "f" and not is_sparse(values):
         # see GH#13418: no special formatting is desired at the
         # output (important for appropriate 'quoting' behaviour),
         # so do not pass it through the FloatArrayFormatter
@@ -2181,6 +2342,13 @@ def to_native_types(
         res = res.astype(object, copy=False)
         return res
 
+    elif isinstance(values, ExtensionArray):
+        mask = isna(values)
+
+        new_values = np.asarray(values.astype(object))
+        new_values[mask] = na_rep
+        return new_values
+
     else:
 
         mask = isna(values)
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 782842d167570..dafc437d5880e 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import itertools
 from typing import (
     TYPE_CHECKING,
@@ -13,6 +14,7 @@
     NaT,
     internals as libinternals,
 )
+from pandas._libs.missing import NA
 from pandas._typing import (
     ArrayLike,
     DtypeObj,
@@ -27,20 +29,30 @@
 )
 from pandas.core.dtypes.common import (
     is_1d_only_ea_dtype,
-    is_1d_only_ea_obj,
-    is_datetime64tz_dtype,
     is_dtype_equal,
+    is_scalar,
+    needs_i8_conversion,
 )
 from pandas.core.dtypes.concat import (
     cast_to_common_type,
     concat_compat,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    ExtensionDtype,
+)
+from pandas.core.dtypes.missing import (
+    is_valid_na_for_dtype,
+    isna,
+    isna_all,
+)
 
+import pandas.core.algorithms as algos
 from pandas.core.arrays import (
     DatetimeArray,
     ExtensionArray,
 )
+from pandas.core.arrays.sparse import SparseDtype
 from pandas.core.construction import ensure_wrapped_if_datetimelike
 from pandas.core.internals.array_manager import (
     ArrayManager,
@@ -137,16 +149,6 @@ def concat_arrays(to_concat: list) -> ArrayLike:
     else:
         target_dtype = find_common_type([arr.dtype for arr in to_concat_no_proxy])
 
-    if target_dtype.kind in ["m", "M"]:
-        # for datetimelike use DatetimeArray/TimedeltaArray concatenation
-        # don't use arr.astype(target_dtype, copy=False), because that doesn't
-        # work for DatetimeArray/TimedeltaArray (returns ndarray)
-        to_concat = [
-            arr.to_array(target_dtype) if isinstance(arr, NullArrayProxy) else arr
-            for arr in to_concat
-        ]
-        return type(to_concat_no_proxy[0])._concat_same_type(to_concat, axis=0)
-
     to_concat = [
         arr.to_array(target_dtype)
         if isinstance(arr, NullArrayProxy)
@@ -192,29 +194,19 @@ def concatenate_managers(
     if isinstance(mgrs_indexers[0][0], ArrayManager):
         return _concatenate_array_managers(mgrs_indexers, axes, concat_axis, copy)
 
-    # Assertions disabled for performance
-    # for tup in mgrs_indexers:
-    #    # caller is responsible for ensuring this
-    #    indexers = tup[1]
-    #    assert concat_axis not in indexers
-
-    if concat_axis == 0:
-        return _concat_managers_axis0(mgrs_indexers, axes, copy)
-
     mgrs_indexers = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers)
 
-    # Assertion disabled for performance
-    # assert all(not x[1] for x in mgrs_indexers)
-
-    concat_plans = [_get_mgr_concatenation_plan(mgr) for mgr, _ in mgrs_indexers]
-    concat_plan = _combine_concat_plans(concat_plans)
+    concat_plans = [
+        _get_mgr_concatenation_plan(mgr, indexers) for mgr, indexers in mgrs_indexers
+    ]
+    concat_plan = _combine_concat_plans(concat_plans, concat_axis)
     blocks = []
 
     for placement, join_units in concat_plan:
         unit = join_units[0]
         blk = unit.block
 
-        if len(join_units) == 1:
+        if len(join_units) == 1 and not join_units[0].indexers:
             values = blk.values
             if copy:
                 values = values.copy()
@@ -238,7 +230,7 @@ def concatenate_managers(
 
             fastpath = blk.values.dtype == values.dtype
         else:
-            values = _concatenate_join_units(join_units, copy=copy)
+            values = _concatenate_join_units(join_units, concat_axis, copy=copy)
             fastpath = False
 
         if fastpath:
@@ -251,42 +243,6 @@ def concatenate_managers(
     return BlockManager(tuple(blocks), axes)
 
 
-def _concat_managers_axis0(
-    mgrs_indexers, axes: list[Index], copy: bool
-) -> BlockManager:
-    """
-    concat_managers specialized to concat_axis=0, with reindexing already
-    having been done in _maybe_reindex_columns_na_proxy.
-    """
-    had_reindexers = {
-        i: len(mgrs_indexers[i][1]) > 0 for i in range(len(mgrs_indexers))
-    }
-    mgrs_indexers = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers)
-
-    mgrs = [x[0] for x in mgrs_indexers]
-
-    offset = 0
-    blocks = []
-    for i, mgr in enumerate(mgrs):
-        # If we already reindexed, then we definitely don't need another copy
-        made_copy = had_reindexers[i]
-
-        for blk in mgr.blocks:
-            if made_copy:
-                nb = blk.copy(deep=False)
-            elif copy:
-                nb = blk.copy()
-            else:
-                # by slicing instead of copy(deep=False), we get a new array
-                #  object, see test_concat_copy
-                nb = blk.getitem_block(slice(None))
-            nb._mgr_locs = nb._mgr_locs.add(offset)
-            blocks.append(nb)
-
-        offset += len(mgr.items)
-    return BlockManager(tuple(blocks), axes)
-
-
 def _maybe_reindex_columns_na_proxy(
     axes: list[Index], mgrs_indexers: list[tuple[BlockManager, dict[int, np.ndarray]]]
 ) -> list[tuple[BlockManager, dict[int, np.ndarray]]]:
@@ -297,33 +253,36 @@ def _maybe_reindex_columns_na_proxy(
     Columns added in this reindexing have dtype=np.void, indicating they
     should be ignored when choosing a column's final dtype.
     """
-    new_mgrs_indexers: list[tuple[BlockManager, dict[int, np.ndarray]]] = []
-
+    new_mgrs_indexers = []
     for mgr, indexers in mgrs_indexers:
-        # For axis=0 (i.e. columns) we use_na_proxy and only_slice, so this
-        #  is a cheap reindexing.
-        for i, indexer in indexers.items():
-            mgr = mgr.reindex_indexer(
-                axes[i],
-                indexers[i],
-                axis=i,
+        # We only reindex for axis=0 (i.e. columns), as this can be done cheaply
+        if 0 in indexers:
+            new_mgr = mgr.reindex_indexer(
+                axes[0],
+                indexers[0],
+                axis=0,
                 copy=False,
-                only_slice=True,  # only relevant for i==0
+                only_slice=True,
                 allow_dups=True,
-                use_na_proxy=True,  # only relevant for i==0
+                use_na_proxy=True,
             )
-        new_mgrs_indexers.append((mgr, {}))
+            new_indexers = indexers.copy()
+            del new_indexers[0]
+            new_mgrs_indexers.append((new_mgr, new_indexers))
+        else:
+            new_mgrs_indexers.append((mgr, indexers))
 
     return new_mgrs_indexers
 
 
-def _get_mgr_concatenation_plan(mgr: BlockManager):
+def _get_mgr_concatenation_plan(mgr: BlockManager, indexers: dict[int, np.ndarray]):
     """
-    Construct concatenation plan for given block manager.
+    Construct concatenation plan for given block manager and indexers.
 
     Parameters
     ----------
     mgr : BlockManager
+    indexers : dict of {axis: indexer}
 
     Returns
     -------
@@ -333,11 +292,15 @@ def _get_mgr_concatenation_plan(mgr: BlockManager):
     # Calculate post-reindex shape , save for item axis which will be separate
     # for each block anyway.
     mgr_shape_list = list(mgr.shape)
+    for ax, indexer in indexers.items():
+        mgr_shape_list[ax] = len(indexer)
     mgr_shape = tuple(mgr_shape_list)
 
+    assert 0 not in indexers
+
     if mgr.is_single_block:
         blk = mgr.blocks[0]
-        return [(blk.mgr_locs, JoinUnit(blk, mgr_shape))]
+        return [(blk.mgr_locs, JoinUnit(blk, mgr_shape, indexers))]
 
     blknos = mgr.blknos
     blklocs = mgr.blklocs
@@ -348,6 +311,8 @@ def _get_mgr_concatenation_plan(mgr: BlockManager):
         assert placements.is_slice_like
         assert blkno != -1
 
+        join_unit_indexers = indexers.copy()
+
         shape_list = list(mgr_shape)
         shape_list[0] = len(placements)
         shape = tuple(shape_list)
@@ -372,14 +337,13 @@ def _get_mgr_concatenation_plan(mgr: BlockManager):
             )
         )
 
-        if not unit_no_ax0_reindexing:
-            # create block from subset of columns
-            blk = blk.getitem_block(ax0_blk_indexer)
+        # Omit indexer if no item reindexing is required.
+        if unit_no_ax0_reindexing:
+            join_unit_indexers.pop(0, None)
+        else:
+            join_unit_indexers[0] = ax0_blk_indexer
 
-        # Assertions disabled for performance
-        # assert blk._mgr_locs.as_slice == placements.as_slice
-        # assert blk.shape[0] == shape[0]
-        unit = JoinUnit(blk, shape)
+        unit = JoinUnit(blk, shape, join_unit_indexers)
 
         plan.append((placements, unit))
 
@@ -387,82 +351,198 @@ def _get_mgr_concatenation_plan(mgr: BlockManager):
 
 
 class JoinUnit:
-    def __init__(self, block: Block, shape: Shape):
+    def __init__(self, block: Block, shape: Shape, indexers=None):
         # Passing shape explicitly is required for cases when block is None.
+        # Note: block is None implies indexers is None, but not vice-versa
+        if indexers is None:
+            indexers = {}
         self.block = block
+        self.indexers = indexers
         self.shape = shape
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({repr(self.block)})"
+        return f"{type(self).__name__}({repr(self.block)}, {self.indexers})"
+
+    @cache_readonly
+    def needs_filling(self) -> bool:
+        for indexer in self.indexers.values():
+            # FIXME: cache results of indexer == -1 checks.
+            if (indexer == -1).any():
+                return True
+
+        return False
+
+    @cache_readonly
+    def dtype(self) -> DtypeObj:
+        blk = self.block
+        if blk.values.dtype.kind == "V":
+            raise AssertionError("Block is None, no dtype")
+
+        if not self.needs_filling:
+            return blk.dtype
+        return ensure_dtype_can_hold_na(blk.dtype)
+
+    def _is_valid_na_for(self, dtype: DtypeObj) -> bool:
+        """
+        Check that we are all-NA of a type/dtype that is compatible with this dtype.
+        Augments `self.is_na` with an additional check of the type of NA values.
+        """
+        if not self.is_na:
+            return False
+        if self.block.dtype.kind == "V":
+            return True
+
+        if self.dtype == object:
+            values = self.block.values
+            return all(is_valid_na_for_dtype(x, dtype) for x in values.ravel(order="K"))
+
+        na_value = self.block.fill_value
+        if na_value is NaT and not is_dtype_equal(self.dtype, dtype):
+            # e.g. we are dt64 and other is td64
+            # fill_values match but we should not cast self.block.values to dtype
+            # TODO: this will need updating if we ever have non-nano dt64/td64
+            return False
+
+        if na_value is NA and needs_i8_conversion(dtype):
+            # FIXME: kludge; test_append_empty_frame_with_timedelta64ns_nat
+            #  e.g. self.dtype == "Int64" and dtype is td64, we dont want
+            #  to consider these as matching
+            return False
+
+        # TODO: better to use can_hold_element?
+        return is_valid_na_for_dtype(na_value, dtype)
 
     @cache_readonly
     def is_na(self) -> bool:
         blk = self.block
         if blk.dtype.kind == "V":
             return True
-        return False
-
-    def get_reindexed_values(self, empty_dtype: DtypeObj) -> ArrayLike:
-        values: ArrayLike
 
-        if self.is_na:
-            return make_na_array(empty_dtype, self.shape)
+        if not blk._can_hold_na:
+            return False
 
+        values = blk.values
+        if values.size == 0:
+            return True
+        if isinstance(values.dtype, SparseDtype):
+            return False
+
+        if values.ndim == 1:
+            # TODO(EA2D): no need for special case with 2D EAs
+            val = values[0]
+            if not is_scalar(val) or not isna(val):
+                # ideally isna_all would do this short-circuiting
+                return False
+            return isna_all(values)
         else:
+            val = values[0][0]
+            if not is_scalar(val) or not isna(val):
+                # ideally isna_all would do this short-circuiting
+                return False
+            return all(isna_all(row) for row in values)
+
+    def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
+        values: ArrayLike
 
-            if not self.block._can_consolidate:
+        if upcasted_na is None and self.block.dtype.kind != "V":
+            # No upcasting is necessary
+            fill_value = self.block.fill_value
+            values = self.block.get_values()
+        else:
+            fill_value = upcasted_na
+
+            if self._is_valid_na_for(empty_dtype):
+                # note: always holds when self.block.dtype.kind == "V"
+                blk_dtype = self.block.dtype
+
+                if blk_dtype == np.dtype("object"):
+                    # we want to avoid filling with np.nan if we are
+                    # using None; we already know that we are all
+                    # nulls
+                    values = self.block.values.ravel(order="K")
+                    if len(values) and values[0] is None:
+                        fill_value = None
+
+                if isinstance(empty_dtype, DatetimeTZDtype):
+                    # NB: exclude e.g. pyarrow[dt64tz] dtypes
+                    i8values = np.full(self.shape, fill_value.value)
+                    return DatetimeArray(i8values, dtype=empty_dtype)
+
+                elif is_1d_only_ea_dtype(empty_dtype):
+                    if is_dtype_equal(blk_dtype, empty_dtype) and self.indexers:
+                        # avoid creating new empty array if we already have an array
+                        # with correct dtype that can be reindexed
+                        pass
+                    else:
+                        empty_dtype = cast(ExtensionDtype, empty_dtype)
+                        cls = empty_dtype.construct_array_type()
+
+                        missing_arr = cls._from_sequence([], dtype=empty_dtype)
+                        ncols, nrows = self.shape
+                        assert ncols == 1, ncols
+                        empty_arr = -1 * np.ones((nrows,), dtype=np.intp)
+                        return missing_arr.take(
+                            empty_arr, allow_fill=True, fill_value=fill_value
+                        )
+                elif isinstance(empty_dtype, ExtensionDtype):
+                    # TODO: no tests get here, a handful would if we disabled
+                    #  the dt64tz special-case above (which is faster)
+                    cls = empty_dtype.construct_array_type()
+                    missing_arr = cls._empty(shape=self.shape, dtype=empty_dtype)
+                    missing_arr[:] = fill_value
+                    return missing_arr
+                else:
+                    # NB: we should never get here with empty_dtype integer or bool;
+                    #  if we did, the missing_arr.fill would cast to gibberish
+                    missing_arr = np.empty(self.shape, dtype=empty_dtype)
+                    missing_arr.fill(fill_value)
+                    return missing_arr
+
+            if (not self.indexers) and (not self.block._can_consolidate):
                 # preserve these for validation in concat_compat
                 return self.block.values
 
-            # No dtype upcasting is done here, it will be performed during
-            # concatenation itself.
-            values = self.block.values
+            if self.block.is_bool:
+                # External code requested filling/upcasting, bool values must
+                # be upcasted to object to avoid being upcasted to numeric.
+                values = self.block.astype(np.dtype("object")).values
+            else:
+                # No dtype upcasting is done here, it will be performed during
+                # concatenation itself.
+                values = self.block.values
 
-        return values
+        if not self.indexers:
+            # If there's no indexing to be done, we want to signal outside
+            # code that this array must be copied explicitly.  This is done
+            # by returning a view and checking `retval.base`.
+            values = values.view()
 
+        else:
+            for ax, indexer in self.indexers.items():
+                values = algos.take_nd(values, indexer, axis=ax)
 
-def make_na_array(dtype: DtypeObj, shape: Shape) -> ArrayLike:
-    """
-    Construct an np.ndarray or ExtensionArray of the given dtype and shape
-    holding all-NA values.
-    """
-    if is_datetime64tz_dtype(dtype):
-        # NaT here is analogous to dtype.na_value below
-        i8values = np.full(shape, NaT.value)
-        return DatetimeArray(i8values, dtype=dtype)
-
-    elif is_1d_only_ea_dtype(dtype):
-        dtype = cast(ExtensionDtype, dtype)
-        cls = dtype.construct_array_type()
-
-        missing_arr = cls._from_sequence([], dtype=dtype)
-        nrows = shape[-1]
-        taker = -1 * np.ones((nrows,), dtype=np.intp)
-        return missing_arr.take(taker, allow_fill=True, fill_value=dtype.na_value)
-    elif isinstance(dtype, ExtensionDtype):
-        # TODO: no tests get here, a handful would if we disabled
-        #  the dt64tz special-case above (which is faster)
-        cls = dtype.construct_array_type()
-        missing_arr = cls._empty(shape=shape, dtype=dtype)
-        missing_arr[:] = dtype.na_value
-        return missing_arr
-    else:
-        # NB: we should never get here with dtype integer or bool;
-        #  if we did, the missing_arr.fill would cast to gibberish
-        missing_arr = np.empty(shape, dtype=dtype)
-        fill_value = _dtype_to_na_value(dtype)
-        missing_arr.fill(fill_value)
-        return missing_arr
+        return values
 
 
-def _concatenate_join_units(join_units: list[JoinUnit], copy: bool) -> ArrayLike:
+def _concatenate_join_units(
+    join_units: list[JoinUnit], concat_axis: int, copy: bool
+) -> ArrayLike:
     """
-    Concatenate values from several join units along axis=1.
+    Concatenate values from several join units along selected axis.
     """
+    if concat_axis == 0 and len(join_units) > 1:
+        # Concatenating join units along ax0 is handled in _merge_blocks.
+        raise AssertionError("Concatenating join units along axis0")
 
     empty_dtype = _get_empty_dtype(join_units)
 
-    to_concat = [ju.get_reindexed_values(empty_dtype=empty_dtype) for ju in join_units]
+    has_none_blocks = any(unit.block.dtype.kind == "V" for unit in join_units)
+    upcasted_na = _dtype_to_na_value(empty_dtype, has_none_blocks)
+
+    to_concat = [
+        ju.get_reindexed_values(empty_dtype=empty_dtype, upcasted_na=upcasted_na)
+        for ju in join_units
+    ]
 
     if len(to_concat) == 1:
         # Only one block, nothing to concatenate.
@@ -476,7 +556,7 @@ def _concatenate_join_units(join_units: list[JoinUnit], copy: bool) -> ArrayLike
             else:
                 concat_values = concat_values.copy()
 
-    elif any(is_1d_only_ea_obj(t) for t in to_concat):
+    elif any(is_1d_only_ea_dtype(t.dtype) for t in to_concat):
         # TODO(EA2D): special case not needed if all EAs used HybridBlocks
         # NB: we are still assuming here that Hybrid blocks have shape (1, N)
         # concatting with at least one EA means we are concatting a single column
@@ -485,19 +565,21 @@ def _concatenate_join_units(join_units: list[JoinUnit], copy: bool) -> ArrayLike
         # error: No overload variant of "__getitem__" of "ExtensionArray" matches
         # argument type "Tuple[int, slice]"
         to_concat = [
-            t if is_1d_only_ea_obj(t) else t[0, :]  # type: ignore[call-overload]
+            t
+            if is_1d_only_ea_dtype(t.dtype)
+            else t[0, :]  # type: ignore[call-overload]
             for t in to_concat
         ]
         concat_values = concat_compat(to_concat, axis=0, ea_compat_axis=True)
         concat_values = ensure_block_shape(concat_values, 2)
 
     else:
-        concat_values = concat_compat(to_concat, axis=1)
+        concat_values = concat_compat(to_concat, axis=concat_axis)
 
     return concat_values
 
 
-def _dtype_to_na_value(dtype: DtypeObj):
+def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
     """
     Find the NA value to go with this dtype.
     """
@@ -511,6 +593,9 @@ def _dtype_to_na_value(dtype: DtypeObj):
         # different from missing.na_value_for_dtype
         return None
     elif dtype.kind in ["i", "u"]:
+        if not has_none_blocks:
+            # different from missing.na_value_for_dtype
+            return None
         return np.nan
     elif dtype.kind == "O":
         return np.nan
@@ -535,12 +620,14 @@ def _get_empty_dtype(join_units: Sequence[JoinUnit]) -> DtypeObj:
         empty_dtype = join_units[0].block.dtype
         return empty_dtype
 
-    needs_can_hold_na = any(unit.is_na for unit in join_units)
+    has_none_blocks = any(unit.block.dtype.kind == "V" for unit in join_units)
 
-    dtypes = [unit.block.dtype for unit in join_units if not unit.is_na]
+    dtypes = [unit.dtype for unit in join_units if not unit.is_na]
+    if not len(dtypes):
+        dtypes = [unit.dtype for unit in join_units if unit.block.dtype.kind != "V"]
 
     dtype = find_common_type(dtypes)
-    if needs_can_hold_na:
+    if has_none_blocks:
         dtype = ensure_dtype_can_hold_na(dtype)
     return dtype
 
@@ -572,6 +659,9 @@ def _is_uniform_join_units(join_units: list[JoinUnit]) -> bool:
         # unless we're an extension dtype.
         all(not ju.is_na or ju.block.is_extension for ju in join_units)
         and
+        # no blocks with indexers (as then the dimensions do not fit)
+        all(not ju.indexers for ju in join_units)
+        and
         # only use this path when there is something to concatenate
         len(join_units) > 1
     )
@@ -591,17 +681,28 @@ def _trim_join_unit(join_unit: JoinUnit, length: int) -> JoinUnit:
 
     Extra items that didn't fit are returned as a separate block.
     """
+    if 0 not in join_unit.indexers:
+        extra_indexers = join_unit.indexers
+
+        if join_unit.block is None:
+            extra_block = None
+        else:
+            extra_block = join_unit.block.getitem_block(slice(length, None))
+            join_unit.block = join_unit.block.getitem_block(slice(length))
+    else:
+        extra_block = join_unit.block
 
-    extra_block = join_unit.block.getitem_block(slice(length, None))
-    join_unit.block = join_unit.block.getitem_block(slice(length))
+        extra_indexers = copy.copy(join_unit.indexers)
+        extra_indexers[0] = extra_indexers[0][length:]
+        join_unit.indexers[0] = join_unit.indexers[0][:length]
 
     extra_shape = (join_unit.shape[0] - length,) + join_unit.shape[1:]
     join_unit.shape = (length,) + join_unit.shape[1:]
 
-    return JoinUnit(block=extra_block, shape=extra_shape)
+    return JoinUnit(block=extra_block, indexers=extra_indexers, shape=extra_shape)
 
 
-def _combine_concat_plans(plans):
+def _combine_concat_plans(plans, concat_axis: int):
     """
     Combine multiple concatenation plans into one.
 
@@ -611,6 +712,18 @@ def _combine_concat_plans(plans):
         for p in plans[0]:
             yield p[0], [p[1]]
 
+    elif concat_axis == 0:
+        offset = 0
+        for plan in plans:
+            last_plc = None
+
+            for plc, unit in plan:
+                yield plc.add(offset), [unit]
+                last_plc = plc
+
+            if last_plc is not None:
+                offset += last_plc.as_slice.stop
+
     else:
         # singleton list so we can modify it as a side-effect within _next_or_none
         num_ended = [0]
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 532309dfc40b3..c1d0ab730fe7e 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -35,7 +35,6 @@
 )
 from pandas.core.dtypes.common import (
     is_1d_only_ea_dtype,
-    is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
@@ -44,7 +43,6 @@
     is_named_tuple,
     is_object_dtype,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
     ABCSeries,
@@ -169,7 +167,7 @@ def rec_array_to_mgr(
     dtype: DtypeObj | None,
     copy: bool,
     typ: str,
-):
+) -> Manager:
     """
     Extract from a masked rec array and create the manager.
     """
@@ -328,22 +326,22 @@ def ndarray_to_mgr(
     else:
         # by definition an array here
         # the dtypes will be coerced to a single dtype
-        values = _prep_ndarray(values, copy=copy_on_sanitize)
+        values = _prep_ndarraylike(values, copy=copy_on_sanitize)
 
     if dtype is not None and not is_dtype_equal(values.dtype, dtype):
-        shape = values.shape
-        flat = values.ravel()
-
         # GH#40110 see similar check inside sanitize_array
         rcf = not (is_integer_dtype(dtype) and values.dtype.kind == "f")
 
         values = sanitize_array(
-            flat, None, dtype=dtype, copy=copy_on_sanitize, raise_cast_failure=rcf
+            values,
+            None,
+            dtype=dtype,
+            copy=copy_on_sanitize,
+            raise_cast_failure=rcf,
+            allow_2d=True,
         )
 
-        values = values.reshape(shape)
-
-    # _prep_ndarray ensures that values.ndim == 2 at this point
+    # _prep_ndarraylike ensures that values.ndim == 2 at this point
     index, columns = _get_axes(
         values.shape[0], values.shape[1], index=index, columns=columns
     )
@@ -466,7 +464,13 @@ def dict_to_mgr(
                 # GH#1783
                 nan_dtype = np.dtype("object")
                 val = construct_1d_arraylike_from_scalar(np.nan, len(index), nan_dtype)
-                arrays.loc[missing] = [val] * missing.sum()
+                nmissing = missing.sum()
+                if copy:
+                    rhs = [val] * nmissing
+                else:
+                    # GH#45369
+                    rhs = [val.copy() for _ in range(nmissing)]
+                arrays.loc[missing] = rhs
 
         arrays = list(arrays)
         columns = ensure_index(columns)
@@ -475,23 +479,16 @@ def dict_to_mgr(
         keys = list(data.keys())
         columns = Index(keys)
         arrays = [com.maybe_iterable_to_list(data[k]) for k in keys]
-        # GH#24096 need copy to be deep for datetime64tz case
-        # TODO: See if we can avoid these copies
         arrays = [arr if not isinstance(arr, Index) else arr._data for arr in arrays]
-        arrays = [
-            arr if not is_datetime64tz_dtype(arr) else arr.copy() for arr in arrays
-        ]
 
     if copy:
-        # arrays_to_mgr (via form_blocks) won't make copies for EAs
-        # dtype attr check to exclude EADtype-castable strs
-        arrays = [
-            x
-            if not hasattr(x, "dtype") or not isinstance(x.dtype, ExtensionDtype)
-            else x.copy()
-            for x in arrays
-        ]
-        # TODO: can we get rid of the dt64tz special case above?
+        if typ == "block":
+            # We only need to copy arrays that will not get consolidated, i.e.
+            #  only EA arrays
+            arrays = [x.copy() if isinstance(x, ExtensionArray) else x for x in arrays]
+        else:
+            # dtype check to exclude e.g. range objects, scalars
+            arrays = [x.copy() if hasattr(x, "dtype") else x for x in arrays]
 
     return arrays_to_mgr(arrays, columns, index, dtype=dtype, typ=typ, consolidate=copy)
 
@@ -540,15 +537,16 @@ def treat_as_nested(data) -> bool:
 # ---------------------------------------------------------------------
 
 
-def _prep_ndarray(values, copy: bool = True) -> np.ndarray:
+def _prep_ndarraylike(
+    values, copy: bool = True
+) -> np.ndarray | DatetimeArray | TimedeltaArray:
     if isinstance(values, TimedeltaArray) or (
         isinstance(values, DatetimeArray) and values.tz is None
     ):
-        # On older numpy, np.asarray below apparently does not call __array__,
-        #  so nanoseconds get dropped.
-        values = values._ndarray
+        # By retaining DTA/TDA instead of unpacking, we end up retaining non-nano
+        pass
 
-    if not isinstance(values, (np.ndarray, ABCSeries, Index)):
+    elif not isinstance(values, (np.ndarray, ABCSeries, Index)):
         if len(values) == 0:
             return np.empty((0, 0), dtype=object)
         elif isinstance(values, range):
@@ -916,12 +914,7 @@ def _list_of_series_to_arrays(
         values = extract_array(s, extract_numpy=True)
         aligned_values.append(algorithms.take_nd(values, indexer))
 
-    # error: Argument 1 to "vstack" has incompatible type "List[ExtensionArray]";
-    # expected "Sequence[Union[Union[int, float, complex, str, bytes, generic],
-    # Sequence[Union[int, float, complex, str, bytes, generic]],
-    # Sequence[Sequence[Any]], _SupportsArray]]"
-    content = np.vstack(aligned_values)  # type: ignore[arg-type]
-
+    content = np.vstack(aligned_values)
     return content, columns
 
 
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 3e0b62da64f42..5ab4aef7462ee 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -5,15 +5,20 @@
     Any,
     Callable,
     Hashable,
+    Literal,
     Sequence,
     TypeVar,
     cast,
 )
 import warnings
+import weakref
 
 import numpy as np
 
+from pandas._config.config import _global_config
+
 from pandas._libs import (
+    algos as libalgos,
     internals as libinternals,
     lib,
 )
@@ -36,7 +41,6 @@
     is_1d_only_ea_dtype,
     is_dtype_equal,
     is_list_like,
-    needs_i8_conversion,
 )
 from pandas.core.dtypes.dtypes import ExtensionDtype
 from pandas.core.dtypes.generic import (
@@ -51,6 +55,7 @@
 import pandas.core.algorithms as algos
 from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 from pandas.core.arrays.sparse import SparseDtype
+import pandas.core.common as com
 from pandas.core.construction import (
     ensure_wrapped_if_datetimelike,
     extract_array,
@@ -141,16 +146,27 @@ class BaseBlockManager(DataManager):
     _blklocs: npt.NDArray[np.intp]
     blocks: tuple[Block, ...]
     axes: list[Index]
+    refs: list[weakref.ref | None] | None
+    parent: object
+
+    @property
+    def ndim(self) -> int:
+        raise NotImplementedError
 
-    ndim: int
     _known_consolidated: bool
     _is_consolidated: bool
 
-    def __init__(self, blocks, axes, verify_integrity: bool = True):
+    def __init__(self, blocks, axes, refs=None, verify_integrity: bool = True) -> None:
         raise NotImplementedError
 
     @classmethod
-    def from_blocks(cls: type_t[T], blocks: list[Block], axes: list[Index]) -> T:
+    def from_blocks(
+        cls: type_t[T],
+        blocks: list[Block],
+        axes: list[Index],
+        refs: list[weakref.ref | None] | None = None,
+        parent: object = None,
+    ) -> T:
         raise NotImplementedError
 
     @property
@@ -223,6 +239,35 @@ def is_single_block(self) -> bool:
     def items(self) -> Index:
         return self.axes[0]
 
+    def _has_no_reference(self, i: int) -> bool:
+        """
+        Check for column `i` if it has references.
+        (whether it references another array or is itself being referenced)
+        Returns True if the column has no references.
+        """
+        blkno = self.blknos[i]
+        return self._has_no_reference_block(blkno)
+
+    def _has_no_reference_block(self, blkno: int) -> bool:
+        """
+        Check for block `i` if it has references.
+        (whether it references another array or is itself being referenced)
+        Returns True if the block has no references.
+        """
+        # TODO(CoW) include `or self.refs[blkno]() is None` ?
+        return (
+            self.refs is None or self.refs[blkno] is None
+        ) and weakref.getweakrefcount(self.blocks[blkno]) == 0
+
+    def _clear_reference_block(self, blkno: int) -> None:
+        """
+        Clear any reference for column `i`.
+        """
+        if self.refs is not None:
+            self.refs[blkno] = None
+            if com.all_none(*self.refs):
+                self.parent = None
+
     def get_dtypes(self):
         dtypes = np.array([blk.dtype for blk in self.blocks])
         return dtypes.take(self.blknos)
@@ -235,6 +280,9 @@ def arrays(self) -> list[ArrayLike]:
         Only for compatibility with ArrayManager for testing convenience.
         Not to be used in actual code, and return value is not the same as the
         ArrayManager method (list of 1D arrays vs iterator of 2D ndarrays / 1D EAs).
+
+        Warning! The returned arrays don't handle Copy-on-Write, so this should
+        be used with caution (only in read-mode).
         """
         return [blk.values for blk in self.blocks]
 
@@ -334,9 +382,24 @@ def setitem(self: T, indexer, value) -> T:
 
         For SingleBlockManager, this backs s[indexer] = value
         """
+        if isinstance(indexer, np.ndarray) and indexer.ndim > self.ndim:
+            raise ValueError(f"Cannot set values with ndim > {self.ndim}")
+
+        if _using_copy_on_write() and not self._has_no_reference(0):
+            # if being referenced -> perform Copy-on-Write and clear the reference
+            # this method is only called if there is a single block -> hardcoded 0
+            self = self.copy()
+
         return self.apply("setitem", indexer=indexer, value=value)
 
     def putmask(self, mask, new, align: bool = True):
+        if _using_copy_on_write() and any(
+            not self._has_no_reference_block(i) for i in range(len(self.blocks))
+        ):
+            # some reference -> copy full dataframe
+            # TODO(CoW) this could be optimized to only copy the blocks that would
+            # get modified
+            self = self.copy()
 
         if align:
             align_keys = ["new", "mask"]
@@ -363,54 +426,20 @@ def shift(self: T, periods: int, axis: int, fill_value) -> T:
         if fill_value is lib.no_default:
             fill_value = None
 
-        if (
-            axis == 0
-            and self.ndim == 2
-            and (
-                self.nblocks > 1
-                or (
-                    # If we only have one block and we know that we can't
-                    #  keep the same dtype (i.e. the _can_hold_element check)
-                    #  then we can go through the reindex_indexer path
-                    #  (and avoid casting logic in the Block method).
-                    #  The exception to this (until 2.0) is datetimelike
-                    #  dtypes with integers, which cast.
-                    not self.blocks[0]._can_hold_element(fill_value)
-                    # TODO(2.0): remove special case for integer-with-datetimelike
-                    #  once deprecation is enforced
-                    and not (
-                        lib.is_integer(fill_value)
-                        and needs_i8_conversion(self.blocks[0].dtype)
-                    )
-                )
-            )
-        ):
-            # GH#35488 we need to watch out for multi-block cases
-            # We only get here with fill_value not-lib.no_default
-            ncols = self.shape[0]
-            nper = abs(periods)
-            nper = min(nper, ncols)
-            if periods > 0:
-                indexer = np.array(
-                    [-1] * nper + list(range(ncols - periods)), dtype=np.intp
-                )
-            else:
-                indexer = np.array(
-                    list(range(nper, ncols)) + [-1] * nper, dtype=np.intp
-                )
-            result = self.reindex_indexer(
-                self.items,
-                indexer,
-                axis=0,
-                fill_value=fill_value,
-                allow_dups=True,
-                consolidate=False,
-            )
-            return result
-
         return self.apply("shift", periods=periods, axis=axis, fill_value=fill_value)
 
     def fillna(self: T, value, limit, inplace: bool, downcast) -> T:
+
+        if limit is not None:
+            # Do this validation even if we go through one of the no-op paths
+            limit = libalgos.validate_limit(None, limit=limit)
+        if inplace:
+            # TODO(CoW) can be optimized to only copy those blocks that have refs
+            if _using_copy_on_write() and any(
+                not self._has_no_reference_block(i) for i in range(len(self.blocks))
+            ):
+                self = self.copy()
+
         return self.apply(
             "fillna", value=value, limit=limit, inplace=inplace, downcast=downcast
         )
@@ -559,17 +588,26 @@ def _combine(
         inv_indexer = lib.get_reverse_indexer(indexer, self.shape[0])
 
         new_blocks: list[Block] = []
+        # TODO(CoW) we could optimize here if we know that the passed blocks
+        # are fully "owned" (eg created from an operation, not coming from
+        # an existing manager)
+        new_refs: list[weakref.ref | None] | None = None if copy else []
         for b in blocks:
-            b = b.copy(deep=copy)
-            b.mgr_locs = BlockPlacement(inv_indexer[b.mgr_locs.indexer])
-            new_blocks.append(b)
+            nb = b.copy(deep=copy)
+            nb.mgr_locs = BlockPlacement(inv_indexer[nb.mgr_locs.indexer])
+            new_blocks.append(nb)
+            if not copy:
+                # None has no attribute "append"
+                new_refs.append(weakref.ref(b))  # type: ignore[union-attr]
 
         axes = list(self.axes)
         if index is not None:
             axes[-1] = index
         axes[0] = self.items.take(indexer)
 
-        return type(self).from_blocks(new_blocks, axes)
+        return type(self).from_blocks(
+            new_blocks, axes, new_refs, parent=None if copy else self
+        )
 
     @property
     def nblocks(self) -> int:
@@ -581,14 +619,22 @@ def copy(self: T, deep=True) -> T:
 
         Parameters
         ----------
-        deep : bool or string, default True
-            If False, return shallow copy (do not copy data)
+        deep : bool, string or None, default True
+            If False or None, return a shallow copy (do not copy data)
             If 'all', copy data and a deep copy of the index
 
         Returns
         -------
         BlockManager
         """
+        if deep is None:
+            if _using_copy_on_write():
+                # use shallow copy
+                deep = False
+            else:
+                # preserve deep copy for BlockManager with copy=None
+                deep = True
+
         # this preserves the notion of view copying of axes
         if deep:
             # hit in e.g. tests.io.json.test_pandas
@@ -601,8 +647,17 @@ def copy_func(ax):
             new_axes = list(self.axes)
 
         res = self.apply("copy", deep=deep)
+        new_refs: list[weakref.ref | None] | None
+        if deep:
+            new_refs = None
+            parent = None
+        else:
+            new_refs = [weakref.ref(blk) for blk in self.blocks]
+            parent = self
 
         res.axes = new_axes
+        res.refs = new_refs
+        res.parent = parent
 
         if self.ndim > 1:
             # Avoid needing to re-compute these
@@ -626,7 +681,7 @@ def consolidate(self: T) -> T:
         if self.is_consolidated():
             return self
 
-        bm = type(self)(self.blocks, self.axes, verify_integrity=False)
+        bm = type(self)(self.blocks, self.axes, self.refs, verify_integrity=False)
         bm._is_consolidated = False
         bm._consolidate_inplace()
         return bm
@@ -634,12 +689,11 @@ def consolidate(self: T) -> T:
     def reindex_indexer(
         self: T,
         new_axis: Index,
-        indexer,
+        indexer: npt.NDArray[np.intp] | None,
         axis: int,
         fill_value=None,
         allow_dups: bool = False,
-        copy: bool = True,
-        consolidate: bool = True,
+        copy: bool | None = True,
         only_slice: bool = False,
         *,
         use_na_proxy: bool = False,
@@ -648,13 +702,12 @@ def reindex_indexer(
         Parameters
         ----------
         new_axis : Index
-        indexer : ndarray of int64 or None
+        indexer : ndarray[intp] or None
         axis : int
         fill_value : object, default None
         allow_dups : bool, default False
-        copy : bool, default True
-        consolidate: bool, default True
-            Whether to consolidate inplace before reindexing.
+        copy : bool or None, default True
+            If None, regard as False to get shallow copy.
         only_slice : bool, default False
             Whether to take views, not copies, along columns.
         use_na_proxy : bool, default False
@@ -662,6 +715,14 @@ def reindex_indexer(
 
         pandas-indexer with -1's only.
         """
+        if copy is None:
+            if _using_copy_on_write():
+                # use shallow copy
+                copy = False
+            else:
+                # preserve deep copy for BlockManager with copy=None
+                copy = True
+
         if indexer is None:
             if new_axis is self.axes[axis] and not copy:
                 return self
@@ -671,9 +732,6 @@ def reindex_indexer(
             result.axes[axis] = new_axis
             return result
 
-        if consolidate:
-            self._consolidate_inplace()
-
         # some axes don't allow reindexing with dups
         if not allow_dups:
             self.axes[axis]._validate_can_reindex(indexer)
@@ -682,12 +740,13 @@ def reindex_indexer(
             raise IndexError("Requested axis not found in manager")
 
         if axis == 0:
-            new_blocks = self._slice_take_blocks_ax0(
+            new_blocks, new_refs = self._slice_take_blocks_ax0(
                 indexer,
                 fill_value=fill_value,
                 only_slice=only_slice,
                 use_na_proxy=use_na_proxy,
             )
+            parent = None if com.all_none(*new_refs) else self
         else:
             new_blocks = [
                 blk.take_nd(
@@ -699,11 +758,13 @@ def reindex_indexer(
                 )
                 for blk in self.blocks
             ]
+            new_refs = None
+            parent = None
 
         new_axes = list(self.axes)
         new_axes[axis] = new_axis
 
-        new_mgr = type(self).from_blocks(new_blocks, new_axes)
+        new_mgr = type(self).from_blocks(new_blocks, new_axes, new_refs, parent=parent)
         if axis == 1:
             # We can avoid the need to rebuild these
             new_mgr._blknos = self.blknos.copy()
@@ -717,7 +778,7 @@ def _slice_take_blocks_ax0(
         only_slice: bool = False,
         *,
         use_na_proxy: bool = False,
-    ) -> list[Block]:
+    ) -> tuple[list[Block], list[weakref.ref | None]]:
         """
         Slice/take blocks along axis=0.
 
@@ -750,9 +811,11 @@ def _slice_take_blocks_ax0(
                 # GH#32959 EABlock would fail since we can't make 0-width
                 # TODO(EA2D): special casing unnecessary with 2D EAs
                 if sllen == 0:
-                    return []
+                    return [], []
                 bp = BlockPlacement(slice(0, sllen))
-                return [blk.getitem_block_columns(slobj, new_mgr_locs=bp)]
+                return [blk.getitem_block_columns(slobj, new_mgr_locs=bp)], [
+                    weakref.ref(blk)
+                ]
             elif not allow_fill or self.ndim == 1:
                 if allow_fill and fill_value is None:
                     fill_value = blk.fill_value
@@ -768,7 +831,7 @@ def _slice_take_blocks_ax0(
                     ]
                     # We have
                     #  all(np.shares_memory(nb.values, blk.values) for nb in blocks)
-                    return blocks
+                    return blocks, [weakref.ref(blk)] * len(blocks)
                 else:
                     bp = BlockPlacement(slice(0, sllen))
                     return [
@@ -778,7 +841,7 @@ def _slice_take_blocks_ax0(
                             new_mgr_locs=bp,
                             fill_value=fill_value,
                         )
-                    ]
+                    ], [None]
 
         if sl_type == "slice":
             blknos = self.blknos[slobj]
@@ -794,6 +857,7 @@ def _slice_take_blocks_ax0(
         # When filling blknos, make sure blknos is updated before appending to
         # blocks list, that way new blkno is exactly len(blocks).
         blocks = []
+        refs: list[weakref.ref | None] = []
         group = not only_slice
         for blkno, mgr_locs in libinternals.get_blkno_placements(blknos, group=group):
             if blkno == -1:
@@ -806,6 +870,7 @@ def _slice_take_blocks_ax0(
                         use_na_proxy=use_na_proxy,
                     )
                 )
+                refs.append(None)
             else:
                 blk = self.blocks[blkno]
 
@@ -819,18 +884,20 @@ def _slice_take_blocks_ax0(
                         newblk = blk.copy(deep=False)
                         newblk.mgr_locs = BlockPlacement(slice(mgr_loc, mgr_loc + 1))
                         blocks.append(newblk)
+                        refs.append(weakref.ref(blk))
 
                 else:
                     # GH#32779 to avoid the performance penalty of copying,
                     #  we may try to only slice
                     taker = blklocs[mgr_locs.indexer]
                     max_len = max(len(mgr_locs), taker.max() + 1)
-                    if only_slice:
+                    if only_slice or _using_copy_on_write():
                         taker = lib.maybe_indices_to_slice(taker, max_len)
 
                     if isinstance(taker, slice):
                         nb = blk.getitem_block_columns(taker, new_mgr_locs=mgr_locs)
                         blocks.append(nb)
+                        refs.append(weakref.ref(blk))
                     elif only_slice:
                         # GH#33597 slice instead of take, so we get
                         #  views instead of copies
@@ -840,11 +907,13 @@ def _slice_take_blocks_ax0(
                             nb = blk.getitem_block_columns(slc, new_mgr_locs=bp)
                             # We have np.shares_memory(nb.values, blk.values)
                             blocks.append(nb)
+                            refs.append(weakref.ref(blk))
                     else:
                         nb = blk.take_nd(taker, axis=0, new_mgr_locs=mgr_locs)
                         blocks.append(nb)
+                        refs.append(None)
 
-        return blocks
+        return blocks, refs
 
     def _make_na_block(
         self, placement: BlockPlacement, fill_value=None, use_na_proxy: bool = False
@@ -872,7 +941,13 @@ def _make_na_block(
         block_values.fill(fill_value)
         return new_block_2d(block_values, placement=placement)
 
-    def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
+    def take(
+        self: T,
+        indexer,
+        axis: int = 1,
+        verify: bool = True,
+        convert_indices: bool = True,
+    ) -> T:
         """
         Take items along any axis.
 
@@ -881,6 +956,8 @@ def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
         verify : bool, default True
             Check that all entries are between 0 and len(self) - 1, inclusive.
             Pass verify=False if this check has been done by the caller.
+        convert_indices : bool, default True
+            Whether to attempt to convert indices to positive values.
 
         Returns
         -------
@@ -894,7 +971,8 @@ def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
         )
 
         n = self.shape[axis]
-        indexer = maybe_convert_indices(indexer, n, verify=verify)
+        if convert_indices:
+            indexer = maybe_convert_indices(indexer, n, verify=verify)
 
         new_labels = self.axes[axis].take(indexer)
         return self.reindex_indexer(
@@ -902,7 +980,7 @@ def take(self: T, indexer, axis: int = 1, verify: bool = True) -> T:
             indexer=indexer,
             axis=axis,
             allow_dups=True,
-            consolidate=False,
+            copy=None,
         )
 
 
@@ -920,8 +998,10 @@ def __init__(
         self,
         blocks: Sequence[Block],
         axes: Sequence[Index],
+        refs: list[weakref.ref | None] | None = None,
+        parent: object = None,
         verify_integrity: bool = True,
-    ):
+    ) -> None:
 
         if verify_integrity:
             # Assertion disabled for performance
@@ -969,18 +1049,33 @@ def _verify_integrity(self) -> None:
                 f"block items\n# manager items: {len(self.items)}, # "
                 f"tot_items: {tot_items}"
             )
+        if self.refs is not None:
+            if len(self.refs) != len(self.blocks):
+                raise AssertionError(
+                    "Number of passed refs must equal the number of blocks: "
+                    f"{len(self.refs)} refs vs {len(self.blocks)} blocks."
+                    "\nIf you see this error, please report a bug at "
+                    "https://github.com/pandas-dev/pandas/issues"
+                )
 
     @classmethod
-    def from_blocks(cls, blocks: list[Block], axes: list[Index]) -> BlockManager:
+    def from_blocks(
+        cls,
+        blocks: list[Block],
+        axes: list[Index],
+        refs: list[weakref.ref | None] | None = None,
+        parent: object = None,
+    ) -> BlockManager:
         """
         Constructor for BlockManager and SingleBlockManager with same signature.
         """
-        return cls(blocks, axes, verify_integrity=False)
+        parent = parent if _using_copy_on_write() else None
+        return cls(blocks, axes, refs, parent, verify_integrity=False)
 
     # ----------------------------------------------------------------
     # Indexing
 
-    def fast_xs(self, loc: int) -> ArrayLike:
+    def fast_xs(self, loc: int) -> SingleBlockManager:
         """
         Return the array corresponding to `frame.iloc[loc]`.
 
@@ -993,16 +1088,29 @@ def fast_xs(self, loc: int) -> ArrayLike:
         np.ndarray or ExtensionArray
         """
         if len(self.blocks) == 1:
-            return self.blocks[0].iget((slice(None), loc))
+            result = self.blocks[0].iget((slice(None), loc))
+            block = new_block(result, placement=slice(0, len(result)), ndim=1)
+            # in the case of a single block, the new block is a view
+            ref = weakref.ref(self.blocks[0])
+            return SingleBlockManager(block, self.axes[0], [ref], parent=self)
 
         dtype = interleaved_dtype([blk.dtype for blk in self.blocks])
 
         n = len(self)
-        if isinstance(dtype, ExtensionDtype):
+
+        # GH#46406
+        immutable_ea = isinstance(dtype, SparseDtype)
+
+        if isinstance(dtype, ExtensionDtype) and not immutable_ea:
             cls = dtype.construct_array_type()
             result = cls._empty((n,), dtype=dtype)
         else:
-            result = np.empty(n, dtype=dtype)
+            # error: Argument "dtype" to "empty" has incompatible type
+            # "Union[Type[object], dtype[Any], ExtensionDtype, None]"; expected
+            # "None"
+            result = np.empty(
+                n, dtype=object if immutable_ea else dtype  # type: ignore[arg-type]
+            )
             result = ensure_wrapped_if_datetimelike(result)
 
         for blk in self.blocks:
@@ -1011,9 +1119,14 @@ def fast_xs(self, loc: int) -> ArrayLike:
             for i, rl in enumerate(blk.mgr_locs):
                 result[rl] = blk.iget((i, loc))
 
-        return result
+        if immutable_ea:
+            dtype = cast(ExtensionDtype, dtype)
+            result = dtype.construct_array_type()._from_sequence(result, dtype=dtype)
+
+        block = new_block(result, placement=slice(0, len(result)), ndim=1)
+        return SingleBlockManager(block, self.axes[0])
 
-    def iget(self, i: int) -> SingleBlockManager:
+    def iget(self, i: int, track_ref: bool = True) -> SingleBlockManager:
         """
         Return the data as a SingleBlockManager.
         """
@@ -1023,12 +1136,18 @@ def iget(self, i: int) -> SingleBlockManager:
         # shortcut for select a single-dim from a 2-dim BM
         bp = BlockPlacement(slice(0, len(values)))
         nb = type(block)(values, placement=bp, ndim=1)
-        return SingleBlockManager(nb, self.axes[1])
+        ref = weakref.ref(block) if track_ref else None
+        parent = self if track_ref else None
+        return SingleBlockManager(nb, self.axes[1], [ref], parent)
 
     def iget_values(self, i: int) -> ArrayLike:
         """
         Return the data for column i as the values (ndarray or ExtensionArray).
+
+        Warning! The returned array is a view but doesn't handle Copy-on-Write,
+        so this should be used with caution.
         """
+        # TODO(CoW) making the arrays read-only might make this safer to use?
         block = self.blocks[self.blknos[i]]
         values = block.iget(self.blklocs[i])
         return values
@@ -1038,6 +1157,9 @@ def column_arrays(self) -> list[np.ndarray]:
         """
         Used in the JSON C code to access column arrays.
         This optimizes compared to using `iget_values` by converting each
+
+        Warning! This doesn't handle Copy-on-Write, so should be used with
+        caution (current use case of consuming this in the JSON code is fine).
         """
         # This is an optimized equivalent to
         #  result = [self.iget_values(i) for i in range(len(self.items))]
@@ -1090,14 +1212,12 @@ def iset(
             #  containing (self._blknos[loc], BlockPlacement(slice(0, 1, 1)))
 
             # Check if we can use _iset_single fastpath
+            loc = cast(int, loc)
             blkno = self.blknos[loc]
             blk = self.blocks[blkno]
             if len(blk._mgr_locs) == 1:  # TODO: fastest way to check this?
                 return self._iset_single(
-                    # error: Argument 1 to "_iset_single" of "BlockManager" has
-                    # incompatible type "Union[int, slice, ndarray[Any, Any]]";
-                    # expected "int"
-                    loc,  # type:ignore[arg-type]
+                    loc,
                     value,
                     inplace=inplace,
                     blkno=blkno,
@@ -1127,24 +1247,35 @@ def value_getitem(placement):
         unfit_mgr_locs = []
         unfit_val_locs = []
         removed_blknos = []
-        for blkno, val_locs in libinternals.get_blkno_placements(blknos, group=True):
-            blk = self.blocks[blkno]
+        for blkno_l, val_locs in libinternals.get_blkno_placements(blknos, group=True):
+            blk = self.blocks[blkno_l]
             blk_locs = blklocs[val_locs.indexer]
             if inplace and blk.should_store(value):
-                blk.set_inplace(blk_locs, value_getitem(val_locs))
+                # Updating inplace -> check if we need to do Copy-on-Write
+                if _using_copy_on_write() and not self._has_no_reference_block(blkno_l):
+                    blk.set_inplace(blk_locs, value_getitem(val_locs), copy=True)
+                    self._clear_reference_block(blkno_l)
+                else:
+                    blk.set_inplace(blk_locs, value_getitem(val_locs))
             else:
                 unfit_mgr_locs.append(blk.mgr_locs.as_array[blk_locs])
                 unfit_val_locs.append(val_locs)
 
                 # If all block items are unfit, schedule the block for removal.
                 if len(val_locs) == len(blk.mgr_locs):
-                    removed_blknos.append(blkno)
+                    removed_blknos.append(blkno_l)
                 else:
-                    blk.delete(blk_locs)
-                    self._blklocs[blk.mgr_locs.indexer] = np.arange(len(blk))
+                    nb = blk.delete(blk_locs)
+                    blocks_tup = (
+                        self.blocks[:blkno_l] + (nb,) + self.blocks[blkno_l + 1 :]
+                    )
+                    self.blocks = blocks_tup
+                    self._blklocs[nb.mgr_locs.indexer] = np.arange(len(nb))
+                    # blk.delete gives a copy, so we can remove a possible reference
+                    self._clear_reference_block(blkno_l)
 
         if len(removed_blknos):
-            # Remove blocks & update blknos accordingly
+            # Remove blocks & update blknos and refs accordingly
             is_deleted = np.zeros(self.nblocks, dtype=np.bool_)
             is_deleted[removed_blknos] = True
 
@@ -1155,6 +1286,12 @@ def value_getitem(placement):
             self.blocks = tuple(
                 blk for i, blk in enumerate(self.blocks) if i not in set(removed_blknos)
             )
+            if self.refs is not None:
+                self.refs = [
+                    ref
+                    for i, ref in enumerate(self.refs)
+                    if i not in set(removed_blknos)
+                ]
 
         if unfit_val_locs:
             unfit_idxr = np.concatenate(unfit_mgr_locs)
@@ -1191,6 +1328,10 @@ def value_getitem(placement):
                 self._blklocs[unfit_idxr] = np.arange(unfit_count)
 
             self.blocks += tuple(new_blocks)
+            # TODO(CoW) is this always correct to assume that the new_blocks
+            # are not referencing anything else?
+            if self.refs is not None:
+                self.refs = list(self.refs) + [None] * len(new_blocks)
 
             # Newly created block's dtype may already be present.
             self._known_consolidated = False
@@ -1208,16 +1349,48 @@ def _iset_single(
         # Caller is responsible for verifying value.shape
 
         if inplace and blk.should_store(value):
+            copy = False
+            if _using_copy_on_write() and not self._has_no_reference_block(blkno):
+                # perform Copy-on-Write and clear the reference
+                copy = True
+                self._clear_reference_block(blkno)
             iloc = self.blklocs[loc]
-            blk.set_inplace(slice(iloc, iloc + 1), value)
+            blk.set_inplace(slice(iloc, iloc + 1), value, copy=copy)
             return
 
         nb = new_block_2d(value, placement=blk._mgr_locs)
         old_blocks = self.blocks
         new_blocks = old_blocks[:blkno] + (nb,) + old_blocks[blkno + 1 :]
         self.blocks = new_blocks
+        self._clear_reference_block(blkno)
         return
 
+    def column_setitem(
+        self, loc: int, idx: int | slice | np.ndarray, value, inplace: bool = False
+    ) -> None:
+        """
+        Set values ("setitem") into a single column (not setting the full column).
+
+        This is a method on the BlockManager level, to avoid creating an
+        intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`)
+        """
+        if _using_copy_on_write() and not self._has_no_reference(loc):
+            # otherwise perform Copy-on-Write and clear the reference
+            blkno = self.blknos[loc]
+            blocks = list(self.blocks)
+            blocks[blkno] = blocks[blkno].copy()
+            self.blocks = tuple(blocks)
+            self._clear_reference_block(blkno)
+
+        # this manager is only created temporarily to mutate the values in place
+        # so don't track references, otherwise the `setitem` would perform CoW again
+        col_mgr = self.iget(loc, track_ref=False)
+        if inplace:
+            col_mgr.setitem_inplace(idx, value)
+        else:
+            new_mgr = col_mgr.setitem((idx,), value)
+            self.iset(loc, new_mgr._block.values, inplace=True)
+
     def insert(self, loc: int, item: Hashable, value: ArrayLike) -> None:
         """
         Insert item at selected position.
@@ -1253,6 +1426,9 @@ def insert(self, loc: int, item: Hashable, value: ArrayLike) -> None:
 
         self.axes[0] = new_axis
         self.blocks += (block,)
+        # TODO(CoW) do we always "own" the passed `value`?
+        if self.refs is not None:
+            self.refs += [None]
 
         self._known_consolidated = False
 
@@ -1306,10 +1482,12 @@ def idelete(self, indexer) -> BlockManager:
         is_deleted[indexer] = True
         taker = (~is_deleted).nonzero()[0]
 
-        nbs = self._slice_take_blocks_ax0(taker, only_slice=True)
+        nbs, new_refs = self._slice_take_blocks_ax0(taker, only_slice=True)
         new_columns = self.items[~is_deleted]
         axes = [new_columns, self.axes[1]]
-        return type(self)(tuple(nbs), axes, verify_integrity=False)
+        # TODO this might not be needed (can a delete ever be done in chained manner?)
+        parent = None if com.all_none(*new_refs) else self
+        return type(self)(tuple(nbs), axes, new_refs, parent, verify_integrity=False)
 
     # ----------------------------------------------------------------
     # Block-wise Operation
@@ -1544,7 +1722,7 @@ def as_array(
         self,
         dtype: np.dtype | None = None,
         copy: bool = False,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Convert the blockmanager data into an numpy array.
@@ -1564,6 +1742,7 @@ def as_array(
         -------
         arr : ndarray
         """
+        # TODO(CoW) handle case where resulting array is a view
         if len(self.blocks) == 0:
             arr = np.empty(self.shape, dtype=float)
             return arr.transpose()
@@ -1603,7 +1782,7 @@ def as_array(
     def _interleave(
         self,
         dtype: np.dtype | None = None,
-        na_value=lib.no_default,
+        na_value: object = lib.no_default,
     ) -> np.ndarray:
         """
         Return ndarray from blocks with specified item order
@@ -1683,8 +1862,15 @@ def _consolidate_check(self) -> None:
         self._known_consolidated = True
 
     def _consolidate_inplace(self) -> None:
+        # In general, _consolidate_inplace should only be called via
+        #  DataFrame._consolidate_inplace, otherwise we will fail to invalidate
+        #  the DataFrame's _item_cache. The exception is for newly-created
+        #  BlockManager objects not yet attached to a DataFrame.
         if not self.is_consolidated():
-            self.blocks = tuple(_consolidate(self.blocks))
+            if self.refs is None:
+                self.blocks = _consolidate(self.blocks)
+            else:
+                self.blocks, self.refs = _consolidate_with_refs(self.blocks, self.refs)
             self._is_consolidated = True
             self._known_consolidated = True
             self._rebuild_blknos_and_blklocs()
@@ -1693,7 +1879,10 @@ def _consolidate_inplace(self) -> None:
 class SingleBlockManager(BaseBlockManager, SingleDataManager):
     """manage a single block with"""
 
-    ndim = 1
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
+
     _is_consolidated = True
     _known_consolidated = True
     __slots__ = ()
@@ -1703,9 +1892,11 @@ def __init__(
         self,
         block: Block,
         axis: Index,
+        refs: list[weakref.ref | None] | None = None,
+        parent: object = None,
         verify_integrity: bool = False,
         fastpath=lib.no_default,
-    ):
+    ) -> None:
         # Assertions disabled for performance
         # assert isinstance(block, Block), type(block)
         # assert isinstance(axis, Index), type(axis)
@@ -1720,15 +1911,25 @@ def __init__(
 
         self.axes = [axis]
         self.blocks = (block,)
+        self.refs = refs
+        self.parent = parent if _using_copy_on_write() else None
 
     @classmethod
-    def from_blocks(cls, blocks: list[Block], axes: list[Index]) -> SingleBlockManager:
+    def from_blocks(
+        cls,
+        blocks: list[Block],
+        axes: list[Index],
+        refs: list[weakref.ref | None] | None = None,
+        parent: object = None,
+    ) -> SingleBlockManager:
         """
         Constructor for BlockManager and SingleBlockManager with same signature.
         """
         assert len(blocks) == 1
         assert len(axes) == 1
-        return cls(blocks[0], axes[0], verify_integrity=False)
+        if refs is not None:
+            assert len(refs) == 1
+        return cls(blocks[0], axes[0], refs, parent, verify_integrity=False)
 
     @classmethod
     def from_array(cls, array: ArrayLike, index: Index) -> SingleBlockManager:
@@ -1747,7 +1948,21 @@ def to_2d_mgr(self, columns: Index) -> BlockManager:
         bp = BlockPlacement(0)
         new_blk = type(blk)(arr, placement=bp, ndim=2)
         axes = [columns, self.axes[0]]
-        return BlockManager([new_blk], axes=axes, verify_integrity=False)
+        refs: list[weakref.ref | None] = [weakref.ref(blk)]
+        parent = self if _using_copy_on_write() else None
+        return BlockManager(
+            [new_blk], axes=axes, refs=refs, parent=parent, verify_integrity=False
+        )
+
+    def _has_no_reference(self, i: int = 0) -> bool:
+        """
+        Check for column `i` if it has references.
+        (whether it references another array or is itself being referenced)
+        Returns True if the column has no references.
+        """
+        return (self.refs is None or self.refs[0] is None) and weakref.getweakrefcount(
+            self.blocks[0]
+        ) == 0
 
     def __getstate__(self):
         block_values = [b.values for b in self.blocks]
@@ -1805,7 +2020,7 @@ def _blklocs(self):
         """compat with BlockManager"""
         return None
 
-    def getitem_mgr(self, indexer) -> SingleBlockManager:
+    def getitem_mgr(self, indexer: slice | npt.NDArray[np.bool_]) -> SingleBlockManager:
         # similar to get_slice, but not restricted to slice indexer
         blk = self._block
         array = blk._slice(indexer)
@@ -1817,7 +2032,9 @@ def getitem_mgr(self, indexer) -> SingleBlockManager:
         block = type(blk)(array, placement=bp, ndim=1)
 
         new_idx = self.index[indexer]
-        return type(self)(block, new_idx)
+        # TODO(CoW) in theory only need to track reference if new_array is a view
+        ref = weakref.ref(blk)
+        return type(self)(block, new_idx, [ref], parent=self)
 
     def get_slice(self, slobj: slice, axis: int = 0) -> SingleBlockManager:
         # Assertion disabled for performance
@@ -1830,7 +2047,9 @@ def get_slice(self, slobj: slice, axis: int = 0) -> SingleBlockManager:
         bp = BlockPlacement(slice(0, len(array)))
         block = type(blk)(array, placement=bp, ndim=1)
         new_index = self.index._getitem_slice(slobj)
-        return type(self)(block, new_index)
+        # TODO this method is only used in groupby SeriesSplitter at the moment,
+        # so passing refs / parent is not yet covered by the tests
+        return type(self)(block, new_index, [weakref.ref(blk)], parent=self)
 
     @property
     def index(self) -> Index:
@@ -1857,23 +2076,44 @@ def array_values(self):
 
     def get_numeric_data(self, copy: bool = False):
         if self._block.is_numeric:
-            if copy:
-                return self.copy()
-            return self
+            return self.copy(deep=copy)
         return self.make_empty()
 
     @property
     def _can_hold_na(self) -> bool:
         return self._block._can_hold_na
 
+    def setitem_inplace(self, indexer, value) -> None:
+        """
+        Set values with indexer.
+
+        For Single[Block/Array]Manager, this backs s[indexer] = value
+
+        This is an inplace version of `setitem()`, mutating the manager/values
+        in place, not returning a new Manager (and Block), and thus never changing
+        the dtype.
+        """
+        if _using_copy_on_write() and not self._has_no_reference(0):
+            self.blocks = (self._block.copy(),)
+            self.refs = None
+            self.parent = None
+            self._cache.clear()
+
+        super().setitem_inplace(indexer, value)
+
     def idelete(self, indexer) -> SingleBlockManager:
         """
         Delete single location from SingleBlockManager.
 
         Ensures that self.blocks doesn't become empty.
         """
-        self._block.delete(indexer)
+        nb = self._block.delete(indexer)
+        self.blocks = (nb,)
         self.axes[0] = self.axes[0].delete(indexer)
+        self._cache.clear()
+        # clear reference since delete always results in a new array
+        self.refs = None
+        self.parent = None
         return self
 
     def fast_xs(self, loc):
@@ -1890,6 +2130,9 @@ def set_values(self, values: ArrayLike):
         Use at your own risk! This does not check if the passed values are
         valid for the current Block/SingleBlockManager (length, dtype, etc).
         """
+        # TODO(CoW) do we need to handle copy on write here? Currently this is
+        # only used for FrameColumnApply.series_generator (what if apply is
+        # mutating inplace?)
         self.blocks[0].values = values
         self.blocks[0]._mgr_locs = BlockPlacement(slice(len(values)))
 
@@ -1919,7 +2162,7 @@ def create_block_manager_from_blocks(
     # If verify_integrity=False, then caller is responsible for checking
     #  all(x.shape[-1] == len(axes[1]) for x in blocks)
     #  sum(x.shape[0] for x in blocks) == len(axes[0])
-    #  set(x for for blk in blocks for x in blk.mgr_locs) == set(range(len(axes[0])))
+    #  set(x for blk in blocks for x in blk.mgr_locs) == set(range(len(axes[0])))
     #  all(blk.ndim == 2 for blk in blocks)
     # This allows us to safely pass verify_integrity=False
 
@@ -2073,7 +2316,7 @@ def _stack_arrays(tuples, dtype: np.dtype):
     return stacked, placement
 
 
-def _consolidate(blocks: tuple[Block, ...]) -> list[Block]:
+def _consolidate(blocks: tuple[Block, ...]) -> tuple[Block, ...]:
     """
     Merge blocks having same dtype, exclude non-consolidating blocks
     """
@@ -2083,19 +2326,44 @@ def _consolidate(blocks: tuple[Block, ...]) -> list[Block]:
 
     new_blocks: list[Block] = []
     for (_can_consolidate, dtype), group_blocks in grouper:
-        merged_blocks = _merge_blocks(
+        merged_blocks, _ = _merge_blocks(
             list(group_blocks), dtype=dtype, can_consolidate=_can_consolidate
         )
         new_blocks = extend_blocks(merged_blocks, new_blocks)
-    return new_blocks
+    return tuple(new_blocks)
+
+
+def _consolidate_with_refs(
+    blocks: tuple[Block, ...], refs
+) -> tuple[tuple[Block, ...], list[weakref.ref | None]]:
+    """
+    Merge blocks having same dtype, exclude non-consolidating blocks, handling
+    refs
+    """
+    gkey = lambda x: x[0]._consolidate_key
+    grouper = itertools.groupby(sorted(zip(blocks, refs), key=gkey), gkey)
+
+    new_blocks: list[Block] = []
+    new_refs: list[weakref.ref | None] = []
+    for (_can_consolidate, dtype), group_blocks_refs in grouper:
+        group_blocks, group_refs = list(zip(*list(group_blocks_refs)))
+        merged_blocks, consolidated = _merge_blocks(
+            list(group_blocks), dtype=dtype, can_consolidate=_can_consolidate
+        )
+        new_blocks = extend_blocks(merged_blocks, new_blocks)
+        if consolidated:
+            new_refs.extend([None])
+        else:
+            new_refs.extend(group_refs)
+    return tuple(new_blocks), new_refs
 
 
 def _merge_blocks(
     blocks: list[Block], dtype: DtypeObj, can_consolidate: bool
-) -> list[Block]:
+) -> tuple[list[Block], bool]:
 
     if len(blocks) == 1:
-        return blocks
+        return blocks, False
 
     if can_consolidate:
 
@@ -2121,10 +2389,10 @@ def _merge_blocks(
         new_mgr_locs = new_mgr_locs[argsort]
 
         bp = BlockPlacement(new_mgr_locs)
-        return [new_block_2d(new_values, placement=bp)]
+        return [new_block_2d(new_values, placement=bp)], True
 
     # can't consolidate --> no merge
-    return blocks
+    return blocks, False
 
 
 def _fast_count_smallints(arr: npt.NDArray[np.intp]):
@@ -2157,3 +2425,10 @@ def _preprocess_slice_or_indexer(
         if not allow_fill:
             indexer = maybe_convert_indices(indexer, length)
         return "fancy", indexer, len(indexer)
+
+
+_mode_options = _global_config["mode"]
+
+
+def _using_copy_on_write():
+    return _mode_options["copy_on_write"]
diff --git a/pandas/core/internals/ops.py b/pandas/core/internals/ops.py
index c938a018574f9..5febb302a9de9 100644
--- a/pandas/core/internals/ops.py
+++ b/pandas/core/internals/ops.py
@@ -36,7 +36,7 @@ def _iter_block_pairs(
 
         left_ea = blk_vals.ndim == 1
 
-        rblks = right._slice_take_blocks_ax0(locs.indexer, only_slice=True)
+        rblks, _ = right._slice_take_blocks_ax0(locs.indexer, only_slice=True)
 
         # Assertions are disabled for performance, but should hold:
         # if left_ea:
@@ -125,9 +125,7 @@ def _get_same_shape_values(
         # argument type "Tuple[Union[ndarray, slice], slice]"
         lvals = lvals[rblk.mgr_locs.indexer, :]  # type: ignore[call-overload]
         assert lvals.shape[0] == 1, lvals.shape
-        # error: No overload variant of "__getitem__" of "ExtensionArray" matches
-        # argument type "Tuple[int, slice]"
-        lvals = lvals[0, :]  # type: ignore[call-overload]
+        lvals = lvals[0, :]
     else:
         # lvals are 1D, rvals are 2D
         assert rvals.shape[0] == 1, rvals.shape
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index 4a673fcc6439a..6005e11efbac4 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -43,7 +43,7 @@
     from pandas import Index
 
 
-def check_value_size(value, mask: np.ndarray, length: int):
+def check_value_size(value, mask: npt.NDArray[np.bool_], length: int):
     """
     Validate the size of the values passed to ExtensionArray.fillna.
     """
@@ -104,7 +104,7 @@ def mask_missing(arr: ArrayLike, values_to_mask) -> npt.NDArray[np.bool_]:
     return mask
 
 
-def clean_fill_method(method, allow_nearest: bool = False):
+def clean_fill_method(method: str | None, allow_nearest: bool = False):
     # asfreq is compat for resampling
     if method in [None, "asfreq"]:
         return None
@@ -161,7 +161,7 @@ def clean_interp_method(method: str, index: Index, **kwargs) -> str:
         raise ValueError(f"method must be one of {valid}. Got '{method}' instead.")
 
     if method in ("krogh", "piecewise_polynomial", "pchip"):
-        if not index.is_monotonic:
+        if not index.is_monotonic_increasing:
             raise ValueError(
                 f"{method} interpolation requires that the index be monotonic."
             )
@@ -191,7 +191,7 @@ def find_valid_index(values, *, how: str) -> int | None:
     is_valid = ~isna(values)
 
     if values.ndim == 2:
-        is_valid = is_valid.any(1)  # reduce axis 1
+        is_valid = is_valid.any(axis=1)  # reduce axis 1
 
     if how == "first":
         idxpos = is_valid[::].argmax()
@@ -333,8 +333,13 @@ def func(yvalues: np.ndarray) -> None:
             **kwargs,
         )
 
-    # interp each column independently
-    np.apply_along_axis(func, axis, data)
+    # error: Argument 1 to "apply_along_axis" has incompatible type
+    # "Callable[[ndarray[Any, Any]], None]"; expected "Callable[...,
+    # Union[_SupportsArray[dtype[<nothing>]], Sequence[_SupportsArray
+    # [dtype[<nothing>]]], Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]],
+    # Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]],
+    # Sequence[Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]]]]]"
+    np.apply_along_axis(func, axis, data)  # type: ignore[arg-type]
     return
 
 
@@ -773,13 +778,23 @@ def interpolate_2d(
     """
     if limit_area is not None:
         np.apply_along_axis(
-            partial(
+            # error: Argument 1 to "apply_along_axis" has incompatible type
+            # "partial[None]"; expected
+            # "Callable[..., Union[_SupportsArray[dtype[<nothing>]],
+            # Sequence[_SupportsArray[dtype[<nothing>]]],
+            # Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]],
+            # Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]],
+            # Sequence[Sequence[Sequence[Sequence[_
+            # SupportsArray[dtype[<nothing>]]]]]]]]"
+            partial(  # type: ignore[arg-type]
                 _interpolate_with_limit_area,
                 method=method,
                 limit=limit,
                 limit_area=limit_area,
             ),
-            axis,
+            # error: Argument 2 to "apply_along_axis" has incompatible type
+            # "Union[str, int]"; expected "SupportsIndex"
+            axis,  # type: ignore[arg-type]
             values,
         )
         return
@@ -892,7 +907,7 @@ def get_fill_func(method, ndim: int = 1):
     return {"pad": _pad_2d, "backfill": _backfill_2d}[method]
 
 
-def clean_reindex_fill_method(method):
+def clean_reindex_fill_method(method) -> str | None:
     return clean_fill_method(method, allow_nearest=True)
 
 
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 40664f178993e..6658b25d09e6d 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -5,6 +5,7 @@
 import operator
 from typing import (
     Any,
+    Callable,
     cast,
 )
 import warnings
@@ -16,7 +17,6 @@
 from pandas._libs import (
     NaT,
     NaTType,
-    Timedelta,
     iNaT,
     lib,
 )
@@ -72,7 +72,7 @@ def set_use_bottleneck(v: bool = True) -> None:
 
 
 class disallow:
-    def __init__(self, *dtypes: Dtype):
+    def __init__(self, *dtypes: Dtype) -> None:
         super().__init__()
         self.dtypes = tuple(pandas_dtype(dtype).type for dtype in dtypes)
 
@@ -104,7 +104,7 @@ def _f(*args, **kwargs):
 
 
 class bottleneck_switch:
-    def __init__(self, name=None, **kwargs):
+    def __init__(self, name=None, **kwargs) -> None:
         self.name = name
         self.kwargs = kwargs
 
@@ -162,6 +162,10 @@ def f(
 def _bn_ok_dtype(dtype: DtypeObj, name: str) -> bool:
     # Bottleneck chokes on datetime64, PeriodDtype (or and EA)
     if not is_object_dtype(dtype) and not needs_i8_conversion(dtype):
+        # GH 42878
+        # Bottleneck uses naive summation leading to O(n) loss of precision
+        # unlike numpy which implements pairwise summation, which has O(log(n)) loss
+        # crossref: https://github.com/pydata/bottleneck/issues/379
 
         # GH 15507
         # bottleneck does not properly upcast during the sum
@@ -171,7 +175,7 @@ def _bn_ok_dtype(dtype: DtypeObj, name: str) -> bool:
         # further we also want to preserve NaN when all elements
         # are NaN, unlike bottleneck/numpy which consider this
         # to be 0
-        return name not in ["nansum", "nanprod"]
+        return name not in ["nansum", "nanprod", "nanmean"]
     return False
 
 
@@ -367,19 +371,23 @@ def _wrap_results(result, dtype: np.dtype, fill_value=None):
                 result = np.datetime64("NaT", "ns")
             else:
                 result = np.int64(result).view("datetime64[ns]")
+            # retain original unit
+            result = result.astype(dtype, copy=False)
         else:
             # If we have float dtype, taking a view will give the wrong result
             result = result.astype(dtype)
     elif is_timedelta64_dtype(dtype):
         if not isinstance(result, np.ndarray):
-            if result == fill_value:
-                result = np.nan
+            if result == fill_value or np.isnan(result):
+                result = np.timedelta64("NaT").astype(dtype)
 
-            # raise if we have a timedelta64[ns] which is too large
-            if np.fabs(result) > lib.i8max:
+            elif np.fabs(result) > lib.i8max:
+                # raise if we have a timedelta64[ns] which is too large
                 raise ValueError("overflow in timedelta operation")
+            else:
+                # return a timedelta64 with the original unit
+                result = np.int64(result).astype(dtype, copy=False)
 
-            result = Timedelta(result, unit="ns")
         else:
             result = result.astype("m8[ns]").view(dtype)
 
@@ -641,7 +649,7 @@ def _mask_datetimelike_result(
         result[axis_mask] = iNaT  # type: ignore[index]
     else:
         if mask.any():
-            return NaT
+            return np.int64(iNaT).view(orig_values.dtype)
     return result
 
 
@@ -819,7 +827,7 @@ def _get_counts_nanvar(
     axis: int | None,
     ddof: int,
     dtype: np.dtype = np.dtype(np.float64),
-) -> tuple[int | float | np.ndarray, int | float | np.ndarray]:
+) -> tuple[float | np.ndarray, float | np.ndarray]:
     """
     Get the count of non-null values along an axis, accounting
     for degrees of freedom.
@@ -1202,7 +1210,7 @@ def nanskew(
     adjusted = values - mean
     if skipna and mask is not None:
         np.putmask(adjusted, mask, 0)
-    adjusted2 = adjusted ** 2
+    adjusted2 = adjusted**2
     adjusted3 = adjusted2 * adjusted
     m2 = adjusted2.sum(axis, dtype=np.float64)
     m3 = adjusted3.sum(axis, dtype=np.float64)
@@ -1215,7 +1223,7 @@ def nanskew(
     m3 = _zero_out_fperr(m3)
 
     with np.errstate(invalid="ignore", divide="ignore"):
-        result = (count * (count - 1) ** 0.5 / (count - 2)) * (m3 / m2 ** 1.5)
+        result = (count * (count - 1) ** 0.5 / (count - 2)) * (m3 / m2**1.5)
 
     dtype = values.dtype
     if is_float_dtype(dtype):
@@ -1290,15 +1298,15 @@ def nankurt(
     adjusted = values - mean
     if skipna and mask is not None:
         np.putmask(adjusted, mask, 0)
-    adjusted2 = adjusted ** 2
-    adjusted4 = adjusted2 ** 2
+    adjusted2 = adjusted**2
+    adjusted4 = adjusted2**2
     m2 = adjusted2.sum(axis, dtype=np.float64)
     m4 = adjusted4.sum(axis, dtype=np.float64)
 
     with np.errstate(invalid="ignore", divide="ignore"):
         adj = 3 * (count - 1) ** 2 / ((count - 2) * (count - 3))
         numerator = count * (count + 1) * (count - 1) * m4
-        denominator = (count - 2) * (count - 3) * m2 ** 2
+        denominator = (count - 2) * (count - 3) * m2**2
 
     # floating point error
     #
@@ -1406,7 +1414,7 @@ def _get_counts(
     mask: npt.NDArray[np.bool_] | None,
     axis: int | None,
     dtype: np.dtype = np.dtype(np.float64),
-) -> int | float | np.ndarray:
+) -> float | np.ndarray:
     """
     Get the count of non-null values along an axis
 
@@ -1468,8 +1476,8 @@ def _maybe_null_out(
             if is_numeric_dtype(result):
                 if np.iscomplexobj(result):
                     result = result.astype("c16")
-                else:
-                    result = result.astype("f8")
+                elif not is_float_dtype(result):
+                    result = result.astype("f8", copy=False)
                 result[null_mask] = np.nan
             else:
                 # GH12941, use None to auto cast null
@@ -1524,7 +1532,7 @@ def _zero_out_fperr(arg):
 @disallow("M8", "m8")
 def nancorr(
     a: np.ndarray, b: np.ndarray, *, method="pearson", min_periods: int | None = None
-):
+) -> float:
     """
     a, b: ndarrays
     """
@@ -1546,7 +1554,7 @@ def nancorr(
     return f(a, b)
 
 
-def get_corr_func(method):
+def get_corr_func(method) -> Callable[[np.ndarray, np.ndarray], float]:
     if method == "kendall":
         from scipy.stats import kendalltau
 
@@ -1583,7 +1591,7 @@ def nancov(
     *,
     min_periods: int | None = None,
     ddof: int | None = 1,
-):
+) -> float:
     if len(a) != len(b):
         raise AssertionError("Operands to nancov must have same size")
 
diff --git a/pandas/core/ops/__init__.py b/pandas/core/ops/__init__.py
index 540a557f7c7cc..cd470b8feff14 100644
--- a/pandas/core/ops/__init__.py
+++ b/pandas/core/ops/__init__.py
@@ -11,7 +11,7 @@
 
 import numpy as np
 
-from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op  # noqa:F401
+from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op
 from pandas._typing import Level
 from pandas.util._decorators import Appender
 from pandas.util._exceptions import find_stack_level
@@ -30,7 +30,7 @@
     algorithms,
     roperator,
 )
-from pandas.core.ops.array_ops import (  # noqa:F401
+from pandas.core.ops.array_ops import (
     arithmetic_op,
     comp_method_OBJECT_ARRAY,
     comparison_op,
@@ -38,7 +38,7 @@
     logical_op,
     maybe_prepare_scalar_for_op,
 )
-from pandas.core.ops.common import (  # noqa:F401
+from pandas.core.ops.common import (
     get_op_result_name,
     unpack_zerodim_and_defer,
 )
@@ -47,14 +47,14 @@
     _op_descriptions,
     make_flex_doc,
 )
-from pandas.core.ops.invalid import invalid_comparison  # noqa:F401
-from pandas.core.ops.mask_ops import (  # noqa: F401
+from pandas.core.ops.invalid import invalid_comparison
+from pandas.core.ops.mask_ops import (
     kleene_and,
     kleene_or,
     kleene_xor,
 )
-from pandas.core.ops.methods import add_flex_arithmetic_methods  # noqa:F401
-from pandas.core.roperator import (  # noqa:F401
+from pandas.core.ops.methods import add_flex_arithmetic_methods
+from pandas.core.roperator import (
     radd,
     rand_,
     rdiv,
@@ -334,7 +334,9 @@ def should_reindex_frame_op(
         left_uniques = left.columns.unique()
         right_uniques = right.columns.unique()
         cols = left_uniques.intersection(right_uniques)
-        if len(cols) and not (cols.equals(left_uniques) and cols.equals(right_uniques)):
+        if len(cols) and not (
+            len(cols) == len(left_uniques) and len(cols) == len(right_uniques)
+        ):
             # TODO: is there a shortcut available when len(cols) == 0?
             return True
 
@@ -473,3 +475,40 @@ def f(self, other, axis=default_axis, level=None):
     f.__name__ = op_name
 
     return f
+
+
+__all__ = [
+    "add_flex_arithmetic_methods",
+    "align_method_FRAME",
+    "align_method_SERIES",
+    "ARITHMETIC_BINOPS",
+    "arithmetic_op",
+    "COMPARISON_BINOPS",
+    "comparison_op",
+    "comp_method_OBJECT_ARRAY",
+    "fill_binop",
+    "flex_arith_method_FRAME",
+    "flex_comp_method_FRAME",
+    "flex_method_SERIES",
+    "frame_arith_method_with_reindex",
+    "invalid_comparison",
+    "kleene_and",
+    "kleene_or",
+    "kleene_xor",
+    "logical_op",
+    "maybe_dispatch_ufunc_to_dunder_op",
+    "radd",
+    "rand_",
+    "rdiv",
+    "rdivmod",
+    "rfloordiv",
+    "rmod",
+    "rmul",
+    "ror_",
+    "rpow",
+    "rsub",
+    "rtruediv",
+    "rxor",
+    "should_reindex_frame_op",
+    "unpack_zerodim_and_defer",
+]
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 84b8ce6bdcb31..6a1c586d90b6e 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -2,6 +2,8 @@
 Functions for arithmetic and comparison operations on NumPy arrays and
 ExtensionArrays.
 """
+from __future__ import annotations
+
 import datetime
 from functools import partial
 import operator
@@ -219,7 +221,9 @@ def arithmetic_op(left: ArrayLike, right: Any, op):
         # (https://github.com/pandas-dev/pandas/issues/41165)
         _bool_arith_check(op, left, right)
 
-        res_values = _na_arithmetic_op(left, right, op)
+        # error: Argument 1 to "_na_arithmetic_op" has incompatible type
+        # "Union[ExtensionArray, ndarray[Any, Any]]"; expected "ndarray[Any, Any]"
+        res_values = _na_arithmetic_op(left, right, op)  # type: ignore[arg-type]
 
     return res_values
 
diff --git a/pandas/core/ops/common.py b/pandas/core/ops/common.py
index b883fe7751daa..f0e6aa3750cee 100644
--- a/pandas/core/ops/common.py
+++ b/pandas/core/ops/common.py
@@ -1,6 +1,8 @@
 """
 Boilerplate functions used in defining binary operations.
 """
+from __future__ import annotations
+
 from functools import wraps
 from typing import Callable
 
diff --git a/pandas/core/ops/dispatch.py b/pandas/core/ops/dispatch.py
index bfd4afe0de86f..2f500703ccfb3 100644
--- a/pandas/core/ops/dispatch.py
+++ b/pandas/core/ops/dispatch.py
@@ -1,6 +1,8 @@
 """
 Functions for defining unary operations.
 """
+from __future__ import annotations
+
 from typing import Any
 
 from pandas._typing import ArrayLike
diff --git a/pandas/core/ops/docstrings.py b/pandas/core/ops/docstrings.py
index 9134ec7a73bea..9c3158b3465b7 100644
--- a/pandas/core/ops/docstrings.py
+++ b/pandas/core/ops/docstrings.py
@@ -428,14 +428,16 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 Parameters
 ----------
 other : Series or scalar value
+level : int or name
+    Broadcast across a level, matching Index values on the
+    passed MultiIndex level.
 fill_value : None or float value, default None (NaN)
     Fill existing missing (NaN) values, and any new element needed for
     successful Series alignment, with this value before computation.
     If data in both corresponding Series locations is missing
     the result of filling (at that location) will be missing.
-level : int or name
-    Broadcast across a level, matching Index values on the
-    passed MultiIndex level.
+axis : {{0 or 'index'}}
+    Unused. Parameter needed for compatibility with DataFrame.
 
 Returns
 -------
@@ -459,10 +461,10 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 
 Parameters
 ----------
-other : scalar, sequence, Series, or DataFrame
+other : scalar, sequence, Series, dict or DataFrame
     Any single or multiple element data structure, or list-like object.
 axis : {{0 or 'index', 1 or 'columns'}}
-    Whether to compare by the index (0 or 'index') or columns
+    Whether to compare by the index (0 or 'index') or columns.
     (1 or 'columns'). For Series input, axis to match Series index on.
 level : int or label
     Broadcast across a level, matching Index values on the
@@ -554,6 +556,20 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 triangle        2      179
 rectangle       3      359
 
+Multiply a dictionary by axis.
+
+>>> df.mul({{'angles': 0, 'degrees': 2}})
+            angles	degrees
+circle	         0	    720
+triangle	     0	    360
+rectangle	     0	    720
+
+>>> df.mul({{'circle': 0, 'triangle': 2, 'rectangle': 3}}, axis='index')
+            angles	degrees
+circle		     0	      0
+triangle	     6	    360
+rectangle	    12	   1080
+
 Multiply a DataFrame of different shape with operator version.
 
 >>> other = pd.DataFrame({{'angles': [0, 3, 4]}},
diff --git a/pandas/core/ops/invalid.py b/pandas/core/ops/invalid.py
index cc4a1f11edd2b..eb27cf7450119 100644
--- a/pandas/core/ops/invalid.py
+++ b/pandas/core/ops/invalid.py
@@ -1,12 +1,14 @@
 """
 Templates for invalid operations.
 """
+from __future__ import annotations
+
 import operator
 
 import numpy as np
 
 
-def invalid_comparison(left, right, op):
+def invalid_comparison(left, right, op) -> np.ndarray:
     """
     If a comparison has mismatched types and is not necessarily meaningful,
     follow python3 conventions by:
diff --git a/pandas/core/ops/mask_ops.py b/pandas/core/ops/mask_ops.py
index 57bacba0d4bee..adc1f63c568bf 100644
--- a/pandas/core/ops/mask_ops.py
+++ b/pandas/core/ops/mask_ops.py
@@ -184,6 +184,6 @@ def kleene_and(
     return result, mask
 
 
-def raise_for_nan(value, method: str):
+def raise_for_nan(value, method: str) -> None:
     if lib.is_float(value) and np.isnan(value):
         raise ValueError(f"Cannot perform logical '{method}' with floating NaN")
diff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py
index df22919ed19f1..e8a930083a778 100644
--- a/pandas/core/ops/methods.py
+++ b/pandas/core/ops/methods.py
@@ -1,6 +1,8 @@
 """
 Functions to generate methods and pin them to the appropriate classes.
 """
+from __future__ import annotations
+
 import operator
 
 from pandas.core.dtypes.generic import (
@@ -43,7 +45,7 @@ def _get_method_wrappers(cls):
     return arith_flex, comp_flex
 
 
-def add_flex_arithmetic_methods(cls):
+def add_flex_arithmetic_methods(cls) -> None:
     """
     Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)
     to the class.
diff --git a/pandas/core/ops/missing.py b/pandas/core/ops/missing.py
index 8d5f7fb8de758..850ca44e996c4 100644
--- a/pandas/core/ops/missing.py
+++ b/pandas/core/ops/missing.py
@@ -21,6 +21,8 @@
 
     3) divmod behavior consistent with 1) and 2).
 """
+from __future__ import annotations
+
 import operator
 
 import numpy as np
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index e0b9eac618bc9..0ac43b773bbf9 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -34,7 +34,10 @@
     npt,
 )
 from pandas.compat.numpy import function as nv
-from pandas.errors import AbstractMethodError
+from pandas.errors import (
+    AbstractMethodError,
+    DataError,
+)
 from pandas.util._decorators import (
     Appender,
     Substitution,
@@ -50,10 +53,7 @@
 
 import pandas.core.algorithms as algos
 from pandas.core.apply import ResamplerWindowApply
-from pandas.core.base import (
-    DataError,
-    PandasObject,
-)
+from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.generic import (
     NDFrame,
@@ -68,7 +68,6 @@
 )
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.groupby.ops import BinGrouper
-from pandas.core.indexes.api import Index
 from pandas.core.indexes.datetimes import (
     DatetimeIndex,
     date_range,
@@ -96,6 +95,7 @@
 if TYPE_CHECKING:
     from pandas import (
         DataFrame,
+        Index,
         Series,
     )
 
@@ -149,21 +149,26 @@ def __init__(
         axis: int = 0,
         kind=None,
         *,
+        group_keys: bool | lib.NoDefault = lib.no_default,
         selection=None,
         **kwargs,
-    ):
+    ) -> None:
         self.groupby = groupby
         self.keys = None
         self.sort = True
         self.axis = axis
         self.kind = kind
         self.squeeze = False
-        self.group_keys = True
+        self.group_keys = group_keys
         self.as_index = True
 
         self.groupby._set_grouper(self._convert_obj(obj), sort=True)
         self.binner, self.grouper = self._get_binner()
         self._selection = selection
+        if self.groupby.key is not None:
+            self.exclusions = frozenset([self.groupby.key])
+        else:
+            self.exclusions = frozenset()
 
     @final
     def _shallow_copy(self, obj, **kwargs):
@@ -200,7 +205,7 @@ def __getattr__(self, attr: str):
 
     # error: Signature of "obj" incompatible with supertype "BaseGroupBy"
     @property
-    def obj(self) -> NDFrameT:  # type: ignore[override]
+    def obj(self) -> NDFrame:  # type: ignore[override]
         # error: Incompatible return value type (got "Optional[Any]",
         # expected "NDFrameT")
         return self.groupby.obj  # type: ignore[return-value]
@@ -357,8 +362,9 @@ def aggregate(self, func=None, *args, **kwargs):
 
     def transform(self, arg, *args, **kwargs):
         """
-        Call function producing a like-indexed Series on each group and return
-        a Series with the transformed values.
+        Call function producing a like-indexed Series on each group.
+
+        Return a Series with the transformed values.
 
         Parameters
         ----------
@@ -388,7 +394,7 @@ def transform(self, arg, *args, **kwargs):
         """
         return self._selected_obj.groupby(self.groupby).transform(arg, *args, **kwargs)
 
-    def _downsample(self, f):
+    def _downsample(self, f, **kwargs):
         raise AbstractMethodError(self)
 
     def _upsample(self, f, limit=None, fill_value=None):
@@ -409,7 +415,9 @@ def _gotitem(self, key, ndim: int, subset=None):
         grouper = self.grouper
         if subset is None:
             subset = self.obj
-        grouped = get_groupby(subset, by=None, grouper=grouper, axis=self.axis)
+        grouped = get_groupby(
+            subset, by=None, grouper=grouper, axis=self.axis, group_keys=self.group_keys
+        )
 
         # try the key selection
         try:
@@ -423,9 +431,14 @@ def _groupby_and_aggregate(self, how, *args, **kwargs):
         """
         grouper = self.grouper
 
-        obj = self._selected_obj
-
-        grouped = get_groupby(obj, by=None, grouper=grouper, axis=self.axis)
+        if self._selected_obj.ndim == 1:
+            obj = self._selected_obj
+        else:
+            # Excludes `on` column when provided
+            obj = self._obj_with_exclusions
+        grouped = get_groupby(
+            obj, by=None, grouper=grouper, axis=self.axis, group_keys=self.group_keys
+        )
 
         try:
             if isinstance(obj, ABCDataFrame) and callable(how):
@@ -490,11 +503,11 @@ def _apply_loffset(self, result):
         self.loffset = None
         return result
 
-    def _get_resampler_for_grouping(self, groupby):
+    def _get_resampler_for_grouping(self, groupby, key=None):
         """
         Return the correct class for resampling with groupby.
         """
-        return self._resampler_for_grouping(self, groupby=groupby)
+        return self._resampler_for_grouping(self, groupby=groupby, key=key)
 
     def _wrap_result(self, result):
         """
@@ -532,6 +545,21 @@ def ffill(self, limit=None):
         return self._upsample("ffill", limit=limit)
 
     def pad(self, limit=None):
+        """
+        Forward fill the values.
+
+        .. deprecated:: 1.4
+            Use ffill instead.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        An upsampled Series.
+        """
         warnings.warn(
             "pad is deprecated and will be removed in a future version. "
             "Use ffill instead.",
@@ -540,8 +568,6 @@ def pad(self, limit=None):
         )
         return self.ffill(limit=limit)
 
-    pad.__doc__ = ffill.__doc__
-
     def nearest(self, limit=None):
         """
         Resample by using the nearest value.
@@ -705,6 +731,22 @@ def bfill(self, limit=None):
         return self._upsample("bfill", limit=limit)
 
     def backfill(self, limit=None):
+        """
+        Backward fill the values.
+
+        .. deprecated:: 1.4
+            Use bfill instead.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        Series, DataFrame
+            An upsampled Series or DataFrame with backward filled NaN values.
+        """
         warnings.warn(
             "backfill is deprecated and will be removed in a future version. "
             "Use bfill instead.",
@@ -713,8 +755,6 @@ def backfill(self, limit=None):
         )
         return self.bfill(limit=limit)
 
-    backfill.__doc__ = bfill.__doc__
-
     def fillna(self, method, limit=None):
         """
         Fill missing values introduced by upsampling.
@@ -925,7 +965,13 @@ def asfreq(self, fill_value=None):
         """
         return self._upsample("asfreq", fill_value=fill_value)
 
-    def std(self, ddof=1, *args, **kwargs):
+    def std(
+        self,
+        ddof=1,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+        *args,
+        **kwargs,
+    ):
         """
         Compute standard deviation of groups, excluding missing values.
 
@@ -933,6 +979,10 @@ def std(self, ddof=1, *args, **kwargs):
         ----------
         ddof : int, default 1
             Degrees of freedom.
+        numeric_only : bool, default False
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
 
         Returns
         -------
@@ -940,10 +990,15 @@ def std(self, ddof=1, *args, **kwargs):
             Standard deviation of values within each group.
         """
         nv.validate_resampler_func("std", args, kwargs)
-        # error: Unexpected keyword argument "ddof" for "_downsample"
-        return self._downsample("std", ddof=ddof)  # type: ignore[call-arg]
+        return self._downsample("std", ddof=ddof, numeric_only=numeric_only)
 
-    def var(self, ddof=1, *args, **kwargs):
+    def var(
+        self,
+        ddof=1,
+        numeric_only: bool | lib.NoDefault = lib.no_default,
+        *args,
+        **kwargs,
+    ):
         """
         Compute variance of groups, excluding missing values.
 
@@ -952,14 +1007,18 @@ def var(self, ddof=1, *args, **kwargs):
         ddof : int, default 1
             Degrees of freedom.
 
+        numeric_only : bool, default False
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
         Returns
         -------
         DataFrame or Series
             Variance of values within each group.
         """
         nv.validate_resampler_func("var", args, kwargs)
-        # error: Unexpected keyword argument "ddof" for "_downsample"
-        return self._downsample("var", ddof=ddof)  # type: ignore[call-arg]
+        return self._downsample("var", ddof=ddof, numeric_only=numeric_only)
 
     @doc(GroupBy.size)
     def size(self):
@@ -1015,41 +1074,94 @@ def quantile(self, q=0.5, **kwargs):
             Return a DataFrame, where the coulmns are groupby columns,
             and the values are its quantiles.
         """
-        # error: Unexpected keyword argument "q" for "_downsample"
-        # error: Too many arguments for "_downsample"
-        return self._downsample("quantile", q=q, **kwargs)  # type: ignore[call-arg]
+        return self._downsample("quantile", q=q, **kwargs)
 
 
-# downsample methods
-for method in ["sum", "prod", "min", "max", "first", "last"]:
+def _add_downsample_kernel(
+    name: str, args: tuple[str, ...], docs_class: type = GroupBy
+) -> None:
+    """
+    Add a kernel to Resampler.
+
+    Arguments
+    ---------
+    name : str
+        Name of the kernel.
+    args : tuple
+        Arguments of the method.
+    docs_class : type
+        Class to get kernel docstring from.
+    """
+    assert args in (
+        ("numeric_only", "min_count"),
+        ("numeric_only",),
+        ("ddof", "numeric_only"),
+        (),
+    )
 
-    def f(self, _method=method, min_count=0, *args, **kwargs):
-        nv.validate_resampler_func(_method, args, kwargs)
-        return self._downsample(_method, min_count=min_count)
+    # Explicitly provide args rather than args/kwargs for API docs
+    if args == ("numeric_only", "min_count"):
 
-    f.__doc__ = getattr(GroupBy, method).__doc__
-    setattr(Resampler, method, f)
+        def f(
+            self,
+            numeric_only: bool | lib.NoDefault = lib.no_default,
+            min_count: int = 0,
+            *args,
+            **kwargs,
+        ):
+            nv.validate_resampler_func(name, args, kwargs)
+            if numeric_only is lib.no_default and name != "sum":
+                # For DataFrameGroupBy, set it to be False for methods other than `sum`.
+                numeric_only = False
 
+            return self._downsample(
+                name, numeric_only=numeric_only, min_count=min_count
+            )
 
-# downsample methods
-for method in ["mean", "sem", "median", "ohlc"]:
+    elif args == ("numeric_only",):
+        # error: All conditional function variants must have identical signatures
+        def f(  # type: ignore[misc]
+            self, numeric_only: bool | lib.NoDefault = lib.no_default, *args, **kwargs
+        ):
+            nv.validate_resampler_func(name, args, kwargs)
+            return self._downsample(name, numeric_only=numeric_only)
+
+    elif args == ("ddof", "numeric_only"):
+        # error: All conditional function variants must have identical signatures
+        def f(  # type: ignore[misc]
+            self,
+            ddof: int = 1,
+            numeric_only: bool | lib.NoDefault = lib.no_default,
+            *args,
+            **kwargs,
+        ):
+            nv.validate_resampler_func(name, args, kwargs)
+            return self._downsample(name, ddof=ddof, numeric_only=numeric_only)
 
-    def g(self, _method=method, *args, **kwargs):
-        nv.validate_resampler_func(_method, args, kwargs)
-        return self._downsample(_method)
+    else:
+        # error: All conditional function variants must have identical signatures
+        def f(  # type: ignore[misc]
+            self,
+            *args,
+            **kwargs,
+        ):
+            nv.validate_resampler_func(name, args, kwargs)
+            return self._downsample(name)
 
-    g.__doc__ = getattr(GroupBy, method).__doc__
-    setattr(Resampler, method, g)
+    f.__doc__ = getattr(docs_class, name).__doc__
+    setattr(Resampler, name, f)
 
 
-# series only methods
+for method in ["sum", "prod", "min", "max", "first", "last"]:
+    _add_downsample_kernel(method, ("numeric_only", "min_count"))
+for method in ["mean", "median"]:
+    _add_downsample_kernel(method, ("numeric_only",))
+for method in ["sem"]:
+    _add_downsample_kernel(method, ("ddof", "numeric_only"))
+for method in ["ohlc"]:
+    _add_downsample_kernel(method, ())
 for method in ["nunique"]:
-
-    def h(self, _method=method):
-        return self._downsample(_method)
-
-    h.__doc__ = getattr(SeriesGroupBy, method).__doc__
-    setattr(Resampler, method, h)
+    _add_downsample_kernel(method, (), SeriesGroupBy)
 
 
 class _GroupByMixin(PandasObject):
@@ -1060,7 +1172,7 @@ class _GroupByMixin(PandasObject):
     _attributes: list[str]  # in practice the same as Resampler._attributes
     _selection: IndexLabel | None = None
 
-    def __init__(self, obj, parent=None, groupby=None, **kwargs):
+    def __init__(self, obj, parent=None, groupby=None, key=None, **kwargs) -> None:
         # reached via ._gotitem and _get_resampler_for_grouping
 
         if parent is None:
@@ -1073,6 +1185,7 @@ def __init__(self, obj, parent=None, groupby=None, **kwargs):
         self._selection = kwargs.get("selection")
 
         self.binner = parent.binner
+        self.key = key
 
         self._groupby = groupby
         self._groupby.mutated = True
@@ -1125,6 +1238,8 @@ def _gotitem(self, key, ndim, subset=None):
 
         # Try to select from a DataFrame, falling back to a Series
         try:
+            if isinstance(key, list) and self.key not in key:
+                key.append(self.key)
             groupby = self._groupby[key]
         except IndexError:
             groupby = self._groupby
@@ -1164,7 +1279,11 @@ def _downsample(self, how, **kwargs):
         """
         how = com.get_cython_func(how) or how
         ax = self.ax
-        obj = self._selected_obj
+        if self._selected_obj.ndim == 1:
+            obj = self._selected_obj
+        else:
+            # Excludes `on` column when provided
+            obj = self._obj_with_exclusions
 
         if not len(ax):
             # reset to the new freq
@@ -1415,7 +1534,9 @@ def _constructor(self):
         return TimedeltaIndexResampler
 
 
-def get_resampler(obj, kind=None, **kwds):
+def get_resampler(
+    obj, kind=None, **kwds
+) -> DatetimeIndexResampler | PeriodIndexResampler | TimedeltaIndexResampler:
     """
     Create a TimeGrouper and return our resampler.
     """
@@ -1435,7 +1556,7 @@ def get_resampler_for_grouping(
     # .resample uses 'on' similar to how .groupby uses 'key'
     tg = TimeGrouper(freq=rule, key=on, **kwargs)
     resampler = tg._get_resampler(groupby.obj, kind=kind)
-    return resampler._get_resampler_for_grouping(groupby=groupby)
+    return resampler._get_resampler_for_grouping(groupby=groupby, key=tg.key)
 
 
 class TimeGrouper(Grouper):
@@ -1466,19 +1587,20 @@ def __init__(
         self,
         freq="Min",
         closed: Literal["left", "right"] | None = None,
-        label: str | None = None,
+        label: Literal["left", "right"] | None = None,
         how="mean",
         axis=0,
         fill_method=None,
         limit=None,
         loffset=None,
         kind: str | None = None,
-        convention: str | None = None,
+        convention: Literal["start", "end", "e", "s"] | None = None,
         base: int | None = None,
         origin: str | TimestampConvertibleTypes = "start_day",
         offset: TimedeltaConvertibleTypes | None = None,
+        group_keys: bool | lib.NoDefault = True,
         **kwargs,
-    ):
+    ) -> None:
         # Check for correctness of the keyword arguments which would
         # otherwise silently use the default if misspelled
         if label not in {None, "left", "right"}:
@@ -1518,13 +1640,11 @@ def __init__(
         self.closed = closed
         self.label = label
         self.kind = kind
-
-        self.convention = convention or "E"
-        self.convention = self.convention.lower()
-
+        self.convention = convention if convention is not None else "e"
         self.how = how
         self.fill_method = fill_method
         self.limit = limit
+        self.group_keys = group_keys
 
         if origin in ("epoch", "start", "start_day", "end", "end_day"):
             self.origin = origin
@@ -1590,11 +1710,17 @@ def _get_resampler(self, obj, kind=None):
 
         ax = self.ax
         if isinstance(ax, DatetimeIndex):
-            return DatetimeIndexResampler(obj, groupby=self, kind=kind, axis=self.axis)
+            return DatetimeIndexResampler(
+                obj, groupby=self, kind=kind, axis=self.axis, group_keys=self.group_keys
+            )
         elif isinstance(ax, PeriodIndex) or kind == "period":
-            return PeriodIndexResampler(obj, groupby=self, kind=kind, axis=self.axis)
+            return PeriodIndexResampler(
+                obj, groupby=self, kind=kind, axis=self.axis, group_keys=self.group_keys
+            )
         elif isinstance(ax, TimedeltaIndex):
-            return TimedeltaIndexResampler(obj, groupby=self, axis=self.axis)
+            return TimedeltaIndexResampler(
+                obj, groupby=self, axis=self.axis, group_keys=self.group_keys
+            )
 
         raise TypeError(
             "Only valid with DatetimeIndex, "
@@ -1702,12 +1828,19 @@ def _get_time_delta_bins(self, ax: TimedeltaIndex):
             return binner, [], labels
 
         start, end = ax.min(), ax.max()
+
+        if self.closed == "right":
+            end += self.freq
+
         labels = binner = timedelta_range(
             start=start, end=end, freq=self.freq, name=ax.name
         )
 
-        end_stamps = labels + self.freq
-        bins = ax.searchsorted(end_stamps, side="left")
+        end_stamps = labels
+        if self.closed == "left":
+            end_stamps += self.freq
+
+        bins = ax.searchsorted(end_stamps, side=self.closed)
 
         if self.offset:
             # GH 10530 & 31809
@@ -1752,7 +1885,9 @@ def _get_period_bins(self, ax: PeriodIndex):
         # NaT handling as in pandas._lib.lib.generate_bins_dt64()
         nat_count = 0
         if memb.hasnans:
-            nat_count = np.sum(memb._isnan)
+            # error: Incompatible types in assignment (expression has type
+            # "bool_", variable has type "int")  [assignment]
+            nat_count = np.sum(memb._isnan)  # type: ignore[assignment]
             memb = memb[~memb._isnan]
 
         if not len(memb):
diff --git a/pandas/core/reshape/api.py b/pandas/core/reshape/api.py
index bffdadb96c972..b1884c497f0ad 100644
--- a/pandas/core/reshape/api.py
+++ b/pandas/core/reshape/api.py
@@ -1,6 +1,8 @@
-# flake8: noqa:F401
-
 from pandas.core.reshape.concat import concat
+from pandas.core.reshape.encoding import (
+    from_dummies,
+    get_dummies,
+)
 from pandas.core.reshape.melt import (
     lreshape,
     melt,
@@ -16,8 +18,24 @@
     pivot,
     pivot_table,
 )
-from pandas.core.reshape.reshape import get_dummies
 from pandas.core.reshape.tile import (
     cut,
     qcut,
 )
+
+__all__ = [
+    "concat",
+    "crosstab",
+    "cut",
+    "from_dummies",
+    "get_dummies",
+    "lreshape",
+    "melt",
+    "merge",
+    "merge_asof",
+    "merge_ordered",
+    "pivot",
+    "pivot_table",
+    "qcut",
+    "wide_to_long",
+]
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 71b53d50273e0..5328c7995ea6f 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -6,6 +6,7 @@
 from collections import abc
 from typing import (
     TYPE_CHECKING,
+    Callable,
     Hashable,
     Iterable,
     Literal,
@@ -17,7 +18,10 @@
 
 import numpy as np
 
-from pandas._typing import Axis
+from pandas._typing import (
+    Axis,
+    HashableT,
+)
 from pandas.util._decorators import (
     cache_readonly,
     deprecate_nonkeyword_arguments,
@@ -61,7 +65,7 @@
 
 @overload
 def concat(
-    objs: Iterable[DataFrame] | Mapping[Hashable, DataFrame],
+    objs: Iterable[DataFrame] | Mapping[HashableT, DataFrame],
     axis: Literal[0, "index"] = ...,
     join: str = ...,
     ignore_index: bool = ...,
@@ -77,7 +81,7 @@ def concat(
 
 @overload
 def concat(
-    objs: Iterable[Series] | Mapping[Hashable, Series],
+    objs: Iterable[Series] | Mapping[HashableT, Series],
     axis: Literal[0, "index"] = ...,
     join: str = ...,
     ignore_index: bool = ...,
@@ -93,7 +97,7 @@ def concat(
 
 @overload
 def concat(
-    objs: Iterable[NDFrame] | Mapping[Hashable, NDFrame],
+    objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],
     axis: Literal[0, "index"] = ...,
     join: str = ...,
     ignore_index: bool = ...,
@@ -109,7 +113,7 @@ def concat(
 
 @overload
 def concat(
-    objs: Iterable[NDFrame] | Mapping[Hashable, NDFrame],
+    objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],
     axis: Literal[1, "columns"],
     join: str = ...,
     ignore_index: bool = ...,
@@ -125,7 +129,7 @@ def concat(
 
 @overload
 def concat(
-    objs: Iterable[NDFrame] | Mapping[Hashable, NDFrame],
+    objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],
     axis: Axis = ...,
     join: str = ...,
     ignore_index: bool = ...,
@@ -141,7 +145,7 @@ def concat(
 
 @deprecate_nonkeyword_arguments(version=None, allowed_args=["objs"])
 def concat(
-    objs: Iterable[NDFrame] | Mapping[Hashable, NDFrame],
+    objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],
     axis: Axis = 0,
     join: str = "outer",
     ignore_index: bool = False,
@@ -153,8 +157,9 @@ def concat(
     copy: bool = True,
 ) -> DataFrame | Series:
     """
-    Concatenate pandas objects along a particular axis with optional set logic
-    along the other axes.
+    Concatenate pandas objects along a particular axis.
+
+    Allows optional set logic along the other axes.
 
     Can also add a layer of hierarchical indexing on the concatenation axis,
     which may be useful if the labels are the same (or overlapping) on
@@ -211,8 +216,6 @@ def concat(
 
     See Also
     --------
-    Series.append : Concatenate Series.
-    DataFrame.append : Concatenate DataFrames.
     DataFrame.join : Join DataFrames using indexes.
     DataFrame.merge : Merge DataFrames by indexes or columns.
 
@@ -224,6 +227,9 @@ def concat(
     pandas objects can be found `here
     <https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html>`__.
 
+    It is not recommended to build DataFrames by adding single rows in a
+    for loop. Build a list of rows and make a DataFrame in a single concat.
+
     Examples
     --------
     Combine two ``Series``.
@@ -342,6 +348,22 @@ def concat(
     Traceback (most recent call last):
         ...
     ValueError: Indexes have overlapping values: ['a']
+
+    Append a single row to the end of a ``DataFrame`` object.
+
+    >>> df7 = pd.DataFrame({'a': 1, 'b': 2}, index=[0])
+    >>> df7
+        a   b
+    0   1   2
+    >>> new_row = pd.Series({'a': 3, 'b': 4})
+    >>> new_row
+    a    3
+    b    4
+    dtype: int64
+    >>> pd.concat([df7, new_row.to_frame().T], ignore_index=True)
+        a   b
+    0   1   2
+    1   3   4
     """
     op = _Concatenator(
         objs,
@@ -366,7 +388,7 @@ class _Concatenator:
 
     def __init__(
         self,
-        objs: Iterable[NDFrame] | Mapping[Hashable, NDFrame],
+        objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],
         axis=0,
         join: str = "outer",
         keys=None,
@@ -376,7 +398,7 @@ def __init__(
         verify_integrity: bool = False,
         copy: bool = True,
         sort=False,
-    ):
+    ) -> None:
         if isinstance(objs, (ABCSeries, ABCDataFrame, str)):
             raise TypeError(
                 "first argument must be an iterable of pandas "
@@ -467,7 +489,9 @@ def __init__(
 
         # Standardize axis parameter to int
         if isinstance(sample, ABCSeries):
-            axis = sample._constructor_expanddim._get_axis_number(axis)
+            from pandas import DataFrame
+
+            axis = DataFrame._get_axis_number(axis)
         else:
             axis = sample._get_axis_number(axis)
 
@@ -539,7 +563,7 @@ def __init__(
         self.new_axes = self._get_new_axes()
 
     def get_result(self):
-        cons: type[DataFrame | Series]
+        cons: Callable[..., DataFrame | Series]
         sample: DataFrame | Series
 
         # series only
@@ -662,6 +686,8 @@ def _get_concat_axis(self) -> Index:
             return idx
 
         if self.keys is None:
+            if self.levels is not None:
+                raise ValueError("levels supported only when keys is not None")
             concat_axis = _concat_indexes(indexes)
         else:
             concat_axis = _make_concat_multiindex(
@@ -702,10 +728,14 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None) -> MultiInde
             names = [None]
 
         if levels is None:
-            levels = [ensure_index(keys)]
+            levels = [ensure_index(keys).unique()]
         else:
             levels = [ensure_index(x) for x in levels]
 
+    for level in levels:
+        if not level.is_unique:
+            raise ValueError(f"Level values not unique: {level.tolist()}")
+
     if not all_indexes_same(indexes) or not all(level.is_unique for level in levels):
         codes_list = []
 
diff --git a/pandas/core/reshape/encoding.py b/pandas/core/reshape/encoding.py
new file mode 100644
index 0000000000000..da4de8cc57e65
--- /dev/null
+++ b/pandas/core/reshape/encoding.py
@@ -0,0 +1,520 @@
+from __future__ import annotations
+
+from collections import defaultdict
+import itertools
+from typing import Hashable
+
+import numpy as np
+
+from pandas._libs.sparse import IntIndex
+from pandas._typing import Dtype
+
+from pandas.core.dtypes.common import (
+    is_integer_dtype,
+    is_list_like,
+    is_object_dtype,
+)
+
+from pandas.core.arrays import SparseArray
+from pandas.core.arrays.categorical import factorize_from_iterable
+from pandas.core.frame import DataFrame
+from pandas.core.indexes.api import Index
+from pandas.core.series import Series
+
+
+def get_dummies(
+    data,
+    prefix=None,
+    prefix_sep="_",
+    dummy_na: bool = False,
+    columns=None,
+    sparse: bool = False,
+    drop_first: bool = False,
+    dtype: Dtype | None = None,
+) -> DataFrame:
+    """
+    Convert categorical variable into dummy/indicator variables.
+
+    Parameters
+    ----------
+    data : array-like, Series, or DataFrame
+        Data of which to get dummy indicators.
+    prefix : str, list of str, or dict of str, default None
+        String to append DataFrame column names.
+        Pass a list with length equal to the number of columns
+        when calling get_dummies on a DataFrame. Alternatively, `prefix`
+        can be a dictionary mapping column names to prefixes.
+    prefix_sep : str, default '_'
+        If appending prefix, separator/delimiter to use. Or pass a
+        list or dictionary as with `prefix`.
+    dummy_na : bool, default False
+        Add a column to indicate NaNs, if False NaNs are ignored.
+    columns : list-like, default None
+        Column names in the DataFrame to be encoded.
+        If `columns` is None then all the columns with
+        `object`, `string`, or `category` dtype will be converted.
+    sparse : bool, default False
+        Whether the dummy-encoded columns should be backed by
+        a :class:`SparseArray` (True) or a regular NumPy array (False).
+    drop_first : bool, default False
+        Whether to get k-1 dummies out of k categorical levels by removing the
+        first level.
+    dtype : dtype, default np.uint8
+        Data type for new columns. Only a single dtype is allowed.
+
+    Returns
+    -------
+    DataFrame
+        Dummy-coded data.
+
+    See Also
+    --------
+    Series.str.get_dummies : Convert Series to dummy codes.
+    :func:`~pandas.from_dummies` : Convert dummy codes to categorical ``DataFrame``.
+
+    Notes
+    -----
+    Reference :ref:`the user guide <reshaping.dummies>` for more examples.
+
+    Examples
+    --------
+    >>> s = pd.Series(list('abca'))
+
+    >>> pd.get_dummies(s)
+       a  b  c
+    0  1  0  0
+    1  0  1  0
+    2  0  0  1
+    3  1  0  0
+
+    >>> s1 = ['a', 'b', np.nan]
+
+    >>> pd.get_dummies(s1)
+       a  b
+    0  1  0
+    1  0  1
+    2  0  0
+
+    >>> pd.get_dummies(s1, dummy_na=True)
+       a  b  NaN
+    0  1  0    0
+    1  0  1    0
+    2  0  0    1
+
+    >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
+    ...                    'C': [1, 2, 3]})
+
+    >>> pd.get_dummies(df, prefix=['col1', 'col2'])
+       C  col1_a  col1_b  col2_a  col2_b  col2_c
+    0  1       1       0       0       1       0
+    1  2       0       1       1       0       0
+    2  3       1       0       0       0       1
+
+    >>> pd.get_dummies(pd.Series(list('abcaa')))
+       a  b  c
+    0  1  0  0
+    1  0  1  0
+    2  0  0  1
+    3  1  0  0
+    4  1  0  0
+
+    >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True)
+       b  c
+    0  0  0
+    1  1  0
+    2  0  1
+    3  0  0
+    4  0  0
+
+    >>> pd.get_dummies(pd.Series(list('abc')), dtype=float)
+         a    b    c
+    0  1.0  0.0  0.0
+    1  0.0  1.0  0.0
+    2  0.0  0.0  1.0
+    """
+    from pandas.core.reshape.concat import concat
+
+    dtypes_to_encode = ["object", "string", "category"]
+
+    if isinstance(data, DataFrame):
+        # determine columns being encoded
+        if columns is None:
+            data_to_encode = data.select_dtypes(include=dtypes_to_encode)
+        elif not is_list_like(columns):
+            raise TypeError("Input must be a list-like for parameter `columns`")
+        else:
+            data_to_encode = data[columns]
+
+        # validate prefixes and separator to avoid silently dropping cols
+        def check_len(item, name):
+
+            if is_list_like(item):
+                if not len(item) == data_to_encode.shape[1]:
+                    len_msg = (
+                        f"Length of '{name}' ({len(item)}) did not match the "
+                        "length of the columns being encoded "
+                        f"({data_to_encode.shape[1]})."
+                    )
+                    raise ValueError(len_msg)
+
+        check_len(prefix, "prefix")
+        check_len(prefix_sep, "prefix_sep")
+
+        if isinstance(prefix, str):
+            prefix = itertools.cycle([prefix])
+        if isinstance(prefix, dict):
+            prefix = [prefix[col] for col in data_to_encode.columns]
+
+        if prefix is None:
+            prefix = data_to_encode.columns
+
+        # validate separators
+        if isinstance(prefix_sep, str):
+            prefix_sep = itertools.cycle([prefix_sep])
+        elif isinstance(prefix_sep, dict):
+            prefix_sep = [prefix_sep[col] for col in data_to_encode.columns]
+
+        with_dummies: list[DataFrame]
+        if data_to_encode.shape == data.shape:
+            # Encoding the entire df, do not prepend any dropped columns
+            with_dummies = []
+        elif columns is not None:
+            # Encoding only cols specified in columns. Get all cols not in
+            # columns to prepend to result.
+            with_dummies = [data.drop(columns, axis=1)]
+        else:
+            # Encoding only object and category dtype columns. Get remaining
+            # columns to prepend to result.
+            with_dummies = [data.select_dtypes(exclude=dtypes_to_encode)]
+
+        for (col, pre, sep) in zip(data_to_encode.items(), prefix, prefix_sep):
+            # col is (column_name, column), use just column data here
+            dummy = _get_dummies_1d(
+                col[1],
+                prefix=pre,
+                prefix_sep=sep,
+                dummy_na=dummy_na,
+                sparse=sparse,
+                drop_first=drop_first,
+                dtype=dtype,
+            )
+            with_dummies.append(dummy)
+        result = concat(with_dummies, axis=1)
+    else:
+        result = _get_dummies_1d(
+            data,
+            prefix,
+            prefix_sep,
+            dummy_na,
+            sparse=sparse,
+            drop_first=drop_first,
+            dtype=dtype,
+        )
+    return result
+
+
+def _get_dummies_1d(
+    data,
+    prefix,
+    prefix_sep="_",
+    dummy_na: bool = False,
+    sparse: bool = False,
+    drop_first: bool = False,
+    dtype: Dtype | None = None,
+) -> DataFrame:
+    from pandas.core.reshape.concat import concat
+
+    # Series avoids inconsistent NaN handling
+    codes, levels = factorize_from_iterable(Series(data))
+
+    if dtype is None:
+        dtype = np.dtype(np.uint8)
+    # error: Argument 1 to "dtype" has incompatible type "Union[ExtensionDtype, str,
+    # dtype[Any], Type[object]]"; expected "Type[Any]"
+    dtype = np.dtype(dtype)  # type: ignore[arg-type]
+
+    if is_object_dtype(dtype):
+        raise ValueError("dtype=object is not a valid dtype for get_dummies")
+
+    def get_empty_frame(data) -> DataFrame:
+        index: Index | np.ndarray
+        if isinstance(data, Series):
+            index = data.index
+        else:
+            index = Index(range(len(data)))
+        return DataFrame(index=index)
+
+    # if all NaN
+    if not dummy_na and len(levels) == 0:
+        return get_empty_frame(data)
+
+    codes = codes.copy()
+    if dummy_na:
+        codes[codes == -1] = len(levels)
+        levels = levels.insert(len(levels), np.nan)
+
+    # if dummy_na, we just fake a nan level. drop_first will drop it again
+    if drop_first and len(levels) == 1:
+        return get_empty_frame(data)
+
+    number_of_cols = len(levels)
+
+    if prefix is None:
+        dummy_cols = levels
+    else:
+        dummy_cols = Index([f"{prefix}{prefix_sep}{level}" for level in levels])
+
+    index: Index | None
+    if isinstance(data, Series):
+        index = data.index
+    else:
+        index = None
+
+    if sparse:
+
+        fill_value: bool | float
+        if is_integer_dtype(dtype):
+            fill_value = 0
+        elif dtype == np.dtype(bool):
+            fill_value = False
+        else:
+            fill_value = 0.0
+
+        sparse_series = []
+        N = len(data)
+        sp_indices: list[list] = [[] for _ in range(len(dummy_cols))]
+        mask = codes != -1
+        codes = codes[mask]
+        n_idx = np.arange(N)[mask]
+
+        for ndx, code in zip(n_idx, codes):
+            sp_indices[code].append(ndx)
+
+        if drop_first:
+            # remove first categorical level to avoid perfect collinearity
+            # GH12042
+            sp_indices = sp_indices[1:]
+            dummy_cols = dummy_cols[1:]
+        for col, ixs in zip(dummy_cols, sp_indices):
+            sarr = SparseArray(
+                np.ones(len(ixs), dtype=dtype),
+                sparse_index=IntIndex(N, ixs),
+                fill_value=fill_value,
+                dtype=dtype,
+            )
+            sparse_series.append(Series(data=sarr, index=index, name=col))
+
+        return concat(sparse_series, axis=1, copy=False)
+
+    else:
+        # take on axis=1 + transpose to ensure ndarray layout is column-major
+        dummy_mat = np.eye(number_of_cols, dtype=dtype).take(codes, axis=1).T
+
+        if not dummy_na:
+            # reset NaN GH4446
+            dummy_mat[codes == -1] = 0
+
+        if drop_first:
+            # remove first GH12042
+            dummy_mat = dummy_mat[:, 1:]
+            dummy_cols = dummy_cols[1:]
+        return DataFrame(dummy_mat, index=index, columns=dummy_cols)
+
+
+def from_dummies(
+    data: DataFrame,
+    sep: None | str = None,
+    default_category: None | Hashable | dict[str, Hashable] = None,
+) -> DataFrame:
+    """
+    Create a categorical ``DataFrame`` from a ``DataFrame`` of dummy variables.
+
+    Inverts the operation performed by :func:`~pandas.get_dummies`.
+
+    .. versionadded:: 1.5.0
+
+    Parameters
+    ----------
+    data : DataFrame
+        Data which contains dummy-coded variables in form of integer columns of
+        1's and 0's.
+    sep : str, default None
+        Separator used in the column names of the dummy categories they are
+        character indicating the separation of the categorical names from the prefixes.
+        For example, if your column names are 'prefix_A' and 'prefix_B',
+        you can strip the underscore by specifying sep='_'.
+    default_category : None, Hashable or dict of Hashables, default None
+        The default category is the implied category when a value has none of the
+        listed categories specified with a one, i.e. if all dummies in a row are
+        zero. Can be a single value for all variables or a dict directly mapping
+        the default categories to a prefix of a variable.
+
+    Returns
+    -------
+    DataFrame
+        Categorical data decoded from the dummy input-data.
+
+    Raises
+    ------
+    ValueError
+        * When the input ``DataFrame`` ``data`` contains NA values.
+        * When the input ``DataFrame`` ``data`` contains column names with separators
+          that do not match the separator specified with ``sep``.
+        * When a ``dict`` passed to ``default_category`` does not include an implied
+          category for each prefix.
+        * When a value in ``data`` has more than one category assigned to it.
+        * When ``default_category=None`` and a value in ``data`` has no category
+          assigned to it.
+    TypeError
+        * When the input ``data`` is not of type ``DataFrame``.
+        * When the input ``DataFrame`` ``data`` contains non-dummy data.
+        * When the passed ``sep`` is of a wrong data type.
+        * When the passed ``default_category`` is of a wrong data type.
+
+    See Also
+    --------
+    :func:`~pandas.get_dummies` : Convert ``Series`` or ``DataFrame`` to dummy codes.
+    :class:`~pandas.Categorical` : Represent a categorical variable in classic.
+
+    Notes
+    -----
+    The columns of the passed dummy data should only include 1's and 0's,
+    or boolean values.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({"a": [1, 0, 0, 1], "b": [0, 1, 0, 0],
+    ...                    "c": [0, 0, 1, 0]})
+
+    >>> df
+       a  b  c
+    0  1  0  0
+    1  0  1  0
+    2  0  0  1
+    3  1  0  0
+
+    >>> pd.from_dummies(df)
+    0     a
+    1     b
+    2     c
+    3     a
+
+    >>> df = pd.DataFrame({"col1_a": [1, 0, 1], "col1_b": [0, 1, 0],
+    ...                    "col2_a": [0, 1, 0], "col2_b": [1, 0, 0],
+    ...                    "col2_c": [0, 0, 1]})
+
+    >>> df
+          col1_a  col1_b  col2_a  col2_b  col2_c
+    0       1       0       0       1       0
+    1       0       1       1       0       0
+    2       1       0       0       0       1
+
+    >>> pd.from_dummies(df, sep="_")
+        col1    col2
+    0    a       b
+    1    b       a
+    2    a       c
+
+    >>> df = pd.DataFrame({"col1_a": [1, 0, 0], "col1_b": [0, 1, 0],
+    ...                    "col2_a": [0, 1, 0], "col2_b": [1, 0, 0],
+    ...                    "col2_c": [0, 0, 0]})
+
+    >>> df
+          col1_a  col1_b  col2_a  col2_b  col2_c
+    0       1       0       0       1       0
+    1       0       1       1       0       0
+    2       0       0       0       0       0
+
+    >>> pd.from_dummies(df, sep="_", default_category={"col1": "d", "col2": "e"})
+        col1    col2
+    0    a       b
+    1    b       a
+    2    d       e
+    """
+    from pandas.core.reshape.concat import concat
+
+    if not isinstance(data, DataFrame):
+        raise TypeError(
+            "Expected 'data' to be a 'DataFrame'; "
+            f"Received 'data' of type: {type(data).__name__}"
+        )
+
+    if data.isna().any().any():
+        raise ValueError(
+            "Dummy DataFrame contains NA value in column: "
+            f"'{data.isna().any().idxmax()}'"
+        )
+
+    # index data with a list of all columns that are dummies
+    try:
+        data_to_decode = data.astype("boolean", copy=False)
+    except TypeError:
+        raise TypeError("Passed DataFrame contains non-dummy data")
+
+    # collect prefixes and get lists to slice data for each prefix
+    variables_slice = defaultdict(list)
+    if sep is None:
+        variables_slice[""] = list(data.columns)
+    elif isinstance(sep, str):
+        for col in data_to_decode.columns:
+            prefix = col.split(sep)[0]
+            if len(prefix) == len(col):
+                raise ValueError(f"Separator not specified for column: {col}")
+            variables_slice[prefix].append(col)
+    else:
+        raise TypeError(
+            "Expected 'sep' to be of type 'str' or 'None'; "
+            f"Received 'sep' of type: {type(sep).__name__}"
+        )
+
+    if default_category is not None:
+        if isinstance(default_category, dict):
+            if not len(default_category) == len(variables_slice):
+                len_msg = (
+                    f"Length of 'default_category' ({len(default_category)}) "
+                    f"did not match the length of the columns being encoded "
+                    f"({len(variables_slice)})"
+                )
+                raise ValueError(len_msg)
+        elif isinstance(default_category, Hashable):
+            default_category = dict(
+                zip(variables_slice, [default_category] * len(variables_slice))
+            )
+        else:
+            raise TypeError(
+                "Expected 'default_category' to be of type "
+                "'None', 'Hashable', or 'dict'; "
+                "Received 'default_category' of type: "
+                f"{type(default_category).__name__}"
+            )
+
+    cat_data = {}
+    for prefix, prefix_slice in variables_slice.items():
+        if sep is None:
+            cats = prefix_slice.copy()
+        else:
+            cats = [col[len(prefix + sep) :] for col in prefix_slice]
+        assigned = data_to_decode.loc[:, prefix_slice].sum(axis=1)
+        if any(assigned > 1):
+            raise ValueError(
+                "Dummy DataFrame contains multi-assignment(s); "
+                f"First instance in row: {assigned.idxmax()}"
+            )
+        elif any(assigned == 0):
+            if isinstance(default_category, dict):
+                cats.append(default_category[prefix])
+            else:
+                raise ValueError(
+                    "Dummy DataFrame contains unassigned value(s); "
+                    f"First instance in row: {assigned.idxmin()}"
+                )
+            data_slice = concat(
+                (data_to_decode.loc[:, prefix_slice], assigned == 0), axis=1
+            )
+        else:
+            data_slice = data_to_decode.loc[:, prefix_slice]
+        cats_array = np.array(cats, dtype="object")
+        # get indices of True entries along axis=1
+        cat_data[prefix] = cats_array[data_slice.to_numpy().nonzero()[1]]
+
+    return DataFrame(cat_data)
diff --git a/pandas/core/reshape/melt.py b/pandas/core/reshape/melt.py
index 7026e470df1c0..5de9c8e2f4108 100644
--- a/pandas/core/reshape/melt.py
+++ b/pandas/core/reshape/melt.py
@@ -131,9 +131,15 @@ def melt(
     for col in id_vars:
         id_data = frame.pop(col)
         if is_extension_array_dtype(id_data):
-            id_data = concat([id_data] * K, ignore_index=True)
+            if K > 0:
+                id_data = concat([id_data] * K, ignore_index=True)
+            else:
+                # We can't concat empty list. (GH 46044)
+                id_data = type(id_data)([], name=id_data.name, dtype=id_data.dtype)
         else:
-            id_data = np.tile(id_data._values, K)
+            # error: Incompatible types in assignment (expression has type
+            # "ndarray[Any, dtype[Any]]", variable has type "Series")
+            id_data = np.tile(id_data._values, K)  # type: ignore[assignment]
         mdata[col] = id_data
 
     mcolumns = id_vars + var_name + [value_name]
@@ -257,7 +263,9 @@ def wide_to_long(
     df: DataFrame, stubnames, i, j, sep: str = "", suffix: str = r"\d+"
 ) -> DataFrame:
     r"""
-    Wide panel to long format. Less flexible but more user-friendly than melt.
+    Unpivot a DataFrame from wide to long format.
+
+    Less flexible but more user-friendly than melt.
 
     With stubnames ['A', 'B'], this function expects to find one or more
     group of columns with format
@@ -490,7 +498,7 @@ def wide_to_long(
     """
 
     def get_var_names(df, stub: str, sep: str, suffix: str) -> list[str]:
-        regex = fr"^{re.escape(stub)}{re.escape(sep)}{suffix}$"
+        regex = rf"^{re.escape(stub)}{re.escape(sep)}{suffix}$"
         pattern = re.compile(regex)
         return [col for col in df.columns if pattern.match(col)]
 
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 412cc5a8b43a3..ec3dfa0b5f87e 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -6,13 +6,14 @@
 import copy
 import datetime
 from functools import partial
-import hashlib
 import string
 from typing import (
     TYPE_CHECKING,
     Hashable,
+    Sequence,
     cast,
 )
+import uuid
 import warnings
 
 import numpy as np
@@ -24,6 +25,7 @@
     lib,
 )
 from pandas._typing import (
+    AnyArrayLike,
     ArrayLike,
     DtypeObj,
     IndexLabel,
@@ -34,6 +36,7 @@
 from pandas.util._decorators import (
     Appender,
     Substitution,
+    cache_readonly,
 )
 from pandas.util._exceptions import find_stack_level
 
@@ -46,7 +49,6 @@
     is_bool,
     is_bool_dtype,
     is_categorical_dtype,
-    is_datetime64tz_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
     is_float_dtype,
@@ -58,6 +60,7 @@
     is_object_dtype,
     needs_i8_conversion,
 )
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
     ABCSeries,
@@ -73,17 +76,17 @@
     MultiIndex,
     Series,
 )
-from pandas.core import groupby
 import pandas.core.algorithms as algos
 from pandas.core.arrays import ExtensionArray
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 import pandas.core.common as com
 from pandas.core.construction import extract_array
 from pandas.core.frame import _merge_doc
-from pandas.core.internals import concatenate_managers
 from pandas.core.sorting import is_int64_overflow_possible
 
 if TYPE_CHECKING:
     from pandas import DataFrame
+    from pandas.core import groupby
     from pandas.core.arrays import DatetimeArray
 
 
@@ -115,11 +118,10 @@ def merge(
         right_index=right_index,
         sort=sort,
         suffixes=suffixes,
-        copy=copy,
         indicator=indicator,
         validate=validate,
     )
-    return op.get_result()
+    return op.get_result(copy=copy)
 
 
 if __debug__:
@@ -149,7 +151,7 @@ def _groupby_and_merge(by, left: DataFrame, right: DataFrame, merge_pieces):
     if all(item in right.columns for item in by):
         rby = right.groupby(by, sort=False)
 
-    for key, lhs in lby:
+    for key, lhs in lby.grouper.get_iterator(lby._selected_obj, axis=lby.axis):
 
         if rby is None:
             rhs = right
@@ -195,7 +197,7 @@ def merge_ordered(
     how: str = "outer",
 ) -> DataFrame:
     """
-    Perform merge with optional filling/interpolation.
+    Perform a merge for ordered data with optional filling/interpolation.
 
     Designed for ordered data like time series data. Optionally
     perform group-wise merge (see examples).
@@ -340,7 +342,7 @@ def merge_asof(
     direction: str = "backward",
 ) -> DataFrame:
     """
-    Perform an asof merge.
+    Perform a merge by key distance.
 
     This is similar to a left-join except that we match on nearest
     key rather than equal keys. Both DataFrames must be sorted by the key.
@@ -607,6 +609,21 @@ class _MergeOperation:
     """
 
     _merge_type = "merge"
+    how: str
+    on: IndexLabel | None
+    # left_on/right_on may be None when passed, but in validate_specification
+    #  get replaced with non-None.
+    left_on: Sequence[Hashable | AnyArrayLike]
+    right_on: Sequence[Hashable | AnyArrayLike]
+    left_index: bool
+    right_index: bool
+    axis: int
+    bm_axis: int
+    sort: bool
+    suffixes: Suffixes
+    copy: bool
+    indicator: bool
+    validate: str | None
 
     def __init__(
         self,
@@ -621,10 +638,9 @@ def __init__(
         right_index: bool = False,
         sort: bool = True,
         suffixes: Suffixes = ("_x", "_y"),
-        copy: bool = True,
         indicator: bool = False,
         validate: str | None = None,
-    ):
+    ) -> None:
         _left = _validate_operand(left)
         _right = _validate_operand(right)
         self.left = self.orig_left = _left
@@ -637,10 +653,7 @@ def __init__(
         self.axis = 1 - axis if self.left.ndim == 2 else 0
 
         self.on = com.maybe_make_list(on)
-        self.left_on = com.maybe_make_list(left_on)
-        self.right_on = com.maybe_make_list(right_on)
 
-        self.copy = copy
         self.suffixes = suffixes
         self.sort = sort
 
@@ -649,16 +662,6 @@ def __init__(
 
         self.indicator = indicator
 
-        self.indicator_name: str | None
-        if isinstance(self.indicator, str):
-            self.indicator_name = self.indicator
-        elif isinstance(self.indicator, bool):
-            self.indicator_name = "_merge" if self.indicator else None
-        else:
-            raise ValueError(
-                "indicator option can only accept boolean or string arguments"
-            )
-
         if not is_bool(left_index):
             raise ValueError(
                 f"left_index parameter must be of type bool, not {type(left_index)}"
@@ -672,14 +675,14 @@ def __init__(
         if _left.columns.nlevels != _right.columns.nlevels:
             msg = (
                 "merging between different levels is deprecated and will be removed "
-                f"in a future version. ({left.columns.nlevels} levels on the left, "
-                f"{right.columns.nlevels} on the right)"
+                f"in a future version. ({_left.columns.nlevels} levels on the left, "
+                f"{_right.columns.nlevels} on the right)"
             )
             # stacklevel chosen to be correct when this is reached via pd.merge
             # (and not DataFrame.join)
             warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
 
-        self._validate_specification()
+        self.left_on, self.right_on = self._validate_left_right_on(left_on, right_on)
 
         cross_col = None
         if self.how == "cross":
@@ -709,28 +712,70 @@ def __init__(
         if validate is not None:
             self._validate(validate)
 
-    def get_result(self) -> DataFrame:
-        if self.indicator:
-            self.left, self.right = self._indicator_pre_merge(self.left, self.right)
-
-        join_index, left_indexer, right_indexer = self._get_join_info()
+    def _reindex_and_concat(
+        self,
+        join_index: Index,
+        left_indexer: npt.NDArray[np.intp] | None,
+        right_indexer: npt.NDArray[np.intp] | None,
+        copy: bool,
+    ) -> DataFrame:
+        """
+        reindex along index and concat along columns.
+        """
+        # Take views so we do not alter the originals
+        left = self.left[:]
+        right = self.right[:]
 
         llabels, rlabels = _items_overlap_with_suffix(
             self.left._info_axis, self.right._info_axis, self.suffixes
         )
 
-        lindexers = {1: left_indexer} if left_indexer is not None else {}
-        rindexers = {1: right_indexer} if right_indexer is not None else {}
+        if left_indexer is not None:
+            # Pinning the index here (and in the right code just below) is not
+            #  necessary, but makes the `.take` more performant if we have e.g.
+            #  a MultiIndex for left.index.
+            lmgr = left._mgr.reindex_indexer(
+                join_index,
+                left_indexer,
+                axis=1,
+                copy=False,
+                only_slice=True,
+                allow_dups=True,
+                use_na_proxy=True,
+            )
+            left = left._constructor(lmgr)
+        left.index = join_index
+
+        if right_indexer is not None:
+            rmgr = right._mgr.reindex_indexer(
+                join_index,
+                right_indexer,
+                axis=1,
+                copy=False,
+                only_slice=True,
+                allow_dups=True,
+                use_na_proxy=True,
+            )
+            right = right._constructor(rmgr)
+        right.index = join_index
+
+        from pandas import concat
 
-        result_data = concatenate_managers(
-            [(self.left._mgr, lindexers), (self.right._mgr, rindexers)],
-            axes=[llabels.append(rlabels), join_index],
-            concat_axis=0,
-            copy=self.copy,
-        )
+        left.columns = llabels
+        right.columns = rlabels
+        result = concat([left, right], axis=1, copy=copy)
+        return result
+
+    def get_result(self, copy: bool = True) -> DataFrame:
+        if self.indicator:
+            self.left, self.right = self._indicator_pre_merge(self.left, self.right)
 
-        typ = self.left._constructor
-        result = typ(result_data).__finalize__(self, method=self._merge_type)
+        join_index, left_indexer, right_indexer = self._get_join_info()
+
+        result = self._reindex_and_concat(
+            join_index, left_indexer, right_indexer, copy=copy
+        )
+        result = result.__finalize__(self, method=self._merge_type)
 
         if self.indicator:
             result = self._indicator_post_merge(result)
@@ -749,6 +794,17 @@ def _maybe_drop_cross_column(
         if cross_col is not None:
             del result[cross_col]
 
+    @cache_readonly
+    def _indicator_name(self) -> str | None:
+        if isinstance(self.indicator, str):
+            return self.indicator
+        elif isinstance(self.indicator, bool):
+            return "_merge" if self.indicator else None
+        else:
+            raise ValueError(
+                "indicator option can only accept boolean or string arguments"
+            )
+
     def _indicator_pre_merge(
         self, left: DataFrame, right: DataFrame
     ) -> tuple[DataFrame, DataFrame]:
@@ -761,7 +817,7 @@ def _indicator_pre_merge(
                     "Cannot use `indicator=True` option when "
                     f"data contains a column named {i}"
                 )
-        if self.indicator_name in columns:
+        if self._indicator_name in columns:
             raise ValueError(
                 "Cannot use name of an existing column for indicator column"
             )
@@ -782,13 +838,13 @@ def _indicator_post_merge(self, result: DataFrame) -> DataFrame:
         result["_left_indicator"] = result["_left_indicator"].fillna(0)
         result["_right_indicator"] = result["_right_indicator"].fillna(0)
 
-        result[self.indicator_name] = Categorical(
+        result[self._indicator_name] = Categorical(
             (result["_left_indicator"] + result["_right_indicator"]),
             categories=[1, 2, 3],
         )
-        result[self.indicator_name] = result[self.indicator_name].cat.rename_categories(
-            ["left_only", "right_only", "both"]
-        )
+        result[self._indicator_name] = result[
+            self._indicator_name
+        ].cat.rename_categories(["left_only", "right_only", "both"])
 
         result = result.drop(labels=["_left_indicator", "_right_indicator"], axis=1)
         return result
@@ -818,8 +874,16 @@ def _maybe_restore_index_levels(self, result: DataFrame) -> None:
             self.join_names, self.left_on, self.right_on
         ):
             if (
-                self.orig_left._is_level_reference(left_key)
-                and self.orig_right._is_level_reference(right_key)
+                # Argument 1 to "_is_level_reference" of "NDFrame" has incompatible
+                # type "Union[Hashable, ExtensionArray, Index, Series]"; expected
+                # "Hashable"
+                self.orig_left._is_level_reference(left_key)  # type: ignore[arg-type]
+                # Argument 1 to "_is_level_reference" of "NDFrame" has incompatible
+                # type "Union[Hashable, ExtensionArray, Index, Series]"; expected
+                # "Hashable"
+                and self.orig_right._is_level_reference(
+                    right_key  # type: ignore[arg-type]
+                )
                 and left_key == right_key
                 and name not in result.index.names
             ):
@@ -900,16 +964,11 @@ def _maybe_add_join_keys(
                 # if we have an all missing left_indexer
                 # make sure to just use the right values or vice-versa
                 mask_left = left_indexer == -1
-                mask_right = right_indexer == -1
                 # error: Item "bool" of "Union[Any, bool]" has no attribute "all"
                 if mask_left.all():  # type: ignore[union-attr]
                     key_col = Index(rvals)
                     result_dtype = rvals.dtype
-                # error: Item "bool" of "Union[Any, bool]" has no attribute "all"
-                elif (
-                    right_indexer is not None
-                    and mask_right.all()  # type: ignore[union-attr]
-                ):
+                elif right_indexer is not None and (right_indexer == -1).all():
                     key_col = Index(lvals)
                     result_dtype = lvals.dtype
                 else:
@@ -976,7 +1035,6 @@ def _get_join_info(
                     )
                 else:
                     join_index = self.right.index.take(right_indexer)
-                    left_indexer = np.array([-1] * len(join_index), dtype=np.intp)
             elif self.left_index:
                 if self.how == "asof":
                     # GH#33463 asof should always behave like a left merge
@@ -996,7 +1054,6 @@ def _get_join_info(
                     )
                 else:
                     join_index = self.left.index.take(left_indexer)
-                    right_indexer = np.array([-1] * len(join_index), dtype=np.intp)
             else:
                 join_index = Index(np.arange(len(left_indexer)))
 
@@ -1050,13 +1107,13 @@ def _get_merge_keys(self):
 
         Returns
         -------
-        left_keys, right_keys
+        left_keys, right_keys, join_names
         """
-        left_keys = []
-        right_keys = []
-        # error: Need type annotation for 'join_names' (hint: "join_names: List[<type>]
-        # = ...")
-        join_names = []  # type: ignore[var-annotated]
+        # left_keys, right_keys entries can actually be anything listlike
+        #  with a 'dtype' attr
+        left_keys: list[AnyArrayLike] = []
+        right_keys: list[AnyArrayLike] = []
+        join_names: list[Hashable] = []
         right_drop = []
         left_drop = []
 
@@ -1073,17 +1130,22 @@ def _get_merge_keys(self):
         # a pd.merge_asof(left_index=True, left_by=...) will result in a
         # self.left_on array with a None in the middle of it. This requires
         # a work-around as designated in the code below.
-        # See _validate_specification() for where this happens.
+        # See _validate_left_right_on() for where this happens.
 
         # ugh, spaghetti re #733
         if _any(self.left_on) and _any(self.right_on):
             for lk, rk in zip(self.left_on, self.right_on):
                 if is_lkey(lk):
+                    lk = cast(AnyArrayLike, lk)
                     left_keys.append(lk)
                     if is_rkey(rk):
+                        rk = cast(AnyArrayLike, rk)
                         right_keys.append(rk)
                         join_names.append(None)  # what to do?
                     else:
+                        # Then we're either Hashable or a wrong-length arraylike,
+                        #  the latter of which will raise
+                        rk = cast(Hashable, rk)
                         if rk is not None:
                             right_keys.append(right._get_label_or_level_values(rk))
                             join_names.append(rk)
@@ -1093,20 +1155,27 @@ def _get_merge_keys(self):
                             join_names.append(right.index.name)
                 else:
                     if not is_rkey(rk):
+                        # Then we're either Hashable or a wrong-length arraylike,
+                        #  the latter of which will raise
+                        rk = cast(Hashable, rk)
                         if rk is not None:
                             right_keys.append(right._get_label_or_level_values(rk))
                         else:
                             # work-around for merge_asof(right_index=True)
                             right_keys.append(right.index)
-                        if lk is not None and lk == rk:
+                        if lk is not None and lk == rk:  # FIXME: what about other NAs?
                             # avoid key upcast in corner case (length-0)
                             if len(left) > 0:
                                 right_drop.append(rk)
                             else:
                                 left_drop.append(lk)
                     else:
+                        rk = cast(AnyArrayLike, rk)
                         right_keys.append(rk)
                     if lk is not None:
+                        # Then we're either Hashable or a wrong-length arraylike,
+                        #  the latter of which will raise
+                        lk = cast(Hashable, lk)
                         left_keys.append(left._get_label_or_level_values(lk))
                         join_names.append(lk)
                     else:
@@ -1116,9 +1185,13 @@ def _get_merge_keys(self):
         elif _any(self.left_on):
             for k in self.left_on:
                 if is_lkey(k):
+                    k = cast(AnyArrayLike, k)
                     left_keys.append(k)
                     join_names.append(None)
                 else:
+                    # Then we're either Hashable or a wrong-length arraylike,
+                    #  the latter of which will raise
+                    k = cast(Hashable, k)
                     left_keys.append(left._get_label_or_level_values(k))
                     join_names.append(k)
             if isinstance(self.right.index, MultiIndex):
@@ -1133,9 +1206,13 @@ def _get_merge_keys(self):
         elif _any(self.right_on):
             for k in self.right_on:
                 if is_rkey(k):
+                    k = cast(AnyArrayLike, k)
                     right_keys.append(k)
                     join_names.append(None)
                 else:
+                    # Then we're either Hashable or a wrong-length arraylike,
+                    #  the latter of which will raise
+                    k = cast(Hashable, k)
                     right_keys.append(right._get_label_or_level_values(k))
                     join_names.append(k)
             if isinstance(self.left.index, MultiIndex):
@@ -1201,23 +1278,29 @@ def _maybe_coerce_merge_keys(self) -> None:
 
                 # check whether ints and floats
                 elif is_integer_dtype(rk.dtype) and is_float_dtype(lk.dtype):
-                    if not (lk == lk.astype(rk.dtype))[~np.isnan(lk)].all():
-                        warnings.warn(
-                            "You are merging on int and float "
-                            "columns where the float values "
-                            "are not equal to their int representation.",
-                            UserWarning,
-                        )
+                    # GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int
+                    with np.errstate(invalid="ignore"):
+                        if not (lk == lk.astype(rk.dtype))[~np.isnan(lk)].all():
+                            warnings.warn(
+                                "You are merging on int and float "
+                                "columns where the float values "
+                                "are not equal to their int representation.",
+                                UserWarning,
+                                stacklevel=find_stack_level(),
+                            )
                     continue
 
                 elif is_float_dtype(rk.dtype) and is_integer_dtype(lk.dtype):
-                    if not (rk == rk.astype(lk.dtype))[~np.isnan(rk)].all():
-                        warnings.warn(
-                            "You are merging on int and float "
-                            "columns where the float values "
-                            "are not equal to their int representation.",
-                            UserWarning,
-                        )
+                    # GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int
+                    with np.errstate(invalid="ignore"):
+                        if not (rk == rk.astype(lk.dtype))[~np.isnan(rk)].all():
+                            warnings.warn(
+                                "You are merging on int and float "
+                                "columns where the float values "
+                                "are not equal to their int representation.",
+                                UserWarning,
+                                stacklevel=find_stack_level(),
+                            )
                     continue
 
                 # let's infer and see if we are ok
@@ -1261,12 +1344,12 @@ def _maybe_coerce_merge_keys(self) -> None:
                 raise ValueError(msg)
             elif not needs_i8_conversion(lk.dtype) and needs_i8_conversion(rk.dtype):
                 raise ValueError(msg)
-            elif is_datetime64tz_dtype(lk.dtype) and not is_datetime64tz_dtype(
-                rk.dtype
+            elif isinstance(lk.dtype, DatetimeTZDtype) and not isinstance(
+                rk.dtype, DatetimeTZDtype
             ):
                 raise ValueError(msg)
-            elif not is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(
-                rk.dtype
+            elif not isinstance(lk.dtype, DatetimeTZDtype) and isinstance(
+                rk.dtype, DatetimeTZDtype
             ):
                 raise ValueError(msg)
 
@@ -1308,7 +1391,7 @@ def _create_cross_configuration(
             DataFrames with cross_col, the merge operation set to inner and the column
             to join over.
         """
-        cross_col = f"_cross_{hashlib.md5().hexdigest()}"
+        cross_col = f"_cross_{uuid.uuid4()}"
         how = "inner"
         return (
             left.assign(**{cross_col: 1}),
@@ -1317,25 +1400,27 @@ def _create_cross_configuration(
             cross_col,
         )
 
-    def _validate_specification(self) -> None:
+    def _validate_left_right_on(self, left_on, right_on):
+        left_on = com.maybe_make_list(left_on)
+        right_on = com.maybe_make_list(right_on)
+
         if self.how == "cross":
             if (
                 self.left_index
                 or self.right_index
-                or self.right_on is not None
-                or self.left_on is not None
+                or right_on is not None
+                or left_on is not None
                 or self.on is not None
             ):
                 raise MergeError(
                     "Can not pass on, right_on, left_on or set right_index=True or "
                     "left_index=True"
                 )
-            return
         # Hm, any way to make this logic less complicated??
-        elif self.on is None and self.left_on is None and self.right_on is None:
+        elif self.on is None and left_on is None and right_on is None:
 
             if self.left_index and self.right_index:
-                self.left_on, self.right_on = (), ()
+                left_on, right_on = (), ()
             elif self.left_index:
                 raise MergeError("Must pass right_on or right_index=True")
             elif self.right_index:
@@ -1348,8 +1433,8 @@ def _validate_specification(self) -> None:
                 if len(common_cols) == 0:
                     raise MergeError(
                         "No common columns to perform merge on. "
-                        f"Merge options: left_on={self.left_on}, "
-                        f"right_on={self.right_on}, "
+                        f"Merge options: left_on={left_on}, "
+                        f"right_on={right_on}, "
                         f"left_index={self.left_index}, "
                         f"right_index={self.right_index}"
                     )
@@ -1358,9 +1443,9 @@ def _validate_specification(self) -> None:
                     or not right_cols.join(common_cols, how="inner").is_unique
                 ):
                     raise MergeError(f"Data columns not unique: {repr(common_cols)}")
-                self.left_on = self.right_on = common_cols
+                left_on = right_on = common_cols
         elif self.on is not None:
-            if self.left_on is not None or self.right_on is not None:
+            if left_on is not None or right_on is not None:
                 raise MergeError(
                     'Can only pass argument "on" OR "left_on" '
                     'and "right_on", not a combination of both.'
@@ -1370,40 +1455,42 @@ def _validate_specification(self) -> None:
                     'Can only pass argument "on" OR "left_index" '
                     'and "right_index", not a combination of both.'
                 )
-            self.left_on = self.right_on = self.on
-        elif self.left_on is not None:
+            left_on = right_on = self.on
+        elif left_on is not None:
             if self.left_index:
                 raise MergeError(
                     'Can only pass argument "left_on" OR "left_index" not both.'
                 )
-            if not self.right_index and self.right_on is None:
+            if not self.right_index and right_on is None:
                 raise MergeError('Must pass "right_on" OR "right_index".')
-            n = len(self.left_on)
+            n = len(left_on)
             if self.right_index:
-                if len(self.left_on) != self.right.index.nlevels:
+                if len(left_on) != self.right.index.nlevels:
                     raise ValueError(
                         "len(left_on) must equal the number "
                         'of levels in the index of "right"'
                     )
-                self.right_on = [None] * n
-        elif self.right_on is not None:
+                right_on = [None] * n
+        elif right_on is not None:
             if self.right_index:
                 raise MergeError(
                     'Can only pass argument "right_on" OR "right_index" not both.'
                 )
-            if not self.left_index and self.left_on is None:
+            if not self.left_index and left_on is None:
                 raise MergeError('Must pass "left_on" OR "left_index".')
-            n = len(self.right_on)
+            n = len(right_on)
             if self.left_index:
-                if len(self.right_on) != self.left.index.nlevels:
+                if len(right_on) != self.left.index.nlevels:
                     raise ValueError(
                         "len(right_on) must equal the number "
                         'of levels in the index of "left"'
                     )
-                self.left_on = [None] * n
-        if self.how != "cross" and len(self.right_on) != len(self.left_on):
+                left_on = [None] * n
+        if self.how != "cross" and len(right_on) != len(left_on):
             raise ValueError("len(right_on) must equal len(left_on)")
 
+        return left_on, right_on
+
     def _validate(self, validate: str) -> None:
 
         # Check uniqueness of each
@@ -1476,6 +1563,20 @@ def get_join_indexers(
         right_keys
     ), "left_key and right_keys must be the same length"
 
+    # fast-path for empty left/right
+    left_n = len(left_keys[0])
+    right_n = len(right_keys[0])
+    if left_n == 0:
+        if how in ["left", "inner", "cross"]:
+            return _get_empty_indexer()
+        elif not sort and how in ["right", "outer"]:
+            return _get_no_sort_one_missing_indexer(right_n, True)
+    elif right_n == 0:
+        if how in ["right", "inner", "cross"]:
+            return _get_empty_indexer()
+        elif not sort and how in ["left", "outer"]:
+            return _get_no_sort_one_missing_indexer(left_n, False)
+
     # get left & right join labels and num. of levels at each location
     mapped = (
         _factorize_keys(left_keys[n], right_keys[n], sort=sort, how=how)
@@ -1617,10 +1718,9 @@ def __init__(
         right_index: bool = False,
         axis: int = 1,
         suffixes: Suffixes = ("_x", "_y"),
-        copy: bool = True,
         fill_method: str | None = None,
         how: str = "outer",
-    ):
+    ) -> None:
 
         self.fill_method = fill_method
         _MergeOperation.__init__(
@@ -1638,7 +1738,7 @@ def __init__(
             sort=True,  # factorize sorts
         )
 
-    def get_result(self) -> DataFrame:
+    def get_result(self, copy: bool = True) -> DataFrame:
         join_index, left_indexer, right_indexer = self._get_join_info()
 
         llabels, rlabels = _items_overlap_with_suffix(
@@ -1660,29 +1760,14 @@ def get_result(self) -> DataFrame:
             left_join_indexer = left_indexer
             right_join_indexer = right_indexer
 
-        lindexers = {1: left_join_indexer} if left_join_indexer is not None else {}
-        rindexers = {1: right_join_indexer} if right_join_indexer is not None else {}
-
-        result_data = concatenate_managers(
-            [(self.left._mgr, lindexers), (self.right._mgr, rindexers)],
-            axes=[llabels.append(rlabels), join_index],
-            concat_axis=0,
-            copy=self.copy,
+        result = self._reindex_and_concat(
+            join_index, left_join_indexer, right_join_indexer, copy=copy
         )
-
-        typ = self.left._constructor
-        result = typ(result_data)
-
         self._maybe_add_join_keys(result, left_indexer, right_indexer)
 
         return result
 
 
-def _asof_function(direction: str):
-    name = f"asof_join_{direction}"
-    return getattr(libjoin, name, None)
-
-
 def _asof_by_function(direction: str):
     name = f"asof_join_{direction}_on_X_by_Y"
     return getattr(libjoin, name, None)
@@ -1728,7 +1813,7 @@ def __init__(
         tolerance=None,
         allow_exact_matches: bool = True,
         direction: str = "backward",
-    ):
+    ) -> None:
 
         self.by = by
         self.left_by = left_by
@@ -1752,14 +1837,14 @@ def __init__(
             fill_method=fill_method,
         )
 
-    def _validate_specification(self) -> None:
-        super()._validate_specification()
+    def _validate_left_right_on(self, left_on, right_on):
+        left_on, right_on = super()._validate_left_right_on(left_on, right_on)
 
         # we only allow on to be a single item for on
-        if len(self.left_on) != 1 and not self.left_index:
+        if len(left_on) != 1 and not self.left_index:
             raise MergeError("can only asof on a key for left")
 
-        if len(self.right_on) != 1 and not self.right_index:
+        if len(right_on) != 1 and not self.right_index:
             raise MergeError("can only asof on a key for right")
 
         if self.left_index and isinstance(self.left.index, MultiIndex):
@@ -1780,27 +1865,27 @@ def _validate_specification(self) -> None:
 
         # GH#29130 Check that merge keys do not have dtype object
         if not self.left_index:
-            left_on = self.left_on[0]
-            if is_array_like(left_on):
-                lo_dtype = left_on.dtype
+            left_on_0 = left_on[0]
+            if is_array_like(left_on_0):
+                lo_dtype = left_on_0.dtype
             else:
                 lo_dtype = (
-                    self.left[left_on].dtype
-                    if left_on in self.left.columns
-                    else self.left.index.get_level_values(left_on)
+                    self.left[left_on_0].dtype
+                    if left_on_0 in self.left.columns
+                    else self.left.index.get_level_values(left_on_0)
                 )
         else:
             lo_dtype = self.left.index.dtype
 
         if not self.right_index:
-            right_on = self.right_on[0]
-            if is_array_like(right_on):
-                ro_dtype = right_on.dtype
+            right_on_0 = right_on[0]
+            if is_array_like(right_on_0):
+                ro_dtype = right_on_0.dtype
             else:
                 ro_dtype = (
-                    self.right[right_on].dtype
-                    if right_on in self.right.columns
-                    else self.right.index.get_level_values(right_on)
+                    self.right[right_on_0].dtype
+                    if right_on_0 in self.right.columns
+                    else self.right.index.get_level_values(right_on_0)
                 )
         else:
             ro_dtype = self.right.index.dtype
@@ -1822,13 +1907,15 @@ def _validate_specification(self) -> None:
             if len(self.left_by) != len(self.right_by):
                 raise MergeError("left_by and right_by must be same length")
 
-            self.left_on = self.left_by + list(self.left_on)
-            self.right_on = self.right_by + list(self.right_on)
+            left_on = self.left_by + list(left_on)
+            right_on = self.right_by + list(right_on)
 
         # check 'direction' is valid
         if self.direction not in ["backward", "forward", "nearest"]:
             raise MergeError(f"direction invalid: {self.direction}")
 
+        return left_on, right_on
+
     def _get_merge_keys(self):
 
         # note this function has side effects
@@ -1906,14 +1993,27 @@ def _get_join_indexers(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]
 
         def flip(xs) -> np.ndarray:
             """unlike np.transpose, this returns an array of tuples"""
-            # error: Item "ndarray" of "Union[Any, Union[ExtensionArray, ndarray]]" has
-            # no attribute "_values_for_argsort"
-            xs = [
-                x
-                if not is_extension_array_dtype(x)
-                else extract_array(x)._values_for_argsort()  # type: ignore[union-attr]
-                for x in xs
-            ]
+
+            def injection(obj):
+                if not is_extension_array_dtype(obj):
+                    # ndarray
+                    return obj
+                obj = extract_array(obj)
+                if isinstance(obj, NDArrayBackedExtensionArray):
+                    # fastpath for e.g. dt64tz, categorical
+                    return obj._ndarray
+                # FIXME: returning obj._values_for_argsort() here doesn't
+                #  break in any existing test cases, but i (@jbrockmendel)
+                #  am pretty sure it should!
+                #  e.g.
+                #  arr = pd.array([0, pd.NA, 255], dtype="UInt8")
+                #  will have values_for_argsort (before GH#45434)
+                #  np.array([0, 255, 255], dtype=np.uint8)
+                #  and the non-injectivity should make a difference somehow
+                #  shouldn't it?
+                return np.asarray(obj)
+
+            xs = [injection(x) for x in xs]
             labels = list(string.ascii_lowercase[: len(xs)])
             dtypes = [x.dtype for x in xs]
             labeled_dtypes = list(zip(labels, dtypes))
@@ -1929,14 +2029,14 @@ def flip(xs) -> np.ndarray:
         tolerance = self.tolerance
 
         # we require sortedness and non-null values in the join keys
-        if not Index(left_values).is_monotonic:
+        if not Index(left_values).is_monotonic_increasing:
             side = "left"
             if isna(left_values).any():
                 raise ValueError(f"Merge keys contain null values on {side} side")
             else:
                 raise ValueError(f"{side} keys must be sorted")
 
-        if not Index(right_values).is_monotonic:
+        if not Index(right_values).is_monotonic_increasing:
             side = "right"
             if isna(right_values).any():
                 raise ValueError(f"Merge keys contain null values on {side} side")
@@ -1966,6 +2066,8 @@ def flip(xs) -> np.ndarray:
                 left_by_values = left_by_values[0]
                 right_by_values = right_by_values[0]
             else:
+                # We get here with non-ndarrays in test_merge_by_col_tz_aware
+                #  and test_merge_groupby_multiple_column_with_categorical_column
                 left_by_values = flip(left_by_values)
                 right_by_values = flip(right_by_values)
 
@@ -1989,8 +2091,16 @@ def flip(xs) -> np.ndarray:
             )
         else:
             # choose appropriate function by type
-            func = _asof_function(self.direction)
-            return func(left_values, right_values, self.allow_exact_matches, tolerance)
+            func = _asof_by_function(self.direction)
+            return func(
+                left_values,
+                right_values,
+                None,
+                None,
+                self.allow_exact_matches,
+                tolerance,
+                False,
+            )
 
 
 def _get_multiindex_indexer(
@@ -2039,6 +2149,43 @@ def _get_single_indexer(
     return libjoin.left_outer_join(left_key, right_key, count, sort=sort)
 
 
+def _get_empty_indexer() -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    """Return empty join indexers."""
+    return (
+        np.array([], dtype=np.intp),
+        np.array([], dtype=np.intp),
+    )
+
+
+def _get_no_sort_one_missing_indexer(
+    n: int, left_missing: bool
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    """
+    Return join indexers where all of one side is selected without sorting
+    and none of the other side is selected.
+
+    Parameters
+    ----------
+    n : int
+        Length of indexers to create.
+    left_missing : bool
+        If True, the left indexer will contain only -1's.
+        If False, the right indexer will contain only -1's.
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+        Left indexer
+    np.ndarray[np.intp]
+        Right indexer
+    """
+    idx = np.arange(n, dtype=np.intp)
+    idx_missing = np.full(shape=n, fill_value=-1, dtype=np.intp)
+    if left_missing:
+        return idx_missing, idx
+    return idx, idx_missing
+
+
 def _left_join_on_index(
     left_ax: Index, right_ax: Index, join_keys, sort: bool = False
 ) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp]]:
@@ -2127,9 +2274,10 @@ def _factorize_keys(
     rk = extract_array(rk, extract_numpy=True, extract_range=True)
     # TODO: if either is a RangeIndex, we can likely factorize more efficiently?
 
-    if is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(rk.dtype):
+    if isinstance(lk.dtype, DatetimeTZDtype) and isinstance(rk.dtype, DatetimeTZDtype):
         # Extract the ndarray (UTC-localized) values
         # Note: we dont need the dtypes to match, as these can still be compared
+        # TODO(non-nano): need to make sure resolutions match
         lk = cast("DatetimeArray", lk)._ndarray
         rk = cast("DatetimeArray", rk)._ndarray
 
@@ -2148,8 +2296,6 @@ def _factorize_keys(
         rk = ensure_int64(rk.codes)
 
     elif isinstance(lk, ExtensionArray) and is_dtype_equal(lk.dtype, rk.dtype):
-        # error: Incompatible types in assignment (expression has type "ndarray",
-        # variable has type "ExtensionArray")
         lk, _ = lk._values_for_factorize()
 
         # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute
@@ -2213,14 +2359,13 @@ def _factorize_keys(
 
 
 def _sort_labels(
-    uniques: np.ndarray, left: np.ndarray, right: np.ndarray
+    uniques: np.ndarray, left: npt.NDArray[np.intp], right: npt.NDArray[np.intp]
 ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
 
     llength = len(left)
     labels = np.concatenate([left, right])
 
     _, new_labels = algos.safe_sort(uniques, labels, na_sentinel=-1)
-    assert new_labels.dtype == np.intp
     new_left, new_right = new_labels[:llength], new_labels[llength:]
 
     return new_left, new_right
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index 069f0e5003cdf..7ef58c7836c81 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -19,7 +19,9 @@
 from pandas.util._decorators import (
     Appender,
     Substitution,
+    deprecate_nonkeyword_arguments,
 )
+from pandas.util._exceptions import rewrite_warning
 
 from pandas.core.dtypes.cast import maybe_downcast_to_dtype
 from pandas.core.dtypes.common import (
@@ -162,7 +164,18 @@ def __internal_pivot_table(
         values = list(values)
 
     grouped = data.groupby(keys, observed=observed, sort=sort)
-    agged = grouped.agg(aggfunc)
+    msg = (
+        "pivot_table dropped a column because it failed to aggregate. This behavior "
+        "is deprecated and will raise in a future version of pandas. Select only the "
+        "columns that can be aggregated."
+    )
+    with rewrite_warning(
+        target_message="The default value of numeric_only",
+        target_category=FutureWarning,
+        new_message=msg,
+    ):
+        agged = grouped.agg(aggfunc)
+
     if dropna and isinstance(agged, ABCDataFrame) and len(agged.columns):
         agged = agged.dropna(how="all")
 
@@ -178,7 +191,9 @@ def __internal_pivot_table(
                 and v in agged
                 and not is_integer_dtype(agged[v])
             ):
-                if not isinstance(agged[v], ABCDataFrame):
+                if not isinstance(agged[v], ABCDataFrame) and isinstance(
+                    data[v].dtype, np.dtype
+                ):
                     # exclude DataFrame case bc maybe_downcast_to_dtype expects
                     #  ArrayLike
                     # e.g. test_pivot_table_multiindex_columns_doctest_case
@@ -216,7 +231,7 @@ def __internal_pivot_table(
             )
             table = table.reindex(m, axis=1)
 
-    if isinstance(table, ABCDataFrame):
+    if sort is True and isinstance(table, ABCDataFrame):
         table = table.sort_index(axis=1)
 
     if fill_value is not None:
@@ -315,7 +330,7 @@ def _add_margins(
 
     from pandas import DataFrame
 
-    margin_dummy = DataFrame(row_margin, columns=[key]).T
+    margin_dummy = DataFrame(row_margin, columns=Index([key])).T
 
     row_names = result.index.names
     # check the result column and leave floats
@@ -470,6 +485,7 @@ def _convert_by(by):
 
 @Substitution("\ndata : DataFrame")
 @Appender(_shared_docs["pivot"], indents=1)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["data"])
 def pivot(
     data: DataFrame,
     index: IndexLabel | None = None,
@@ -481,6 +497,7 @@ def pivot(
 
     columns_listlike = com.convert_to_list_like(columns)
 
+    indexed: DataFrame | Series
     if values is None:
         if index is not None:
             cols = com.convert_to_list_like(index)
@@ -517,7 +534,10 @@ def pivot(
             )
         else:
             indexed = data._constructor_sliced(data[values]._values, index=multiindex)
-    return indexed.unstack(columns_listlike)
+    # error: Argument 1 to "unstack" of "DataFrame" has incompatible type "Union
+    # [List[Any], ExtensionArray, ndarray[Any, Any], Index, Series]"; expected
+    # "Hashable"
+    return indexed.unstack(columns_listlike)  # type: ignore[arg-type]
 
 
 def crosstab(
@@ -533,9 +553,10 @@ def crosstab(
     normalize=False,
 ) -> DataFrame:
     """
-    Compute a simple cross tabulation of two (or more) factors. By default
-    computes a frequency table of the factors unless an array of values and an
-    aggregation function are passed.
+    Compute a simple cross tabulation of two (or more) factors.
+
+    By default, computes a frequency table of the factors unless an
+    array of values and an aggregation function are passed.
 
     Parameters
     ----------
@@ -589,6 +610,8 @@ def crosstab(
     In the event that there aren't overlapping indexes an empty DataFrame will
     be returned.
 
+    Reference :ref:`the user guide <reshaping.crosstabulations>` for more examples.
+
     Examples
     --------
     >>> a = np.array(["foo", "foo", "foo", "foo", "bar", "bar",
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index d043e3ad53f9a..1a99bf0d62e72 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -1,37 +1,32 @@
 from __future__ import annotations
 
 import itertools
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
 import warnings
 
 import numpy as np
 
 import pandas._libs.reshape as libreshape
-from pandas._libs.sparse import IntIndex
-from pandas._typing import (
-    Dtype,
-    npt,
-)
+from pandas._typing import npt
 from pandas.errors import PerformanceWarning
 from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.cast import maybe_promote
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     is_1d_only_ea_dtype,
-    is_bool_dtype,
     is_extension_array_dtype,
     is_integer,
-    is_integer_dtype,
-    is_list_like,
-    is_object_dtype,
     needs_i8_conversion,
 )
 from pandas.core.dtypes.dtypes import ExtensionDtype
 from pandas.core.dtypes.missing import notna
 
 import pandas.core.algorithms as algos
-from pandas.core.arrays import SparseArray
 from pandas.core.arrays.categorical import factorize_from_iterable
 from pandas.core.construction import ensure_wrapped_if_datetimelike
 from pandas.core.frame import DataFrame
@@ -39,7 +34,6 @@
     Index,
     MultiIndex,
 )
-from pandas.core.indexes.frozen import FrozenList
 from pandas.core.series import Series
 from pandas.core.sorting import (
     compress_group_index,
@@ -51,6 +45,7 @@
 
 if TYPE_CHECKING:
     from pandas.core.arrays import ExtensionArray
+    from pandas.core.indexes.frozen import FrozenList
 
 
 class _Unstacker:
@@ -99,7 +94,7 @@ class _Unstacker:
     unstacked : DataFrame
     """
 
-    def __init__(self, index: MultiIndex, level=-1, constructor=None):
+    def __init__(self, index: MultiIndex, level=-1, constructor=None) -> None:
 
         if constructor is None:
             constructor = DataFrame
@@ -136,6 +131,7 @@ def __init__(self, index: MultiIndex, level=-1, constructor=None):
                 f"The following operation may generate {num_cells} cells "
                 f"in the resulting pandas object.",
                 PerformanceWarning,
+                stacklevel=find_stack_level(),
             )
 
         self._make_selectors()
@@ -161,7 +157,7 @@ def _indexer_and_to_sort(
         return indexer, to_sort
 
     @cache_readonly
-    def sorted_labels(self):
+    def sorted_labels(self) -> list[np.ndarray]:
         indexer, to_sort = self._indexer_and_to_sort
         return [line.take(indexer) for line in to_sort]
 
@@ -194,7 +190,6 @@ def _make_selectors(self):
 
         self.group_index = comp_index
         self.mask = mask
-        self.unique_groups = obs_ids
         self.compressor = comp_index.searchsorted(np.arange(ngroups))
 
     @cache_readonly
@@ -209,7 +204,7 @@ def arange_result(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.bool_]]:
         return new_values, mask.any(0)
         # TODO: in all tests we have mask.any(0).all(); can we rely on that?
 
-    def get_result(self, values, value_columns, fill_value):
+    def get_result(self, values, value_columns, fill_value) -> DataFrame:
 
         if values.ndim == 1:
             values = values[:, np.newaxis]
@@ -262,6 +257,8 @@ def get_new_values(self, values, fill_value=None):
         else:
             if isinstance(dtype, ExtensionDtype):
                 # GH#41875
+                # We are assuming that fill_value can be held by this dtype,
+                #  unlike the non-EA case that promotes.
                 cls = dtype.construct_array_type()
                 new_values = cls._empty(result_shape, dtype=dtype)
                 new_values[:] = fill_value
@@ -279,9 +276,6 @@ def get_new_values(self, values, fill_value=None):
         if needs_i8_conversion(values.dtype):
             sorted_values = sorted_values.view("i8")
             new_values = new_values.view("i8")
-        elif is_bool_dtype(values.dtype):
-            sorted_values = sorted_values.astype("object")
-            new_values = new_values.astype("object")
         else:
             sorted_values = sorted_values.astype(name, copy=False)
 
@@ -357,7 +351,7 @@ def _repeater(self) -> np.ndarray:
         return repeater
 
     @cache_readonly
-    def new_index(self):
+    def new_index(self) -> MultiIndex:
         # Does not depend on values or value_columns
         result_codes = [lab.take(self.compressor) for lab in self.sorted_labels[:-1]]
 
@@ -463,7 +457,7 @@ def _unstack_multiple(data, clocs, fill_value=None):
     return unstacked
 
 
-def unstack(obj, level, fill_value=None):
+def unstack(obj: Series | DataFrame, level, fill_value=None):
 
     if isinstance(level, (tuple, list)):
         if len(level) != 1:
@@ -500,19 +494,20 @@ def unstack(obj, level, fill_value=None):
         )
 
 
-def _unstack_frame(obj, level, fill_value=None):
+def _unstack_frame(obj: DataFrame, level, fill_value=None):
+    assert isinstance(obj.index, MultiIndex)  # checked by caller
+    unstacker = _Unstacker(obj.index, level=level, constructor=obj._constructor)
+
     if not obj._can_fast_transpose:
-        unstacker = _Unstacker(obj.index, level=level)
         mgr = obj._mgr.unstack(unstacker, fill_value=fill_value)
         return obj._constructor(mgr)
     else:
-        unstacker = _Unstacker(obj.index, level=level, constructor=obj._constructor)
         return unstacker.get_result(
             obj._values, value_columns=obj.columns, fill_value=fill_value
         )
 
 
-def _unstack_extension_series(series, level, fill_value):
+def _unstack_extension_series(series: Series, level, fill_value) -> DataFrame:
     """
     Unstack an ExtensionArray-backed Series.
 
@@ -545,14 +540,14 @@ def _unstack_extension_series(series, level, fill_value):
     return result
 
 
-def stack(frame, level=-1, dropna=True):
+def stack(frame: DataFrame, level=-1, dropna: bool = True):
     """
     Convert DataFrame to Series with multi-level Index. Columns become the
     second level of the resulting hierarchical index
 
     Returns
     -------
-    stacked : Series
+    stacked : Series or DataFrame
     """
 
     def factorize(index):
@@ -687,8 +682,10 @@ def _stack_multi_column_index(columns: MultiIndex) -> MultiIndex:
     )
 
 
-def _stack_multi_columns(frame, level_num=-1, dropna=True):
-    def _convert_level_number(level_num: int, columns):
+def _stack_multi_columns(
+    frame: DataFrame, level_num: int = -1, dropna: bool = True
+) -> DataFrame:
+    def _convert_level_number(level_num: int, columns: Index):
         """
         Logic for converting the level number to something we can safely pass
         to swaplevel.
@@ -701,32 +698,36 @@ def _convert_level_number(level_num: int, columns):
 
         return level_num
 
-    this = frame.copy()
+    this = frame.copy(deep=False)
+    mi_cols = this.columns  # cast(MultiIndex, this.columns)
+    assert isinstance(mi_cols, MultiIndex)  # caller is responsible
 
     # this makes life much simpler
-    if level_num != frame.columns.nlevels - 1:
+    if level_num != mi_cols.nlevels - 1:
         # roll levels to put selected level at end
-        roll_columns = this.columns
-        for i in range(level_num, frame.columns.nlevels - 1):
+        roll_columns = mi_cols
+        for i in range(level_num, mi_cols.nlevels - 1):
             # Need to check if the ints conflict with level names
             lev1 = _convert_level_number(i, roll_columns)
             lev2 = _convert_level_number(i + 1, roll_columns)
             roll_columns = roll_columns.swaplevel(lev1, lev2)
-        this.columns = roll_columns
+        this.columns = mi_cols = roll_columns
 
-    if not this.columns._is_lexsorted():
+    if not mi_cols._is_lexsorted():
         # Workaround the edge case where 0 is one of the column names,
         # which interferes with trying to sort based on the first
         # level
-        level_to_sort = _convert_level_number(0, this.columns)
+        level_to_sort = _convert_level_number(0, mi_cols)
         this = this.sort_index(level=level_to_sort, axis=1)
+        mi_cols = this.columns
 
-    new_columns = _stack_multi_column_index(this.columns)
+    mi_cols = cast(MultiIndex, mi_cols)
+    new_columns = _stack_multi_column_index(mi_cols)
 
     # time to ravel the values
     new_data = {}
-    level_vals = this.columns.levels[-1]
-    level_codes = sorted(set(this.columns.codes[-1]))
+    level_vals = mi_cols.levels[-1]
+    level_codes = sorted(set(mi_cols.codes[-1]))
     level_vals_nan = level_vals.insert(len(level_vals), None)
 
     level_vals_used = np.take(level_vals_nan, level_codes)
@@ -812,299 +813,6 @@ def _convert_level_number(level_num: int, columns):
     return result
 
 
-def get_dummies(
-    data,
-    prefix=None,
-    prefix_sep="_",
-    dummy_na: bool = False,
-    columns=None,
-    sparse: bool = False,
-    drop_first: bool = False,
-    dtype: Dtype | None = None,
-) -> DataFrame:
-    """
-    Convert categorical variable into dummy/indicator variables.
-
-    Parameters
-    ----------
-    data : array-like, Series, or DataFrame
-        Data of which to get dummy indicators.
-    prefix : str, list of str, or dict of str, default None
-        String to append DataFrame column names.
-        Pass a list with length equal to the number of columns
-        when calling get_dummies on a DataFrame. Alternatively, `prefix`
-        can be a dictionary mapping column names to prefixes.
-    prefix_sep : str, default '_'
-        If appending prefix, separator/delimiter to use. Or pass a
-        list or dictionary as with `prefix`.
-    dummy_na : bool, default False
-        Add a column to indicate NaNs, if False NaNs are ignored.
-    columns : list-like, default None
-        Column names in the DataFrame to be encoded.
-        If `columns` is None then all the columns with
-        `object` or `category` dtype will be converted.
-    sparse : bool, default False
-        Whether the dummy-encoded columns should be backed by
-        a :class:`SparseArray` (True) or a regular NumPy array (False).
-    drop_first : bool, default False
-        Whether to get k-1 dummies out of k categorical levels by removing the
-        first level.
-    dtype : dtype, default np.uint8
-        Data type for new columns. Only a single dtype is allowed.
-
-    Returns
-    -------
-    DataFrame
-        Dummy-coded data.
-
-    See Also
-    --------
-    Series.str.get_dummies : Convert Series to dummy codes.
-
-    Examples
-    --------
-    >>> s = pd.Series(list('abca'))
-
-    >>> pd.get_dummies(s)
-       a  b  c
-    0  1  0  0
-    1  0  1  0
-    2  0  0  1
-    3  1  0  0
-
-    >>> s1 = ['a', 'b', np.nan]
-
-    >>> pd.get_dummies(s1)
-       a  b
-    0  1  0
-    1  0  1
-    2  0  0
-
-    >>> pd.get_dummies(s1, dummy_na=True)
-       a  b  NaN
-    0  1  0    0
-    1  0  1    0
-    2  0  0    1
-
-    >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
-    ...                    'C': [1, 2, 3]})
-
-    >>> pd.get_dummies(df, prefix=['col1', 'col2'])
-       C  col1_a  col1_b  col2_a  col2_b  col2_c
-    0  1       1       0       0       1       0
-    1  2       0       1       1       0       0
-    2  3       1       0       0       0       1
-
-    >>> pd.get_dummies(pd.Series(list('abcaa')))
-       a  b  c
-    0  1  0  0
-    1  0  1  0
-    2  0  0  1
-    3  1  0  0
-    4  1  0  0
-
-    >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True)
-       b  c
-    0  0  0
-    1  1  0
-    2  0  1
-    3  0  0
-    4  0  0
-
-    >>> pd.get_dummies(pd.Series(list('abc')), dtype=float)
-         a    b    c
-    0  1.0  0.0  0.0
-    1  0.0  1.0  0.0
-    2  0.0  0.0  1.0
-    """
-    from pandas.core.reshape.concat import concat
-
-    dtypes_to_encode = ["object", "category"]
-
-    if isinstance(data, DataFrame):
-        # determine columns being encoded
-        if columns is None:
-            data_to_encode = data.select_dtypes(include=dtypes_to_encode)
-        elif not is_list_like(columns):
-            raise TypeError("Input must be a list-like for parameter `columns`")
-        else:
-            data_to_encode = data[columns]
-
-        # validate prefixes and separator to avoid silently dropping cols
-        def check_len(item, name):
-
-            if is_list_like(item):
-                if not len(item) == data_to_encode.shape[1]:
-                    len_msg = (
-                        f"Length of '{name}' ({len(item)}) did not match the "
-                        "length of the columns being encoded "
-                        f"({data_to_encode.shape[1]})."
-                    )
-                    raise ValueError(len_msg)
-
-        check_len(prefix, "prefix")
-        check_len(prefix_sep, "prefix_sep")
-
-        if isinstance(prefix, str):
-            prefix = itertools.cycle([prefix])
-        if isinstance(prefix, dict):
-            prefix = [prefix[col] for col in data_to_encode.columns]
-
-        if prefix is None:
-            prefix = data_to_encode.columns
-
-        # validate separators
-        if isinstance(prefix_sep, str):
-            prefix_sep = itertools.cycle([prefix_sep])
-        elif isinstance(prefix_sep, dict):
-            prefix_sep = [prefix_sep[col] for col in data_to_encode.columns]
-
-        with_dummies: list[DataFrame]
-        if data_to_encode.shape == data.shape:
-            # Encoding the entire df, do not prepend any dropped columns
-            with_dummies = []
-        elif columns is not None:
-            # Encoding only cols specified in columns. Get all cols not in
-            # columns to prepend to result.
-            with_dummies = [data.drop(columns, axis=1)]
-        else:
-            # Encoding only object and category dtype columns. Get remaining
-            # columns to prepend to result.
-            with_dummies = [data.select_dtypes(exclude=dtypes_to_encode)]
-
-        for (col, pre, sep) in zip(data_to_encode.items(), prefix, prefix_sep):
-            # col is (column_name, column), use just column data here
-            dummy = _get_dummies_1d(
-                col[1],
-                prefix=pre,
-                prefix_sep=sep,
-                dummy_na=dummy_na,
-                sparse=sparse,
-                drop_first=drop_first,
-                dtype=dtype,
-            )
-            with_dummies.append(dummy)
-        result = concat(with_dummies, axis=1)
-    else:
-        result = _get_dummies_1d(
-            data,
-            prefix,
-            prefix_sep,
-            dummy_na,
-            sparse=sparse,
-            drop_first=drop_first,
-            dtype=dtype,
-        )
-    return result
-
-
-def _get_dummies_1d(
-    data,
-    prefix,
-    prefix_sep="_",
-    dummy_na: bool = False,
-    sparse: bool = False,
-    drop_first: bool = False,
-    dtype: Dtype | None = None,
-) -> DataFrame:
-    from pandas.core.reshape.concat import concat
-
-    # Series avoids inconsistent NaN handling
-    codes, levels = factorize_from_iterable(Series(data))
-
-    if dtype is None:
-        dtype = np.dtype(np.uint8)
-    # error: Argument 1 to "dtype" has incompatible type "Union[ExtensionDtype, str,
-    # dtype[Any], Type[object]]"; expected "Type[Any]"
-    dtype = np.dtype(dtype)  # type: ignore[arg-type]
-
-    if is_object_dtype(dtype):
-        raise ValueError("dtype=object is not a valid dtype for get_dummies")
-
-    def get_empty_frame(data) -> DataFrame:
-        if isinstance(data, Series):
-            index = data.index
-        else:
-            index = np.arange(len(data))
-        return DataFrame(index=index)
-
-    # if all NaN
-    if not dummy_na and len(levels) == 0:
-        return get_empty_frame(data)
-
-    codes = codes.copy()
-    if dummy_na:
-        codes[codes == -1] = len(levels)
-        levels = np.append(levels, np.nan)
-
-    # if dummy_na, we just fake a nan level. drop_first will drop it again
-    if drop_first and len(levels) == 1:
-        return get_empty_frame(data)
-
-    number_of_cols = len(levels)
-
-    if prefix is None:
-        dummy_cols = levels
-    else:
-        dummy_cols = Index([f"{prefix}{prefix_sep}{level}" for level in levels])
-
-    index: Index | None
-    if isinstance(data, Series):
-        index = data.index
-    else:
-        index = None
-
-    if sparse:
-
-        fill_value: bool | float | int
-        if is_integer_dtype(dtype):
-            fill_value = 0
-        elif dtype == np.dtype(bool):
-            fill_value = False
-        else:
-            fill_value = 0.0
-
-        sparse_series = []
-        N = len(data)
-        sp_indices: list[list] = [[] for _ in range(len(dummy_cols))]
-        mask = codes != -1
-        codes = codes[mask]
-        n_idx = np.arange(N)[mask]
-
-        for ndx, code in zip(n_idx, codes):
-            sp_indices[code].append(ndx)
-
-        if drop_first:
-            # remove first categorical level to avoid perfect collinearity
-            # GH12042
-            sp_indices = sp_indices[1:]
-            dummy_cols = dummy_cols[1:]
-        for col, ixs in zip(dummy_cols, sp_indices):
-            sarr = SparseArray(
-                np.ones(len(ixs), dtype=dtype),
-                sparse_index=IntIndex(N, ixs),
-                fill_value=fill_value,
-                dtype=dtype,
-            )
-            sparse_series.append(Series(data=sarr, index=index, name=col))
-
-        return concat(sparse_series, axis=1, copy=False)
-
-    else:
-        # take on axis=1 + transpose to ensure ndarray layout is column-major
-        dummy_mat = np.eye(number_of_cols, dtype=dtype).take(codes, axis=1).T
-
-        if not dummy_na:
-            # reset NaN GH4446
-            dummy_mat[codes == -1] = 0
-
-        if drop_first:
-            # remove first GH12042
-            dummy_mat = dummy_mat[:, 1:]
-            dummy_cols = dummy_cols[1:]
-        return DataFrame(dummy_mat, index=index, columns=dummy_cols)
-
-
 def _reorder_for_extension_array_stack(
     arr: ExtensionArray, n_rows: int, n_columns: int
 ) -> ExtensionArray:
diff --git a/pandas/core/reshape/tile.py b/pandas/core/reshape/tile.py
index 8cf94e5e433a6..94705790e40bd 100644
--- a/pandas/core/reshape/tile.py
+++ b/pandas/core/reshape/tile.py
@@ -16,6 +16,7 @@
     Timestamp,
 )
 from pandas._libs.lib import infer_dtype
+from pandas._typing import IntervalLeftRight
 
 from pandas.core.dtypes.common import (
     DT64NS_DTYPE,
@@ -145,6 +146,8 @@ def cut(
     Any NA values will be NA in the result. Out of bounds values will be NA in
     the resulting Series or Categorical object.
 
+    Reference :ref:`the user guide <reshaping.tile.cut>` for more examples.
+
     Examples
     --------
     Discretize into three equal-sized bins.
@@ -558,7 +561,7 @@ def _format_labels(
     bins, precision: int, right: bool = True, include_lowest: bool = False, dtype=None
 ):
     """based on the dtype, return our labels"""
-    closed = "right" if right else "left"
+    closed: IntervalLeftRight = "right" if right else "left"
 
     formatter: Callable[[Any], Timestamp] | Callable[[Any], Timedelta]
 
diff --git a/pandas/core/reshape/util.py b/pandas/core/reshape/util.py
index d2c08712abacd..1154940f2c4a6 100644
--- a/pandas/core/reshape/util.py
+++ b/pandas/core/reshape/util.py
@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 import numpy as np
 
+from pandas._typing import NumpyIndexT
+
 from pandas.core.dtypes.common import is_list_like
 
 
-def cartesian_product(X):
+def cartesian_product(X) -> list[np.ndarray]:
     """
     Numpy version of itertools.product.
     Sometimes faster (for large inputs)...
@@ -51,10 +55,18 @@ def cartesian_product(X):
         # if any factor is empty, the cartesian product is empty
         b = np.zeros_like(cumprodX)
 
-    return [tile_compat(np.repeat(x, b[i]), np.product(a[i])) for i, x in enumerate(X)]
+    # error: Argument of type "int_" cannot be assigned to parameter "num" of
+    # type "int" in function "tile_compat"
+    return [
+        tile_compat(
+            np.repeat(x, b[i]),
+            np.product(a[i]),  # pyright: ignore[reportGeneralTypeIssues]
+        )
+        for i, x in enumerate(X)
+    ]
 
 
-def tile_compat(arr, num: int):
+def tile_compat(arr: NumpyIndexT, num: int) -> NumpyIndexT:
     """
     Index compat for np.tile.
 
diff --git a/pandas/core/roperator.py b/pandas/core/roperator.py
index e6691ddf8984e..2f320f4e9c6b9 100644
--- a/pandas/core/roperator.py
+++ b/pandas/core/roperator.py
@@ -2,6 +2,8 @@
 Reversed Operations not available in the stdlib operator module.
 Defining these instead of using lambdas allows us to reference them by name.
 """
+from __future__ import annotations
+
 import operator
 
 
@@ -45,7 +47,7 @@ def rdivmod(left, right):
 
 
 def rpow(left, right):
-    return right ** left
+    return right**left
 
 
 def rand_(left, right):
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 7ca80601bbfd0..8f0faae338e6a 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -12,6 +12,7 @@
     Hashable,
     Iterable,
     Literal,
+    Mapping,
     Sequence,
     Union,
     cast,
@@ -33,17 +34,28 @@
 from pandas._libs.lib import no_default
 from pandas._typing import (
     AggFuncType,
+    AnyArrayLike,
     ArrayLike,
     Axis,
     Dtype,
     DtypeObj,
+    FilePath,
     FillnaOptions,
+    Frequency,
+    IgnoreRaise,
     IndexKeyFunc,
+    IndexLabel,
+    Level,
+    NaPosition,
+    QuantileInterpolation,
+    Renamer,
     SingleManager,
+    SortKind,
     StorageOptions,
     TimedeltaConvertibleTypes,
     TimestampConvertibleTypes,
     ValueKeyFunc,
+    WriteBuffer,
     npt,
 )
 from pandas.compat.numpy import function as nv
@@ -51,6 +63,7 @@
 from pandas.util._decorators import (
     Appender,
     Substitution,
+    deprecate_kwarg,
     deprecate_nonkeyword_arguments,
     doc,
 )
@@ -62,7 +75,7 @@
 )
 
 from pandas.core.dtypes.cast import (
-    can_hold_element,
+    LossySetitemError,
     convert_dtypes,
     maybe_box_native,
     maybe_cast_pointwise_result,
@@ -73,6 +86,7 @@
     is_integer,
     is_iterator,
     is_list_like,
+    is_numeric_dtype,
     is_object_dtype,
     is_scalar,
     pandas_dtype,
@@ -90,6 +104,7 @@
 from pandas.core import (
     algorithms,
     base,
+    common as com,
     missing,
     nanops,
     ops,
@@ -99,7 +114,6 @@
 from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.categorical import CategoricalAccessor
 from pandas.core.arrays.sparse import SparseAccessor
-import pandas.core.common as com
 from pandas.core.construction import (
     create_series_with_explicit_dtype,
     extract_array,
@@ -149,10 +163,10 @@
 import pandas.plotting
 
 if TYPE_CHECKING:
-
     from pandas._typing import (
         NumpySorter,
         NumpyValueArrayLike,
+        Suffixes,
     )
 
     from pandas.core.frame import DataFrame
@@ -166,7 +180,7 @@
     "klass": "Series",
     "axes_single_arg": "{0 or 'index'}",
     "axis": """axis : {0 or 'index'}
-        Parameter needed for compatibility with DataFrame.""",
+        Unused. Parameter needed for compatibility with DataFrame.""",
     "inplace": """inplace : bool, default False
         If True, performs operation inplace and returns None.""",
     "unique": "np.ndarray",
@@ -233,6 +247,10 @@ class Series(base.IndexOpsMixin, NDFrame):
     copy : bool, default False
         Copy input data. Only affects Series or 1d ndarray input. See examples.
 
+    Notes
+    -----
+    Please reference the :ref:`User Guide <basics.series>` for more information.
+
     Examples
     --------
     Constructing Series from a dictionary with an Index specified
@@ -329,7 +347,7 @@ def __init__(
         name=None,
         copy: bool = False,
         fastpath: bool = False,
-    ):
+    ) -> None:
 
         if (
             isinstance(data, (SingleBlockManager, SingleArrayManager))
@@ -458,8 +476,12 @@ def __init__(
                     data = SingleArrayManager.from_array(data, index)
 
         NDFrame.__init__(self, data)
-        self.name = name
-        self._set_axis(0, index, fastpath=True)
+        if fastpath:
+            # skips validation of the name
+            object.__setattr__(self, "_name", name)
+        else:
+            self.name = name
+            self._set_axis(0, index)
 
     def _init_dict(
         self, data, index: Index | None = None, dtype: DtypeObj | None = None
@@ -522,11 +544,11 @@ def _init_dict(
     # ----------------------------------------------------------------------
 
     @property
-    def _constructor(self) -> type[Series]:
+    def _constructor(self) -> Callable[..., Series]:
         return Series
 
     @property
-    def _constructor_expanddim(self) -> type[DataFrame]:
+    def _constructor_expanddim(self) -> Callable[..., DataFrame]:
         """
         Used when a manipulation result has one higher dimension as the
         original, such as Series.to_frame()
@@ -540,17 +562,19 @@ def _constructor_expanddim(self) -> type[DataFrame]:
     def _can_hold_na(self) -> bool:
         return self._mgr._can_hold_na
 
-    def _set_axis(self, axis: int, labels, fastpath: bool = False) -> None:
+    def _set_axis(self, axis: int, labels: AnyArrayLike | list) -> None:
         """
         Override generic, we want to set the _typ here.
 
         This is called from the cython code when we set the `index` attribute
         directly, e.g. `series.index = [1, 2, 3]`.
         """
-        if not fastpath:
-            labels = ensure_index(labels)
+        labels = ensure_index(labels)
 
-        if labels._is_all_dates:
+        if labels._is_all_dates and not (
+            type(labels) is Index and not isinstance(labels.dtype, np.dtype)
+        ):
+            # exclude e.g. timestamp[ns][pyarrow] dtype from this casting
             deep_labels = labels
             if isinstance(labels, CategoricalIndex):
                 deep_labels = labels.categories
@@ -560,17 +584,13 @@ def _set_axis(self, axis: int, labels, fastpath: bool = False) -> None:
             ):
                 try:
                     labels = DatetimeIndex(labels)
-                    # need to set here because we changed the index
-                    if fastpath:
-                        self._mgr.set_axis(axis, labels)
                 except (tslibs.OutOfBoundsDatetime, ValueError):
                     # labels may exceeds datetime bounds,
                     # or not be a DatetimeIndex
                     pass
 
-        if not fastpath:
-            # The ensure_index call above ensures we have an Index object
-            self._mgr.set_axis(axis, labels)
+        # The ensure_index call above ensures we have an Index object
+        self._mgr.set_axis(axis, labels)
 
     # ndarray compatibility
     @property
@@ -726,7 +746,7 @@ def array(self) -> ExtensionArray:
         return self._mgr.array_values()
 
     # ops
-    def ravel(self, order="C"):
+    def ravel(self, order: str = "C") -> np.ndarray:
         """
         Return the flattened underlying data as an ndarray.
 
@@ -894,7 +914,9 @@ def axes(self) -> list[Index]:
     # Indexing Methods
 
     @Appender(NDFrame.take.__doc__)
-    def take(self, indices, axis=0, is_copy=None, **kwargs) -> Series:
+    def take(
+        self, indices, axis: Axis = 0, is_copy: bool | None = None, **kwargs
+    ) -> Series:
         if is_copy is not None:
             warnings.warn(
                 "is_copy is deprecated and will be removed in a future version. "
@@ -922,7 +944,7 @@ def _take_with_is_copy(self, indices, axis=0) -> Series:
         """
         return self.take(indices=indices, axis=axis)
 
-    def _ixs(self, i: int, axis: int = 0):
+    def _ixs(self, i: int, axis: int = 0) -> Any:
         """
         Return the i-th value or values in the Series by location.
 
@@ -1024,10 +1046,13 @@ def _get_with(self, key):
         # handle the dup indexing case GH#4246
         return self.loc[key]
 
-    def _get_values_tuple(self, key):
+    def _get_values_tuple(self, key: tuple):
         # mpl hackaround
         if com.any_none(*key):
-            result = self._get_values(key)
+            # mpl compat if we look up e.g. ser[:, np.newaxis];
+            #  see tests.series.timeseries.test_mpl_compat_hack
+            # the asarray is needed to avoid returning a 2D DatetimeArray
+            result = np.asarray(self._values[key])
             deprecate_ndim_indexing(result, stacklevel=find_stack_level())
             return result
 
@@ -1040,15 +1065,9 @@ def _get_values_tuple(self, key):
             self
         )
 
-    def _get_values(self, indexer):
-        try:
-            new_mgr = self._mgr.getitem_mgr(indexer)
-            return self._constructor(new_mgr).__finalize__(self)
-        except ValueError:
-            # mpl compat if we look up e.g. ser[:, np.newaxis];
-            #  see tests.series.timeseries.test_mpl_compat_hack
-            # the asarray is needed to avoid returning a 2D DatetimeArray
-            return np.asarray(self._values[indexer])
+    def _get_values(self, indexer: slice | npt.NDArray[np.bool_]) -> Series:
+        new_mgr = self._mgr.getitem_mgr(indexer)
+        return self._constructor(new_mgr).__finalize__(self)
 
     def _get_value(self, label, takeable: bool = False):
         """
@@ -1084,7 +1103,9 @@ def __setitem__(self, key, value) -> None:
 
         try:
             self._set_with_engine(key, value)
-        except (KeyError, ValueError):
+        except KeyError:
+            # We have a scalar (or for MultiIndex or object-dtype, scalar-like)
+            #  key that is not present in self.index.
             if is_integer(key) and self.index.inferred_type != "integer":
                 # positional setter
                 if not self.index._should_fallback_to_positional:
@@ -1098,15 +1119,22 @@ def __setitem__(self, key, value) -> None:
                         FutureWarning,
                         stacklevel=find_stack_level(),
                     )
-                # this is equivalent to self._values[key] = value
-                self._mgr.setitem_inplace(key, value)
+                # can't use _mgr.setitem_inplace yet bc could have *both*
+                #  KeyError and then ValueError, xref GH#45070
+                self._set_values(key, value)
             else:
                 # GH#12862 adding a new key to the Series
                 self.loc[key] = value
 
-        except (InvalidIndexError, TypeError) as err:
+        except (TypeError, ValueError, LossySetitemError):
+            # The key was OK, but we cannot set the value losslessly
+            indexer = self.index.get_loc(key)
+            self._set_values(indexer, value)
+
+        except InvalidIndexError as err:
             if isinstance(key, tuple) and not isinstance(self.index, MultiIndex):
                 # cases with MultiIndex don't get here bc they raise KeyError
+                # e.g. test_basic_getitem_setitem_corner
                 raise KeyError(
                     "key of type tuple not found and not a MultiIndex"
                 ) from err
@@ -1141,37 +1169,36 @@ def __setitem__(self, key, value) -> None:
                 self._set_with(key, value)
 
         if cacher_needs_updating:
-            self._maybe_update_cacher()
+            self._maybe_update_cacher(inplace=True)
 
     def _set_with_engine(self, key, value) -> None:
         loc = self.index.get_loc(key)
-        if not can_hold_element(self._values, value):
-            raise ValueError
 
         # this is equivalent to self._values[key] = value
         self._mgr.setitem_inplace(loc, value)
 
     def _set_with(self, key, value):
-        # other: fancy integer or otherwise
+        # We got here via exception-handling off of InvalidIndexError, so
+        #  key should always be listlike at this point.
         assert not isinstance(key, tuple)
 
-        if is_scalar(key):
-            key = [key]
-        elif is_iterator(key):
+        if is_iterator(key):
             # Without this, the call to infer_dtype will consume the generator
             key = list(key)
 
-        key_type = lib.infer_dtype(key, skipna=False)
+        if not self.index._should_fallback_to_positional:
+            # Regardless of the key type, we're treating it as labels
+            self._set_labels(key, value)
 
-        # Note: key_type == "boolean" should not occur because that
-        #  should be caught by the is_bool_indexer check in __setitem__
-        if key_type == "integer":
-            if not self.index._should_fallback_to_positional:
-                self._set_labels(key, value)
-            else:
-                self._set_values(key, value)
         else:
-            self.loc[key] = value
+            # Note: key_type == "boolean" should not occur because that
+            #  should be caught by the is_bool_indexer check in __setitem__
+            key_type = lib.infer_dtype(key, skipna=False)
+
+            if key_type == "integer":
+                self._set_values(key, value)
+            else:
+                self._set_labels(key, value)
 
     def _set_labels(self, key, value) -> None:
         key = com.asarray_tuplesafe(key)
@@ -1235,7 +1262,6 @@ def _reset_cacher(self) -> None:
         Reset the cacher.
         """
         if hasattr(self, "_cacher"):
-            # should only get here with self.ndim == 1
             del self._cacher
 
     def _set_as_cached(self, item, cacher) -> None:
@@ -1275,7 +1301,16 @@ def _maybe_update_cacher(
             # a copy
             if ref is None:
                 del self._cacher
-            elif len(self) == len(ref) and self.name in ref.columns:
+            # for CoW, we never want to update the parent DataFrame cache
+            # if the Series changed, and always pop the cached item
+            elif (
+                not (
+                    get_option("mode.copy_on_write")
+                    and get_option("mode.data_manager") == "block"
+                )
+                and len(self) == len(ref)
+                and self.name in ref.columns
+            ):
                 # GH#42530 self.name must be in ref.columns
                 # to ensure column still in dataframe
                 # otherwise, either self or ref has swapped in new arrays
@@ -1296,7 +1331,7 @@ def _maybe_update_cacher(
     def _is_mixed_type(self):
         return False
 
-    def repeat(self, repeats, axis=None) -> Series:
+    def repeat(self, repeats: int | Sequence[int], axis: None = None) -> Series:
         """
         Repeat elements of a Series.
 
@@ -1310,8 +1345,7 @@ def repeat(self, repeats, axis=None) -> Series:
             non-negative integer. Repeating 0 times will return an empty
             Series.
         axis : None
-            Must be ``None``. Has no effect but is accepted for compatibility
-            with numpy.
+            Unused. Parameter needed for compatibility with DataFrame.
 
         Returns
         -------
@@ -1355,8 +1389,51 @@ def repeat(self, repeats, axis=None) -> Series:
             self, method="repeat"
         )
 
+    @overload
+    def reset_index(
+        self,
+        level: IndexLabel = ...,
+        *,
+        drop: Literal[False] = ...,
+        name: Level = ...,
+        inplace: Literal[False] = ...,
+        allow_duplicates: bool = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def reset_index(
+        self,
+        level: IndexLabel = ...,
+        *,
+        drop: Literal[True],
+        name: Level = ...,
+        inplace: Literal[False] = ...,
+        allow_duplicates: bool = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def reset_index(
+        self,
+        level: IndexLabel = ...,
+        *,
+        drop: bool = ...,
+        name: Level = ...,
+        inplace: Literal[True],
+        allow_duplicates: bool = ...,
+    ) -> None:
+        ...
+
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "level"])
-    def reset_index(self, level=None, drop=False, name=lib.no_default, inplace=False):
+    def reset_index(
+        self,
+        level: IndexLabel = None,
+        drop: bool = False,
+        name: Level = lib.no_default,
+        inplace: bool = False,
+        allow_duplicates: bool = False,
+    ) -> DataFrame | Series | None:
         """
         Generate a new DataFrame or Series with the index reset.
 
@@ -1378,6 +1455,10 @@ def reset_index(self, level=None, drop=False, name=lib.no_default, inplace=False
             when `drop` is True.
         inplace : bool, default False
             Modify the Series in place (do not create a new object).
+        allow_duplicates : bool, default False
+            Allow duplicate column labels to be created.
+
+            .. versionadded:: 1.5.0
 
         Returns
         -------
@@ -1468,11 +1549,14 @@ def reset_index(self, level=None, drop=False, name=lib.no_default, inplace=False
         if drop:
             new_index = default_index(len(self))
             if level is not None:
+                level_list: Sequence[Hashable]
                 if not isinstance(level, (tuple, list)):
-                    level = [level]
-                level = [self.index._get_level_number(lev) for lev in level]
-                if len(level) < self.index.nlevels:
-                    new_index = self.index.droplevel(level)
+                    level_list = [level]
+                else:
+                    level_list = level
+                level_list = [self.index._get_level_number(lev) for lev in level_list]
+                if len(level_list) < self.index.nlevels:
+                    new_index = self.index.droplevel(level_list)
 
             if inplace:
                 self.index = new_index
@@ -1494,7 +1578,10 @@ def reset_index(self, level=None, drop=False, name=lib.no_default, inplace=False
                     name = self.name
 
             df = self.to_frame(name)
-            return df.reset_index(level=level, drop=drop)
+            return df.reset_index(
+                level=level, drop=drop, allow_duplicates=allow_duplicates
+            )
+        return None
 
     # ----------------------------------------------------------------------
     # Rendering Methods
@@ -1506,19 +1593,51 @@ def __repr__(self) -> str:
         repr_params = fmt.get_series_repr_params()
         return self.to_string(**repr_params)
 
+    @overload
+    def to_string(
+        self,
+        buf: None = ...,
+        na_rep: str = ...,
+        float_format: str | None = ...,
+        header: bool = ...,
+        index: bool = ...,
+        length=...,
+        dtype=...,
+        name=...,
+        max_rows: int | None = ...,
+        min_rows: int | None = ...,
+    ) -> str:
+        ...
+
+    @overload
+    def to_string(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        na_rep: str = ...,
+        float_format: str | None = ...,
+        header: bool = ...,
+        index: bool = ...,
+        length=...,
+        dtype=...,
+        name=...,
+        max_rows: int | None = ...,
+        min_rows: int | None = ...,
+    ) -> None:
+        ...
+
     def to_string(
         self,
-        buf=None,
-        na_rep="NaN",
-        float_format=None,
-        header=True,
-        index=True,
+        buf: FilePath | WriteBuffer[str] | None = None,
+        na_rep: str = "NaN",
+        float_format: str | None = None,
+        header: bool = True,
+        index: bool = True,
         length=False,
         dtype=False,
         name=False,
-        max_rows=None,
-        min_rows=None,
-    ):
+        max_rows: int | None = None,
+        min_rows: int | None = None,
+    ) -> str | None:
         """
         Render a string representation of the Series.
 
@@ -1577,11 +1696,17 @@ def to_string(
         if buf is None:
             return result
         else:
-            try:
-                buf.write(result)
-            except AttributeError:
-                with open(buf, "w") as f:
+            if hasattr(buf, "write"):
+                # error: Item "str" of "Union[str, PathLike[str], WriteBuffer
+                # [str]]" has no attribute "write"
+                buf.write(result)  # type: ignore[union-attr]
+            else:
+                # error: Argument 1 to "open" has incompatible type "Union[str,
+                # PathLike[str], WriteBuffer[str]]"; expected "Union[Union[str,
+                # bytes, PathLike[str], PathLike[bytes]], int]"
+                with open(buf, "w") as f:  # type: ignore[arg-type]
                     f.write(result)
+        return None
 
     @doc(
         klass=_shared_doc_kwargs["klass"],
@@ -1691,8 +1816,35 @@ def items(self) -> Iterable[tuple[Hashable, Any]]:
         """
         return zip(iter(self.index), iter(self))
 
-    @Appender(items.__doc__)
     def iteritems(self) -> Iterable[tuple[Hashable, Any]]:
+        """
+        Lazily iterate over (index, value) tuples.
+
+        .. deprecated:: 1.5.0
+            iteritems is deprecated and will be removed in a future version.
+            Use .items instead.
+
+        This method returns an iterable tuple (index, value). This is
+        convenient if you want to create a lazy iterator.
+
+        Returns
+        -------
+        iterable
+            Iterable of tuples containing the (index, value) pairs from a
+            Series.
+
+        See Also
+        --------
+        Series.items : Recommended alternative.
+        DataFrame.items : Iterate over (column name, Series) pairs.
+        DataFrame.iterrows : Iterate over DataFrame rows as (index, Series) pairs.
+        """
+        warnings.warn(
+            "iteritems is deprecated and will be removed in a future version. "
+            "Use .items instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
         return self.items()
 
     # ----------------------------------------------------------------------
@@ -1709,7 +1861,7 @@ def keys(self) -> Index:
         """
         return self.index
 
-    def to_dict(self, into=dict):
+    def to_dict(self, into: type[dict] = dict) -> dict:
         """
         Convert Series to {label -> value} dict or dict-like object.
 
@@ -1748,7 +1900,7 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
 
         Parameters
         ----------
-        name : object, default None
+        name : object, optional
             The passed name should substitute for the series name (if it has
             one).
 
@@ -1767,6 +1919,17 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
         1    b
         2    c
         """
+        if name is None:
+            warnings.warn(
+                "Explicitly passing `name=None` currently preserves the Series' name "
+                "or uses a default name of 0. This behaviour is deprecated, and in "
+                "the future `None` will be used as the name of the resulting "
+                "DataFrame column.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            name = lib.no_default
+
         columns: Index
         if name is lib.no_default:
             name = self.name
@@ -1779,7 +1942,8 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
             columns = Index([name])
 
         mgr = self._mgr.to_2d_mgr(columns)
-        return self._constructor_expanddim(mgr)
+        df = self._constructor_expanddim(mgr)
+        return df.__finalize__(self, method="to_frame")
 
     def _set_name(self, name, inplace=False) -> Series:
         """
@@ -1882,11 +2046,11 @@ def _set_name(self, name, inplace=False) -> Series:
     def groupby(
         self,
         by=None,
-        axis=0,
-        level=None,
+        axis: Axis = 0,
+        level: Level = None,
         as_index: bool = True,
         sort: bool = True,
-        group_keys: bool = True,
+        group_keys: bool | lib.NoDefault = no_default,
         squeeze: bool | lib.NoDefault = no_default,
         observed: bool = False,
         dropna: bool = True,
@@ -1909,8 +2073,6 @@ def groupby(
             raise TypeError("You have to supply one of 'by' and 'level'")
         axis = self._get_axis_number(axis)
 
-        # error: Argument "squeeze" to "SeriesGroupBy" has incompatible type
-        # "Union[bool, NoDefault]"; expected "bool"
         return SeriesGroupBy(
             obj=self,
             keys=by,
@@ -1919,7 +2081,7 @@ def groupby(
             as_index=as_index,
             sort=sort,
             group_keys=group_keys,
-            squeeze=squeeze,  # type: ignore[arg-type]
+            squeeze=squeeze,
             observed=observed,
             dropna=dropna,
         )
@@ -1928,8 +2090,7 @@ def groupby(
     # Statistics, overridden ndarray methods
 
     # TODO: integrate bottleneck
-
-    def count(self, level=None):
+    def count(self, level: Level = None):
         """
         Return number of non-NA/null observations in the Series.
 
@@ -1982,7 +2143,9 @@ def count(self, level=None):
             lev = lev.insert(cnt, lev._na_value)
 
         obs = level_codes[notna(self._values)]
-        out = np.bincount(obs, minlength=len(lev) or None)
+        # error: Argument "minlength" to "bincount" has incompatible type
+        # "Optional[int]"; expected "SupportsIndex"
+        out = np.bincount(obs, minlength=len(lev) or None)  # type: ignore[arg-type]
         return self._constructor(out, index=lev, dtype="int64").__finalize__(
             self, method="count"
         )
@@ -2031,6 +2194,7 @@ def unique(self) -> ArrayLike:
 
         See Also
         --------
+        Series.drop_duplicates : Return Series with duplicate values removed.
         unique : Top-level unique method for any 1-d array-like object.
         Index.unique : Return Index with unique values from an Index object.
 
@@ -2078,23 +2242,30 @@ def unique(self) -> ArrayLike:
         return super().unique()
 
     @overload
-    def drop_duplicates(self, keep=..., inplace: Literal[False] = ...) -> Series:
-        ...
-
-    @overload
-    def drop_duplicates(self, keep, inplace: Literal[True]) -> None:
+    def drop_duplicates(
+        self,
+        keep: Literal["first", "last", False] = ...,
+        *,
+        inplace: Literal[False] = ...,
+    ) -> Series:
         ...
 
     @overload
-    def drop_duplicates(self, *, inplace: Literal[True]) -> None:
+    def drop_duplicates(
+        self, keep: Literal["first", "last", False] = ..., *, inplace: Literal[True]
+    ) -> None:
         ...
 
     @overload
-    def drop_duplicates(self, keep=..., inplace: bool = ...) -> Series | None:
+    def drop_duplicates(
+        self, keep: Literal["first", "last", False] = ..., *, inplace: bool = ...
+    ) -> Series | None:
         ...
 
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
-    def drop_duplicates(self, keep="first", inplace=False) -> Series | None:
+    def drop_duplicates(
+        self, keep: Literal["first", "last", False] = "first", inplace=False
+    ) -> Series | None:
         """
         Return Series with duplicate values removed.
 
@@ -2121,6 +2292,7 @@ def drop_duplicates(self, keep="first", inplace=False) -> Series | None:
         DataFrame.drop_duplicates : Equivalent method on DataFrame.
         Series.duplicated : Related method on Series, indicating duplicate
             Series values.
+        Series.unique : Return unique values as an array.
 
         Examples
         --------
@@ -2177,7 +2349,7 @@ def drop_duplicates(self, keep="first", inplace=False) -> Series | None:
         else:
             return result
 
-    def duplicated(self, keep="first") -> Series:
+    def duplicated(self, keep: Literal["first", "last", False] = "first") -> Series:
         """
         Indicate duplicate Series values.
 
@@ -2257,7 +2429,7 @@ def duplicated(self, keep="first") -> Series:
         result = self._constructor(res, index=self.index)
         return result.__finalize__(self, method="duplicated")
 
-    def idxmin(self, axis=0, skipna=True, *args, **kwargs):
+    def idxmin(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Hashable:
         """
         Return the row label of the minimum value.
 
@@ -2266,9 +2438,8 @@ def idxmin(self, axis=0, skipna=True, *args, **kwargs):
 
         Parameters
         ----------
-        axis : int, default 0
-            For compatibility with DataFrame.idxmin. Redundant for application
-            on Series.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         skipna : bool, default True
             Exclude NA/null values. If the entire Series is NA, the result
             will be NA.
@@ -2326,7 +2497,7 @@ def idxmin(self, axis=0, skipna=True, *args, **kwargs):
             return np.nan
         return self.index[i]
 
-    def idxmax(self, axis=0, skipna=True, *args, **kwargs):
+    def idxmax(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Hashable:
         """
         Return the row label of the maximum value.
 
@@ -2335,9 +2506,8 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
 
         Parameters
         ----------
-        axis : int, default 0
-            For compatibility with DataFrame.idxmax. Redundant for application
-            on Series.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         skipna : bool, default True
             Exclude NA/null values. If the entire Series is NA, the result
             will be NA.
@@ -2396,7 +2566,7 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
             return np.nan
         return self.index[i]
 
-    def round(self, decimals=0, *args, **kwargs) -> Series:
+    def round(self, decimals: int = 0, *args, **kwargs) -> Series:
         """
         Round each value in a Series to the given number of decimals.
 
@@ -2436,7 +2606,33 @@ def round(self, decimals=0, *args, **kwargs) -> Series:
 
         return result
 
-    def quantile(self, q=0.5, interpolation="linear"):
+    @overload
+    def quantile(
+        self, q: float = ..., interpolation: QuantileInterpolation = ...
+    ) -> float:
+        ...
+
+    @overload
+    def quantile(
+        self,
+        q: Sequence[float] | AnyArrayLike,
+        interpolation: QuantileInterpolation = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def quantile(
+        self,
+        q: float | Sequence[float] | AnyArrayLike = ...,
+        interpolation: QuantileInterpolation = ...,
+    ) -> float | Series:
+        ...
+
+    def quantile(
+        self,
+        q: float | Sequence[float] | AnyArrayLike = 0.5,
+        interpolation: QuantileInterpolation = "linear",
+    ) -> float | Series:
         """
         Return value at the given quantile.
 
@@ -2495,10 +2691,19 @@ def quantile(self, q=0.5, interpolation="linear"):
             # scalar
             return result.iloc[0]
 
-    def corr(self, other, method="pearson", min_periods=None) -> float:
+    def corr(
+        self,
+        other: Series,
+        method: Literal["pearson", "kendall", "spearman"]
+        | Callable[[np.ndarray, np.ndarray], float] = "pearson",
+        min_periods: int | None = None,
+    ) -> float:
         """
         Compute correlation with `other` Series, excluding missing values.
 
+        The two `Series` objects are not required to be the same length and will be
+        aligned internally before the correlation function is applied.
+
         Parameters
         ----------
         other : Series
@@ -2529,6 +2734,14 @@ def corr(self, other, method="pearson", min_periods=None) -> float:
         DataFrame.corrwith : Compute pairwise correlation with another
             DataFrame or Series.
 
+        Notes
+        -----
+        Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations.
+
+        * `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_
+        * `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_
+        * `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_
+
         Examples
         --------
         >>> def histogram_intersection(a, b):
@@ -2538,7 +2751,7 @@ def corr(self, other, method="pearson", min_periods=None) -> float:
         >>> s2 = pd.Series([.3, .6, .0, .1])
         >>> s1.corr(s2, method=histogram_intersection)
         0.3
-        """
+        """  # noqa:E501
         this, other = self.align(other, join="inner", copy=False)
         if len(this) == 0:
             return np.nan
@@ -2563,6 +2776,9 @@ def cov(
         """
         Compute covariance with Series, excluding missing values.
 
+        The two `Series` objects are not required to be the same length and
+        will be aligned internally before the covariance is calculated.
+
         Parameters
         ----------
         other : Series
@@ -2689,7 +2905,7 @@ def diff(self, periods: int = 1) -> Series:
             self, method="diff"
         )
 
-    def autocorr(self, lag=1) -> float:
+    def autocorr(self, lag: int = 1) -> float:
         """
         Compute the lag-N autocorrelation.
 
@@ -2734,7 +2950,7 @@ def autocorr(self, lag=1) -> float:
         """
         return self.corr(self.shift(lag))
 
-    def dot(self, other):
+    def dot(self, other: AnyArrayLike) -> Series | np.ndarray:
         """
         Compute the dot product between the Series and the columns of other.
 
@@ -2839,10 +3055,14 @@ def searchsorted(  # type: ignore[override]
 
     def append(
         self, to_append, ignore_index: bool = False, verify_integrity: bool = False
-    ):
+    ) -> Series:
         """
         Concatenate two or more Series.
 
+        .. deprecated:: 1.4.0
+            Use :func:`concat` instead. For further details see
+            :ref:`whatsnew_140.deprecations.frame_series_append`
+
         Parameters
         ----------
         to_append : Series or list/tuple of Series
@@ -3078,15 +3298,22 @@ def compare(
         align_axis: Axis = 1,
         keep_shape: bool = False,
         keep_equal: bool = False,
+        result_names: Suffixes = ("self", "other"),
     ) -> DataFrame | Series:
         return super().compare(
             other=other,
             align_axis=align_axis,
             keep_shape=keep_shape,
             keep_equal=keep_equal,
+            result_names=result_names,
         )
 
-    def combine(self, other, func, fill_value=None) -> Series:
+    def combine(
+        self,
+        other: Series | Hashable,
+        func: Callable[[Hashable, Hashable], Hashable],
+        fill_value: Hashable = None,
+    ) -> Series:
         """
         Combine the Series with a Series or scalar according to `func`.
 
@@ -3233,7 +3460,7 @@ def combine_first(self, other) -> Series:
 
         return this.where(notna(this), other)
 
-    def update(self, other) -> None:
+    def update(self, other: Series | Sequence | Mapping) -> None:
         """
         Modify Series in place using values from passed Series.
 
@@ -3313,17 +3540,47 @@ def update(self, other) -> None:
     # ----------------------------------------------------------------------
     # Reindexing, sorting
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    # error: Signature of "sort_values" incompatible with supertype "NDFrame"
+    @overload  # type: ignore[override]
     def sort_values(
         self,
-        axis=0,
-        ascending: bool | int | Sequence[bool | int] = True,
+        *,
+        axis: Axis = ...,
+        ascending: bool | int | Sequence[bool] | Sequence[int] = ...,
+        inplace: Literal[False] = ...,
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool = ...,
+        key: ValueKeyFunc = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def sort_values(
+        self,
+        *,
+        axis: Axis = ...,
+        ascending: bool | int | Sequence[bool] | Sequence[int] = ...,
+        inplace: Literal[True],
+        kind: str = ...,
+        na_position: str = ...,
+        ignore_index: bool = ...,
+        key: ValueKeyFunc = ...,
+    ) -> None:
+        ...
+
+    # error: Signature of "sort_values" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def sort_values(  # type: ignore[override]
+        self,
+        axis: Axis = 0,
+        ascending: bool | int | Sequence[bool] | Sequence[int] = True,
         inplace: bool = False,
         kind: str = "quicksort",
         na_position: str = "last",
         ignore_index: bool = False,
         key: ValueKeyFunc = None,
-    ):
+    ) -> Series | None:
         """
         Sort by the values.
 
@@ -3332,9 +3589,8 @@ def sort_values(
 
         Parameters
         ----------
-        axis : {0 or 'index'}, default 0
-            Axis to direct sorting. The value 'index' is accepted for
-            compatibility with DataFrame.sort_values.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         ascending : bool or list of bools, default True
             If True, sort values in ascending order, otherwise descending.
         inplace : bool, default False
@@ -3518,24 +3774,73 @@ def sort_values(
         if ignore_index:
             result.index = default_index(len(sorted_index))
 
-        if inplace:
-            self._update_inplace(result)
-        else:
+        if not inplace:
             return result.__finalize__(self, method="sort_values")
+        self._update_inplace(result)
+        return None
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def sort_index(
         self,
-        axis=0,
-        level=None,
-        ascending: bool | int | Sequence[bool | int] = True,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: Literal[True],
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def sort_index(
+        self,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: Literal[False] = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def sort_index(
+        self,
+        *,
+        axis: Axis = ...,
+        level: IndexLabel = ...,
+        ascending: bool | Sequence[bool] = ...,
+        inplace: bool = ...,
+        kind: SortKind = ...,
+        na_position: NaPosition = ...,
+        sort_remaining: bool = ...,
+        ignore_index: bool = ...,
+        key: IndexKeyFunc = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "sort_index" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def sort_index(  # type: ignore[override]
+        self,
+        axis: Axis = 0,
+        level: IndexLabel = None,
+        ascending: bool | Sequence[bool] = True,
         inplace: bool = False,
-        kind: str = "quicksort",
-        na_position: str = "last",
+        kind: SortKind = "quicksort",
+        na_position: NaPosition = "last",
         sort_remaining: bool = True,
         ignore_index: bool = False,
         key: IndexKeyFunc = None,
-    ):
+    ) -> Series | None:
         """
         Sort Series by index labels.
 
@@ -3544,8 +3849,8 @@ def sort_index(
 
         Parameters
         ----------
-        axis : int, default 0
-            Axis to direct sorting. This can only be 0 for Series.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         level : int, optional
             If not None, sort on values in specified index level(s).
         ascending : bool or list-like of bools, default True
@@ -3672,18 +3977,23 @@ def sort_index(
         """
 
         return super().sort_index(
-            axis,
-            level,
-            ascending,
-            inplace,
-            kind,
-            na_position,
-            sort_remaining,
-            ignore_index,
-            key,
+            axis=axis,
+            level=level,
+            ascending=ascending,
+            inplace=inplace,
+            kind=kind,
+            na_position=na_position,
+            sort_remaining=sort_remaining,
+            ignore_index=ignore_index,
+            key=key,
         )
 
-    def argsort(self, axis=0, kind="quicksort", order=None) -> Series:
+    def argsort(
+        self,
+        axis: Axis = 0,
+        kind: SortKind = "quicksort",
+        order: None = None,
+    ) -> Series:
         """
         Return the integer indices that would sort the Series values.
 
@@ -3692,8 +4002,8 @@ def argsort(self, axis=0, kind="quicksort", order=None) -> Series:
 
         Parameters
         ----------
-        axis : {0 or "index"}
-            Has no effect but is accepted for compatibility with numpy.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         kind : {'mergesort', 'quicksort', 'heapsort', 'stable'}, default 'quicksort'
             Choice of sorting algorithm. See :func:`numpy.sort` for more
             information. 'mergesort' and 'stable' are the only stable algorithms.
@@ -3723,7 +4033,9 @@ def argsort(self, axis=0, kind="quicksort", order=None) -> Series:
         res = self._constructor(result, index=self.index, name=self.name, dtype=np.intp)
         return res.__finalize__(self, method="argsort")
 
-    def nlargest(self, n=5, keep="first") -> Series:
+    def nlargest(
+        self, n: int = 5, keep: Literal["first", "last", "all"] = "first"
+    ) -> Series:
         """
         Return the largest `n` elements.
 
@@ -3978,7 +4290,7 @@ def nsmallest(self, n: int = 5, keep: str = "first") -> Series:
         dtype: object"""
         ),
     )
-    def swaplevel(self, i=-2, j=-1, copy=True) -> Series:
+    def swaplevel(self, i: Level = -2, j: Level = -1, copy: bool = True) -> Series:
         """
         Swap levels i and j in a :class:`MultiIndex`.
 
@@ -4003,7 +4315,7 @@ def swaplevel(self, i=-2, j=-1, copy=True) -> Series:
             self, method="swaplevel"
         )
 
-    def reorder_levels(self, order) -> Series:
+    def reorder_levels(self, order: Sequence[Level]) -> Series:
         """
         Rearrange index levels using input order.
 
@@ -4061,6 +4373,8 @@ def explode(self, ignore_index: bool = False) -> Series:
         result in a np.nan for that row. In addition, the ordering of elements in
         the output will be non-deterministic when exploding sets.
 
+        Reference :ref:`the user guide <reshaping.explode>` for more examples.
+
         Examples
         --------
         >>> s = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])
@@ -4094,7 +4408,7 @@ def explode(self, ignore_index: bool = False) -> Series:
 
         return self._constructor(values, index=index, name=self.name)
 
-    def unstack(self, level=-1, fill_value=None) -> DataFrame:
+    def unstack(self, level: IndexLabel = -1, fill_value: Hashable = None) -> DataFrame:
         """
         Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
 
@@ -4110,6 +4424,10 @@ def unstack(self, level=-1, fill_value=None) -> DataFrame:
         DataFrame
             Unstacked Series.
 
+        Notes
+        -----
+        Reference :ref:`the user guide <reshaping.stacking>` for more examples.
+
         Examples
         --------
         >>> s = pd.Series([1, 2, 3, 4],
@@ -4139,9 +4457,13 @@ def unstack(self, level=-1, fill_value=None) -> DataFrame:
     # ----------------------------------------------------------------------
     # function application
 
-    def map(self, arg, na_action=None) -> Series:
+    def map(
+        self,
+        arg: Callable | Mapping | Series,
+        na_action: Literal["ignore"] | None = None,
+    ) -> Series:
         """
-        Map values of Series according to input correspondence.
+        Map values of Series according to an input mapping or function.
 
         Used for substituting each value in a Series with another value,
         that may be derived from a function, a ``dict`` or
@@ -4271,7 +4593,7 @@ def _gotitem(self, key, ndim, subset=None) -> Series:
         see_also=_agg_see_also_doc,
         examples=_agg_examples_doc,
     )
-    def aggregate(self, func=None, axis=0, *args, **kwargs):
+    def aggregate(self, func=None, axis: Axis = 0, *args, **kwargs):
         # Validate the axis parameter
         self._get_axis_number(axis)
 
@@ -4285,6 +4607,42 @@ def aggregate(self, func=None, axis=0, *args, **kwargs):
 
     agg = aggregate
 
+    # error: Signature of "any" incompatible with supertype "NDFrame"  [override]
+    @overload  # type: ignore[override]
+    def any(
+        self,
+        *,
+        axis: Axis = ...,
+        bool_only: bool | None = ...,
+        skipna: bool = ...,
+        level: None = ...,
+        **kwargs,
+    ) -> bool:
+        ...
+
+    @overload
+    def any(
+        self,
+        *,
+        axis: Axis = ...,
+        bool_only: bool | None = ...,
+        skipna: bool = ...,
+        level: Level,
+        **kwargs,
+    ) -> Series | bool:
+        ...
+
+    @doc(NDFrame.any, **_shared_doc_kwargs)
+    def any(
+        self,
+        axis: Axis = 0,
+        bool_only: bool | None = None,
+        skipna: bool = True,
+        level: Level | None = None,
+        **kwargs,
+    ) -> Series | bool:
+        ...
+
     @doc(
         _shared_docs["transform"],
         klass=_shared_doc_kwargs["klass"],
@@ -4440,10 +4798,17 @@ def _reduce(
 
         else:
             # dispatch to numpy arrays
-            if numeric_only:
+            if numeric_only and not is_numeric_dtype(self.dtype):
                 kwd_name = "numeric_only"
                 if name in ["any", "all"]:
                     kwd_name = "bool_only"
+                # GH#47500 - change to TypeError to match other methods
+                warnings.warn(
+                    f"Calling Series.{name} with {kwd_name}={numeric_only} and "
+                    f"dtype {self.dtype} will raise a TypeError in the future",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
                 raise NotImplementedError(
                     f"Series.{name} does not implement {kwd_name}."
                 )
@@ -4455,7 +4820,9 @@ def _reindex_indexer(
     ) -> Series:
         # Note: new_index is None iff indexer is None
         # if not None, indexer is np.intp
-        if indexer is None:
+        if indexer is None and (
+            new_index is None or new_index.names == self.index.names
+        ):
             if copy:
                 return self.copy()
             return self
@@ -4480,17 +4847,17 @@ def _needs_reindex_multi(self, axes, method, level) -> bool:
     )
     def align(
         self,
-        other,
-        join="outer",
-        axis=None,
-        level=None,
-        copy=True,
-        fill_value=None,
-        method=None,
-        limit=None,
-        fill_axis=0,
-        broadcast_axis=None,
-    ):
+        other: Series,
+        join: Literal["outer", "inner", "left", "right"] = "outer",
+        axis: Axis | None = None,
+        level: Level = None,
+        copy: bool = True,
+        fill_value: Hashable = None,
+        method: FillnaOptions | None = None,
+        limit: int | None = None,
+        fill_axis: Axis = 0,
+        broadcast_axis: Axis | None = None,
+    ) -> Series:
         return super().align(
             other,
             join=join,
@@ -4504,40 +4871,85 @@ def align(
             broadcast_axis=broadcast_axis,
         )
 
+    @overload
     def rename(
         self,
-        index=None,
+        index: Renamer | Hashable | None = ...,
         *,
-        axis=None,
-        copy=True,
-        inplace=False,
-        level=None,
-        errors="ignore",
-    ) -> Series | None:
-        """
-        Alter Series index labels or name.
-
-        Function / dict values must be unique (1-to-1). Labels not contained in
-        a dict / Series will be left as-is. Extra labels listed don't throw an
-        error.
+        axis: Axis | None = ...,
+        copy: bool = ...,
+        inplace: Literal[True],
+        level: Level | None = ...,
+        errors: IgnoreRaise = ...,
+    ) -> None:
+        ...
 
-        Alternatively, change ``Series.name`` with a scalar value.
+    @overload
+    def rename(
+        self,
+        index: Renamer | Hashable | None = ...,
+        *,
+        axis: Axis | None = ...,
+        copy: bool = ...,
+        inplace: Literal[False] = ...,
+        level: Level | None = ...,
+        errors: IgnoreRaise = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def rename(
+        self,
+        index: Renamer | Hashable | None = ...,
+        *,
+        axis: Axis | None = ...,
+        copy: bool = ...,
+        inplace: bool = ...,
+        level: Level | None = ...,
+        errors: IgnoreRaise = ...,
+    ) -> Series | None:
+        ...
+
+    def rename(
+        self,
+        index: Renamer | Hashable | None = None,
+        *,
+        axis: Axis | None = None,
+        copy: bool = True,
+        inplace: bool = False,
+        level: Level | None = None,
+        errors: IgnoreRaise = "ignore",
+    ) -> Series | None:
+        """
+        Alter Series index labels or name.
+
+        Function / dict values must be unique (1-to-1). Labels not contained in
+        a dict / Series will be left as-is. Extra labels listed don't throw an
+        error.
+
+        Alternatively, change ``Series.name`` with a scalar value.
 
         See the :ref:`user guide <basics.rename>` for more.
 
         Parameters
         ----------
-        axis : {0 or "index"}
-            Unused. Accepted for compatibility with DataFrame method only.
-        index : scalar, hashable sequence, dict-like or function, optional
+        index : scalar, hashable sequence, dict-like or function optional
             Functions or dict-like are transformations to apply to
             the index.
             Scalar or hashable sequence-like will alter the ``Series.name``
             attribute.
-
-        **kwargs
-            Additional keyword arguments passed to the function. Only the
-            "inplace" keyword is used.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
+        copy : bool, default True
+            Also copy underlying data.
+        inplace : bool, default False
+            Whether to return a new Series. If True the value of copy is ignored.
+        level : int or level name, default None
+            In case of MultiIndex, only rename labels in the specified level.
+        errors : {'ignore', 'raise'}, default 'ignore'
+            If 'raise', raise `KeyError` when a `dict-like mapper` or
+            `index` contains labels that are not present in the index being transformed.
+            If 'ignore', existing keys will be renamed and extra keys will be ignored.
 
         Returns
         -------
@@ -4578,30 +4990,54 @@ def rename(
             axis = self._get_axis_number(axis)
 
         if callable(index) or is_dict_like(index):
+            # error: Argument 1 to "_rename" of "NDFrame" has incompatible
+            # type "Union[Union[Mapping[Any, Hashable], Callable[[Any],
+            # Hashable]], Hashable, None]"; expected "Union[Mapping[Any,
+            # Hashable], Callable[[Any], Hashable], None]"
             return super()._rename(
-                index, copy=copy, inplace=inplace, level=level, errors=errors
+                index,  # type: ignore[arg-type]
+                copy=copy,
+                inplace=inplace,
+                level=level,
+                errors=errors,
             )
         else:
             return self._set_name(index, inplace=inplace)
 
     @overload
     def set_axis(
-        self, labels, axis: Axis = ..., inplace: Literal[False] = ...
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[False] | lib.NoDefault = ...,
+        copy: bool | lib.NoDefault = ...,
     ) -> Series:
         ...
 
     @overload
-    def set_axis(self, labels, axis: Axis, inplace: Literal[True]) -> None:
-        ...
-
-    @overload
-    def set_axis(self, labels, *, inplace: Literal[True]) -> None:
+    def set_axis(
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: Literal[True],
+        copy: bool | lib.NoDefault = ...,
+    ) -> None:
         ...
 
     @overload
-    def set_axis(self, labels, axis: Axis = ..., inplace: bool = ...) -> Series | None:
+    def set_axis(
+        self,
+        labels,
+        *,
+        axis: Axis = ...,
+        inplace: bool | lib.NoDefault = ...,
+        copy: bool | lib.NoDefault = ...,
+    ) -> Series | None:
         ...
 
+    # error: Signature of "set_axis" incompatible with supertype "NDFrame"
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
     @Appender(
         """
@@ -4628,8 +5064,14 @@ def set_axis(self, labels, axis: Axis = ..., inplace: bool = ...) -> Series | No
         see_also_sub="",
     )
     @Appender(NDFrame.set_axis.__doc__)
-    def set_axis(self, labels, axis: Axis = 0, inplace: bool = False):
-        return super().set_axis(labels, axis=axis, inplace=inplace)
+    def set_axis(  # type: ignore[override]
+        self,
+        labels,
+        axis: Axis = 0,
+        inplace: bool | lib.NoDefault = lib.no_default,
+        copy: bool | lib.NoDefault = lib.no_default,
+    ) -> Series | None:
+        return super().set_axis(labels, axis=axis, inplace=inplace, copy=copy)
 
     # error: Cannot determine type of 'reindex'
     @doc(
@@ -4651,17 +5093,61 @@ def reindex(self, *args, **kwargs) -> Series:
             kwargs.update({"index": index})
         return super().reindex(**kwargs)
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    @overload
     def drop(
         self,
-        labels=None,
-        axis=0,
-        index=None,
-        columns=None,
-        level=None,
-        inplace=False,
-        errors="raise",
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: Literal[True],
+        errors: IgnoreRaise = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def drop(
+        self,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: Literal[False] = ...,
+        errors: IgnoreRaise = ...,
     ) -> Series:
+        ...
+
+    @overload
+    def drop(
+        self,
+        labels: IndexLabel = ...,
+        *,
+        axis: Axis = ...,
+        index: IndexLabel = ...,
+        columns: IndexLabel = ...,
+        level: Level | None = ...,
+        inplace: bool = ...,
+        errors: IgnoreRaise = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "drop" incompatible with supertype "NDFrame"
+    # github.com/python/mypy/issues/12387
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
+    def drop(  # type: ignore[override]
+        self,
+        labels: IndexLabel = None,
+        axis: Axis = 0,
+        index: IndexLabel = None,
+        columns: IndexLabel = None,
+        level: Level | None = None,
+        inplace: bool = False,
+        errors: IgnoreRaise = "raise",
+    ) -> Series | None:
         """
         Return Series with specified index labels removed.
 
@@ -4673,8 +5159,8 @@ def drop(
         ----------
         labels : single label or list-like
             Index labels to drop.
-        axis : 0, default 0
-            Redundant for application on Series.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         index : single label or list-like
             Redundant for application on Series, but 'index' can be used instead
             of 'labels'.
@@ -4761,129 +5247,53 @@ def drop(
     @overload
     def fillna(
         self,
-        value=...,
+        value: Hashable | Mapping | Series | DataFrame = ...,
+        *,
         method: FillnaOptions | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> Series:
         ...
 
     @overload
     def fillna(
         self,
-        value,
-        method: FillnaOptions | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
+        value: Hashable | Mapping | Series | DataFrame = ...,
         *,
+        method: FillnaOptions | None = ...,
+        axis: Axis | None = ...,
         inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value,
-        *,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: FillnaOptions | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: FillnaOptions | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> None:
         ...
 
     @overload
     def fillna(
         self,
-        value,
-        method: FillnaOptions | None,
+        value: Hashable | Mapping | Series | DataFrame = ...,
         *,
-        inplace: Literal[True],
-        limit=...,
-        downcast=...,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value=...,
         method: FillnaOptions | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,
-        limit=...,
-        downcast=...,
+        limit: int | None = ...,
+        downcast: dict | None = ...,
     ) -> Series | None:
         ...
 
-    # error: Cannot determine type of 'fillna'
+    #  error: Signature of "fillna" incompatible with supertype "NDFrame"
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "value"])
-    @doc(NDFrame.fillna, **_shared_doc_kwargs)  # type: ignore[has-type]
-    def fillna(
+    @doc(NDFrame.fillna, **_shared_doc_kwargs)
+    def fillna(  # type: ignore[override]
         self,
-        value: object | ArrayLike | None = None,
+        value: Hashable | Mapping | Series | DataFrame = None,
         method: FillnaOptions | None = None,
-        axis=None,
-        inplace=False,
-        limit=None,
-        downcast=None,
+        axis: Axis | None = None,
+        inplace: bool = False,
+        limit: int | None = None,
+        downcast: dict | None = None,
     ) -> Series | None:
         return super().fillna(
             value=value,
@@ -4921,22 +5331,52 @@ def pop(self, item: Hashable) -> Any:
         """
         return super().pop(item=item)
 
-    # error: Cannot determine type of 'replace'
+    # error: Signature of "replace" incompatible with supertype "NDFrame"
+    @overload  # type: ignore[override]
+    def replace(
+        self,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        regex: bool = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def replace(
+        self,
+        to_replace=...,
+        value=...,
+        *,
+        inplace: Literal[True],
+        limit: int | None = ...,
+        regex: bool = ...,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    # error: Signature of "replace" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(
+        version=None, allowed_args=["self", "to_replace", "value"]
+    )
     @doc(
-        NDFrame.replace,  # type: ignore[has-type]
+        NDFrame.replace,
         klass=_shared_doc_kwargs["klass"],
         inplace=_shared_doc_kwargs["inplace"],
         replace_iloc=_shared_doc_kwargs["replace_iloc"],
     )
-    def replace(
+    def replace(  # type: ignore[override]
         self,
         to_replace=None,
         value=lib.no_default,
-        inplace=False,
-        limit=None,
-        regex=False,
-        method: str | lib.NoDefault = lib.no_default,
-    ):
+        inplace: bool = False,
+        limit: int | None = None,
+        regex: bool = False,
+        method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = lib.no_default,
+    ) -> Series | None:
         return super().replace(
             to_replace=to_replace,
             value=value,
@@ -4978,7 +5418,7 @@ def _replace_single(self, to_replace, method: str, inplace: bool, limit):
             values._fill_mask_inplace(method, limit, mask)
         else:
             fill_f = missing.get_fill_func(method)
-            values, _ = fill_f(values, limit=limit, mask=mask)
+            fill_f(values, limit=limit, mask=mask)
 
         if inplace:
             return
@@ -4986,7 +5426,9 @@ def _replace_single(self, to_replace, method: str, inplace: bool, limit):
 
     # error: Cannot determine type of 'shift'
     @doc(NDFrame.shift, klass=_shared_doc_kwargs["klass"])  # type: ignore[has-type]
-    def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> Series:
+    def shift(
+        self, periods: int = 1, freq=None, axis: Axis = 0, fill_value: Hashable = None
+    ) -> Series:
         return super().shift(
             periods=periods, freq=freq, axis=axis, fill_value=fill_value
         )
@@ -5123,7 +5565,12 @@ def isin(self, values) -> Series:
             self, method="isin"
         )
 
-    def between(self, left, right, inclusive="both") -> Series:
+    def between(
+        self,
+        left,
+        right,
+        inclusive: Literal["both", "neither", "left", "right"] = "both",
+    ) -> Series:
         """
         Return boolean Series equivalent to left <= series <= right.
 
@@ -5191,7 +5638,9 @@ def between(self, left, right, inclusive="both") -> Series:
         3    False
         dtype: bool
         """
-        if inclusive is True or inclusive is False:
+        # error: Non-overlapping identity check (left operand type: "Literal['both',
+        # 'neither', 'left', 'right']", right operand type: "Literal[False]")
+        if inclusive is True or inclusive is False:  # type: ignore[comparison-overlap]
             warnings.warn(
                 "Boolean inputs to the `inclusive` argument are deprecated in "
                 "favour of `both` or `neither`.",
@@ -5253,8 +5702,10 @@ def _convert_dtypes(
         return result
 
     # error: Cannot determine type of 'isna'
+    # error: Return type "Series" of "isna" incompatible with return type "ndarray
+    # [Any, dtype[bool_]]" in supertype "IndexOpsMixin"
     @doc(NDFrame.isna, klass=_shared_doc_kwargs["klass"])  # type: ignore[has-type]
-    def isna(self) -> Series:
+    def isna(self) -> Series:  # type: ignore[override]
         return NDFrame.isna(self)
 
     # error: Cannot determine type of 'isna'
@@ -5278,8 +5729,22 @@ def notnull(self) -> Series:
         """
         return super().notnull()
 
+    @overload
+    def dropna(
+        self, *, axis: Axis = ..., inplace: Literal[False] = ..., how: str | None = ...
+    ) -> Series:
+        ...
+
+    @overload
+    def dropna(
+        self, *, axis: Axis = ..., inplace: Literal[True], how: str | None = ...
+    ) -> None:
+        ...
+
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
-    def dropna(self, axis=0, inplace=False, how=None):
+    def dropna(
+        self, axis: Axis = 0, inplace: bool = False, how: str | None = None
+    ) -> Series | None:
         """
         Return a new Series with missing values removed.
 
@@ -5288,8 +5753,8 @@ def dropna(self, axis=0, inplace=False, how=None):
 
         Parameters
         ----------
-        axis : {0 or 'index'}, default 0
-            There is only one axis to drop values from.
+        axis : {0 or 'index'}
+            Unused. Parameter needed for compatibility with DataFrame.
         inplace : bool, default False
             If True, do operation inplace and return None.
         how : str, optional
@@ -5361,11 +5826,9 @@ def dropna(self, axis=0, inplace=False, how=None):
             else:
                 return result
         else:
-            if inplace:
-                # do nothing
-                pass
-            else:
+            if not inplace:
                 return self.copy()
+        return None
 
     # ----------------------------------------------------------------------
     # Time series-oriented methods
@@ -5374,11 +5837,11 @@ def dropna(self, axis=0, inplace=False, how=None):
     @doc(NDFrame.asfreq, **_shared_doc_kwargs)  # type: ignore[has-type]
     def asfreq(
         self,
-        freq,
-        method=None,
+        freq: Frequency,
+        method: FillnaOptions | None = None,
         how: str | None = None,
         normalize: bool = False,
-        fill_value=None,
+        fill_value: Hashable = None,
     ) -> Series:
         return super().asfreq(
             freq=freq,
@@ -5393,17 +5856,18 @@ def asfreq(
     def resample(
         self,
         rule,
-        axis=0,
+        axis: Axis = 0,
         closed: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
         loffset=None,
         base: int | None = None,
-        on=None,
-        level=None,
+        on: Level = None,
+        level: Level = None,
         origin: str | TimestampConvertibleTypes = "start_day",
         offset: TimedeltaConvertibleTypes | None = None,
+        group_keys: bool | lib.NoDefault = no_default,
     ) -> Resampler:
         return super().resample(
             rule=rule,
@@ -5418,9 +5882,15 @@ def resample(
             level=level,
             origin=origin,
             offset=offset,
+            group_keys=group_keys,
         )
 
-    def to_timestamp(self, freq=None, how="start", copy=True) -> Series:
+    def to_timestamp(
+        self,
+        freq=None,
+        how: Literal["s", "e", "start", "end"] = "start",
+        copy: bool = True,
+    ) -> Series:
         """
         Cast to DatetimeIndex of Timestamps, at *beginning* of period.
 
@@ -5449,7 +5919,7 @@ def to_timestamp(self, freq=None, how="start", copy=True) -> Series:
             self, method="to_timestamp"
         )
 
-    def to_period(self, freq=None, copy=True) -> Series:
+    def to_period(self, freq: str | None = None, copy: bool = True) -> Series:
         """
         Convert Series from DatetimeIndex to PeriodIndex.
 
@@ -5476,25 +5946,93 @@ def to_period(self, freq=None, copy=True) -> Series:
             self, method="to_period"
         )
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def ffill(
-        self: Series,
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def ffill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def ffill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "ffill" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def ffill(  # type: ignore[override]
+        self,
         axis: None | Axis = None,
         inplace: bool = False,
         limit: None | int = None,
-        downcast=None,
+        downcast: dict | None = None,
     ) -> Series | None:
-        return super().ffill(axis, inplace, limit, downcast)
+        return super().ffill(axis=axis, inplace=inplace, limit=limit, downcast=downcast)
 
-    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    @overload
     def bfill(
-        self: Series,
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[False] = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def bfill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: Literal[True],
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def bfill(
+        self,
+        *,
+        axis: None | Axis = ...,
+        inplace: bool = ...,
+        limit: None | int = ...,
+        downcast: dict | None = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "bfill" incompatible with supertype "NDFrame"
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self"])
+    def bfill(  # type: ignore[override]
+        self,
         axis: None | Axis = None,
         inplace: bool = False,
         limit: None | int = None,
-        downcast=None,
+        downcast: dict | None = None,
     ) -> Series | None:
-        return super().bfill(axis, inplace, limit, downcast)
+        return super().bfill(axis=axis, inplace=inplace, limit=limit, downcast=downcast)
 
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "lower", "upper"]
@@ -5533,35 +6071,137 @@ def interpolate(
             **kwargs,
         )
 
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def where(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: bool = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "where" incompatible with supertype "NDFrame"
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "cond", "other"]
     )
-    def where(
+    def where(  # type: ignore[override]
         self,
         cond,
         other=lib.no_default,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
-        return super().where(cond, other, inplace, axis, level, errors, try_cast)
+        inplace: bool = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = lib.no_default,
+        try_cast: bool | lib.NoDefault = lib.no_default,
+    ) -> Series | None:
+        return super().where(
+            cond,
+            other,
+            inplace=inplace,
+            axis=axis,
+            level=level,
+            try_cast=try_cast,
+        )
 
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[False] = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: Literal[True],
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def mask(
+        self,
+        cond,
+        other=...,
+        *,
+        inplace: bool = ...,
+        axis: Axis | None = ...,
+        level: Level = ...,
+        errors: IgnoreRaise | lib.NoDefault = ...,
+        try_cast: bool | lib.NoDefault = ...,
+    ) -> Series | None:
+        ...
+
+    # error: Signature of "mask" incompatible with supertype "NDFrame"
+    @deprecate_kwarg(old_arg_name="errors", new_arg_name=None)
     @deprecate_nonkeyword_arguments(
         version=None, allowed_args=["self", "cond", "other"]
     )
-    def mask(
+    def mask(  # type: ignore[override]
         self,
         cond,
         other=np.nan,
-        inplace=False,
-        axis=None,
-        level=None,
-        errors=lib.no_default,
-        try_cast=lib.no_default,
-    ):
-        return super().mask(cond, other, inplace, axis, level, errors, try_cast)
+        inplace: bool = False,
+        axis: Axis | None = None,
+        level: Level = None,
+        errors: IgnoreRaise | lib.NoDefault = lib.no_default,
+        try_cast: bool | lib.NoDefault = lib.no_default,
+    ) -> Series | None:
+        return super().mask(
+            cond,
+            other,
+            inplace=inplace,
+            axis=axis,
+            level=level,
+            try_cast=try_cast,
+        )
 
     # ----------------------------------------------------------------------
     # Add index
@@ -5570,7 +6210,7 @@ def mask(
     _info_axis_number = 0
     _info_axis_name = "index"
 
-    index: Index = properties.AxisProperty(
+    index = properties.AxisProperty(
         axis=0, doc="The index (axis labels) of the Series."
     )
 
diff --git a/pandas/core/shared_docs.py b/pandas/core/shared_docs.py
index f79fd3ed09f8d..09c8cf39f5839 100644
--- a/pandas/core/shared_docs.py
+++ b/pandas/core/shared_docs.py
@@ -75,6 +75,11 @@
 keep_equal : bool, default False
     If true, the result keeps values that are equal.
     Otherwise, equal values are shown as NaNs.
+
+result_names : tuple, default ('self', 'other')
+    Set the dataframes names in the comparison.
+
+    .. versionadded:: 1.5.0
 """
 
 _shared_docs[
@@ -96,15 +101,16 @@
     will be used to determine the groups (the Series' values are first
     aligned; see ``.align()`` method). If a list or ndarray of length
     equal to the selected axis is passed (see the `groupby user guide
-    <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`),
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`_),
     the values are used as-is to determine the groups. A label or list
     of labels may be passed to group by the columns in ``self``.
     Notice that a tuple is interpreted as a (single) key.
 axis : {0 or 'index', 1 or 'columns'}, default 0
-    Split along rows (0) or columns (1).
+    Split along rows (0) or columns (1). For `Series` this parameter
+    is unused and defaults to 0.
 level : int, level name, or sequence of such, default None
     If the axis is a MultiIndex (hierarchical), group by a particular
-    level or levels.
+    level or levels. Do not specify both ``by`` and ``level``.
 as_index : bool, default True
     For aggregated output, return object with group labels as the
     index. Only relevant for DataFrame input. as_index=False is
@@ -113,8 +119,20 @@
     Sort group keys. Get better performance by turning this off.
     Note this does not influence the order of observations within each
     group. Groupby preserves the order of rows within each group.
-group_keys : bool, default True
-    When calling apply, add group keys to index to identify pieces.
+group_keys : bool, optional
+    When calling apply and the ``by`` argument produces a like-indexed
+    (i.e. :ref:`a transform <groupby.transform>`) result, add group keys to
+    index to identify pieces. By default group keys are not included
+    when the result's index (and column) labels match the inputs, and
+    are included otherwise. This argument has no effect if the result produced
+    is not like-indexed with respect to the input.
+
+    .. versionchanged:: 1.5.0
+
+       Warns that `group_keys` will no longer be ignored when the
+       result from ``apply`` is a like-indexed Series or DataFrame.
+       Specify ``group_keys`` explicitly to include the group keys or
+       not.
 squeeze : bool, default False
     Reduce the dimensionality of the return type if possible,
     otherwise return a consistent type.
@@ -195,6 +213,10 @@
 DataFrame.explode : Explode a DataFrame from list-like
         columns to long format.
 
+Notes
+-----
+Reference :ref:`the user guide <reshaping.melt>` for more examples.
+
 Examples
 --------
 >>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
@@ -267,9 +289,7 @@
 _shared_docs[
     "transform"
 ] = """
-Call ``func`` on self producing a {klass} with transformed values.
-
-Produced {klass} will have same axis length as self.
+Call ``func`` on self producing a {klass} with the same axis shape as self.
 
 Parameters
 ----------
@@ -398,38 +418,55 @@
 ] = """storage_options : dict, optional
     Extra options that make sense for a particular storage connection, e.g.
     host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
-    are forwarded to ``urllib`` as header options. For other URLs (e.g.
-    starting with "s3://", and "gcs://") the key-value pairs are forwarded to
-    ``fsspec``. Please see ``fsspec`` and ``urllib`` for more details."""
+    are forwarded to ``urllib.request.Request`` as header options. For other
+    URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
+    forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
+    details, and for more examples on storage options refer `here
+    <https://pandas.pydata.org/docs/user_guide/io.html?
+    highlight=storage_options#reading-writing-remote-files>`_."""
 
 _shared_docs[
     "compression_options"
 ] = """compression : str or dict, default 'infer'
-    For on-the-fly compression of the output data. If 'infer' and '%s'
+    For on-the-fly compression of the output data. If 'infer' and '%s' is
     path-like, then detect compression from the following extensions: '.gz',
-    '.bz2', '.zip', '.xz', or '.zst' (otherwise no compression). Set to
-    ``None`` for no compression. Can also be a dict with key ``'method'`` set
-    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``} and other
-    key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``,
-    ``bz2.BZ2File``, or ``zstandard.ZstdDecompressor``, respectively. As an
-    example, the following could be passed for faster compression and to create
+    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
+    (otherwise no compression).
+    Set to ``None`` for no compression.
+    Can also be a dict with key ``'method'`` set
+    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'tar'``} and other
+    key-value pairs are forwarded to
+    ``zipfile.ZipFile``, ``gzip.GzipFile``,
+    ``bz2.BZ2File``, ``zstandard.ZstdCompressor`` or
+    ``tarfile.TarFile``, respectively.
+    As an example, the following could be passed for faster compression and to create
     a reproducible gzip archive:
-    ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``."""
+    ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.
+
+        .. versionadded:: 1.5.0
+            Added support for `.tar` files."""
 
 _shared_docs[
     "decompression_options"
 ] = """compression : str or dict, default 'infer'
     For on-the-fly decompression of on-disk data. If 'infer' and '%s' is
     path-like, then detect compression from the following extensions: '.gz',
-    '.bz2', '.zip', '.xz', or '.zst' (otherwise no compression). If using
-    'zip', the ZIP file must contain only one data file to be read in. Set to
-    ``None`` for no decompression. Can also be a dict with key ``'method'`` set
-    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``} and other
-    key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``,
-    ``bz2.BZ2File``, or ``zstandard.ZstdDecompressor``, respectively. As an
-    example, the following could be passed for Zstandard decompression using a
+    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
+    (otherwise no compression).
+    If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
+    Set to ``None`` for no decompression.
+    Can also be a dict with key ``'method'`` set
+    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'tar'``} and other
+    key-value pairs are forwarded to
+    ``zipfile.ZipFile``, ``gzip.GzipFile``,
+    ``bz2.BZ2File``, ``zstandard.ZstdDecompressor`` or
+    ``tarfile.TarFile``, respectively.
+    As an example, the following could be passed for Zstandard decompression using a
     custom compression dictionary:
-    ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``."""
+    ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
+
+        .. versionadded:: 1.5.0
+            Added support for `.tar` files."""
 
 _shared_docs[
     "replace"
@@ -468,8 +505,8 @@
             - Dicts can be used to specify different replacement values
               for different existing values. For example,
               ``{{'a': 'b', 'y': 'z'}}`` replaces the value 'a' with 'b' and
-              'y' with 'z'. To use a dict in this way the `value`
-              parameter should be `None`.
+              'y' with 'z'. To use a dict in this way, the optional `value`
+              parameter should not be given.
             - For a DataFrame a dict can specify that different values
               should be replaced in different columns. For example,
               ``{{'a': 1, 'b': 'z'}}`` looks for the value 1 in column 'a'
@@ -480,8 +517,8 @@
               specifying the column to search in.
             - For a DataFrame nested dictionaries, e.g.,
               ``{{'a': {{'b': np.nan}}}}``, are read as follows: look in column
-              'a' for the value 'b' and replace it with NaN. The `value`
-              parameter should be ``None`` to use a nested dict in this
+              'a' for the value 'b' and replace it with NaN. The optional `value`
+              parameter should not be specified to use a nested dict in this
               way. You can nest regular expressions as well. Note that
               column names (the top-level dictionary keys in a nested
               dictionary) **cannot** be regular expressions.
@@ -509,7 +546,7 @@
         string. Alternatively, this could be a regular expression or a
         list, dict, or array of regular expressions in which case
         `to_replace` must be ``None``.
-    method : {{'pad', 'ffill', 'bfill', `None`}}
+    method : {{'pad', 'ffill', 'bfill'}}
         The method to use when for replacement, when `to_replace` is a
         scalar, list or tuple and `value` is ``None``.
 
@@ -720,3 +757,137 @@
         .. versionchanged:: 1.4.0
             Previously the explicit ``None`` was silently ignored.
 """
+
+_shared_docs[
+    "idxmin"
+] = """
+    Return index of first occurrence of minimum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {{0 or 'index', 1 or 'columns'}}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+    numeric_only : bool, default {numeric_only_default}
+        Include only `float`, `int` or `boolean` data.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    Series
+        Indexes of minima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmin : Return index of the minimum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmin``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],
+    ...                    'co2_emissions': [37.2, 19.66, 1712]}},
+    ...                    index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the minimum value in each column.
+
+    >>> df.idxmin()
+    consumption                Pork
+    co2_emissions    Wheat Products
+    dtype: object
+
+    To return the index for the minimum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmin(axis="columns")
+    Pork                consumption
+    Wheat Products    co2_emissions
+    Beef                consumption
+    dtype: object
+"""
+
+_shared_docs[
+    "idxmax"
+] = """
+    Return index of first occurrence of maximum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {{0 or 'index', 1 or 'columns'}}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+    numeric_only : bool, default {numeric_only_default}
+        Include only `float`, `int` or `boolean` data.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    Series
+        Indexes of maxima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmax : Return index of the maximum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmax``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],
+    ...                    'co2_emissions': [37.2, 19.66, 1712]}},
+    ...                    index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the maximum value in each column.
+
+    >>> df.idxmax()
+    consumption     Wheat Products
+    co2_emissions             Beef
+    dtype: object
+
+    To return the index for the maximum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmax(axis="columns")
+    Pork              co2_emissions
+    Wheat Products     consumption
+    Beef              co2_emissions
+    dtype: object
+"""
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 7813182222d67..1d1a93b8d1ce2 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -9,7 +9,9 @@
     Hashable,
     Iterable,
     Sequence,
+    cast,
 )
+import warnings
 
 import numpy as np
 
@@ -21,7 +23,10 @@
 from pandas._libs.hashtable import unique_label_indices
 from pandas._typing import (
     IndexKeyFunc,
+    Level,
+    NaPosition,
     Shape,
+    SortKind,
     npt,
 )
 
@@ -40,18 +45,19 @@
 
 if TYPE_CHECKING:
     from pandas import MultiIndex
+    from pandas.core.arrays import ExtensionArray
     from pandas.core.indexes.base import Index
 
 
 def get_indexer_indexer(
     target: Index,
-    level: str | int | list[str] | list[int],
-    ascending: Sequence[bool | int] | bool | int,
-    kind: str,
-    na_position: str,
+    level: Level | list[Level] | None,
+    ascending: Sequence[bool] | bool,
+    kind: SortKind,
+    na_position: NaPosition,
     sort_remaining: bool,
     key: IndexKeyFunc,
-) -> np.ndarray | None:
+) -> npt.NDArray[np.intp] | None:
     """
     Helper method that return the indexer according to input parameters for
     the sort_index method of DataFrame and Series.
@@ -68,7 +74,7 @@ def get_indexer_indexer(
 
     Returns
     -------
-    Optional[ndarray]
+    Optional[ndarray[intp]]
         The indexer for the new index.
     """
 
@@ -90,8 +96,12 @@ def get_indexer_indexer(
         ):
             return None
 
+        # ascending can only be a Sequence for MultiIndex
         indexer = nargsort(
-            target, kind=kind, ascending=ascending, na_position=na_position
+            target,
+            kind=kind,
+            ascending=cast(bool, ascending),
+            na_position=na_position,
         )
     return indexer
 
@@ -214,7 +224,7 @@ def get_compressed_ids(
     return compress_group_index(ids, sort=True)
 
 
-def is_int64_overflow_possible(shape) -> bool:
+def is_int64_overflow_possible(shape: Shape) -> bool:
     the_prod = 1
     for x in shape:
         the_prod *= int(x)
@@ -222,7 +232,9 @@ def is_int64_overflow_possible(shape) -> bool:
     return the_prod >= lib.i8max
 
 
-def decons_group_index(comp_labels, shape):
+def _decons_group_index(
+    comp_labels: npt.NDArray[np.intp], shape: Shape
+) -> list[npt.NDArray[np.intp]]:
     # reconstruct labels
     if is_int64_overflow_possible(shape):
         # at some point group indices are factorized,
@@ -231,7 +243,7 @@ def decons_group_index(comp_labels, shape):
 
     label_list = []
     factor = 1
-    y = 0
+    y = np.array(0)
     x = comp_labels
     for i in reversed(range(len(shape))):
         labels = (x - y) % (factor * shape[i]) // factor
@@ -243,24 +255,32 @@ def decons_group_index(comp_labels, shape):
 
 
 def decons_obs_group_ids(
-    comp_ids: npt.NDArray[np.intp], obs_ids, shape, labels, xnull: bool
-):
+    comp_ids: npt.NDArray[np.intp],
+    obs_ids: npt.NDArray[np.intp],
+    shape: Shape,
+    labels: Sequence[npt.NDArray[np.signedinteger]],
+    xnull: bool,
+) -> list[npt.NDArray[np.intp]]:
     """
     Reconstruct labels from observed group ids.
 
     Parameters
     ----------
     comp_ids : np.ndarray[np.intp]
+    obs_ids: np.ndarray[np.intp]
+    shape : tuple[int]
+    labels : Sequence[np.ndarray[np.signedinteger]]
     xnull : bool
         If nulls are excluded; i.e. -1 labels are passed through.
     """
     if not xnull:
-        lift = np.fromiter(((a == -1).any() for a in labels), dtype="i8")
-        shape = np.asarray(shape, dtype="i8") + lift
+        lift = np.fromiter(((a == -1).any() for a in labels), dtype=np.intp)
+        arr_shape = np.asarray(shape, dtype=np.intp) + lift
+        shape = tuple(arr_shape)
 
     if not is_int64_overflow_possible(shape):
         # obs ids are deconstructable! take the fast route!
-        out = decons_group_index(obs_ids, shape)
+        out = _decons_group_index(obs_ids, shape)
         return out if xnull or not lift.any() else [x - y for x, y in zip(out, lift)]
 
     indexer = unique_label_indices(comp_ids)
@@ -320,7 +340,14 @@ def lexsort_indexer(
     keys = [ensure_key_mapped(k, key) for k in keys]
 
     for k, order in zip(keys, orders):
-        cat = Categorical(k, ordered=True)
+        with warnings.catch_warnings():
+            # TODO(2.0): unnecessary once deprecation is enforced
+            # GH#45618 don't issue warning user can't do anything about
+            warnings.filterwarnings(
+                "ignore", ".*(SparseArray|SparseDtype).*", category=FutureWarning
+            )
+
+            cat = Categorical(k, ordered=True)
 
         if na_position not in ["last", "first"]:
             raise ValueError(f"invalid na_position: {na_position}")
@@ -354,7 +381,7 @@ def nargsort(
     ascending: bool = True,
     na_position: str = "last",
     key: Callable | None = None,
-    mask: np.ndarray | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
 ) -> npt.NDArray[np.intp]:
     """
     Intended to be a drop-in replacement for np.argsort which handles NaNs.
@@ -369,7 +396,7 @@ def nargsort(
     ascending : bool, default True
     na_position : {'first', 'last'}, default 'last'
     key : Optional[Callable], default None
-    mask : Optional[np.ndarray], default None
+    mask : Optional[np.ndarray[bool]], default None
         Passed when called by ExtensionArray.argsort.
 
     Returns
@@ -422,7 +449,7 @@ def nargsort(
     return ensure_platform_int(indexer)
 
 
-def nargminmax(values, method: str, axis: int = 0):
+def nargminmax(values: ExtensionArray, method: str, axis: int = 0):
     """
     Implementation of np.argmin/argmax but for ExtensionArray and which
     handles missing values.
@@ -441,21 +468,21 @@ def nargminmax(values, method: str, axis: int = 0):
     func = np.argmax if method == "argmax" else np.argmin
 
     mask = np.asarray(isna(values))
-    values = values._values_for_argsort()
+    arr_values = values._values_for_argsort()
 
-    if values.ndim > 1:
+    if arr_values.ndim > 1:
         if mask.any():
             if axis == 1:
-                zipped = zip(values, mask)
+                zipped = zip(arr_values, mask)
             else:
-                zipped = zip(values.T, mask.T)
+                zipped = zip(arr_values.T, mask.T)
             return np.array([_nanargminmax(v, m, func) for v, m in zipped])
-        return func(values, axis=axis)
+        return func(arr_values, axis=axis)
 
-    return _nanargminmax(values, mask, func)
+    return _nanargminmax(arr_values, mask, func)
 
 
-def _nanargminmax(values, mask, func) -> int:
+def _nanargminmax(values: np.ndarray, mask: npt.NDArray[np.bool_], func) -> int:
     """
     See nanargminmax.__doc__.
     """
@@ -570,7 +597,7 @@ def get_flattened_list(
     arrays: DefaultDict[int, list[int]] = defaultdict(list)
     for labs, level in zip(labels, levels):
         table = hashtable.Int64HashTable(ngroups)
-        table.map(comp_ids, labs.astype(np.int64, copy=False))
+        table.map_keys_to_values(comp_ids, labs.astype(np.int64, copy=False))
         for i in range(ngroups):
             arrays[i].append(level[table.get_item(i)])
     return [tuple(array) for array in arrays.values()]
@@ -585,9 +612,9 @@ def get_indexer_dict(
     dict:
         Labels mapped to indexers.
     """
-    shape = [len(x) for x in keys]
+    shape = tuple(len(x) for x in keys)
 
-    group_index = get_group_index(label_list, tuple(shape), sort=True, xnull=True)
+    group_index = get_group_index(label_list, shape, sort=True, xnull=True)
     if np.all(group_index == -1):
         # Short-circuit, lib.indices_fast will return the same
         return {}
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index d5abd1606edec..7f50381d10efd 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -17,8 +17,12 @@
 from pandas._typing import (
     DtypeObj,
     F,
+    Scalar,
+)
+from pandas.util._decorators import (
+    Appender,
+    deprecate_nonkeyword_arguments,
 )
-from pandas.util._decorators import Appender
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
@@ -171,7 +175,7 @@ class StringMethods(NoNewAttributesMixin):
     # * cat
     # * extractall
 
-    def __init__(self, data):
+    def __init__(self, data) -> None:
         from pandas.core.arrays.string_ import StringDtype
 
         self._inferred_dtype = self._validate(data)
@@ -580,10 +584,11 @@ def cat(
             data = ensure_object(data)  # type: ignore[assignment]
             na_mask = isna(data)
             if na_rep is None and na_mask.any():
-                data = data[~na_mask]
+                return sep.join(data[~na_mask])
             elif na_rep is not None and na_mask.any():
-                data = np.where(na_mask, na_rep, data)
-            return sep.join(data)
+                return sep.join(np.where(na_mask, na_rep, data))
+            else:
+                return sep.join(data)
 
         try:
             # turn anything in "others" into lists of Series
@@ -658,8 +663,8 @@ def cat(
 
     Parameters
     ----------
-    pat : str or compiled regex, optional
-        String or regular expression to split on.
+    pat : str%(pat_regex)s, optional
+        %(pat_description)s.
         If not specified, split on whitespace.
     n : int, default -1 (all)
         Limit number of splits in output.
@@ -669,28 +674,12 @@ def cat(
 
         - If ``True``, return DataFrame/MultiIndex expanding dimensionality.
         - If ``False``, return Series/Index, containing lists of strings.
-
-    regex : bool, default None
-        Determines if the passed-in pattern is a regular expression:
-
-        - If ``True``, assumes the passed-in pattern is a regular expression
-        - If ``False``, treats the pattern as a literal string.
-        - If ``None`` and `pat` length is 1, treats `pat` as a literal string.
-        - If ``None`` and `pat` length is not 1, treats `pat` as a regular expression.
-        - Cannot be set to False if `pat` is a compiled regex
-
-        .. versionadded:: 1.4.0
-
+    %(regex_argument)s
     Returns
     -------
     Series, Index, DataFrame or MultiIndex
         Type matches caller unless ``expand=True`` (see Notes).
-
-    Raises
-    ------
-    ValueError
-        * if `regex` is False and `pat` is a compiled regex
-
+    %(raises_split)s
     See Also
     --------
     Series.str.split : Split strings around given separator/delimiter.
@@ -712,10 +701,7 @@ def cat(
 
     If using ``expand=True``, Series and Index callers return DataFrame and
     MultiIndex objects, respectively.
-
-    Use of `regex=False` with a `pat` as a compiled regex will raise
-    an error.
-
+    %(regex_pat_note)s
     Examples
     --------
     >>> s = pd.Series(
@@ -789,7 +775,37 @@ def cat(
     0          this is a regular sentence        None
     1  https://docs.python.org/3/tutorial  index.html
     2                                 NaN         NaN
+    %(regex_examples)s"""
+
+    @Appender(
+        _shared_docs["str_split"]
+        % {
+            "side": "beginning",
+            "pat_regex": " or compiled regex",
+            "pat_description": "String or regular expression to split on",
+            "regex_argument": """
+    regex : bool, default None
+        Determines if the passed-in pattern is a regular expression:
+
+        - If ``True``, assumes the passed-in pattern is a regular expression
+        - If ``False``, treats the pattern as a literal string.
+        - If ``None`` and `pat` length is 1, treats `pat` as a literal string.
+        - If ``None`` and `pat` length is not 1, treats `pat` as a regular expression.
+        - Cannot be set to False if `pat` is a compiled regex
 
+        .. versionadded:: 1.4.0
+         """,
+            "raises_split": """
+                      Raises
+                      ------
+                      ValueError
+                          * if `regex` is False and `pat` is a compiled regex
+                      """,
+            "regex_pat_note": """
+    Use of `regex =False` with a `pat` as a compiled regex will raise an error.
+            """,
+            "method": "split",
+            "regex_examples": r"""
     Remember to escape special characters when explicitly using regular expressions.
 
     >>> s = pd.Series(["foo and bar plus baz"])
@@ -828,9 +844,10 @@ def cat(
     >>> s.str.split(r"\.jpg", regex=False, expand=True)
                    0
     0  foojpgbar.jpg
-    """
-
-    @Appender(_shared_docs["str_split"] % {"side": "beginning", "method": "split"})
+    """,
+        }
+    )
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "pat"])
     @forbid_nonstring_types(["bytes"])
     def split(
         self,
@@ -849,7 +866,20 @@ def split(
         result = self._data.array._str_split(pat, n, expand, regex)
         return self._wrap_result(result, returns_string=expand, expand=expand)
 
-    @Appender(_shared_docs["str_split"] % {"side": "end", "method": "rsplit"})
+    @Appender(
+        _shared_docs["str_split"]
+        % {
+            "side": "end",
+            "pat_regex": "",
+            "pat_description": "String to split on",
+            "regex_argument": "",
+            "raises_split": "",
+            "regex_pat_note": "",
+            "method": "rsplit",
+            "regex_examples": "",
+        }
+    )
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "pat"])
     @forbid_nonstring_types(["bytes"])
     def rsplit(self, pat=None, n=-1, expand=False):
         result = self._data.array._str_rsplit(pat, n=n)
@@ -967,15 +997,15 @@ def rpartition(self, sep=" ", expand=True):
 
     def get(self, i):
         """
-        Extract element from each component at specified position.
+        Extract element from each component at specified position or with specified key.
 
-        Extract element from lists, tuples, or strings in each element in the
+        Extract element from lists, tuples, dict, or strings in each element in the
         Series/Index.
 
         Parameters
         ----------
-        i : int
-            Position of element to extract.
+        i : int or hashable dict label
+            Position or key of element to extract.
 
         Returns
         -------
@@ -1015,6 +1045,15 @@ def get(self, i):
         4    NaN
         5    None
         dtype: object
+
+        Return element with given key
+
+        >>> s = pd.Series([{"name": "Hello", "value": "World"},
+        ...               {"name": "Goodbye", "value": "Planet"}])
+        >>> s.str.get('name')
+        0      Hello
+        1    Goodbye
+        dtype: object
         """
         result = self._data.array._str_get(i)
         return self._wrap_result(result)
@@ -1659,19 +1698,23 @@ def zfill(self, width):
 
         Note that ``10`` and ``NaN`` are not strings, therefore they are
         converted to ``NaN``. The minus sign in ``'-1'`` is treated as a
-        regular character and the zero is added to the left of it
+        special character and the zero is added to the right of it
         (:meth:`str.zfill` would have moved it to the left). ``1000``
         remains unchanged as it is longer than `width`.
 
         >>> s.str.zfill(3)
-        0     0-1
+        0     -01
         1     001
         2    1000
         3     NaN
         4     NaN
         dtype: object
         """
-        result = self.pad(width, side="left", fillchar="0")
+        if not is_integer(width):
+            msg = f"width must be of integer type, not {type(width).__name__}"
+            raise TypeError(msg)
+        f = lambda x: x.zfill(width)
+        result = self._data.array._str_map(f)
         return self._wrap_result(result)
 
     def slice(self, start=None, stop=None, step=None):
@@ -1879,6 +1922,7 @@ def encode(self, encoding, errors="strict"):
 
     Strip whitespaces (including newlines) or a set of specified characters
     from each string in the Series/Index from %(side)s.
+    Replaces any non-strings in Series with NaNs.
     Equivalent to :meth:`str.%(method)s`.
 
     Parameters
@@ -1900,12 +1944,14 @@ def encode(self, encoding, errors="strict"):
 
     Examples
     --------
-    >>> s = pd.Series(['1. Ant.  ', '2. Bee!\n', '3. Cat?\t', np.nan])
+    >>> s = pd.Series(['1. Ant.  ', '2. Bee!\n', '3. Cat?\t', np.nan, 10, True])
     >>> s
     0    1. Ant.
     1    2. Bee!\n
     2    3. Cat?\t
     3          NaN
+    4           10
+    5         True
     dtype: object
 
     >>> s.str.strip()
@@ -1913,6 +1959,8 @@ def encode(self, encoding, errors="strict"):
     1    2. Bee!
     2    3. Cat?
     3        NaN
+    4        NaN
+    5        NaN
     dtype: object
 
     >>> s.str.lstrip('123.')
@@ -1920,6 +1968,8 @@ def encode(self, encoding, errors="strict"):
     1    Bee!\n
     2    Cat?\t
     3       NaN
+    4       NaN
+    5       NaN
     dtype: object
 
     >>> s.str.rstrip('.!? \n\t')
@@ -1927,6 +1977,8 @@ def encode(self, encoding, errors="strict"):
     1    2. Bee
     2    3. Cat
     3       NaN
+    4       NaN
+    5       NaN
     dtype: object
 
     >>> s.str.strip('123.!? \n\t')
@@ -1934,6 +1986,8 @@ def encode(self, encoding, errors="strict"):
     1    Bee
     2    Cat
     3    NaN
+    4    NaN
+    5    NaN
     dtype: object
     """
 
@@ -1971,8 +2025,9 @@ def rstrip(self, to_strip=None):
     _shared_docs[
         "str_removefix"
     ] = r"""
-    Remove a %(side)s from an object series. If the %(side)s is not present,
-    the original string will be returned.
+    Remove a %(side)s from an object series.
+
+    If the %(side)s is not present, the original string will be returned.
 
     Parameters
     ----------
@@ -2228,7 +2283,9 @@ def count(self, pat, flags=0):
         return self._wrap_result(result, returns_string=False)
 
     @forbid_nonstring_types(["bytes"])
-    def startswith(self, pat, na=None):
+    def startswith(
+        self, pat: str | tuple[str, ...], na: Scalar | None = None
+    ) -> Series | Index:
         """
         Test if the start of each string element matches a pattern.
 
@@ -2236,8 +2293,9 @@ def startswith(self, pat, na=None):
 
         Parameters
         ----------
-        pat : str
-            Character sequence. Regular expressions are not accepted.
+        pat : str or tuple[str, ...]
+            Character sequence or tuple of strings. Regular expressions are not
+            accepted.
         na : object, default NaN
             Object shown if element tested is not a string. The default depends
             on dtype of the array. For object-dtype, ``numpy.nan`` is used.
@@ -2272,6 +2330,13 @@ def startswith(self, pat, na=None):
         3      NaN
         dtype: object
 
+        >>> s.str.startswith(('b', 'B'))
+        0     True
+        1     True
+        2    False
+        3      NaN
+        dtype: object
+
         Specifying `na` to be `False` instead of `NaN`.
 
         >>> s.str.startswith('b', na=False)
@@ -2281,11 +2346,16 @@ def startswith(self, pat, na=None):
         3    False
         dtype: bool
         """
+        if not isinstance(pat, (str, tuple)):
+            msg = f"expected a string or tuple, not {type(pat).__name__}"
+            raise TypeError(msg)
         result = self._data.array._str_startswith(pat, na=na)
         return self._wrap_result(result, returns_string=False)
 
     @forbid_nonstring_types(["bytes"])
-    def endswith(self, pat, na=None):
+    def endswith(
+        self, pat: str | tuple[str, ...], na: Scalar | None = None
+    ) -> Series | Index:
         """
         Test if the end of each string element matches a pattern.
 
@@ -2293,8 +2363,9 @@ def endswith(self, pat, na=None):
 
         Parameters
         ----------
-        pat : str
-            Character sequence. Regular expressions are not accepted.
+        pat : str or tuple[str, ...]
+            Character sequence or tuple of strings. Regular expressions are not
+            accepted.
         na : object, default NaN
             Object shown if element tested is not a string. The default depends
             on dtype of the array. For object-dtype, ``numpy.nan`` is used.
@@ -2329,6 +2400,13 @@ def endswith(self, pat, na=None):
         3      NaN
         dtype: object
 
+        >>> s.str.endswith(('t', 'T'))
+        0     True
+        1    False
+        2     True
+        3      NaN
+        dtype: object
+
         Specifying `na` to be `False` instead of `NaN`.
 
         >>> s.str.endswith('t', na=False)
@@ -2338,6 +2416,9 @@ def endswith(self, pat, na=None):
         3    False
         dtype: bool
         """
+        if not isinstance(pat, (str, tuple)):
+            msg = f"expected a string or tuple, not {type(pat).__name__}"
+            raise TypeError(msg)
         result = self._data.array._str_endswith(pat, na=na)
         return self._wrap_result(result, returns_string=False)
 
diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index 6b0380a292f07..f884264e9ab75 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -62,7 +62,7 @@ def _str_map(
             na_value = self._str_na_value
 
         if not len(self):
-            return np.ndarray(0, dtype=dtype)
+            return np.array([], dtype=dtype)
 
         arr = np.asarray(self, dtype=object)
         mask = isna(arr)
@@ -360,7 +360,7 @@ def _str_get_dummies(self, sep="|"):
         arr = Series(self).fillna("")
         try:
             arr = sep + arr + sep
-        except TypeError:
+        except (TypeError, NotImplementedError):
             arr = sep + arr.astype(str) + sep
 
         tags: set[str] = set()
@@ -434,9 +434,9 @@ def _str_rstrip(self, to_strip=None):
         return self._str_map(lambda x: x.rstrip(to_strip))
 
     def _str_removeprefix(self, prefix: str) -> Series:
-        # outstanding question on whether to use native methods for users
-        # on Python 3.9+ https://git.io/JE9QK, in which case we could do
-        # return self._str_map(str.removeprefix)
+        # outstanding question on whether to use native methods for users on Python 3.9+
+        # https://github.com/pandas-dev/pandas/pull/39226#issuecomment-836719770,
+        # in which case we could do return self._str_map(str.removeprefix)
 
         def removeprefix(text: str) -> str:
             if text.startswith(prefix):
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 4d9420fc0510d..4739fb49e0d07 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -10,8 +10,9 @@
     Hashable,
     List,
     Tuple,
-    TypeVar,
+    TypedDict,
     Union,
+    cast,
     overload,
 )
 import warnings
@@ -23,12 +24,12 @@
     OutOfBoundsDatetime,
     Timedelta,
     Timestamp,
-    conversion,
     iNaT,
     nat_strings,
     parsing,
+    timezones,
 )
-from pandas._libs.tslibs.parsing import (  # noqa:F401
+from pandas._libs.tslibs.parsing import (
     DateParseError,
     format_is_iso,
     guess_datetime_format,
@@ -37,7 +38,9 @@
 from pandas._typing import (
     AnyArrayLike,
     ArrayLike,
+    DateTimeErrorChoices,
     Timezone,
+    npt,
 )
 from pandas.util._exceptions import find_stack_level
 
@@ -65,6 +68,7 @@
 )
 from pandas.core import algorithms
 from pandas.core.algorithms import unique
+from pandas.core.arrays.base import ExtensionArray
 from pandas.core.arrays.datetimes import (
     maybe_convert_dtype,
     objects_to_datetime64ns,
@@ -76,27 +80,55 @@
 
 if TYPE_CHECKING:
     from pandas._libs.tslibs.nattype import NaTType
+    from pandas._libs.tslibs.timedeltas import UnitChoices
 
-    from pandas import Series
+    from pandas import (
+        DataFrame,
+        Series,
+    )
 
 # ---------------------------------------------------------------------
 # types used in annotations
 
-ArrayConvertible = Union[List, Tuple, AnyArrayLike, "Series"]
-Scalar = Union[int, float, str]
-DatetimeScalar = TypeVar("DatetimeScalar", Scalar, datetime)
+ArrayConvertible = Union[List, Tuple, AnyArrayLike]
+Scalar = Union[float, str]
+DatetimeScalar = Union[Scalar, datetime]
+
 DatetimeScalarOrArrayConvertible = Union[DatetimeScalar, ArrayConvertible]
+
+DatetimeDictArg = Union[List[Scalar], Tuple[Scalar, ...], AnyArrayLike]
+
+
+class YearMonthDayDict(TypedDict, total=True):
+    year: DatetimeDictArg
+    month: DatetimeDictArg
+    day: DatetimeDictArg
+
+
+class FulldatetimeDict(YearMonthDayDict, total=False):
+    hour: DatetimeDictArg
+    hours: DatetimeDictArg
+    minute: DatetimeDictArg
+    minutes: DatetimeDictArg
+    second: DatetimeDictArg
+    seconds: DatetimeDictArg
+    ms: DatetimeDictArg
+    us: DatetimeDictArg
+    ns: DatetimeDictArg
+
+
+DictConvertible = Union[FulldatetimeDict, "DataFrame"]
 start_caching_at = 50
 
 
 # ---------------------------------------------------------------------
 
 
-def _guess_datetime_format_for_array(arr, **kwargs):
+def _guess_datetime_format_for_array(arr, dayfirst: bool | None = False):
     # Try to guess the format based on the first non-NaN element
     non_nan_elements = notna(arr).nonzero()[0]
     if len(non_nan_elements):
-        return guess_datetime_format(arr[non_nan_elements[0]], **kwargs)
+        return guess_datetime_format(arr[non_nan_elements[0]], dayfirst=dayfirst)
 
 
 def should_cache(
@@ -195,7 +227,11 @@ def _maybe_cache(
         unique_dates = unique(arg)
         if len(unique_dates) < len(arg):
             cache_dates = convert_listlike(unique_dates, format)
-            cache_array = Series(cache_dates, index=unique_dates)
+            # GH#45319
+            try:
+                cache_array = Series(cache_dates, index=unique_dates)
+            except OutOfBoundsDatetime:
+                return cache_array
             # GH#39882 and GH#35888 in case of None and NaT we get duplicates
             if not cache_array.index.is_unique:
                 cache_array = cache_array[~cache_array.index.duplicated()]
@@ -234,7 +270,7 @@ def _box_as_indexlike(
 def _convert_and_box_cache(
     arg: DatetimeScalarOrArrayConvertible,
     cache_array: Series,
-    name: str | None = None,
+    name: Hashable | None = None,
 ) -> Index:
     """
     Convert array of dates with a cache and wrap the result in an Index.
@@ -364,7 +400,7 @@ def _convert_listlike_datetimes(
     # NB: this must come after unit transformation
     orig_arg = arg
     try:
-        arg, _ = maybe_convert_dtype(arg, copy=False)
+        arg, _ = maybe_convert_dtype(arg, copy=False, tz=timezones.maybe_get_tz(tz))
     except TypeError:
         if errors == "coerce":
             npvalues = np.array(["NaT"], dtype="datetime64[ns]").repeat(len(arg))
@@ -435,8 +471,6 @@ def _array_strptime_with_fallback(
 
     try:
         result, timezones = array_strptime(arg, fmt, exact=exact, errors=errors)
-        if "%Z" in fmt or "%z" in fmt:
-            return _return_parsed_timezone_results(result, timezones, tz, name)
     except OutOfBoundsDatetime:
         if errors == "raise":
             raise
@@ -462,6 +496,9 @@ def _array_strptime_with_fallback(
         else:
             # Indicates to the caller to fallback to objects_to_datetime64ns
             return None
+    else:
+        if "%Z" in fmt or "%z" in fmt:
+            return _return_parsed_timezone_results(result, timezones, tz, name)
 
     return _box_as_indexlike(result, utc=utc, name=name)
 
@@ -480,38 +517,28 @@ def _to_datetime_with_format(
     Try parsing with the given format, returning None on failure.
     """
     result = None
-    try:
-        # shortcut formatting here
-        if fmt == "%Y%m%d":
-            # pass orig_arg as float-dtype may have been converted to
-            # datetime64[ns]
-            orig_arg = ensure_object(orig_arg)
-            try:
-                # may return None without raising
-                result = _attempt_YYYYMMDD(orig_arg, errors=errors)
-            except (ValueError, TypeError, OutOfBoundsDatetime) as err:
-                raise ValueError(
-                    "cannot convert the input to '%Y%m%d' date format"
-                ) from err
-            if result is not None:
-                utc = tz == "utc"
-                return _box_as_indexlike(result, utc=utc, name=name)
 
-        # fallback
-        res = _array_strptime_with_fallback(
-            arg, name, tz, fmt, exact, errors, infer_datetime_format
-        )
-        return res
-
-    except ValueError as err:
-        # Fallback to try to convert datetime objects if timezone-aware
-        #  datetime objects are found without passing `utc=True`
+    # shortcut formatting here
+    if fmt == "%Y%m%d":
+        # pass orig_arg as float-dtype may have been converted to
+        # datetime64[ns]
+        orig_arg = ensure_object(orig_arg)
         try:
-            values, tz = conversion.datetime_to_datetime64(arg)
-            dta = DatetimeArray(values, dtype=tz_to_dtype(tz))
-            return DatetimeIndex._simple_new(dta, name=name)
-        except (ValueError, TypeError):
-            raise err
+            # may return None without raising
+            result = _attempt_YYYYMMDD(orig_arg, errors=errors)
+        except (ValueError, TypeError, OutOfBoundsDatetime) as err:
+            raise ValueError(
+                "cannot convert the input to '%Y%m%d' date format"
+            ) from err
+        if result is not None:
+            utc = tz == "utc"
+            return _box_as_indexlike(result, utc=utc, name=name)
+
+    # fallback
+    res = _array_strptime_with_fallback(
+        arg, name, tz, fmt, exact, errors, infer_datetime_format
+    )
+    return res
 
 
 def _to_datetime_with_unit(arg, unit, name, tz, errors: str) -> Index:
@@ -627,7 +654,7 @@ def _adjust_to_origin(arg, origin, unit):
 @overload
 def to_datetime(
     arg: DatetimeScalar,
-    errors: str = ...,
+    errors: DateTimeErrorChoices = ...,
     dayfirst: bool = ...,
     yearfirst: bool = ...,
     utc: bool | None = ...,
@@ -637,14 +664,14 @@ def to_datetime(
     infer_datetime_format: bool = ...,
     origin=...,
     cache: bool = ...,
-) -> DatetimeScalar | NaTType:
+) -> Timestamp:
     ...
 
 
 @overload
 def to_datetime(
-    arg: Series,
-    errors: str = ...,
+    arg: Series | DictConvertible,
+    errors: DateTimeErrorChoices = ...,
     dayfirst: bool = ...,
     yearfirst: bool = ...,
     utc: bool | None = ...,
@@ -660,8 +687,8 @@ def to_datetime(
 
 @overload
 def to_datetime(
-    arg: list | tuple | np.ndarray,
-    errors: str = ...,
+    arg: list | tuple | Index | ArrayLike,
+    errors: DateTimeErrorChoices = ...,
     dayfirst: bool = ...,
     yearfirst: bool = ...,
     utc: bool | None = ...,
@@ -676,8 +703,8 @@ def to_datetime(
 
 
 def to_datetime(
-    arg: DatetimeScalarOrArrayConvertible,
-    errors: str = "raise",
+    arg: DatetimeScalarOrArrayConvertible | DictConvertible,
+    errors: DateTimeErrorChoices = "raise",
     dayfirst: bool = False,
     yearfirst: bool = False,
     utc: bool | None = None,
@@ -764,8 +791,8 @@ def to_datetime(
     unit : str, default 'ns'
         The unit of the arg (D,s,ms,us,ns) denote the unit, which is an
         integer or float number. This will be based off the origin.
-        Example, with ``unit='ms'`` and ``origin='unix'`` (the default), this
-        would calculate the number of milliseconds to the unix epoch start.
+        Example, with ``unit='ms'`` and ``origin='unix'``, this would calculate
+        the number of milliseconds to the unix epoch start.
     infer_datetime_format : bool, default False
         If :const:`True` and no `format` is given, attempt to infer the format
         of the datetime strings based on the first non-NaN element,
@@ -975,17 +1002,6 @@ def to_datetime(
     DatetimeIndex(['2020-01-01 01:00:00-01:00', '2020-01-01 02:00:00-01:00'],
                   dtype='datetime64[ns, pytz.FixedOffset(-60)]', freq=None)
 
-    - Finally, mixing timezone-aware strings and :class:`datetime.datetime` always
-      raises an error, even if the elements all have the same time offset.
-
-    >>> from datetime import datetime, timezone, timedelta
-    >>> d = datetime(2020, 1, 1, 18, tzinfo=timezone(-timedelta(hours=1)))
-    >>> pd.to_datetime(["2020-01-01 17:00 -0100", d])
-    Traceback (most recent call last):
-        ...
-    ValueError: Tz-aware datetime.datetime cannot be converted to datetime64
-                unless utc=True
-
     |
 
     Setting ``utc=True`` solves most of the above issues:
@@ -1007,6 +1023,7 @@ def to_datetime(
     - Inputs can contain both naive and aware, string or datetime, the above
       rules still apply
 
+    >>> from datetime import timezone, timedelta
     >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 12:00 -0530',
     ...                datetime(2020, 1, 1, 18),
     ...                datetime(2020, 1, 1, 18,
@@ -1060,7 +1077,14 @@ def to_datetime(
             result = convert_listlike(arg, format, name=arg.name)
     elif is_list_like(arg):
         try:
-            cache_array = _maybe_cache(arg, format, cache, convert_listlike)
+            # error: Argument 1 to "_maybe_cache" has incompatible type
+            # "Union[float, str, datetime, List[Any], Tuple[Any, ...], ExtensionArray,
+            # ndarray[Any, Any], Series]"; expected "Union[List[Any], Tuple[Any, ...],
+            # Union[Union[ExtensionArray, ndarray[Any, Any]], Index, Series], Series]"
+            argc = cast(
+                Union[list, tuple, ExtensionArray, np.ndarray, "Series", Index], arg
+            )
+            cache_array = _maybe_cache(argc, format, cache, convert_listlike)
         except OutOfBoundsDatetime:
             # caching attempts to create a DatetimeIndex, which may raise
             # an OOB. If that's the desired behavior, then just reraise...
@@ -1071,11 +1095,13 @@ def to_datetime(
 
             cache_array = Series([], dtype=object)  # just an empty array
         if not cache_array.empty:
-            result = _convert_and_box_cache(arg, cache_array)
+            result = _convert_and_box_cache(argc, cache_array)
         else:
-            result = convert_listlike(arg, format)
+            result = convert_listlike(argc, format)
     else:
         result = convert_listlike(np.array([arg]), format)[0]
+        if isinstance(arg, bool) and isinstance(result, np.bool_):
+            result = bool(result)  # TODO: avoid this kludge.
 
     #  error: Incompatible return value type (got "Union[Timestamp, NaTType,
     # Series, Index]", expected "Union[DatetimeIndex, Series, float, str,
@@ -1109,7 +1135,7 @@ def to_datetime(
 }
 
 
-def _assemble_from_unit_mappings(arg, errors, tz):
+def _assemble_from_unit_mappings(arg, errors: DateTimeErrorChoices, tz):
     """
     assemble the unit specified fields from the arg (DataFrame)
     Return a Series for actual parsing
@@ -1189,7 +1215,8 @@ def coerce(values):
     except (TypeError, ValueError) as err:
         raise ValueError(f"cannot assemble the datetimes: {err}") from err
 
-    for u in ["h", "m", "s", "ms", "us", "ns"]:
+    units: list[UnitChoices] = ["h", "m", "s", "ms", "us", "ns"]
+    for u in units:
         value = unit_rev.get(u)
         if value is not None and value in arg:
             try:
@@ -1201,7 +1228,7 @@ def coerce(values):
     return values
 
 
-def _attempt_YYYYMMDD(arg: np.ndarray, errors: str) -> np.ndarray | None:
+def _attempt_YYYYMMDD(arg: npt.NDArray[np.object_], errors: str) -> np.ndarray | None:
     """
     try to parse the YYYYMMDD/%Y%m%d format, try to deal with NaT-like,
     arg is a passed in as an object dtype, but could really be ints/strings
@@ -1215,7 +1242,7 @@ def _attempt_YYYYMMDD(arg: np.ndarray, errors: str) -> np.ndarray | None:
 
     def calc(carg):
         # calculate the actual result
-        carg = carg.astype(object)
+        carg = carg.astype(object, copy=False)
         parsed = parsing.try_parse_year_month_day(
             carg / 10000, carg / 100 % 100, carg % 100
         )
@@ -1266,3 +1293,11 @@ def to_time(arg, format=None, infer_time_format=False, errors="raise"):
     from pandas.core.tools.times import to_time
 
     return to_time(arg, format, infer_time_format, errors)
+
+
+__all__ = [
+    "DateParseError",
+    "should_cache",
+    "to_datetime",
+    "to_time",
+]
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index 26197e1ac4847..ef7f4bc92e25b 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -3,6 +3,7 @@
 import numpy as np
 
 from pandas._libs import lib
+from pandas._typing import npt
 
 from pandas.core.dtypes.cast import maybe_downcast_numeric
 from pandas.core.dtypes.common import (
@@ -167,7 +168,7 @@ def to_numeric(arg, errors="raise", downcast=None):
 
     # GH33013: for IntegerArray & FloatingArray extract non-null values for casting
     # save mask to reconstruct the full array after casting
-    mask: np.ndarray | None = None
+    mask: npt.NDArray[np.bool_] | None = None
     if isinstance(values, NumericArray):
         mask = values._mask
         values = values._data[~mask]
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 81b2be4e10e62..5026c97c0b2b0 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -3,6 +3,12 @@
 """
 from __future__ import annotations
 
+from datetime import timedelta
+from typing import (
+    TYPE_CHECKING,
+    overload,
+)
+
 import numpy as np
 
 from pandas._libs import lib
@@ -23,8 +29,61 @@
 
 from pandas.core.arrays.timedeltas import sequence_to_td64ns
 
-
-def to_timedelta(arg, unit=None, errors="raise"):
+if TYPE_CHECKING:
+    from pandas._libs.tslibs.timedeltas import UnitChoices
+    from pandas._typing import (
+        ArrayLike,
+        DateTimeErrorChoices,
+    )
+
+    from pandas import (
+        Index,
+        Series,
+        TimedeltaIndex,
+    )
+
+
+@overload
+def to_timedelta(
+    arg: str | float | timedelta,
+    unit: UnitChoices | None = ...,
+    errors: DateTimeErrorChoices = ...,
+) -> Timedelta:
+    ...
+
+
+@overload
+def to_timedelta(
+    arg: Series,
+    unit: UnitChoices | None = ...,
+    errors: DateTimeErrorChoices = ...,
+) -> Series:
+    ...
+
+
+@overload
+def to_timedelta(
+    arg: list | tuple | range | ArrayLike | Index,
+    unit: UnitChoices | None = ...,
+    errors: DateTimeErrorChoices = ...,
+) -> TimedeltaIndex:
+    ...
+
+
+def to_timedelta(
+    arg: str
+    | int
+    | float
+    | timedelta
+    | list
+    | tuple
+    | range
+    | ArrayLike
+    | Index
+    | Series,
+    unit: UnitChoices | None = None,
+    errors: DateTimeErrorChoices = "raise",
+) -> Timedelta | TimedeltaIndex | Series:
     """
     Convert argument to timedelta.
 
@@ -133,7 +192,11 @@ def to_timedelta(arg, unit=None, errors="raise"):
         return _convert_listlike(arg, unit=unit, errors=errors, name=arg.name)
     elif isinstance(arg, np.ndarray) and arg.ndim == 0:
         # extract array scalar and process below
-        arg = lib.item_from_zerodim(arg)
+        # error: Incompatible types in assignment (expression has type "object",
+        # variable has type "Union[str, int, float, timedelta, List[Any],
+        # Tuple[Any, ...], Union[Union[ExtensionArray, ndarray[Any, Any]], Index,
+        # Series]]")  [assignment]
+        arg = lib.item_from_zerodim(arg)  # type: ignore[assignment]
     elif is_list_like(arg) and getattr(arg, "ndim", 1) == 1:
         return _convert_listlike(arg, unit=unit, errors=errors)
     elif getattr(arg, "ndim", 1) > 1:
diff --git a/pandas/core/tools/times.py b/pandas/core/tools/times.py
index 030cee3f678f4..87667921bf75a 100644
--- a/pandas/core/tools/times.py
+++ b/pandas/core/tools/times.py
@@ -80,17 +80,20 @@ def _convert_listlike(arg, format):
             format_found = False
             for element in arg:
                 time_object = None
-                for time_format in formats:
-                    try:
-                        time_object = datetime.strptime(element, time_format).time()
-                        if not format_found:
-                            # Put the found format in front
-                            fmt = formats.pop(formats.index(time_format))
-                            formats.insert(0, fmt)
-                            format_found = True
-                        break
-                    except (ValueError, TypeError):
-                        continue
+                try:
+                    time_object = time.fromisoformat(element)
+                except (ValueError, TypeError):
+                    for time_format in formats:
+                        try:
+                            time_object = datetime.strptime(element, time_format).time()
+                            if not format_found:
+                                # Put the found format in front
+                                fmt = formats.pop(formats.index(time_format))
+                                formats.insert(0, fmt)
+                                format_found = True
+                            break
+                        except (ValueError, TypeError):
+                            continue
 
                 if time_object is not None:
                     times.append(time_object)
diff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py
index 02899bac14bb2..5a5e46e0227aa 100644
--- a/pandas/core/util/hashing.py
+++ b/pandas/core/util/hashing.py
@@ -16,7 +16,10 @@
 
 from pandas._libs import lib
 from pandas._libs.hashing import hash_object_array
-from pandas._typing import ArrayLike
+from pandas._typing import (
+    ArrayLike,
+    npt,
+)
 
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
@@ -24,6 +27,7 @@
 )
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
+    ABCExtensionArray,
     ABCIndex,
     ABCMultiIndex,
     ABCSeries,
@@ -43,7 +47,9 @@
 _default_hash_key = "0123456789123456"
 
 
-def combine_hash_arrays(arrays: Iterator[np.ndarray], num_items: int) -> np.ndarray:
+def combine_hash_arrays(
+    arrays: Iterator[np.ndarray], num_items: int
+) -> npt.NDArray[np.uint64]:
     """
     Parameters
     ----------
@@ -171,7 +177,7 @@ def hash_tuples(
     vals: MultiIndex | Iterable[tuple[Hashable, ...]],
     encoding: str = "utf8",
     hash_key: str = _default_hash_key,
-) -> np.ndarray:
+) -> npt.NDArray[np.uint64]:
     """
     Hash an MultiIndex / listlike-of-tuples efficiently.
 
@@ -213,7 +219,9 @@ def hash_tuples(
     return h
 
 
-def _hash_categorical(cat: Categorical, encoding: str, hash_key: str) -> np.ndarray:
+def _hash_categorical(
+    cat: Categorical, encoding: str, hash_key: str
+) -> npt.NDArray[np.uint64]:
     """
     Hash a Categorical by hashing its categories, and then mapping the codes
     to the hashes
@@ -256,7 +264,7 @@ def hash_array(
     encoding: str = "utf8",
     hash_key: str = _default_hash_key,
     categorize: bool = True,
-) -> np.ndarray:
+) -> npt.NDArray[np.uint64]:
     """
     Given a 1d array, return an array of deterministic integers.
 
@@ -286,10 +294,17 @@ def hash_array(
     if is_categorical_dtype(dtype):
         vals = cast("Categorical", vals)
         return _hash_categorical(vals, encoding, hash_key)
-    elif not isinstance(vals, np.ndarray):
-        # i.e. ExtensionArray
+
+    elif isinstance(vals, ABCExtensionArray):
         vals, _ = vals._values_for_factorize()
 
+    elif not isinstance(vals, np.ndarray):
+        # GH#42003
+        raise TypeError(
+            "hash_array requires np.ndarray or ExtensionArray, not "
+            f"{type(vals).__name__}. Use hash_pandas_object instead."
+        )
+
     return _hash_ndarray(vals, encoding, hash_key, categorize)
 
 
@@ -298,7 +313,7 @@ def _hash_ndarray(
     encoding: str = "utf8",
     hash_key: str = _default_hash_key,
     categorize: bool = True,
-) -> np.ndarray:
+) -> npt.NDArray[np.uint64]:
     """
     See hash_array.__doc__.
     """
@@ -311,7 +326,7 @@ def _hash_ndarray(
 
     # First, turn whatever array this is into unsigned 64-bit ints, if we can
     # manage it.
-    elif isinstance(dtype, bool):
+    elif dtype == bool:
         vals = vals.astype("u8")
     elif issubclass(dtype.type, (np.datetime64, np.timedelta64)):
         vals = vals.view("i8").astype("u8", copy=False)
diff --git a/pandas/core/util/numba_.py b/pandas/core/util/numba_.py
index 06630989444bb..be798e022ac6e 100644
--- a/pandas/core/util/numba_.py
+++ b/pandas/core/util/numba_.py
@@ -13,7 +13,6 @@
 from pandas.errors import NumbaUtilError
 
 GLOBAL_USE_NUMBA: bool = False
-NUMBA_FUNC_CACHE: dict[tuple[Callable, str], Callable] = {}
 
 
 def maybe_use_numba(engine: str | None) -> bool:
@@ -30,7 +29,7 @@ def set_use_numba(enable: bool = False) -> None:
 
 def get_jit_arguments(
     engine_kwargs: dict[str, bool] | None = None, kwargs: dict | None = None
-) -> tuple[bool, bool, bool]:
+) -> dict[str, bool]:
     """
     Return arguments to pass to numba.JIT, falling back on pandas default JIT settings.
 
@@ -43,7 +42,7 @@ def get_jit_arguments(
 
     Returns
     -------
-    (bool, bool, bool)
+    dict[str, bool]
         nopython, nogil, parallel
 
     Raises
@@ -61,7 +60,7 @@ def get_jit_arguments(
         )
     nogil = engine_kwargs.get("nogil", False)
     parallel = engine_kwargs.get("parallel", False)
-    return nopython, nogil, parallel
+    return {"nopython": nopython, "nogil": nogil, "parallel": parallel}
 
 
 def jit_user_function(
diff --git a/pandas/core/window/__init__.py b/pandas/core/window/__init__.py
index 8f42cd782c67f..857e12e5467a6 100644
--- a/pandas/core/window/__init__.py
+++ b/pandas/core/window/__init__.py
@@ -1,13 +1,23 @@
-from pandas.core.window.ewm import (  # noqa:F401
+from pandas.core.window.ewm import (
     ExponentialMovingWindow,
     ExponentialMovingWindowGroupby,
 )
-from pandas.core.window.expanding import (  # noqa:F401
+from pandas.core.window.expanding import (
     Expanding,
     ExpandingGroupby,
 )
-from pandas.core.window.rolling import (  # noqa:F401
+from pandas.core.window.rolling import (
     Rolling,
     RollingGroupby,
     Window,
 )
+
+__all__ = [
+    "Expanding",
+    "ExpandingGroupby",
+    "ExponentialMovingWindow",
+    "ExponentialMovingWindowGroupby",
+    "Rolling",
+    "RollingGroupby",
+    "Window",
+]
diff --git a/pandas/core/window/common.py b/pandas/core/window/common.py
index 15144116fa924..e31b5c60a37ee 100644
--- a/pandas/core/window/common.py
+++ b/pandas/core/window/common.py
@@ -1,9 +1,14 @@
 """Common utility functions for rolling operations"""
+from __future__ import annotations
+
 from collections import defaultdict
 from typing import cast
+import warnings
 
 import numpy as np
 
+from pandas.util._exceptions import find_stack_level
+
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
     ABCSeries,
@@ -165,3 +170,38 @@ def prep_binary(arg1, arg2):
     X = arg1 + 0 * arg2
     Y = arg2 + 0 * arg1
     return X, Y
+
+
+def maybe_warn_args_and_kwargs(cls, kernel: str, args, kwargs) -> None:
+    """
+    Warn for deprecation of args and kwargs in rolling/expanding functions.
+
+    Parameters
+    ----------
+    cls : type
+        Class to warn about.
+    kernel : str
+        Operation name.
+    args : tuple or None
+        args passed by user. Will be None if and only if kernel does not have args.
+    kwargs : dict or None
+        kwargs passed by user. Will be None if and only if kernel does not have kwargs.
+    """
+    warn_args = args is not None and len(args) > 0
+    warn_kwargs = kwargs is not None and len(kwargs) > 0
+    if warn_args and warn_kwargs:
+        msg = "args and kwargs"
+    elif warn_args:
+        msg = "args"
+    elif warn_kwargs:
+        msg = "kwargs"
+    else:
+        msg = ""
+    if msg != "":
+        warnings.warn(
+            f"Passing additional {msg} to {cls.__name__}.{kernel} has "
+            "no impact on the result and is deprecated. This will "
+            "raise a TypeError in a future version of pandas.",
+            category=FutureWarning,
+            stacklevel=find_stack_level(),
+        )
diff --git a/pandas/core/window/doc.py b/pandas/core/window/doc.py
index 930c12841e4e4..835085d41cffa 100644
--- a/pandas/core/window/doc.py
+++ b/pandas/core/window/doc.py
@@ -1,4 +1,6 @@
 """Any shareable docstring components for rolling/expanding/ewm"""
+from __future__ import annotations
+
 from textwrap import dedent
 
 from pandas.core.shared_docs import _shared_docs
@@ -29,17 +31,30 @@ def create_section_header(header: str) -> str:
     """
 ).replace("\n", "", 1)
 
+kwargs_numeric_only = dedent(
+    """
+    numeric_only : bool, default False
+        Include only float, int, boolean columns.
+
+        .. versionadded:: 1.5.0\n
+    """
+).replace("\n", "", 1)
+
 args_compat = dedent(
     """
     *args
-        For NumPy compatibility and will not have an effect on the result.\n
+        For NumPy compatibility and will not have an effect on the result.
+
+        .. deprecated:: 1.5.0\n
     """
 ).replace("\n", "", 1)
 
 kwargs_compat = dedent(
     """
     **kwargs
-        For NumPy compatibility and will not have an effect on the result.\n
+        For NumPy compatibility and will not have an effect on the result.
+
+        .. deprecated:: 1.5.0\n
     """
 ).replace("\n", "", 1)
 
diff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py
index 4bebc56273805..020ca71050015 100644
--- a/pandas/core/window/ewm.py
+++ b/pandas/core/window/ewm.py
@@ -3,7 +3,10 @@
 import datetime
 from functools import partial
 from textwrap import dedent
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
 import warnings
 
 import numpy as np
@@ -23,7 +26,10 @@
 from pandas.util._decorators import doc
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.dtypes.common import is_datetime64_ns_dtype
+from pandas.core.dtypes.common import (
+    is_datetime64_ns_dtype,
+    is_numeric_dtype,
+)
 from pandas.core.dtypes.missing import isna
 
 import pandas.core.common as common  # noqa: PDF018
@@ -32,13 +38,20 @@
     ExponentialMovingWindowIndexer,
     GroupbyIndexer,
 )
-from pandas.core.util.numba_ import maybe_use_numba
-from pandas.core.window.common import zsqrt
+from pandas.core.util.numba_ import (
+    get_jit_arguments,
+    maybe_use_numba,
+)
+from pandas.core.window.common import (
+    maybe_warn_args_and_kwargs,
+    zsqrt,
+)
 from pandas.core.window.doc import (
     _shared_docs,
     args_compat,
     create_section_header,
     kwargs_compat,
+    kwargs_numeric_only,
     numba_notes,
     template_header,
     template_returns,
@@ -128,8 +141,9 @@ class ExponentialMovingWindow(BaseWindow):
     r"""
     Provide exponentially weighted (EW) calculations.
 
-    Exactly one parameter: ``com``, ``span``, ``halflife``, or ``alpha`` must be
-    provided.
+    Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be
+    provided if ``times`` is not provided. If ``times`` is provided,
+    ``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.
 
     Parameters
     ----------
@@ -149,7 +163,7 @@ class ExponentialMovingWindow(BaseWindow):
         :math:`\alpha = 1 - \exp\left(-\ln(2) / halflife\right)`, for
         :math:`halflife > 0`.
 
-        If ``times`` is specified, the time unit (str or timedelta) over which an
+        If ``times`` is specified, a timedelta convertible unit over which an
         observation decays to half its value. Only applicable to ``mean()``,
         and halflife value will not apply to the other functions.
 
@@ -204,6 +218,8 @@ class ExponentialMovingWindow(BaseWindow):
 
         If ``1`` or ``'columns'``, calculate across the columns.
 
+        For `Series` this parameter is unused and defaults to 0.
+
     times : str, np.ndarray, Series, default None
 
         .. versionadded:: 1.1.0
@@ -346,7 +362,7 @@ def __init__(
         method: str = "single",
         *,
         selection=None,
-    ):
+    ) -> None:
         super().__init__(
             obj=obj,
             min_periods=1 if min_periods is None else max(int(min_periods), 1),
@@ -377,17 +393,14 @@ def __init__(
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
-                self.times = self._selected_obj[self.times]
+                # self.times cannot be str anymore
+                self.times = cast("Series", self._selected_obj[self.times])
             if not is_datetime64_ns_dtype(self.times):
                 raise ValueError("times must be datetime64[ns] dtype.")
-            # error: Argument 1 to "len" has incompatible type "Union[str, ndarray,
-            # NDFrameT, None]"; expected "Sized"
-            if len(self.times) != len(obj):  # type: ignore[arg-type]
+            if len(self.times) != len(obj):
                 raise ValueError("times must be the same length as the object.")
-            if not isinstance(self.halflife, (str, datetime.timedelta)):
-                raise ValueError(
-                    "halflife must be a string or datetime.timedelta object"
-                )
+            if not isinstance(self.halflife, (str, datetime.timedelta, np.timedelta64)):
+                raise ValueError("halflife must be a timedelta convertible object")
             if isna(self.times).any():
                 raise ValueError("Cannot convert NaT values to integer")
             self._deltas = _calculate_deltas(self.times, self.halflife)
@@ -399,14 +412,16 @@ def __init__(
                 self._com = 1.0
         else:
             if self.halflife is not None and isinstance(
-                self.halflife, (str, datetime.timedelta)
+                self.halflife, (str, datetime.timedelta, np.timedelta64)
             ):
                 raise ValueError(
                     "halflife can only be a timedelta convertible argument if "
                     "times is not None."
                 )
             # Without times, points are equally spaced
-            self._deltas = np.ones(max(len(self.obj) - 1, 0), dtype=np.float64)
+            self._deltas = np.ones(
+                max(self.obj.shape[self.axis] - 1, 0), dtype=np.float64
+            )
             self._com = get_center_of_mass(
                 # error: Argument 3 to "get_center_of_mass" has incompatible type
                 # "Union[float, Any, None, timedelta64, signedinteger[_64Bit]]";
@@ -430,7 +445,9 @@ def _get_window_indexer(self) -> BaseIndexer:
         """
         return ExponentialMovingWindowIndexer()
 
-    def online(self, engine="numba", engine_kwargs=None):
+    def online(
+        self, engine="numba", engine_kwargs=None
+    ) -> OnlineExponentialMovingWindow:
         """
         Return an ``OnlineExponentialMovingWindow`` object to calculate
         exponentially moving window aggregations in an online method.
@@ -510,6 +527,7 @@ def aggregate(self, func, *args, **kwargs):
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -523,26 +541,29 @@ def aggregate(self, func, *args, **kwargs):
         aggregation_description="(exponential weighted moment) mean",
         agg_method="mean",
     )
-    def mean(self, *args, engine=None, engine_kwargs=None, **kwargs):
+    def mean(
+        self,
+        numeric_only: bool = False,
+        *args,
+        engine=None,
+        engine_kwargs=None,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "mean", args, kwargs)
         if maybe_use_numba(engine):
             if self.method == "single":
                 func = generate_numba_ewm_func
-                numba_cache_key = (lambda x: x, "ewm_mean")
             else:
                 func = generate_numba_ewm_table_func
-                numba_cache_key = (lambda x: x, "ewm_mean_table")
             ewm_func = func(
-                engine_kwargs=engine_kwargs,
+                **get_jit_arguments(engine_kwargs),
                 com=self._com,
                 adjust=self.adjust,
                 ignore_na=self.ignore_na,
-                deltas=self._deltas,
+                deltas=tuple(self._deltas),
                 normalize=True,
             )
-            return self._apply(
-                ewm_func,
-                numba_cache_key=numba_cache_key,
-            )
+            return self._apply(ewm_func, name="mean")
         elif engine in ("cython", None):
             if engine_kwargs is not None:
                 raise ValueError("cython engine does not accept engine_kwargs")
@@ -557,13 +578,14 @@ def mean(self, *args, engine=None, engine_kwargs=None, **kwargs):
                 deltas=deltas,
                 normalize=True,
             )
-            return self._apply(window_func)
+            return self._apply(window_func, name="mean", numeric_only=numeric_only)
         else:
             raise ValueError("engine must be either 'numba' or 'cython'")
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -577,28 +599,31 @@ def mean(self, *args, engine=None, engine_kwargs=None, **kwargs):
         aggregation_description="(exponential weighted moment) sum",
         agg_method="sum",
     )
-    def sum(self, *args, engine=None, engine_kwargs=None, **kwargs):
+    def sum(
+        self,
+        numeric_only: bool = False,
+        *args,
+        engine=None,
+        engine_kwargs=None,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "sum", args, kwargs)
         if not self.adjust:
             raise NotImplementedError("sum is not implemented with adjust=False")
         if maybe_use_numba(engine):
             if self.method == "single":
                 func = generate_numba_ewm_func
-                numba_cache_key = (lambda x: x, "ewm_sum")
             else:
                 func = generate_numba_ewm_table_func
-                numba_cache_key = (lambda x: x, "ewm_sum_table")
             ewm_func = func(
-                engine_kwargs=engine_kwargs,
+                **get_jit_arguments(engine_kwargs),
                 com=self._com,
                 adjust=self.adjust,
                 ignore_na=self.ignore_na,
-                deltas=self._deltas,
+                deltas=tuple(self._deltas),
                 normalize=False,
             )
-            return self._apply(
-                ewm_func,
-                numba_cache_key=numba_cache_key,
-            )
+            return self._apply(ewm_func, name="sum")
         elif engine in ("cython", None):
             if engine_kwargs is not None:
                 raise ValueError("cython engine does not accept engine_kwargs")
@@ -613,7 +638,7 @@ def sum(self, *args, engine=None, engine_kwargs=None, **kwargs):
                 deltas=deltas,
                 normalize=False,
             )
-            return self._apply(window_func)
+            return self._apply(window_func, name="sum", numeric_only=numeric_only)
         else:
             raise ValueError("engine must be either 'numba' or 'cython'")
 
@@ -626,6 +651,7 @@ def sum(self, *args, engine=None, engine_kwargs=None, **kwargs):
             Use a standard estimation bias correction.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         kwargs_compat,
         create_section_header("Returns"),
@@ -636,9 +662,19 @@ def sum(self, *args, engine=None, engine_kwargs=None, **kwargs):
         aggregation_description="(exponential weighted moment) standard deviation",
         agg_method="std",
     )
-    def std(self, bias: bool = False, *args, **kwargs):
+    def std(self, bias: bool = False, numeric_only: bool = False, *args, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "std", args, kwargs)
         nv.validate_window_func("std", args, kwargs)
-        return zsqrt(self.var(bias=bias, **kwargs))
+        if (
+            numeric_only
+            and self._selected_obj.ndim == 1
+            and not is_numeric_dtype(self._selected_obj.dtype)
+        ):
+            # Raise directly so error message says std instead of var
+            raise NotImplementedError(
+                f"{type(self).__name__}.std does not implement numeric_only"
+            )
+        return zsqrt(self.var(bias=bias, numeric_only=numeric_only, **kwargs))
 
     def vol(self, bias: bool = False, *args, **kwargs):
         warnings.warn(
@@ -660,6 +696,7 @@ def vol(self, bias: bool = False, *args, **kwargs):
             Use a standard estimation bias correction.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         kwargs_compat,
         create_section_header("Returns"),
@@ -670,7 +707,8 @@ def vol(self, bias: bool = False, *args, **kwargs):
         aggregation_description="(exponential weighted moment) variance",
         agg_method="var",
     )
-    def var(self, bias: bool = False, *args, **kwargs):
+    def var(self, bias: bool = False, numeric_only: bool = False, *args, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "var", args, kwargs)
         nv.validate_window_func("var", args, kwargs)
         window_func = window_aggregations.ewmcov
         wfunc = partial(
@@ -684,7 +722,7 @@ def var(self, bias: bool = False, *args, **kwargs):
         def var_func(values, begin, end, min_periods):
             return wfunc(values, begin, end, min_periods, values)
 
-        return self._apply(var_func)
+        return self._apply(var_func, name="var", numeric_only=numeric_only)
 
     @doc(
         template_header,
@@ -705,6 +743,7 @@ def var_func(values, begin, end, min_periods):
             Use a standard estimation bias correction.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -719,10 +758,14 @@ def cov(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         bias: bool = False,
+        numeric_only: bool = False,
         **kwargs,
     ):
         from pandas import Series
 
+        maybe_warn_args_and_kwargs(type(self), "cov", None, kwargs)
+        self._validate_numeric_only("cov", numeric_only)
+
         def cov_func(x, y):
             x_array = self._prep_values(x)
             y_array = self._prep_values(y)
@@ -737,6 +780,7 @@ def cov_func(x, y):
                 min_periods=min_periods,
                 center=self.center,
                 closed=self.closed,
+                step=self.step,
             )
             result = window_aggregations.ewmcov(
                 x_array,
@@ -753,7 +797,9 @@ def cov_func(x, y):
             )
             return Series(result, index=x.index, name=x.name)
 
-        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func)
+        return self._apply_pairwise(
+            self._selected_obj, other, pairwise, cov_func, numeric_only
+        )
 
     @doc(
         template_header,
@@ -772,6 +818,7 @@ def cov_func(x, y):
             observations will be used.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -785,10 +832,14 @@ def corr(
         self,
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
+        numeric_only: bool = False,
         **kwargs,
     ):
         from pandas import Series
 
+        maybe_warn_args_and_kwargs(type(self), "corr", None, kwargs)
+        self._validate_numeric_only("corr", numeric_only)
+
         def cov_func(x, y):
             x_array = self._prep_values(x)
             y_array = self._prep_values(y)
@@ -803,6 +854,7 @@ def cov_func(x, y):
                 min_periods=min_periods,
                 center=self.center,
                 closed=self.closed,
+                step=self.step,
             )
 
             def _cov(X, Y):
@@ -825,7 +877,9 @@ def _cov(X, Y):
                 result = cov / zsqrt(x_var * y_var)
             return Series(result, index=x.index, name=x.name)
 
-        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func)
+        return self._apply_pairwise(
+            self._selected_obj, other, pairwise, cov_func, numeric_only
+        )
 
 
 class ExponentialMovingWindowGroupby(BaseWindowGroupby, ExponentialMovingWindow):
@@ -835,7 +889,7 @@ class ExponentialMovingWindowGroupby(BaseWindowGroupby, ExponentialMovingWindow)
 
     _attributes = ExponentialMovingWindow._attributes + BaseWindowGroupby._attributes
 
-    def __init__(self, obj, *args, _grouper=None, **kwargs):
+    def __init__(self, obj, *args, _grouper=None, **kwargs) -> None:
         super().__init__(obj, *args, _grouper=_grouper, **kwargs)
 
         if not obj.empty and self.times is not None:
@@ -878,7 +932,7 @@ def __init__(
         engine_kwargs: dict[str, bool] | None = None,
         *,
         selection=None,
-    ):
+    ) -> None:
         if times is not None:
             raise NotImplementedError(
                 "times is not implemented with online operations."
@@ -905,7 +959,7 @@ def __init__(
         else:
             raise ValueError("'numba' is the only supported engine")
 
-    def reset(self):
+    def reset(self) -> None:
         """
         Reset the state captured by `update` calls.
         """
@@ -921,6 +975,7 @@ def corr(
         self,
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
+        numeric_only: bool = False,
         **kwargs,
     ):
         return NotImplementedError
@@ -930,6 +985,7 @@ def cov(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         bias: bool = False,
+        numeric_only: bool = False,
         **kwargs,
     ):
         return NotImplementedError
@@ -1011,7 +1067,9 @@ def mean(self, *args, update=None, update_times=None, **kwargs):
             else:
                 result_kwargs["name"] = self._selected_obj.name
             np_array = self._selected_obj.astype(np.float64).to_numpy()
-        ewma_func = generate_online_numba_ewma_func(self.engine_kwargs)
+        ewma_func = generate_online_numba_ewma_func(
+            **get_jit_arguments(self.engine_kwargs)
+        )
         result = self._mean.run_ewm(
             np_array if is_frame else np_array[:, np.newaxis],
             update_deltas,
diff --git a/pandas/core/window/expanding.py b/pandas/core/window/expanding.py
index 8c8b7a8284684..e997ffe1ec132 100644
--- a/pandas/core/window/expanding.py
+++ b/pandas/core/window/expanding.py
@@ -9,6 +9,7 @@
 
 from pandas._typing import (
     Axis,
+    QuantileInterpolation,
     WindowingRankType,
 )
 
@@ -24,11 +25,13 @@
     ExpandingIndexer,
     GroupbyIndexer,
 )
+from pandas.core.window.common import maybe_warn_args_and_kwargs
 from pandas.core.window.doc import (
     _shared_docs,
     args_compat,
     create_section_header,
     kwargs_compat,
+    kwargs_numeric_only,
     numba_notes,
     template_header,
     template_returns,
@@ -64,6 +67,8 @@ class Expanding(RollingAndExpandingMixin):
 
         If ``1`` or ``'columns'``, roll across the columns.
 
+        For `Series` this parameter is unused and defaults to 0.
+
     method : str {'single', 'table'}, default 'single'
         Execute the rolling operation per single column or row (``'single'``)
         or over the entire object (``'table'``).
@@ -124,11 +129,11 @@ def __init__(
         self,
         obj: NDFrame,
         min_periods: int = 1,
-        center=None,
+        center: bool | None = None,
         axis: Axis = 0,
         method: str = "single",
         selection=None,
-    ):
+    ) -> None:
         super().__init__(
             obj=obj,
             min_periods=min_periods,
@@ -190,8 +195,8 @@ def aggregate(self, func, *args, **kwargs):
         aggregation_description="count of non NaN observations",
         agg_method="count",
     )
-    def count(self):
-        return super().count()
+    def count(self, numeric_only: bool = False):
+        return super().count(numeric_only=numeric_only)
 
     @doc(
         template_header,
@@ -226,6 +231,7 @@ def apply(
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -241,17 +247,25 @@ def apply(
     )
     def sum(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "sum", args, kwargs)
         nv.validate_expanding_func("sum", args, kwargs)
-        return super().sum(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().sum(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -267,17 +281,25 @@ def sum(
     )
     def max(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "max", args, kwargs)
         nv.validate_expanding_func("max", args, kwargs)
-        return super().max(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().max(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -293,17 +315,25 @@ def max(
     )
     def min(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "min", args, kwargs)
         nv.validate_expanding_func("min", args, kwargs)
-        return super().min(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().min(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -319,17 +349,25 @@ def min(
     )
     def mean(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "mean", args, kwargs)
         nv.validate_expanding_func("mean", args, kwargs)
-        return super().mean(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().mean(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         window_agg_numba_parameters(),
         kwargs_compat,
         create_section_header("Returns"),
@@ -344,11 +382,18 @@ def mean(
     )
     def median(
         self,
+        numeric_only: bool = False,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
-        return super().median(engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "median", None, kwargs)
+        return super().median(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
@@ -360,6 +405,7 @@ def median(
             is ``N - ddof``, where ``N`` represents the number of elements.\n
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters("1.4"),
         kwargs_compat,
@@ -400,14 +446,20 @@ def median(
     def std(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "std", args, kwargs)
         nv.validate_expanding_func("std", args, kwargs)
         return super().std(
-            ddof=ddof, engine=engine, engine_kwargs=engine_kwargs, **kwargs
+            ddof=ddof,
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
         )
 
     @doc(
@@ -420,6 +472,7 @@ def std(
             is ``N - ddof``, where ``N`` represents the number of elements.\n
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters("1.4"),
         kwargs_compat,
@@ -460,14 +513,20 @@ def std(
     def var(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "var", args, kwargs)
         nv.validate_expanding_func("var", args, kwargs)
         return super().var(
-            ddof=ddof, engine=engine, engine_kwargs=engine_kwargs, **kwargs
+            ddof=ddof,
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
         )
 
     @doc(
@@ -480,6 +539,7 @@ def var(
             is ``N - ddof``, where ``N`` represents the number of elements.\n
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         kwargs_compat,
         create_section_header("Returns"),
@@ -505,12 +565,14 @@ def var(
         aggregation_description="standard error of mean",
         agg_method="sem",
     )
-    def sem(self, ddof: int = 1, *args, **kwargs):
-        return super().sem(ddof=ddof, **kwargs)
+    def sem(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "sem", args, kwargs)
+        return super().sem(ddof=ddof, numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -523,12 +585,14 @@ def sem(self, ddof: int = 1, *args, **kwargs):
         aggregation_description="unbiased skewness",
         agg_method="skew",
     )
-    def skew(self, **kwargs):
-        return super().skew(**kwargs)
+    def skew(self, numeric_only: bool = False, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "skew", None, kwargs)
+        return super().skew(numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -563,8 +627,9 @@ def skew(self, **kwargs):
         aggregation_description="Fisher's definition of kurtosis without bias",
         agg_method="kurt",
     )
-    def kurt(self, **kwargs):
-        return super().kurt(**kwargs)
+    def kurt(self, numeric_only: bool = False, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "kurt", None, kwargs)
+        return super().kurt(numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
@@ -585,6 +650,7 @@ def kurt(self, **kwargs):
                 * midpoint: (`i` + `j`) / 2.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -597,12 +663,15 @@ def kurt(self, **kwargs):
     def quantile(
         self,
         quantile: float,
-        interpolation: str = "linear",
+        interpolation: QuantileInterpolation = "linear",
+        numeric_only: bool = False,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "quantile", None, kwargs)
         return super().quantile(
             quantile=quantile,
             interpolation=interpolation,
+            numeric_only=numeric_only,
             **kwargs,
         )
 
@@ -626,6 +695,7 @@ def quantile(
             form.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -672,12 +742,15 @@ def rank(
         method: WindowingRankType = "average",
         ascending: bool = True,
         pct: bool = False,
+        numeric_only: bool = False,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "rank", None, kwargs)
         return super().rank(
             method=method,
             ascending=ascending,
             pct=pct,
+            numeric_only=numeric_only,
             **kwargs,
         )
 
@@ -701,6 +774,7 @@ def rank(
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -715,9 +789,17 @@ def cov(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
-        return super().cov(other=other, pairwise=pairwise, ddof=ddof, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "cov", None, kwargs)
+        return super().cov(
+            other=other,
+            pairwise=pairwise,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
     @doc(
         template_header,
@@ -736,6 +818,7 @@ def cov(
             observations will be used.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -780,9 +863,17 @@ def corr(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
-        return super().corr(other=other, pairwise=pairwise, ddof=ddof, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "corr", None, kwargs)
+        return super().corr(
+            other=other,
+            pairwise=pairwise,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
 
 class ExpandingGroupby(BaseWindowGroupby, Expanding):
diff --git a/pandas/core/window/numba_.py b/pandas/core/window/numba_.py
index 0e8eea3ec671e..0f9f01e93a477 100644
--- a/pandas/core/window/numba_.py
+++ b/pandas/core/window/numba_.py
@@ -12,18 +12,15 @@
 from pandas._typing import Scalar
 from pandas.compat._optional import import_optional_dependency
 
-from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
-    get_jit_arguments,
-    jit_user_function,
-)
+from pandas.core.util.numba_ import jit_user_function
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_apply_func(
-    kwargs: dict[str, Any],
     func: Callable[..., Scalar],
-    engine_kwargs: dict[str, bool] | None,
-    name: str,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
 ):
     """
     Generate a numba jitted apply function specified by values from engine_kwargs.
@@ -36,25 +33,19 @@ def generate_numba_apply_func(
 
     Parameters
     ----------
-    kwargs : dict
-        **kwargs to be passed into the function
     func : function
         function to be applied to each window and will be JITed
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
-    name: str
-        name of the caller (Rolling/Expanding)
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs, kwargs)
-
-    cache_key = (func, f"{name}_apply_single")
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     numba_func = jit_user_function(func, nopython, nogil, parallel)
     if TYPE_CHECKING:
         import numba
@@ -84,12 +75,15 @@ def roll_apply(
     return roll_apply
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_ewm_func(
-    engine_kwargs: dict[str, bool] | None,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
     com: float,
     adjust: bool,
     ignore_na: bool,
-    deltas: np.ndarray,
+    deltas: tuple,
     normalize: bool,
 ):
     """
@@ -98,25 +92,22 @@ def generate_numba_ewm_func(
 
     Parameters
     ----------
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
     com : float
     adjust : bool
     ignore_na : bool
-    deltas : numpy.ndarray
+    deltas : tuple
     normalize : bool
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs)
-
-    str_key = "ewm_mean" if normalize else "ewm_sum"
-    cache_key = (lambda x: x, str_key)
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     if TYPE_CHECKING:
         import numba
     else:
@@ -183,11 +174,12 @@ def ewm(
     return ewm
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_table_func(
-    kwargs: dict[str, Any],
     func: Callable[..., np.ndarray],
-    engine_kwargs: dict[str, bool] | None,
-    name: str,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
 ):
     """
     Generate a numba jitted function to apply window calculations table-wise.
@@ -201,25 +193,19 @@ def generate_numba_table_func(
 
     Parameters
     ----------
-    kwargs : dict
-        **kwargs to be passed into the function
     func : function
         function to be applied to each window and will be JITed
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
-    name : str
-        caller (Rolling/Expanding) and original method name for numba cache key
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs, kwargs)
-
-    cache_key = (func, f"{name}_table")
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     numba_func = jit_user_function(func, nopython, nogil, parallel)
     if TYPE_CHECKING:
         import numba
@@ -234,8 +220,8 @@ def roll_table(
         minimum_periods: int,
         *args: Any,
     ):
-        result = np.empty(values.shape)
-        min_periods_mask = np.empty(values.shape)
+        result = np.empty((len(begin), values.shape[1]))
+        min_periods_mask = np.empty(result.shape)
         for i in numba.prange(len(result)):
             start = begin[i]
             stop = end[i]
@@ -272,12 +258,15 @@ def nan_agg_with_axis(table):
     return nan_agg_with_axis
 
 
+@functools.lru_cache(maxsize=None)
 def generate_numba_ewm_table_func(
-    engine_kwargs: dict[str, bool] | None,
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
     com: float,
     adjust: bool,
     ignore_na: bool,
-    deltas: np.ndarray,
+    deltas: tuple,
     normalize: bool,
 ):
     """
@@ -286,25 +275,22 @@ def generate_numba_ewm_table_func(
 
     Parameters
     ----------
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
     com : float
     adjust : bool
     ignore_na : bool
-    deltas : numpy.ndarray
+    deltas : tuple
     normalize: bool
 
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs)
-
-    str_key = "ewm_mean_table" if normalize else "ewm_sum_table"
-    cache_key = (lambda x: x, str_key)
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     if TYPE_CHECKING:
         import numba
     else:
diff --git a/pandas/core/window/online.py b/pandas/core/window/online.py
index 8ef4aee154db4..2e25bdd12d3e0 100644
--- a/pandas/core/window/online.py
+++ b/pandas/core/window/online.py
@@ -1,37 +1,34 @@
-from typing import (
-    TYPE_CHECKING,
-    Dict,
-    Optional,
-)
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
 from pandas.compat._optional import import_optional_dependency
 
-from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
-    get_jit_arguments,
-)
-
 
-def generate_online_numba_ewma_func(engine_kwargs: Optional[Dict[str, bool]]):
+def generate_online_numba_ewma_func(
+    nopython: bool,
+    nogil: bool,
+    parallel: bool,
+):
     """
     Generate a numba jitted groupby ewma function specified by values
     from engine_kwargs.
+
     Parameters
     ----------
-    engine_kwargs : dict
-        dictionary of arguments to be passed into numba.jit
+    nopython : bool
+        nopython to be passed into numba.jit
+    nogil : bool
+        nogil to be passed into numba.jit
+    parallel : bool
+        parallel to be passed into numba.jit
+
     Returns
     -------
     Numba function
     """
-    nopython, nogil, parallel = get_jit_arguments(engine_kwargs)
-
-    cache_key = (lambda x: x, "online_ewma")
-    if cache_key in NUMBA_FUNC_CACHE:
-        return NUMBA_FUNC_CACHE[cache_key]
-
     if TYPE_CHECKING:
         import numba
     else:
@@ -91,7 +88,7 @@ def online_ewma(
 
 
 class EWMMeanState:
-    def __init__(self, com, adjust, ignore_na, axis, shape):
+    def __init__(self, com, adjust, ignore_na, axis, shape) -> None:
         alpha = 1.0 / (1.0 + com)
         self.axis = axis
         self.shape = shape
@@ -117,6 +114,6 @@ def run_ewm(self, weighted_avg, deltas, min_periods, ewm_func):
         self.last_ewm = result[-1]
         return result
 
-    def reset(self):
+    def reset(self) -> None:
         self.old_wt = np.ones(self.shape[self.axis - 1])
         self.last_ewm = None
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index c8538f0cf7c90..1a71b41b0e317 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -14,6 +14,7 @@
     Any,
     Callable,
     Hashable,
+    Sized,
 )
 import warnings
 
@@ -28,10 +29,12 @@
     ArrayLike,
     Axis,
     NDFrameT,
+    QuantileInterpolation,
     WindowingRankType,
 )
 from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import function as nv
+from pandas.errors import DataError
 from pandas.util._decorators import doc
 from pandas.util._exceptions import find_stack_level
 
@@ -40,6 +43,7 @@
     is_bool,
     is_integer,
     is_list_like,
+    is_numeric_dtype,
     is_scalar,
     needs_i8_conversion,
 )
@@ -53,10 +57,7 @@
 from pandas.core.algorithms import factorize
 from pandas.core.apply import ResamplerWindowApply
 from pandas.core.arrays import ExtensionArray
-from pandas.core.base import (
-    DataError,
-    SelectionMixin,
-)
+from pandas.core.base import SelectionMixin
 import pandas.core.common as com
 from pandas.core.indexers.objects import (
     BaseIndexer,
@@ -73,11 +74,12 @@
 )
 from pandas.core.reshape.concat import concat
 from pandas.core.util.numba_ import (
-    NUMBA_FUNC_CACHE,
+    get_jit_arguments,
     maybe_use_numba,
 )
 from pandas.core.window.common import (
     flex_binary_moment,
+    maybe_warn_args_and_kwargs,
     zsqrt,
 )
 from pandas.core.window.doc import (
@@ -85,6 +87,7 @@
     args_compat,
     create_section_header,
     kwargs_compat,
+    kwargs_numeric_only,
     kwargs_scipy,
     numba_notes,
     template_header,
@@ -106,7 +109,6 @@
     )
     from pandas.core.generic import NDFrame
     from pandas.core.groupby.ops import BaseGrouper
-    from pandas.core.internals import Block  # noqa:F401
 
 
 class BaseWindow(SelectionMixin):
@@ -121,18 +123,20 @@ def __init__(
         obj: NDFrame,
         window=None,
         min_periods: int | None = None,
-        center: bool = False,
+        center: bool | None = False,
         win_type: str | None = None,
         axis: Axis = 0,
         on: str | Index | None = None,
         closed: str | None = None,
+        step: int | None = None,
         method: str = "single",
         *,
         selection=None,
-    ):
+    ) -> None:
         self.obj = obj
         self.on = on
         self.closed = closed
+        self.step = step
         self.window = window
         self.min_periods = min_periods
         self.center = center
@@ -140,7 +144,7 @@ def __init__(
         self._win_type = win_type
         self.axis = obj._get_axis_number(axis) if axis is not None else None
         self.method = method
-        self._win_freq_i8 = None
+        self._win_freq_i8: int | None = None
         if self.on is None:
             if self.axis == 0:
                 self._on = self.obj.index
@@ -226,6 +230,11 @@ def _validate(self) -> None:
                 )
         if self.method not in ["table", "single"]:
             raise ValueError("method must be 'table' or 'single")
+        if self.step is not None:
+            if not is_integer(self.step):
+                raise ValueError("step must be an integer")
+            elif self.step < 0:
+                raise ValueError("step must be >= 0")
 
     def _check_window_bounds(
         self, start: np.ndarray, end: np.ndarray, num_vals: int
@@ -235,24 +244,70 @@ def _check_window_bounds(
                 f"start ({len(start)}) and end ({len(end)}) bounds must be the "
                 f"same length"
             )
-        elif len(start) != num_vals:
+        elif len(start) != (num_vals + (self.step or 1) - 1) // (self.step or 1):
             raise ValueError(
                 f"start and end bounds ({len(start)}) must be the same length "
-                f"as the object ({num_vals})"
+                f"as the object ({num_vals}) divided by the step ({self.step}) "
+                f"if given and rounded up"
+            )
+
+    def _slice_axis_for_step(self, index: Index, result: Sized | None = None) -> Index:
+        """
+        Slices the index for a given result and the preset step.
+        """
+        return (
+            index
+            if result is None or len(result) == len(index)
+            else index[:: self.step]
+        )
+
+    def _validate_numeric_only(self, name: str, numeric_only: bool) -> None:
+        """
+        Validate numeric_only argument, raising if invalid for the input.
+
+        Parameters
+        ----------
+        name : str
+            Name of the operator (kernel).
+        numeric_only : bool
+            Value passed by user.
+        """
+        if (
+            self._selected_obj.ndim == 1
+            and numeric_only
+            and not is_numeric_dtype(self._selected_obj.dtype)
+        ):
+            raise NotImplementedError(
+                f"{type(self).__name__}.{name} does not implement numeric_only"
             )
 
-    def _create_data(self, obj: NDFrameT) -> NDFrameT:
+    def _make_numeric_only(self, obj: NDFrameT) -> NDFrameT:
+        """Subset DataFrame to numeric columns.
+
+        Parameters
+        ----------
+        obj : DataFrame
+
+        Returns
+        -------
+        obj subset to numeric-only columns.
+        """
+        result = obj.select_dtypes(include=["number"], exclude=["timedelta"])
+        return result
+
+    def _create_data(self, obj: NDFrameT, numeric_only: bool = False) -> NDFrameT:
         """
         Split data into blocks & return conformed data.
         """
         # filter out the on from the object
         if self.on is not None and not isinstance(self.on, Index) and obj.ndim == 2:
             obj = obj.reindex(columns=obj.columns.difference([self.on]), copy=False)
-        if self.axis == 1:
+        if obj.ndim > 1 and (numeric_only or self.axis == 1):
             # GH: 20649 in case of mixed dtype and axis=1 we have to convert everything
             # to float to calculate the complete row at once. We exclude all non-numeric
             # dtypes.
-            obj = obj.select_dtypes(include=["number"], exclude=["timedelta"])
+            obj = self._make_numeric_only(obj)
+        if self.axis == 1:
             obj = obj.astype("float64", copy=False)
             obj._mgr = obj._mgr.consolidate()
         return obj
@@ -324,6 +379,7 @@ def __iter__(self):
             min_periods=self.min_periods,
             center=self.center,
             closed=self.closed,
+            step=self.step,
         )
         self._check_window_bounds(start, end, len(obj))
 
@@ -354,9 +410,7 @@ def _prep_values(self, values: ArrayLike) -> np.ndarray:
         if inf.any():
             values = np.where(inf, np.nan, values)
 
-        # error: Incompatible return value type (got "Optional[ndarray]",
-        # expected "ndarray")
-        return values  # type: ignore[return-value]
+        return values
 
     def _insert_on_column(self, result: DataFrame, obj: DataFrame) -> None:
         # if we have an 'on' column we want to put it back into
@@ -431,19 +485,24 @@ def _apply_series(
             raise DataError("No numeric types to aggregate") from err
 
         result = homogeneous_func(values)
-        return obj._constructor(result, index=obj.index, name=obj.name)
+        index = self._slice_axis_for_step(obj.index, result)
+        return obj._constructor(result, index=index, name=obj.name)
 
     def _apply_blockwise(
-        self, homogeneous_func: Callable[..., ArrayLike], name: str | None = None
+        self,
+        homogeneous_func: Callable[..., ArrayLike],
+        name: str,
+        numeric_only: bool = False,
     ) -> DataFrame | Series:
         """
         Apply the given function to the DataFrame broken down into homogeneous
         sub-frames.
         """
+        self._validate_numeric_only(name, numeric_only)
         if self._selected_obj.ndim == 1:
             return self._apply_series(homogeneous_func, name)
 
-        obj = self._create_data(self._selected_obj)
+        obj = self._create_data(self._selected_obj, numeric_only)
         if name == "count":
             # GH 12541: Special case for count where we support date-like types
             obj = notna(obj).astype(int)
@@ -468,9 +527,12 @@ def hfunc(values: ArrayLike) -> ArrayLike:
                 res_values.append(res)
                 taker.append(i)
 
+        index = self._slice_axis_for_step(
+            obj.index, res_values[0] if len(res_values) > 0 else None
+        )
         df = type(obj)._from_arrays(
             res_values,
-            index=obj.index,
+            index=index,
             columns=obj.columns.take(taker),
             verify_integrity=False,
         )
@@ -493,19 +555,28 @@ def hfunc(values: ArrayLike) -> ArrayLike:
         return self._resolve_output(df, obj)
 
     def _apply_tablewise(
-        self, homogeneous_func: Callable[..., ArrayLike], name: str | None = None
+        self,
+        homogeneous_func: Callable[..., ArrayLike],
+        name: str | None = None,
+        numeric_only: bool = False,
     ) -> DataFrame | Series:
         """
         Apply the given function to the DataFrame across the entire object
         """
         if self._selected_obj.ndim == 1:
             raise ValueError("method='table' not applicable for Series objects.")
-        obj = self._create_data(self._selected_obj)
+        obj = self._create_data(self._selected_obj, numeric_only)
         values = self._prep_values(obj.to_numpy())
         values = values.T if self.axis == 1 else values
         result = homogeneous_func(values)
         result = result.T if self.axis == 1 else result
-        out = obj._constructor(result, index=obj.index, columns=obj.columns)
+        index = self._slice_axis_for_step(obj.index, result)
+        columns = (
+            obj.columns
+            if result.shape[1] == len(obj.columns)
+            else obj.columns[:: self.step]
+        )
+        out = obj._constructor(result, index=index, columns=columns)
 
         return self._resolve_output(out, obj)
 
@@ -515,24 +586,28 @@ def _apply_pairwise(
         other: DataFrame | Series | None,
         pairwise: bool | None,
         func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series],
+        numeric_only: bool,
     ) -> DataFrame | Series:
         """
         Apply the given pairwise function given 2 pandas objects (DataFrame/Series)
         """
+        target = self._create_data(target, numeric_only)
         if other is None:
             other = target
             # only default unset
             pairwise = True if pairwise is None else pairwise
         elif not isinstance(other, (ABCDataFrame, ABCSeries)):
             raise ValueError("other must be a DataFrame or Series")
+        elif other.ndim == 2 and numeric_only:
+            other = self._make_numeric_only(other)
 
         return flex_binary_moment(target, other, func, pairwise=bool(pairwise))
 
     def _apply(
         self,
         func: Callable[..., Any],
-        name: str | None = None,
-        numba_cache_key: tuple[Callable, str] | None = None,
+        name: str,
+        numeric_only: bool = False,
         numba_args: tuple[Any, ...] = (),
         **kwargs,
     ):
@@ -545,8 +620,6 @@ def _apply(
         ----------
         func : callable function to apply
         name : str,
-        numba_cache_key : tuple
-            caching key to be used to store a compiled numba func
         numba_args : tuple
             args to be passed when func is a numba func
         **kwargs
@@ -575,6 +648,7 @@ def calc(x):
                     min_periods=min_periods,
                     center=self.center,
                     closed=self.closed,
+                    step=self.step,
                 )
                 self._check_window_bounds(start, end, len(x))
 
@@ -583,20 +657,16 @@ def calc(x):
             with np.errstate(all="ignore"):
                 result = calc(values)
 
-            if numba_cache_key is not None:
-                NUMBA_FUNC_CACHE[numba_cache_key] = func
-
             return result
 
         if self.method == "single":
-            return self._apply_blockwise(homogeneous_func, name)
+            return self._apply_blockwise(homogeneous_func, name, numeric_only)
         else:
-            return self._apply_tablewise(homogeneous_func, name)
+            return self._apply_tablewise(homogeneous_func, name, numeric_only)
 
     def _numba_apply(
         self,
         func: Callable[..., Any],
-        numba_cache_key_str: str,
         engine_kwargs: dict[str, bool] | None = None,
         *func_args,
     ):
@@ -617,20 +687,22 @@ def _numba_apply(
             min_periods=min_periods,
             center=self.center,
             closed=self.closed,
+            step=self.step,
         )
         self._check_window_bounds(start, end, len(values))
         aggregator = executor.generate_shared_aggregator(
-            func, engine_kwargs, numba_cache_key_str
+            func, **get_jit_arguments(engine_kwargs)
         )
         result = aggregator(values, start, end, min_periods, *func_args)
-        NUMBA_FUNC_CACHE[(func, numba_cache_key_str)] = aggregator
         result = result.T if self.axis == 1 else result
+        index = self._slice_axis_for_step(obj.index, result)
         if obj.ndim == 1:
             result = result.squeeze()
-            out = obj._constructor(result, index=obj.index, name=obj.name)
+            out = obj._constructor(result, index=index, name=obj.name)
             return out
         else:
-            out = obj._constructor(result, index=obj.index, columns=obj.columns)
+            columns = self._slice_axis_for_step(obj.columns, result.T)
+            out = obj._constructor(result, index=index, columns=columns)
             return self._resolve_output(out, obj)
 
     def aggregate(self, func, *args, **kwargs):
@@ -658,7 +730,7 @@ def __init__(
         _grouper: BaseGrouper,
         _as_index: bool = True,
         **kwargs,
-    ):
+    ) -> None:
         from pandas.core.groupby.ops import BaseGrouper
 
         if not isinstance(_grouper, BaseGrouper):
@@ -669,20 +741,23 @@ def __init__(
         # groupby.<agg_func>, but unexpected to users in
         # groupby.rolling.<agg_func>
         obj = obj.drop(columns=self._grouper.names, errors="ignore")
+        # GH 15354
+        if kwargs.get("step") is not None:
+            raise NotImplementedError("step not implemented for groupby")
         super().__init__(obj, *args, **kwargs)
 
     def _apply(
         self,
         func: Callable[..., Any],
-        name: str | None = None,
-        numba_cache_key: tuple[Callable, str] | None = None,
+        name: str,
+        numeric_only: bool = False,
         numba_args: tuple[Any, ...] = (),
         **kwargs,
     ) -> DataFrame | Series:
         result = super()._apply(
             func,
             name,
-            numba_cache_key,
+            numeric_only,
             numba_args,
             **kwargs,
         )
@@ -738,14 +813,14 @@ def _apply_pairwise(
         other: DataFrame | Series | None,
         pairwise: bool | None,
         func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series],
+        numeric_only: bool,
     ) -> DataFrame | Series:
         """
         Apply the given pairwise function given 2 pandas objects (DataFrame/Series)
         """
         # Manually drop the grouping column first
         target = target.drop(columns=self._grouper.names, errors="ignore")
-        target = self._create_data(target)
-        result = super()._apply_pairwise(target, other, pairwise, func)
+        result = super()._apply_pairwise(target, other, pairwise, func, numeric_only)
         # 1) Determine the levels + codes of the groupby levels
         if other is not None and not all(
             len(group) == len(other) for group in self._grouper.indices.values()
@@ -816,7 +891,7 @@ def _apply_pairwise(
         result.index = result_index
         return result
 
-    def _create_data(self, obj: NDFrameT) -> NDFrameT:
+    def _create_data(self, obj: NDFrameT, numeric_only: bool = False) -> NDFrameT:
         """
         Split data into blocks & return conformed data.
         """
@@ -828,7 +903,7 @@ def _create_data(self, obj: NDFrameT) -> NDFrameT:
                 np.int64
             )
             obj = obj.take(groupby_order)
-        return super()._create_data(obj)
+        return super()._create_data(obj, numeric_only)
 
     def _gotitem(self, key, ndim, subset=None):
         # we are setting the index on the actual object
@@ -839,12 +914,6 @@ def _gotitem(self, key, ndim, subset=None):
             subset = self.obj.set_index(self._on)
         return super()._gotitem(key, ndim, subset=subset)
 
-    def _validate_monotonic(self):
-        """
-        Validate that "on" is monotonic; already validated at a higher level.
-        """
-        pass
-
 
 class Window(BaseWindow):
     """
@@ -866,8 +935,8 @@ class Window(BaseWindow):
 
         If a BaseIndexer subclass, the window boundaries
         based on the defined ``get_window_bounds`` method. Additional rolling
-        keyword arguments, namely ``min_periods``, ``center``, and
-        ``closed`` will be passed to ``get_window_bounds``.
+        keyword arguments, namely ``min_periods``, ``center``, ``closed`` and
+        ``step`` will be passed to ``get_window_bounds``.
 
     min_periods : int, default None
         Minimum number of observations in window required to have a value;
@@ -905,6 +974,8 @@ class Window(BaseWindow):
 
         If ``1`` or ``'columns'``, roll across the columns.
 
+        For `Series` this parameter is unused and defaults to 0.
+
     closed : str, default None
         If ``'right'``, the first point in the window is excluded from calculations.
 
@@ -921,6 +992,14 @@ class Window(BaseWindow):
 
             The closed parameter with fixed windows is now supported.
 
+    step : int, default None
+
+        .. versionadded:: 1.5.0
+
+        Evaluate the window at every ``step`` result, equivalent to slicing as
+        ``[::step]``. ``window`` must be an integer. Using a step argument other
+        than None or 1 will produce a result with a different shape than the input.
+
     method : str {'single', 'table'}, default 'single'
 
         .. versionadded:: 1.3.0
@@ -1039,6 +1118,17 @@ class Window(BaseWindow):
     3  3.0
     4  6.0
 
+    **step**
+
+    Rolling sum with a window length of 2 observations, minimum of 1 observation to
+    calculate a value, and a step of 2.
+
+    >>> df.rolling(2, min_periods=1, step=2).sum()
+         B
+    0  0.0
+    2  3.0
+    4  4.0
+
     **win_type**
 
     Rolling sum with a window length of 2, using the Scipy ``'gaussian'``
@@ -1061,6 +1151,7 @@ class Window(BaseWindow):
         "axis",
         "on",
         "closed",
+        "step",
         "method",
     ]
 
@@ -1090,20 +1181,16 @@ def _center_window(self, result: np.ndarray, offset: int) -> np.ndarray:
         """
         Center the result in the window for weighted rolling aggregations.
         """
-        if self.axis > result.ndim - 1:
-            raise ValueError("Requested axis is larger then no. of argument dimensions")
-
         if offset > 0:
-            lead_indexer = [slice(None)] * result.ndim
-            lead_indexer[self.axis] = slice(offset, None)
+            lead_indexer = [slice(offset, None)]
             result = np.copy(result[tuple(lead_indexer)])
         return result
 
     def _apply(
         self,
         func: Callable[[np.ndarray, int, int], np.ndarray],
-        name: str | None = None,
-        numba_cache_key: tuple[Callable, str] | None = None,
+        name: str,
+        numeric_only: bool = False,
         numba_args: tuple[Any, ...] = (),
         **kwargs,
     ):
@@ -1116,8 +1203,8 @@ def _apply(
         ----------
         func : callable function to apply
         name : str,
-        use_numba_cache : tuple
-            unused
+        numeric_only : bool, default False
+            Whether to only operate on bool, int, and float columns
         numba_args : tuple
             unused
         **kwargs
@@ -1153,7 +1240,7 @@ def calc(x):
 
             return result
 
-        return self._apply_blockwise(homogeneous_func, name)
+        return self._apply_blockwise(homogeneous_func, name, numeric_only)[:: self.step]
 
     @doc(
         _shared_docs["aggregate"],
@@ -1200,6 +1287,7 @@ def aggregate(self, func, *args, **kwargs):
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_scipy,
         create_section_header("Returns"),
         template_returns,
@@ -1209,17 +1297,23 @@ def aggregate(self, func, *args, **kwargs):
         aggregation_description="weighted window sum",
         agg_method="sum",
     )
-    def sum(self, *args, **kwargs):
+    def sum(self, numeric_only: bool = False, *args, **kwargs):
         nv.validate_window_func("sum", args, kwargs)
         window_func = window_aggregations.roll_weighted_sum
         # error: Argument 1 to "_apply" of "Window" has incompatible type
         # "Callable[[ndarray, ndarray, int], ndarray]"; expected
         # "Callable[[ndarray, int, int], ndarray]"
-        return self._apply(window_func, name="sum", **kwargs)  # type: ignore[arg-type]
+        return self._apply(
+            window_func,  # type: ignore[arg-type]
+            name="sum",
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_scipy,
         create_section_header("Returns"),
         template_returns,
@@ -1229,18 +1323,24 @@ def sum(self, *args, **kwargs):
         aggregation_description="weighted window mean",
         agg_method="mean",
     )
-    def mean(self, *args, **kwargs):
+    def mean(self, numeric_only: bool = False, *args, **kwargs):
         nv.validate_window_func("mean", args, kwargs)
         window_func = window_aggregations.roll_weighted_mean
         # error: Argument 1 to "_apply" of "Window" has incompatible type
         # "Callable[[ndarray, ndarray, int], ndarray]"; expected
         # "Callable[[ndarray, int, int], ndarray]"
-        return self._apply(window_func, name="mean", **kwargs)  # type: ignore[arg-type]
+        return self._apply(
+            window_func,  # type: ignore[arg-type]
+            name="mean",
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         ".. versionadded:: 1.0.0 \n\n",
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_scipy,
         create_section_header("Returns"),
         template_returns,
@@ -1250,16 +1350,17 @@ def mean(self, *args, **kwargs):
         aggregation_description="weighted window variance",
         agg_method="var",
     )
-    def var(self, ddof: int = 1, *args, **kwargs):
+    def var(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):
         nv.validate_window_func("var", args, kwargs)
         window_func = partial(window_aggregations.roll_weighted_var, ddof=ddof)
         kwargs.pop("name", None)
-        return self._apply(window_func, name="var", **kwargs)
+        return self._apply(window_func, name="var", numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
         ".. versionadded:: 1.0.0 \n\n",
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_scipy,
         create_section_header("Returns"),
         template_returns,
@@ -1269,15 +1370,17 @@ def var(self, ddof: int = 1, *args, **kwargs):
         aggregation_description="weighted window standard deviation",
         agg_method="std",
     )
-    def std(self, ddof: int = 1, *args, **kwargs):
+    def std(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):
         nv.validate_window_func("std", args, kwargs)
-        return zsqrt(self.var(ddof=ddof, name="std", **kwargs))
+        return zsqrt(
+            self.var(ddof=ddof, name="std", numeric_only=numeric_only, **kwargs)
+        )
 
 
 class RollingAndExpandingMixin(BaseWindow):
-    def count(self):
+    def count(self, numeric_only: bool = False):
         window_func = window_aggregations.roll_sum
-        return self._apply(window_func, name="count")
+        return self._apply(window_func, name="count", numeric_only=numeric_only)
 
     def apply(
         self,
@@ -1296,23 +1399,19 @@ def apply(
         if not is_bool(raw):
             raise ValueError("raw parameter must be `True` or `False`")
 
-        numba_cache_key = None
         numba_args: tuple[Any, ...] = ()
         if maybe_use_numba(engine):
             if raw is False:
                 raise ValueError("raw must be `True` when using the numba engine")
-            caller_name = type(self).__name__
             numba_args = args
             if self.method == "single":
                 apply_func = generate_numba_apply_func(
-                    kwargs, func, engine_kwargs, caller_name
+                    func, **get_jit_arguments(engine_kwargs, kwargs)
                 )
-                numba_cache_key = (func, f"{caller_name}_apply_single")
             else:
                 apply_func = generate_numba_table_func(
-                    kwargs, func, engine_kwargs, f"{caller_name}_apply"
+                    func, **get_jit_arguments(engine_kwargs, kwargs)
                 )
-                numba_cache_key = (func, f"{caller_name}_apply_table")
         elif engine in ("cython", None):
             if engine_kwargs is not None:
                 raise ValueError("cython engine does not accept engine_kwargs")
@@ -1322,7 +1421,7 @@ def apply(
 
         return self._apply(
             apply_func,
-            numba_cache_key=numba_cache_key,
+            name="apply",
             numba_args=numba_args,
         )
 
@@ -1345,13 +1444,15 @@ def _generate_cython_apply_func(
 
         def apply_func(values, begin, end, min_periods, raw=raw):
             if not raw:
-                values = Series(values, index=self.obj.index)
+                # GH 45912
+                values = Series(values, index=self._on)
             return window_func(values, begin, end, min_periods)
 
         return apply_func
 
     def sum(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1370,12 +1471,13 @@ def sum(
             else:
                 from pandas.core._numba.kernels import sliding_sum
 
-                return self._numba_apply(sliding_sum, "rolling_sum", engine_kwargs)
+                return self._numba_apply(sliding_sum, engine_kwargs)
         window_func = window_aggregations.roll_sum
-        return self._apply(window_func, name="sum", **kwargs)
+        return self._apply(window_func, name="sum", numeric_only=numeric_only, **kwargs)
 
     def max(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1394,14 +1496,13 @@ def max(
             else:
                 from pandas.core._numba.kernels import sliding_min_max
 
-                return self._numba_apply(
-                    sliding_min_max, "rolling_max", engine_kwargs, True
-                )
+                return self._numba_apply(sliding_min_max, engine_kwargs, True)
         window_func = window_aggregations.roll_max
-        return self._apply(window_func, name="max", **kwargs)
+        return self._apply(window_func, name="max", numeric_only=numeric_only, **kwargs)
 
     def min(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1420,14 +1521,13 @@ def min(
             else:
                 from pandas.core._numba.kernels import sliding_min_max
 
-                return self._numba_apply(
-                    sliding_min_max, "rolling_min", engine_kwargs, False
-                )
+                return self._numba_apply(sliding_min_max, engine_kwargs, False)
         window_func = window_aggregations.roll_min
-        return self._apply(window_func, name="min", **kwargs)
+        return self._apply(window_func, name="min", numeric_only=numeric_only, **kwargs)
 
     def mean(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1446,12 +1546,15 @@ def mean(
             else:
                 from pandas.core._numba.kernels import sliding_mean
 
-                return self._numba_apply(sliding_mean, "rolling_mean", engine_kwargs)
+                return self._numba_apply(sliding_mean, engine_kwargs)
         window_func = window_aggregations.roll_mean
-        return self._apply(window_func, name="mean", **kwargs)
+        return self._apply(
+            window_func, name="mean", numeric_only=numeric_only, **kwargs
+        )
 
     def median(
         self,
+        numeric_only: bool = False,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
@@ -1469,11 +1572,14 @@ def median(
                 engine_kwargs=engine_kwargs,
             )
         window_func = window_aggregations.roll_median_c
-        return self._apply(window_func, name="median", **kwargs)
+        return self._apply(
+            window_func, name="median", numeric_only=numeric_only, **kwargs
+        )
 
     def std(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1486,9 +1592,7 @@ def std(
             else:
                 from pandas.core._numba.kernels import sliding_var
 
-                return zsqrt(
-                    self._numba_apply(sliding_var, "rolling_std", engine_kwargs, ddof)
-                )
+                return zsqrt(self._numba_apply(sliding_var, engine_kwargs, ddof))
         window_func = window_aggregations.roll_var
 
         def zsqrt_func(values, begin, end, min_periods):
@@ -1497,12 +1601,14 @@ def zsqrt_func(values, begin, end, min_periods):
         return self._apply(
             zsqrt_func,
             name="std",
+            numeric_only=numeric_only,
             **kwargs,
         )
 
     def var(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
@@ -1515,36 +1621,48 @@ def var(
             else:
                 from pandas.core._numba.kernels import sliding_var
 
-                return self._numba_apply(
-                    sliding_var, "rolling_var", engine_kwargs, ddof
-                )
+                return self._numba_apply(sliding_var, engine_kwargs, ddof)
         window_func = partial(window_aggregations.roll_var, ddof=ddof)
         return self._apply(
             window_func,
             name="var",
+            numeric_only=numeric_only,
             **kwargs,
         )
 
-    def skew(self, **kwargs):
+    def skew(self, numeric_only: bool = False, **kwargs):
         window_func = window_aggregations.roll_skew
         return self._apply(
             window_func,
             name="skew",
+            numeric_only=numeric_only,
             **kwargs,
         )
 
-    def sem(self, ddof: int = 1, *args, **kwargs):
-        return self.std(*args, **kwargs) / (self.count() - ddof).pow(0.5)
+    def sem(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):
+        nv.validate_rolling_func("sem", args, kwargs)
+        # Raise here so error message says sem instead of std
+        self._validate_numeric_only("sem", numeric_only)
+        return self.std(numeric_only=numeric_only, **kwargs) / (
+            self.count(numeric_only=numeric_only) - ddof
+        ).pow(0.5)
 
-    def kurt(self, **kwargs):
+    def kurt(self, numeric_only: bool = False, **kwargs):
         window_func = window_aggregations.roll_kurt
         return self._apply(
             window_func,
             name="kurt",
+            numeric_only=numeric_only,
             **kwargs,
         )
 
-    def quantile(self, quantile: float, interpolation: str = "linear", **kwargs):
+    def quantile(
+        self,
+        quantile: float,
+        interpolation: QuantileInterpolation = "linear",
+        numeric_only: bool = False,
+        **kwargs,
+    ):
         if quantile == 1.0:
             window_func = window_aggregations.roll_max
         elif quantile == 0.0:
@@ -1556,13 +1674,16 @@ def quantile(self, quantile: float, interpolation: str = "linear", **kwargs):
                 interpolation=interpolation,
             )
 
-        return self._apply(window_func, name="quantile", **kwargs)
+        return self._apply(
+            window_func, name="quantile", numeric_only=numeric_only, **kwargs
+        )
 
     def rank(
         self,
         method: WindowingRankType = "average",
         ascending: bool = True,
         pct: bool = False,
+        numeric_only: bool = False,
         **kwargs,
     ):
         window_func = partial(
@@ -1572,15 +1693,22 @@ def rank(
             percentile=pct,
         )
 
-        return self._apply(window_func, name="rank", **kwargs)
+        return self._apply(
+            window_func, name="rank", numeric_only=numeric_only, **kwargs
+        )
 
     def cov(
         self,
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
+        if self.step is not None:
+            raise NotImplementedError("step not implemented for cov")
+        self._validate_numeric_only("cov", numeric_only)
+
         from pandas import Series
 
         def cov_func(x, y):
@@ -1597,6 +1725,7 @@ def cov_func(x, y):
                 min_periods=min_periods,
                 center=self.center,
                 closed=self.closed,
+                step=self.step,
             )
             self._check_window_bounds(start, end, len(x_array))
 
@@ -1612,15 +1741,21 @@ def cov_func(x, y):
                 result = (mean_x_y - mean_x * mean_y) * (count_x_y / (count_x_y - ddof))
             return Series(result, index=x.index, name=x.name)
 
-        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func)
+        return self._apply_pairwise(
+            self._selected_obj, other, pairwise, cov_func, numeric_only
+        )
 
     def corr(
         self,
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
+        if self.step is not None:
+            raise NotImplementedError("step not implemented for corr")
+        self._validate_numeric_only("corr", numeric_only)
 
         from pandas import Series
 
@@ -1638,6 +1773,7 @@ def corr_func(x, y):
                 min_periods=min_periods,
                 center=self.center,
                 closed=self.closed,
+                step=self.step,
             )
             self._check_window_bounds(start, end, len(x_array))
 
@@ -1663,7 +1799,9 @@ def corr_func(x, y):
                 result = numerator / denominator
             return Series(result, index=x.index, name=x.name)
 
-        return self._apply_pairwise(self._selected_obj, other, pairwise, corr_func)
+        return self._apply_pairwise(
+            self._selected_obj, other, pairwise, corr_func, numeric_only
+        )
 
 
 class Rolling(RollingAndExpandingMixin):
@@ -1676,6 +1814,7 @@ class Rolling(RollingAndExpandingMixin):
         "axis",
         "on",
         "closed",
+        "step",
         "method",
     ]
 
@@ -1688,7 +1827,7 @@ def _validate(self):
             or isinstance(self._on, (DatetimeIndex, TimedeltaIndex, PeriodIndex))
         ) and isinstance(self.window, (str, BaseOffset, timedelta)):
 
-            self._validate_monotonic()
+            self._validate_datetimelike_monotonic()
 
             # this will raise ValueError on non-fixed freqs
             try:
@@ -1699,7 +1838,11 @@ def _validate(self):
                     "compatible with a datetimelike index"
                 ) from err
             if isinstance(self._on, PeriodIndex):
-                self._win_freq_i8 = freq.nanos / (self._on.freq.nanos / self._on.freq.n)
+                # error: Incompatible types in assignment (expression has type
+                # "float", variable has type "Optional[int]")
+                self._win_freq_i8 = freq.nanos / (  # type: ignore[assignment]
+                    self._on.freq.nanos / self._on.freq.n
+                )
             else:
                 self._win_freq_i8 = freq.nanos
 
@@ -1707,24 +1850,35 @@ def _validate(self):
             if self.min_periods is None:
                 self.min_periods = 1
 
+            if self.step is not None:
+                raise NotImplementedError(
+                    "step is not supported with frequency windows"
+                )
+
         elif isinstance(self.window, BaseIndexer):
             # Passed BaseIndexer subclass should handle all other rolling kwargs
-            return
+            pass
         elif not is_integer(self.window) or self.window < 0:
             raise ValueError("window must be an integer 0 or greater")
 
-    def _validate_monotonic(self):
+    def _validate_datetimelike_monotonic(self):
         """
-        Validate monotonic (increasing or decreasing).
+        Validate self._on is monotonic (increasing or decreasing) and has
+        no NaT values for frequency windows.
         """
+        if self._on.hasnans:
+            self._raise_monotonic_error("values must not have NaT")
         if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):
-            self._raise_monotonic_error()
+            self._raise_monotonic_error("values must be monotonic")
 
-    def _raise_monotonic_error(self):
-        formatted = self.on
-        if self.on is None:
-            formatted = "index"
-        raise ValueError(f"{formatted} must be monotonic")
+    def _raise_monotonic_error(self, msg: str):
+        on = self.on
+        if on is None:
+            if self.axis == 0:
+                on = "index"
+            else:
+                on = "column"
+        raise ValueError(f"{on} {msg}")
 
     @doc(
         _shared_docs["aggregate"],
@@ -1770,6 +1924,8 @@ def aggregate(self, func, *args, **kwargs):
 
     @doc(
         template_header,
+        create_section_header("Parameters"),
+        kwargs_numeric_only,
         create_section_header("Returns"),
         template_returns,
         create_section_header("See Also"),
@@ -1802,7 +1958,7 @@ def aggregate(self, func, *args, **kwargs):
         aggregation_description="count of non NaN observations",
         agg_method="count",
     )
-    def count(self):
+    def count(self, numeric_only: bool = False):
         if self.min_periods is None:
             warnings.warn(
                 (
@@ -1817,7 +1973,7 @@ def count(self):
             result = super().count()
             self.min_periods = None
         else:
-            result = super().count()
+            result = super().count(numeric_only)
         return result
 
     @doc(
@@ -1853,6 +2009,7 @@ def apply(
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -1916,17 +2073,25 @@ def apply(
     )
     def sum(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "sum", args, kwargs)
         nv.validate_rolling_func("sum", args, kwargs)
-        return super().sum(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().sum(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -1942,17 +2107,25 @@ def sum(
     )
     def max(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "max", args, kwargs)
         nv.validate_rolling_func("max", args, kwargs)
-        return super().max(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().max(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -1983,17 +2156,25 @@ def max(
     )
     def min(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "min", args, kwargs)
         nv.validate_rolling_func("min", args, kwargs)
-        return super().min(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().min(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters(),
         kwargs_compat,
@@ -2031,17 +2212,25 @@ def min(
     )
     def mean(
         self,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "mean", args, kwargs)
         nv.validate_rolling_func("mean", args, kwargs)
-        return super().mean(*args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        return super().mean(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         window_agg_numba_parameters(),
         kwargs_compat,
         create_section_header("Returns"),
@@ -2071,11 +2260,18 @@ def mean(
     )
     def median(
         self,
+        numeric_only: bool = False,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
-        return super().median(engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "median", None, kwargs)
+        return super().median(
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
+        )
 
     @doc(
         template_header,
@@ -2087,6 +2283,7 @@ def median(
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters("1.4"),
         kwargs_compat,
@@ -2101,10 +2298,7 @@ def median(
         The default ``ddof`` of 1 used in :meth:`Series.std` is different
         than the default ``ddof`` of 0 in :func:`numpy.std`.
 
-        A minimum of one period is required for the rolling calculation.
-
-        The implementation is susceptible to floating point imprecision as
-        shown in the example below.\n
+        A minimum of one period is required for the rolling calculation.\n
         """
         ).replace("\n", "", 1),
         create_section_header("Examples"),
@@ -2112,13 +2306,13 @@ def median(
             """
         >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
         >>> s.rolling(3).std()
-        0             NaN
-        1             NaN
-        2    5.773503e-01
-        3    1.000000e+00
-        4    1.000000e+00
-        5    1.154701e+00
-        6    2.580957e-08
+        0         NaN
+        1         NaN
+        2    0.577350
+        3    1.000000
+        4    1.000000
+        5    1.154701
+        6    0.000000
         dtype: float64
         """
         ).replace("\n", "", 1),
@@ -2129,14 +2323,20 @@ def median(
     def std(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "std", args, kwargs)
         nv.validate_rolling_func("std", args, kwargs)
         return super().std(
-            ddof=ddof, engine=engine, engine_kwargs=engine_kwargs, **kwargs
+            ddof=ddof,
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
         )
 
     @doc(
@@ -2149,6 +2349,7 @@ def std(
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         window_agg_numba_parameters("1.4"),
         kwargs_compat,
@@ -2163,10 +2364,7 @@ def std(
         The default ``ddof`` of 1 used in :meth:`Series.var` is different
         than the default ``ddof`` of 0 in :func:`numpy.var`.
 
-        A minimum of one period is required for the rolling calculation.
-
-        The implementation is susceptible to floating point imprecision as
-        shown in the example below.\n
+        A minimum of one period is required for the rolling calculation.\n
         """
         ).replace("\n", "", 1),
         create_section_header("Examples"),
@@ -2174,13 +2372,13 @@ def std(
             """
         >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
         >>> s.rolling(3).var()
-        0             NaN
-        1             NaN
-        2    3.333333e-01
-        3    1.000000e+00
-        4    1.000000e+00
-        5    1.333333e+00
-        6    6.661338e-16
+        0         NaN
+        1         NaN
+        2    0.333333
+        3    1.000000
+        4    1.000000
+        5    1.333333
+        6    0.000000
         dtype: float64
         """
         ).replace("\n", "", 1),
@@ -2191,19 +2389,26 @@ def std(
     def var(
         self,
         ddof: int = 1,
+        numeric_only: bool = False,
         *args,
         engine: str | None = None,
         engine_kwargs: dict[str, bool] | None = None,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "var", args, kwargs)
         nv.validate_rolling_func("var", args, kwargs)
         return super().var(
-            ddof=ddof, engine=engine, engine_kwargs=engine_kwargs, **kwargs
+            ddof=ddof,
+            numeric_only=numeric_only,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            **kwargs,
         )
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2216,8 +2421,9 @@ def var(
         aggregation_description="unbiased skewness",
         agg_method="skew",
     )
-    def skew(self, **kwargs):
-        return super().skew(**kwargs)
+    def skew(self, numeric_only: bool = False, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "skew", None, kwargs)
+        return super().skew(numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
@@ -2229,6 +2435,7 @@ def skew(self, **kwargs):
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         args_compat,
         kwargs_compat,
         create_section_header("Returns"),
@@ -2253,12 +2460,19 @@ def skew(self, **kwargs):
         aggregation_description="standard error of mean",
         agg_method="sem",
     )
-    def sem(self, ddof: int = 1, *args, **kwargs):
-        return self.std(*args, **kwargs) / (self.count() - ddof).pow(0.5)
+    def sem(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "sem", args, kwargs)
+        nv.validate_rolling_func("sem", args, kwargs)
+        # Raise here so error message says sem instead of std
+        self._validate_numeric_only("sem", numeric_only)
+        return self.std(numeric_only=numeric_only, **kwargs) / (
+            self.count(numeric_only) - ddof
+        ).pow(0.5)
 
     @doc(
         template_header,
         create_section_header("Parameters"),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2293,8 +2507,9 @@ def sem(self, ddof: int = 1, *args, **kwargs):
         aggregation_description="Fisher's definition of kurtosis without bias",
         agg_method="kurt",
     )
-    def kurt(self, **kwargs):
-        return super().kurt(**kwargs)
+    def kurt(self, numeric_only: bool = False, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "kurt", None, kwargs)
+        return super().kurt(numeric_only=numeric_only, **kwargs)
 
     @doc(
         template_header,
@@ -2315,6 +2530,7 @@ def kurt(self, **kwargs):
                 * midpoint: (`i` + `j`) / 2.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2343,10 +2559,18 @@ def kurt(self, **kwargs):
         aggregation_description="quantile",
         agg_method="quantile",
     )
-    def quantile(self, quantile: float, interpolation: str = "linear", **kwargs):
+    def quantile(
+        self,
+        quantile: float,
+        interpolation: QuantileInterpolation = "linear",
+        numeric_only: bool = False,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "quantile", None, kwargs)
         return super().quantile(
             quantile=quantile,
             interpolation=interpolation,
+            numeric_only=numeric_only,
             **kwargs,
         )
 
@@ -2370,6 +2594,7 @@ def quantile(self, quantile: float, interpolation: str = "linear", **kwargs):
             form.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2416,12 +2641,15 @@ def rank(
         method: WindowingRankType = "average",
         ascending: bool = True,
         pct: bool = False,
+        numeric_only: bool = False,
         **kwargs,
     ):
+        maybe_warn_args_and_kwargs(type(self), "rank", None, kwargs)
         return super().rank(
             method=method,
             ascending=ascending,
             pct=pct,
+            numeric_only=numeric_only,
             **kwargs,
         )
 
@@ -2445,6 +2673,7 @@ def rank(
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2459,9 +2688,17 @@ def cov(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
-        return super().cov(other=other, pairwise=pairwise, ddof=ddof, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "cov", None, kwargs)
+        return super().cov(
+            other=other,
+            pairwise=pairwise,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
     @doc(
         template_header,
@@ -2483,6 +2720,7 @@ def cov(
             is ``N - ddof``, where ``N`` represents the number of elements.
         """
         ).replace("\n", "", 1),
+        kwargs_numeric_only,
         kwargs_compat,
         create_section_header("Returns"),
         template_returns,
@@ -2584,9 +2822,17 @@ def corr(
         other: DataFrame | Series | None = None,
         pairwise: bool | None = None,
         ddof: int = 1,
+        numeric_only: bool = False,
         **kwargs,
     ):
-        return super().corr(other=other, pairwise=pairwise, ddof=ddof, **kwargs)
+        maybe_warn_args_and_kwargs(type(self), "corr", None, kwargs)
+        return super().corr(
+            other=other,
+            pairwise=pairwise,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            **kwargs,
+        )
 
 
 Rolling.__doc__ = Window.__doc__
@@ -2619,7 +2865,9 @@ def _get_window_indexer(self) -> GroupbyIndexer:
             window = self.window
         elif self._win_freq_i8 is not None:
             rolling_indexer = VariableWindowIndexer
-            window = self._win_freq_i8
+            # error: Incompatible types in assignment (expression has type
+            # "int", variable has type "BaseIndexer")
+            window = self._win_freq_i8  # type: ignore[assignment]
         else:
             rolling_indexer = FixedWindowIndexer
             window = self.window
@@ -2632,12 +2880,20 @@ def _get_window_indexer(self) -> GroupbyIndexer:
         )
         return window_indexer
 
-    def _validate_monotonic(self):
+    def _validate_datetimelike_monotonic(self):
         """
-        Validate that on is monotonic;
+        Validate that each group in self._on is monotonic
         """
-        if (
-            not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing)
-            or self._on.hasnans
-        ):
-            self._raise_monotonic_error()
+        # GH 46061
+        if self._on.hasnans:
+            self._raise_monotonic_error("values must not have NaT")
+        for group_indices in self._grouper.indices.values():
+            group_on = self._on.take(group_indices)
+            if not (
+                group_on.is_monotonic_increasing or group_on.is_monotonic_decreasing
+            ):
+                on = "index" if self.on is None else self.on
+                raise ValueError(
+                    f"Each group within {on} must be monotonic. "
+                    f"Sort the values in {on} first."
+                )
diff --git a/pandas/errors/__init__.py b/pandas/errors/__init__.py
index cbe94673a8122..d0c9ef94f4453 100644
--- a/pandas/errors/__init__.py
+++ b/pandas/errors/__init__.py
@@ -1,10 +1,13 @@
 """
 Expose public exceptions & warnings
 """
+from __future__ import annotations
 
-from pandas._config.config import OptionError  # noqa:F401
+import ctypes
 
-from pandas._libs.tslibs import (  # noqa:F401
+from pandas._config.config import OptionError
+
+from pandas._libs.tslibs import (
     OutOfBoundsDatetime,
     OutOfBoundsTimedelta,
 )
@@ -12,21 +15,17 @@
 
 class IntCastingNaNError(ValueError):
     """
-    Raised when attempting an astype operation on an array with NaN to an integer
-    dtype.
+    Exception raised when converting (``astype``) an array with NaN to an integer type.
     """
 
-    pass
-
 
 class NullFrequencyError(ValueError):
     """
-    Error raised when a null `freq` attribute is used in an operation
-    that needs a non-null frequency, particularly `DatetimeIndex.shift`,
-    `TimedeltaIndex.shift`, `PeriodIndex.shift`.
-    """
+    Exception raised when a ``freq`` cannot be null.
 
-    pass
+    Particularly ``DatetimeIndex.shift``, ``TimedeltaIndex.shift``,
+    ``PeriodIndex.shift``.
+    """
 
 
 class PerformanceWarning(Warning):
@@ -37,16 +36,17 @@ class PerformanceWarning(Warning):
 
 class UnsupportedFunctionCall(ValueError):
     """
-    Exception raised when attempting to call a numpy function
-    on a pandas object, but that function is not supported by
-    the object e.g. ``np.cumsum(groupby_object)``.
+    Exception raised when attempting to call a unsupported numpy function.
+
+    For example, ``np.cumsum(groupby_object)``.
     """
 
 
 class UnsortedIndexError(KeyError):
     """
-    Error raised when attempting to get a slice of a MultiIndex,
-    and the index has not been lexsorted. Subclass of `KeyError`.
+    Error raised when slicing a MultiIndex which has not been lexsorted.
+
+    Subclass of `KeyError`.
     """
 
 
@@ -121,8 +121,7 @@ class DtypeWarning(Warning):
 
 class EmptyDataError(ValueError):
     """
-    Exception that is thrown in `pd.read_csv` (by both the C and
-    Python engines) when empty data or header is encountered.
+    Exception raised in ``pd.read_csv`` when empty data or header is encountered.
     """
 
 
@@ -169,8 +168,9 @@ class ParserWarning(Warning):
 
 class MergeError(ValueError):
     """
-    Error raised when problems arise during merging due to problems
-    with input data. Subclass of `ValueError`.
+    Exception raised when merging data.
+
+    Subclass of ``ValueError``.
     """
 
 
@@ -182,11 +182,10 @@ class AccessorRegistrationWarning(Warning):
 
 class AbstractMethodError(NotImplementedError):
     """
-    Raise this error instead of NotImplementedError for abstract methods
-    while keeping compatibility with Python 2 and Python 3.
+    Raise this error instead of NotImplementedError for abstract methods.
     """
 
-    def __init__(self, class_instance, methodtype="method"):
+    def __init__(self, class_instance, methodtype: str = "method") -> None:
         types = {"method", "classmethod", "staticmethod", "property"}
         if methodtype not in types:
             raise ValueError(
@@ -236,3 +235,342 @@ class InvalidIndexError(Exception):
 
     .. versionadded:: 1.1.0
     """
+
+
+class DataError(Exception):
+    """
+    Exceptionn raised when performing an operation on non-numerical data.
+
+    For example, calling ``ohlc`` on a non-numerical column or a function
+    on a rolling window.
+    """
+
+
+class SpecificationError(Exception):
+    """
+    Exception raised by ``agg`` when the functions are ill-specified.
+
+    The exception raised in two scenarios.
+
+    The first way is calling ``agg`` on a
+    Dataframe or Series using a nested renamer (dict-of-dict).
+
+    The second way is calling ``agg`` on a Dataframe with duplicated functions
+    names without assigning column name.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2],
+    ...                    'B': range(5),
+    ...                    'C': range(5)})
+    >>> df.groupby('A').B.agg({'foo': 'count'}) # doctest: +SKIP
+    ... # SpecificationError: nested renamer is not supported
+
+    >>> df.groupby('A').agg({'B': {'foo': ['sum', 'max']}}) # doctest: +SKIP
+    ... # SpecificationError: nested renamer is not supported
+
+    >>> df.groupby('A').agg(['min', 'min']) # doctest: +SKIP
+    ... # SpecificationError: nested renamer is not supported
+    """
+
+
+class SettingWithCopyError(ValueError):
+    """
+    Exception raised when trying to set on a copied slice from a ``DataFrame``.
+
+    The ``mode.chained_assignment`` needs to be set to set to 'raise.' This can
+    happen unintentionally when chained indexing.
+
+    For more information on eveluation order,
+    see :ref:`the user guide<indexing.evaluation_order>`.
+
+    For more information on view vs. copy,
+    see :ref:`the user guide<indexing.view_versus_copy>`.
+
+    Examples
+    --------
+    >>> pd.options.mode.chained_assignment = 'raise'
+    >>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2]}, columns=['A'])
+    >>> df.loc[0:3]['A'] = 'a' # doctest: +SKIP
+    ... # SettingWithCopyError: A value is trying to be set on a copy of a...
+    """
+
+
+class SettingWithCopyWarning(Warning):
+    """
+    Warning raised when trying to set on a copied slice from a ``DataFrame``.
+
+    The ``mode.chained_assignment`` needs to be set to set to 'warn.'
+    'Warn' is the default option. This can happen unintentionally when
+    chained indexing.
+
+    For more information on eveluation order,
+    see :ref:`the user guide<indexing.evaluation_order>`.
+
+    For more information on view vs. copy,
+    see :ref:`the user guide<indexing.view_versus_copy>`.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2]}, columns=['A'])
+    >>> df.loc[0:3]['A'] = 'a' # doctest: +SKIP
+    ... # SettingWithCopyWarning: A value is trying to be set on a copy of a...
+    """
+
+
+class NumExprClobberingError(NameError):
+    """
+    Exception raised when trying to use a built-in numexpr name as a variable name.
+
+    ``eval`` or ``query`` will throw the error if the engine is set
+    to 'numexpr'. 'numexpr' is the default engine value for these methods if the
+    numexpr package is installed.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'abs': [1, 1, 1]})
+    >>> df.query("abs > 2") # doctest: +SKIP
+    ... # NumExprClobberingError: Variables in expression "(abs) > (2)" overlap...
+    >>> sin, a = 1, 2
+    >>> pd.eval("sin + a", engine='numexpr') # doctest: +SKIP
+    ... # NumExprClobberingError: Variables in expression "(sin) + (a)" overlap...
+    """
+
+
+class UndefinedVariableError(NameError):
+    """
+    Exception raised by ``query`` or ``eval`` when using an undefined variable name.
+
+    It will also specify whether the undefined variable is local or not.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 1, 1]})
+    >>> df.query("A > x") # doctest: +SKIP
+    ... # UndefinedVariableError: name 'x' is not defined
+    >>> df.query("A > @y") # doctest: +SKIP
+    ... # UndefinedVariableError: local variable 'y' is not defined
+    >>> pd.eval('x + 1') # doctest: +SKIP
+    ... # UndefinedVariableError: name 'x' is not defined
+    """
+
+    def __init__(self, name: str, is_local: bool | None = None) -> None:
+        base_msg = f"{repr(name)} is not defined"
+        if is_local:
+            msg = f"local variable {base_msg}"
+        else:
+            msg = f"name {base_msg}"
+        super().__init__(msg)
+
+
+class IndexingError(Exception):
+    """
+    Exception is raised when trying to index and there is a mismatch in dimensions.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 1, 1]})
+    >>> df.loc[..., ..., 'A'] # doctest: +SKIP
+    ... # IndexingError: indexer may only contain one '...' entry
+    >>> df = pd.DataFrame({'A': [1, 1, 1]})
+    >>> df.loc[1, ..., ...] # doctest: +SKIP
+    ... # IndexingError: Too many indexers
+    >>> df[pd.Series([True], dtype=bool)] # doctest: +SKIP
+    ... # IndexingError: Unalignable boolean Series provided as indexer...
+    >>> s = pd.Series(range(2),
+    ...               index = pd.MultiIndex.from_product([["a", "b"], ["c"]]))
+    >>> s.loc["a", "c", "d"] # doctest: +SKIP
+    ... # IndexingError: Too many indexers
+    """
+
+
+class PyperclipException(RuntimeError):
+    """
+    Exception raised when clipboard functionality is unsupported.
+
+    Raised by ``to_clipboard()`` and ``read_clipboard()``.
+    """
+
+
+class PyperclipWindowsException(PyperclipException):
+    """
+    Exception raised when clipboard functionality is unsupported by Windows.
+
+    Access to the clipboard handle would be denied due to some other
+    window process is accessing it.
+    """
+
+    def __init__(self, message: str) -> None:
+        # attr only exists on Windows, so typing fails on other platforms
+        message += f" ({ctypes.WinError()})"  # type: ignore[attr-defined]
+        super().__init__(message)
+
+
+class CSSWarning(UserWarning):
+    """
+    Warning is raised when converting css styling fails.
+
+    This can be due to the styling not having an equivalent value or because the
+    styling isn't properly formatted.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 1, 1]})
+    >>> df.style.applymap(lambda x: 'background-color: blueGreenRed;')
+    ...         .to_excel('styled.xlsx') # doctest: +SKIP
+    ... # CSSWarning: Unhandled color format: 'blueGreenRed'
+    >>> df.style.applymap(lambda x: 'border: 1px solid red red;')
+    ...         .to_excel('styled.xlsx') # doctest: +SKIP
+    ... # CSSWarning: Too many tokens provided to "border" (expected 1-3)
+    """
+
+
+class PossibleDataLossError(Exception):
+    """
+    Exception raised when trying to open a HDFStore file when already opened.
+
+    Examples
+    --------
+    >>> store = pd.HDFStore('my-store', 'a') # doctest: +SKIP
+    >>> store.open("w") # doctest: +SKIP
+    ... # PossibleDataLossError: Re-opening the file [my-store] with mode [a]...
+    """
+
+
+class ClosedFileError(Exception):
+    """
+    Exception is raised when trying to perform an operation on a closed HDFStore file.
+
+    Examples
+    --------
+    >>> store = pd.HDFStore('my-store', 'a') # doctest: +SKIP
+    >>> store.close() # doctest: +SKIP
+    >>> store.keys() # doctest: +SKIP
+    ... # ClosedFileError: my-store file is not open!
+    """
+
+
+class IncompatibilityWarning(Warning):
+    """
+    Warning raised when trying to use where criteria on an incompatible HDF5 file.
+    """
+
+
+class AttributeConflictWarning(Warning):
+    """
+    Warning raised when index attributes conflict when using HDFStore.
+
+    Occurs when attempting to append an index with a different
+    name than the existing index on an HDFStore or attempting to append an index with a
+    different frequency than the existing index on an HDFStore.
+    """
+
+
+class DatabaseError(OSError):
+    """
+    Error is raised when executing sql with bad syntax or sql that throws an error.
+
+    Examples
+    --------
+    >>> from sqlite3 import connect
+    >>> conn = connect(':memory:')
+    >>> pd.read_sql('select * test', conn) # doctest: +SKIP
+    ... # DatabaseError: Execution failed on sql 'test': near "test": syntax error
+    """
+
+
+class PossiblePrecisionLoss(Warning):
+    """
+    Warning raised by to_stata on a column with a value outside or equal to int64.
+
+    When the column value is outside or equal to the int64 value the column is
+    converted to a float64 dtype.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({"s": pd.Series([1, 2**53], dtype=np.int64)})
+    >>> df.to_stata('test') # doctest: +SKIP
+    ... # PossiblePrecisionLoss: Column converted from int64 to float64...
+    """
+
+
+class ValueLabelTypeMismatch(Warning):
+    """
+    Warning raised by to_stata on a category column that contains non-string values.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({"categories": pd.Series(["a", 2], dtype="category")})
+    >>> df.to_stata('test') # doctest: +SKIP
+    ... # ValueLabelTypeMismatch: Stata value labels (pandas categories) must be str...
+    """
+
+
+class InvalidColumnName(Warning):
+    """
+    Warning raised by to_stata the column contains a non-valid stata name.
+
+    Because the column name is an invalid Stata variable, the name needs to be
+    converted.
+
+    Examples
+    --------
+    >>> df = pd.DataFrame({"0categories": pd.Series([2, 2])})
+    >>> df.to_stata('test') # doctest: +SKIP
+    ... # InvalidColumnName: Not all pandas column names were valid Stata variable...
+    """
+
+
+class CategoricalConversionWarning(Warning):
+    """
+    Warning is raised when reading a partial labeled Stata file using a iterator.
+
+    Examples
+    --------
+    >>> from pandas.io.stata import StataReader
+    >>> with StataReader('dta_file', chunksize=2) as reader: # doctest: +SKIP
+    ...   for i, block in enumerate(reader):
+    ...      print(i, block))
+    ... # CategoricalConversionWarning: One or more series with value labels...
+    """
+
+
+__all__ = [
+    "AbstractMethodError",
+    "AccessorRegistrationWarning",
+    "AttributeConflictWarning",
+    "CategoricalConversionWarning",
+    "ClosedFileError",
+    "CSSWarning",
+    "DatabaseError",
+    "DataError",
+    "DtypeWarning",
+    "DuplicateLabelError",
+    "EmptyDataError",
+    "IncompatibilityWarning",
+    "IntCastingNaNError",
+    "InvalidColumnName",
+    "InvalidIndexError",
+    "IndexingError",
+    "MergeError",
+    "NullFrequencyError",
+    "NumbaUtilError",
+    "NumExprClobberingError",
+    "OptionError",
+    "OutOfBoundsDatetime",
+    "OutOfBoundsTimedelta",
+    "ParserError",
+    "ParserWarning",
+    "PerformanceWarning",
+    "PossibleDataLossError",
+    "PossiblePrecisionLoss",
+    "PyperclipException",
+    "PyperclipWindowsException",
+    "SettingWithCopyError",
+    "SettingWithCopyWarning",
+    "SpecificationError",
+    "UndefinedVariableError",
+    "UnsortedIndexError",
+    "UnsupportedFunctionCall",
+    "ValueLabelTypeMismatch",
+]
diff --git a/pandas/io/api.py b/pandas/io/api.py
index 5926f2166ee9d..4e8b34a61dfc6 100644
--- a/pandas/io/api.py
+++ b/pandas/io/api.py
@@ -2,8 +2,6 @@
 Data IO api
 """
 
-# flake8: noqa
-
 from pandas.io.clipboards import read_clipboard
 from pandas.io.excel import (
     ExcelFile,
@@ -38,3 +36,30 @@
 )
 from pandas.io.stata import read_stata
 from pandas.io.xml import read_xml
+
+__all__ = [
+    "ExcelFile",
+    "ExcelWriter",
+    "HDFStore",
+    "read_clipboard",
+    "read_csv",
+    "read_excel",
+    "read_feather",
+    "read_fwf",
+    "read_gbq",
+    "read_hdf",
+    "read_html",
+    "read_json",
+    "read_orc",
+    "read_parquet",
+    "read_pickle",
+    "read_sas",
+    "read_spss",
+    "read_sql",
+    "read_sql_query",
+    "read_sql_table",
+    "read_stata",
+    "read_table",
+    "read_xml",
+    "to_pickle",
+]
diff --git a/pandas/io/clipboard/__init__.py b/pandas/io/clipboard/__init__.py
index 94cda748e31e8..635fce37f1a0f 100644
--- a/pandas/io/clipboard/__init__.py
+++ b/pandas/io/clipboard/__init__.py
@@ -40,8 +40,10 @@
 Pyperclip into running them with whatever permissions the Python process has.
 
 """
+
 __version__ = "1.7.0"
 
+
 import contextlib
 import ctypes
 from ctypes import (
@@ -58,6 +60,12 @@
 import time
 import warnings
 
+from pandas.errors import (
+    PyperclipException,
+    PyperclipWindowsException,
+)
+from pandas.util._exceptions import find_stack_level
+
 # `import PyQt4` sys.exit()s if DISPLAY is not in the environment.
 # Thus, we need to detect the presence of $DISPLAY manually
 # and not load PyQt4 if it is absent.
@@ -87,17 +95,6 @@ def _executable_exists(name):
     )
 
 
-# Exceptions
-class PyperclipException(RuntimeError):
-    pass
-
-
-class PyperclipWindowsException(PyperclipException):
-    def __init__(self, message):
-        message += f" ({ctypes.WinError()})"
-        super().__init__(message)
-
-
 def _stringifyText(text) -> str:
     acceptedTypes = (str, int, float, bool)
     if not isinstance(text, acceptedTypes):
@@ -276,10 +273,14 @@ def copy_dev_clipboard(text):
         if text == "":
             warnings.warn(
                 "Pyperclip cannot copy a blank string to the clipboard on Cygwin. "
-                "This is effectively a no-op."
+                "This is effectively a no-op.",
+                stacklevel=find_stack_level(),
             )
         if "\r" in text:
-            warnings.warn("Pyperclip cannot handle \\r characters on Cygwin.")
+            warnings.warn(
+                "Pyperclip cannot handle \\r characters on Cygwin.",
+                stacklevel=find_stack_level(),
+            )
 
         with open("/dev/clipboard", "wt") as fd:
             fd.write(text)
@@ -305,7 +306,7 @@ def __bool__(self) -> bool:
 
 # Windows-related clipboard functions:
 class CheckedCall:
-    def __init__(self, f):
+    def __init__(self, f) -> None:
         super().__setattr__("f", f)
 
     def __call__(self, *args):
@@ -523,7 +524,8 @@ def determine_clipboard():
         if os.path.exists("/dev/clipboard"):
             warnings.warn(
                 "Pyperclip's support for Cygwin is not perfect, "
-                "see https://github.com/asweigart/pyperclip/issues/55"
+                "see https://github.com/asweigart/pyperclip/issues/55",
+                stacklevel=find_stack_level(),
             )
             return init_dev_clipboard_clipboard()
 
diff --git a/pandas/io/clipboards.py b/pandas/io/clipboards.py
index 0968f1facf128..a3e778e552439 100644
--- a/pandas/io/clipboards.py
+++ b/pandas/io/clipboards.py
@@ -4,6 +4,8 @@
 from io import StringIO
 import warnings
 
+from pandas.util._exceptions import find_stack_level
+
 from pandas.core.dtypes.generic import ABCDataFrame
 
 from pandas import (
@@ -79,7 +81,8 @@ def read_clipboard(sep: str = r"\s+", **kwargs):  # pragma: no cover
         kwargs["engine"] = "python"
     elif len(sep) > 1 and kwargs.get("engine") == "c":
         warnings.warn(
-            "read_clipboard with regex separator does not work properly with c engine."
+            "read_clipboard with regex separator does not work properly with c engine.",
+            stacklevel=find_stack_level(),
         )
 
     return read_csv(StringIO(text), sep=sep, **kwargs)
@@ -135,10 +138,14 @@ def to_clipboard(
             return
         except TypeError:
             warnings.warn(
-                "to_clipboard in excel mode requires a single character separator."
+                "to_clipboard in excel mode requires a single character separator.",
+                stacklevel=find_stack_level(),
             )
     elif sep is not None:
-        warnings.warn("to_clipboard with excel=False ignores the sep argument.")
+        warnings.warn(
+            "to_clipboard with excel=False ignores the sep argument.",
+            stacklevel=find_stack_level(),
+        )
 
     if isinstance(obj, ABCDataFrame):
         # str(df) has various unhelpful defaults, like truncation
diff --git a/pandas/io/common.py b/pandas/io/common.py
index eaf6f6475ec84..f31de63aa42a7 100644
--- a/pandas/io/common.py
+++ b/pandas/io/common.py
@@ -1,9 +1,12 @@
 """Common IO api utilities"""
 from __future__ import annotations
 
+from abc import (
+    ABC,
+    abstractmethod,
+)
 import bz2
 import codecs
-from collections import abc
 import dataclasses
 import functools
 import gzip
@@ -19,6 +22,7 @@
 import os
 from pathlib import Path
 import re
+import tarfile
 from typing import (
     IO,
     Any,
@@ -26,6 +30,7 @@
     Generic,
     Literal,
     Mapping,
+    Sequence,
     TypeVar,
     cast,
     overload,
@@ -54,7 +59,12 @@
 from pandas.util._decorators import doc
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.dtypes.common import is_file_like
+from pandas.core.dtypes.common import (
+    is_bool,
+    is_file_like,
+    is_integer,
+    is_list_like,
+)
 
 from pandas.core.shared_docs import _shared_docs
 
@@ -98,7 +108,6 @@ class IOHandles(Generic[AnyStr]):
     compression: CompressionDict
     created_handles: list[IO[bytes] | IO[str]] = dataclasses.field(default_factory=list)
     is_wrapped: bool = False
-    is_mmap: bool = False
 
     def close(self) -> None:
         """
@@ -112,11 +121,8 @@ def close(self) -> None:
             self.handle.flush()
             self.handle.detach()
             self.created_handles.remove(self.handle)
-        try:
-            for handle in self.created_handles:
-                handle.close()
-        except (OSError, ValueError):
-            pass
+        for handle in self.created_handles:
+            handle.close()
         self.created_handles = []
         self.is_wrapped = False
 
@@ -175,12 +181,32 @@ def _expand_user(filepath_or_buffer: str | BaseBufferT) -> str | BaseBufferT:
 
 
 def validate_header_arg(header: object) -> None:
-    if isinstance(header, bool):
+    if header is None:
+        return
+    if is_integer(header):
+        header = cast(int, header)
+        if header < 0:
+            # GH 27779
+            raise ValueError(
+                "Passing negative integer to header is invalid. "
+                "For no header, use header=None instead"
+            )
+        return
+    if is_list_like(header, allow_sets=False):
+        header = cast(Sequence, header)
+        if not all(map(is_integer, header)):
+            raise ValueError("header must be integer or list of integers")
+        if any(i < 0 for i in header):
+            raise ValueError("cannot specify multi-index header with negative integers")
+        return
+    if is_bool(header):
         raise TypeError(
             "Passing a bool to header is invalid. Use header=None for no header or "
             "header=int or list-like of ints to specify "
             "the row(s) making up the column names"
         )
+    # GH 16338
+    raise ValueError("header must be integer or list of integers")
 
 
 @overload
@@ -251,7 +277,10 @@ def is_fsspec_url(/service/url: FilePath | BaseBuffer) -> bool:
     )
 
 
-@doc(compression_options=_shared_docs["compression_options"] % "filepath_or_buffer")
+@doc(
+    storage_options=_shared_docs["storage_options"],
+    compression_options=_shared_docs["compression_options"] % "filepath_or_buffer",
+)
 def _get_filepath_or_buffer(
     filepath_or_buffer: FilePath | BaseBuffer,
     encoding: str = "utf-8",
@@ -274,13 +303,7 @@ def _get_filepath_or_buffer(
     encoding : the encoding to use to decode bytes, default is 'utf-8'
     mode : str, optional
 
-    storage_options : dict, optional
-        Extra options that make sense for a particular storage connection, e.g.
-        host, port, username, password, etc., if using a URL that will
-        be parsed by ``fsspec``, e.g., starting "s3://", "gcs://". An error
-        will be raised if providing this argument with a local path or
-        a file-like buffer. See the fsspec and backend storage implementation
-        docs for the set of allowed keys and values
+    {storage_options}
 
         .. versionadded:: 1.2.0
 
@@ -315,6 +338,7 @@ def _get_filepath_or_buffer(
         warnings.warn(
             f"{compression} will not write the byte order mark for {encoding}",
             UnicodeWarning,
+            stacklevel=find_stack_level(),
         )
 
     # Use binary mode when converting path-like objects to file-like objects (fsspec)
@@ -453,13 +477,18 @@ def file_path_to_url(/service/path: str) -> str:
     return urljoin("file:", pathname2url(https://github.com/path))
 
 
-_compression_to_extension = {
-    "gzip": ".gz",
-    "bz2": ".bz2",
-    "zip": ".zip",
-    "xz": ".xz",
-    "zstd": ".zst",
+_extension_to_compression = {
+    ".tar": "tar",
+    ".tar.gz": "tar",
+    ".tar.bz2": "tar",
+    ".tar.xz": "tar",
+    ".gz": "gzip",
+    ".bz2": "bz2",
+    ".zip": "zip",
+    ".xz": "xz",
+    ".zst": "zstd",
 }
+_supported_compressions = set(_extension_to_compression.values())
 
 
 def get_compression_method(
@@ -535,20 +564,18 @@ def infer_compression(
             return None
 
         # Infer compression from the filename/URL extension
-        for compression, extension in _compression_to_extension.items():
+        for extension, compression in _extension_to_compression.items():
             if filepath_or_buffer.lower().endswith(extension):
                 return compression
         return None
 
     # Compression has been specified. Check that it's valid
-    if compression in _compression_to_extension:
+    if compression in _supported_compressions:
         return compression
 
     # https://github.com/python/mypy/issues/5492
     # Unsupported operand types for + ("List[Optional[str]]" and "List[str]")
-    valid = ["infer", None] + sorted(
-        _compression_to_extension
-    )  # type: ignore[operator]
+    valid = ["infer", None] + sorted(_supported_compressions)  # type: ignore[operator]
     msg = (
         f"Unrecognized compression type: {compression}\n"
         f"Valid compression types are {valid}"
@@ -564,11 +591,10 @@ def check_parent_directory(path: Path | str) -> None:
     ----------
     path: Path or str
         Path to check parent directory of
-
     """
     parent = Path(path).parent
     if not parent.is_dir():
-        raise OSError(fr"Cannot save file into a non-existent directory: '{parent}'")
+        raise OSError(rf"Cannot save file into a non-existent directory: '{parent}'")
 
 
 @overload
@@ -601,6 +627,21 @@ def get_handle(
     ...
 
 
+@overload
+def get_handle(
+    path_or_buf: FilePath | BaseBuffer,
+    mode: str,
+    *,
+    encoding: str | None = ...,
+    compression: CompressionOptions = ...,
+    memory_map: bool = ...,
+    is_text: bool = ...,
+    errors: str | None = ...,
+    storage_options: StorageOptions = ...,
+) -> IOHandles[str] | IOHandles[bytes]:
+    ...
+
+
 @doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
 def get_handle(
     path_or_buf: FilePath | BaseBuffer,
@@ -638,7 +679,7 @@ def get_handle(
         .. versionchanged:: 1.4.0 Zstandard support.
 
     memory_map : bool, default False
-        See parsers._parser_params for more information.
+        See parsers._parser_params for more information. Only used by read_csv.
     is_text : bool, default True
         Whether the type of the content passed to the file/buffer is string or
         bytes. This is not the same as `"b" not in mode`. If a string content is
@@ -657,6 +698,8 @@ def get_handle(
     # Windows does not default to utf-8. Set to utf-8 for a consistent behavior
     encoding = encoding or "utf-8"
 
+    errors = errors or "strict"
+
     # read_csv does not know whether the buffer is opened in binary/text mode
     if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
         mode += "b"
@@ -679,14 +722,8 @@ def get_handle(
     handles: list[BaseBuffer]
 
     # memory mapping needs to be the first step
-    handle, memory_map, handles = _maybe_memory_map(
-        handle,
-        memory_map,
-        ioargs.encoding,
-        ioargs.mode,
-        errors,
-        ioargs.compression["method"] not in _compression_to_extension,
-    )
+    # only used for read_csv
+    handle, memory_map, handles = _maybe_memory_map(handle, memory_map)
 
     is_path = isinstance(handle, str)
     compression_args = dict(ioargs.compression)
@@ -707,8 +744,7 @@ def get_handle(
 
         # GZ Compression
         if compression == "gzip":
-            if is_path:
-                assert isinstance(handle, str)
+            if isinstance(handle, str):
                 # error: Incompatible types in assignment (expression has type
                 # "GzipFile", variable has type "Union[str, BaseBuffer]")
                 handle = gzip.GzipFile(  # type: ignore[assignment]
@@ -737,18 +773,18 @@ def get_handle(
 
         # ZIP Compression
         elif compression == "zip":
-            # error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
-            # BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
+            # error: Argument 1 to "_BytesZipFile" has incompatible type
+            # "Union[str, BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
             # ReadBuffer[bytes], WriteBuffer[bytes]]"
             handle = _BytesZipFile(
                 handle, ioargs.mode, **compression_args  # type: ignore[arg-type]
             )
-            if handle.mode == "r":
+            if handle.buffer.mode == "r":
                 handles.append(handle)
-                zip_names = handle.namelist()
+                zip_names = handle.buffer.namelist()
                 if len(zip_names) == 1:
-                    handle = handle.open(zip_names.pop())
-                elif len(zip_names) == 0:
+                    handle = handle.buffer.open(zip_names.pop())
+                elif not zip_names:
                     raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
                 else:
                     raise ValueError(
@@ -756,9 +792,40 @@ def get_handle(
                         f"Only one file per ZIP: {zip_names}"
                     )
 
+        # TAR Encoding
+        elif compression == "tar":
+            compression_args.setdefault("mode", ioargs.mode)
+            if isinstance(handle, str):
+                handle = _BytesTarFile(name=handle, **compression_args)
+            else:
+                # error: Argument "fileobj" to "_BytesTarFile" has incompatible
+                # type "BaseBuffer"; expected "Union[ReadBuffer[bytes],
+                # WriteBuffer[bytes], None]"
+                handle = _BytesTarFile(
+                    fileobj=handle, **compression_args  # type: ignore[arg-type]
+                )
+            assert isinstance(handle, _BytesTarFile)
+            if "r" in handle.buffer.mode:
+                handles.append(handle)
+                files = handle.buffer.getnames()
+                if len(files) == 1:
+                    file = handle.buffer.extractfile(files[0])
+                    assert file is not None
+                    handle = file
+                elif not files:
+                    raise ValueError(f"Zero files found in TAR archive {path_or_buf}")
+                else:
+                    raise ValueError(
+                        "Multiple files found in TAR archive. "
+                        f"Only one file per TAR archive: {files}"
+                    )
+
         # XZ Compression
         elif compression == "xz":
-            handle = get_lzma_file()(handle, ioargs.mode)
+            # error: Argument 1 to "LZMAFile" has incompatible type "Union[str,
+            # BaseBuffer]"; expected "Optional[Union[Union[str, bytes, PathLike[str],
+            # PathLike[bytes]], IO[bytes]]]"
+            handle = get_lzma_file()(handle, ioargs.mode)  # type: ignore[arg-type]
 
         # Zstd Compression
         elif compression == "zstd":
@@ -806,12 +873,19 @@ def get_handle(
             handle,
             encoding=ioargs.encoding,
         )
-    elif is_text and (compression or _is_binary_mode(handle, ioargs.mode)):
+    elif is_text and (
+        compression or memory_map or _is_binary_mode(handle, ioargs.mode)
+    ):
+        if (
+            not hasattr(handle, "readable")
+            or not hasattr(handle, "writable")
+            or not hasattr(handle, "seekable")
+        ):
+            handle = _IOWrapper(handle)
+        # error: Argument 1 to "TextIOWrapper" has incompatible type
+        # "_IOWrapper"; expected "IO[bytes]"
         handle = TextIOWrapper(
-            # error: Argument 1 to "TextIOWrapper" has incompatible type
-            # "Union[IO[bytes], IO[Any], RawIOBase, BufferedIOBase, TextIOBase, mmap]";
-            # expected "IO[bytes]"
-            _IOWrapper(handle),  # type: ignore[arg-type]
+            handle,  # type: ignore[arg-type]
             encoding=ioargs.encoding,
             errors=errors,
             newline="",
@@ -842,157 +916,127 @@ def get_handle(
         # "List[BaseBuffer]"; expected "List[Union[IO[bytes], IO[str]]]"
         created_handles=handles,  # type: ignore[arg-type]
         is_wrapped=is_wrapped,
-        is_mmap=memory_map,
         compression=ioargs.compression,
     )
 
 
-# error: Definition of "__exit__" in base class "ZipFile" is incompatible with
-# definition in base class "BytesIO"  [misc]
-# error: Definition of "__enter__" in base class "ZipFile" is incompatible with
-# definition in base class "BytesIO"  [misc]
-# error: Definition of "__enter__" in base class "ZipFile" is incompatible with
-# definition in base class "BinaryIO"  [misc]
-# error: Definition of "__enter__" in base class "ZipFile" is incompatible with
-# definition in base class "IO"  [misc]
-# error: Definition of "read" in base class "ZipFile" is incompatible with
-# definition in base class "BytesIO"  [misc]
-# error: Definition of "read" in base class "ZipFile" is incompatible with
-# definition in base class "IO"  [misc]
-class _BytesZipFile(zipfile.ZipFile, BytesIO):  # type: ignore[misc]
+# error: Definition of "__enter__" in base class "IOBase" is incompatible
+# with definition in base class "BinaryIO"
+class _BufferedWriter(BytesIO, ABC):  # type: ignore[misc]
     """
-    Wrapper for standard library class ZipFile and allow the returned file-like
-    handle to accept byte strings via `write` method.
-
-    BytesIO provides attributes of file-like object and ZipFile.writestr writes
-    bytes strings into a member of the archive.
+    Some objects do not support multiple .write() calls (TarFile and ZipFile).
+    This wrapper writes to the underlying buffer on close.
     """
 
-    # GH 17778
+    @abstractmethod
+    def write_to_buffer(self) -> None:
+        ...
+
+    def close(self) -> None:
+        if self.closed:
+            # already closed
+            return
+        if self.getvalue():
+            # write to buffer
+            self.seek(0)
+            # error: "_BufferedWriter" has no attribute "buffer"
+            with self.buffer:  # type: ignore[attr-defined]
+                self.write_to_buffer()
+        else:
+            # error: "_BufferedWriter" has no attribute "buffer"
+            self.buffer.close()  # type: ignore[attr-defined]
+        super().close()
+
+
+class _BytesTarFile(_BufferedWriter):
+    def __init__(
+        self,
+        name: str | None = None,
+        mode: Literal["r", "a", "w", "x"] = "r",
+        fileobj: ReadBuffer[bytes] | WriteBuffer[bytes] | None = None,
+        archive_name: str | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.archive_name = archive_name
+        self.name = name
+        # error: Argument "fileobj" to "open" of "TarFile" has incompatible
+        # type "Union[ReadBuffer[bytes], WriteBuffer[bytes], None]"; expected
+        # "Optional[IO[bytes]]"
+        self.buffer = tarfile.TarFile.open(
+            name=name,
+            mode=self.extend_mode(mode),
+            fileobj=fileobj,  # type: ignore[arg-type]
+            **kwargs,
+        )
+
+    def extend_mode(self, mode: str) -> str:
+        mode = mode.replace("b", "")
+        if mode != "w":
+            return mode
+        if self.name is not None:
+            suffix = Path(self.name).suffix
+            if suffix in (".gz", ".xz", ".bz2"):
+                mode = f"{mode}:{suffix[1:]}"
+        return mode
+
+    def infer_filename(self) -> str | None:
+        """
+        If an explicit archive_name is not given, we still want the file inside the zip
+        file not to be named something.tar, because that causes confusion (GH39465).
+        """
+        if self.name is None:
+            return None
+
+        filename = Path(self.name)
+        if filename.suffix == ".tar":
+            return filename.with_suffix("").name
+        elif filename.suffix in (".tar.gz", ".tar.bz2", ".tar.xz"):
+            return filename.with_suffix("").with_suffix("").name
+        return filename.name
+
+    def write_to_buffer(self) -> None:
+        # TarFile needs a non-empty string
+        archive_name = self.archive_name or self.infer_filename() or "tar"
+        tarinfo = tarfile.TarInfo(name=archive_name)
+        tarinfo.size = len(self.getvalue())
+        self.buffer.addfile(tarinfo, self)
+
+
+class _BytesZipFile(_BufferedWriter):
     def __init__(
         self,
         file: FilePath | ReadBuffer[bytes] | WriteBuffer[bytes],
         mode: str,
         archive_name: str | None = None,
         **kwargs,
-    ):
+    ) -> None:
+        super().__init__()
         mode = mode.replace("b", "")
         self.archive_name = archive_name
-        self.multiple_write_buffer: StringIO | BytesIO | None = None
-
-        kwargs_zip: dict[str, Any] = {"compression": zipfile.ZIP_DEFLATED}
-        kwargs_zip.update(kwargs)
 
-        # error: Argument 1 to "__init__" of "ZipFile" has incompatible type
-        # "Union[_PathLike[str], Union[str, Union[IO[Any], RawIOBase, BufferedIOBase,
-        # TextIOBase, TextIOWrapper, mmap]]]"; expected "Union[Union[str,
-        # _PathLike[str]], IO[bytes]]"
-        super().__init__(file, mode, **kwargs_zip)  # type: ignore[arg-type]
+        kwargs.setdefault("compression", zipfile.ZIP_DEFLATED)
+        # error: Argument 1 to "ZipFile" has incompatible type "Union[
+        # Union[str, PathLike[str]], ReadBuffer[bytes], WriteBuffer[bytes]]";
+        # expected "Union[Union[str, PathLike[str]], IO[bytes]]"
+        self.buffer = zipfile.ZipFile(file, mode, **kwargs)  # type: ignore[arg-type]
 
-    def infer_filename(self):
+    def infer_filename(self) -> str | None:
         """
         If an explicit archive_name is not given, we still want the file inside the zip
         file not to be named something.zip, because that causes confusion (GH39465).
         """
-        if isinstance(self.filename, (os.PathLike, str)):
-            filename = Path(self.filename)
+        if isinstance(self.buffer.filename, (os.PathLike, str)):
+            filename = Path(self.buffer.filename)
             if filename.suffix == ".zip":
                 return filename.with_suffix("").name
             return filename.name
         return None
 
-    def write(self, data):
-        # buffer multiple write calls, write on flush
-        if self.multiple_write_buffer is None:
-            self.multiple_write_buffer = (
-                BytesIO() if isinstance(data, bytes) else StringIO()
-            )
-        self.multiple_write_buffer.write(data)
-
-    def flush(self) -> None:
-        # write to actual handle and close write buffer
-        if self.multiple_write_buffer is None or self.multiple_write_buffer.closed:
-            return
-
+    def write_to_buffer(self) -> None:
         # ZipFile needs a non-empty string
         archive_name = self.archive_name or self.infer_filename() or "zip"
-        with self.multiple_write_buffer:
-            super().writestr(archive_name, self.multiple_write_buffer.getvalue())
-
-    def close(self):
-        self.flush()
-        super().close()
-
-    @property
-    def closed(self):
-        return self.fp is None
-
-
-class _MMapWrapper(abc.Iterator):
-    """
-    Wrapper for the Python's mmap class so that it can be properly read in
-    by Python's csv.reader class.
-
-    Parameters
-    ----------
-    f : file object
-        File object to be mapped onto memory. Must support the 'fileno'
-        method or have an equivalent attribute
-
-    """
-
-    def __init__(
-        self,
-        f: IO,
-        encoding: str = "utf-8",
-        errors: str = "strict",
-        decode: bool = True,
-    ):
-        self.encoding = encoding
-        self.errors = errors
-        self.decoder = codecs.getincrementaldecoder(encoding)(errors=errors)
-        self.decode = decode
-
-        self.attributes = {}
-        for attribute in ("seekable", "readable"):
-            if not hasattr(f, attribute):
-                continue
-            self.attributes[attribute] = getattr(f, attribute)()
-        self.mmap = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
-
-    def __getattr__(self, name: str):
-        if name in self.attributes:
-            return lambda: self.attributes[name]
-        return getattr(self.mmap, name)
-
-    def __iter__(self) -> _MMapWrapper:
-        return self
-
-    def read(self, size: int = -1) -> str | bytes:
-        # CSV c-engine uses read instead of iterating
-        content: bytes = self.mmap.read(size)
-        if self.decode and self.encoding != "utf-8":
-            # memory mapping is applied before compression. Encoding should
-            # be applied to the de-compressed data.
-            final = size == -1 or len(content) < size
-            return self.decoder.decode(content, final=final)
-        return content
-
-    def __next__(self) -> str:
-        newbytes = self.mmap.readline()
-
-        # readline returns bytes, not str, but Python's CSV reader
-        # expects str, so convert the output to str before continuing
-        newline = self.decoder.decode(newbytes)
-
-        # mmap doesn't raise if reading past the allocated
-        # data but instead returns an empty string, so raise
-        # if that is returned
-        if newline == "":
-            raise StopIteration
-
-        # IncrementalDecoder seems to push newline to the next line
-        return newline.lstrip("\n")
+        self.buffer.writestr(archive_name, self.getvalue())
 
 
 class _IOWrapper:
@@ -1002,7 +1046,7 @@ class _IOWrapper:
     # methods, e.g., tempfile.SpooledTemporaryFile.
     # If a buffer does not have the above "-able" methods, we simple assume they are
     # seek/read/writ-able.
-    def __init__(self, buffer: BaseBuffer):
+    def __init__(self, buffer: BaseBuffer) -> None:
         self.buffer = buffer
 
     def __getattr__(self, name: str):
@@ -1029,7 +1073,7 @@ def writable(self) -> bool:
 class _BytesIOWrapper:
     # Wrapper that wraps a StringIO buffer and reads bytes from it
     # Created for compat with pyarrow read_csv
-    def __init__(self, buffer: StringIO | TextIOBase, encoding: str = "utf-8"):
+    def __init__(self, buffer: StringIO | TextIOBase, encoding: str = "utf-8") -> None:
         self.buffer = buffer
         self.encoding = encoding
         # Because a character can be represented by more than 1 byte,
@@ -1056,12 +1100,7 @@ def read(self, n: int | None = -1) -> bytes:
 
 
 def _maybe_memory_map(
-    handle: str | BaseBuffer,
-    memory_map: bool,
-    encoding: str,
-    mode: str,
-    errors: str | None,
-    decode: bool,
+    handle: str | BaseBuffer, memory_map: bool
 ) -> tuple[str | BaseBuffer, bool, list[BaseBuffer]]:
     """Try to memory map file/buffer."""
     handles: list[BaseBuffer] = []
@@ -1071,28 +1110,24 @@ def _maybe_memory_map(
 
     # need to open the file first
     if isinstance(handle, str):
-        if encoding and "b" not in mode:
-            # Encoding
-            handle = open(handle, mode, encoding=encoding, errors=errors, newline="")
-        else:
-            # Binary mode
-            handle = open(handle, mode)
+        handle = open(handle, "rb")
         handles.append(handle)
 
-    # error: Argument 1 to "_MMapWrapper" has incompatible type "Union[IO[Any],
-    # RawIOBase, BufferedIOBase, TextIOBase, mmap]"; expected "IO[Any]"
     try:
-        wrapped = cast(
-            BaseBuffer,
-            _MMapWrapper(handle, encoding, errors, decode),  # type: ignore[arg-type]
+        # open mmap and adds *-able
+        # error: Argument 1 to "_IOWrapper" has incompatible type "mmap";
+        # expected "BaseBuffer"
+        wrapped = _IOWrapper(
+            mmap.mmap(
+                handle.fileno(), 0, access=mmap.ACCESS_READ  # type: ignore[arg-type]
+            )
         )
     finally:
         for handle in reversed(handles):
             # error: "BaseBuffer" has no attribute "close"
             handle.close()  # type: ignore[attr-defined]
-    handles.append(wrapped)
 
-    return wrapped, memory_map, handles
+    return wrapped, memory_map, [wrapped]
 
 
 def file_exists(filepath_or_buffer: FilePath | BaseBuffer) -> bool:
diff --git a/pandas/io/date_converters.py b/pandas/io/date_converters.py
index 077524fbee465..85e92da8c2a54 100644
--- a/pandas/io/date_converters.py
+++ b/pandas/io/date_converters.py
@@ -1,13 +1,16 @@
 """This module is designed for community supported date conversion functions"""
+from __future__ import annotations
+
 import warnings
 
 import numpy as np
 
 from pandas._libs.tslibs import parsing
+from pandas._typing import npt
 from pandas.util._exceptions import find_stack_level
 
 
-def parse_date_time(date_col, time_col):
+def parse_date_time(date_col, time_col) -> npt.NDArray[np.object_]:
     """
     Parse columns with dates and times into a single datetime column.
 
@@ -26,7 +29,7 @@ def parse_date_time(date_col, time_col):
     return parsing.try_parse_date_and_time(date_col, time_col)
 
 
-def parse_date_fields(year_col, month_col, day_col):
+def parse_date_fields(year_col, month_col, day_col) -> npt.NDArray[np.object_]:
     """
     Parse columns with years, months and days into a single date column.
 
@@ -48,7 +51,9 @@ def parse_date_fields(year_col, month_col, day_col):
     return parsing.try_parse_year_month_day(year_col, month_col, day_col)
 
 
-def parse_all_fields(year_col, month_col, day_col, hour_col, minute_col, second_col):
+def parse_all_fields(
+    year_col, month_col, day_col, hour_col, minute_col, second_col
+) -> npt.NDArray[np.object_]:
     """
     Parse columns with datetime information into a single datetime column.
 
@@ -78,7 +83,7 @@ def parse_all_fields(year_col, month_col, day_col, hour_col, minute_col, second_
     )
 
 
-def generic_parser(parse_func, *cols):
+def generic_parser(parse_func, *cols) -> np.ndarray:
     """
     Use dateparser to parse columns with data information into a single datetime column.
 
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index b490244f7f396..4b7cd1a99ed20 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -2,6 +2,7 @@
 
 import abc
 import datetime
+from functools import partial
 from io import BytesIO
 import os
 from textwrap import fill
@@ -40,6 +41,7 @@
 from pandas.errors import EmptyDataError
 from pandas.util._decorators import (
     Appender,
+    deprecate_kwarg,
     deprecate_nonkeyword_arguments,
     doc,
 )
@@ -70,6 +72,7 @@
     pop_header_name,
 )
 from pandas.io.parsers import TextParser
+from pandas.io.parsers.readers import validate_integer
 
 _read_excel_doc = (
     """
@@ -119,12 +122,18 @@
     those columns will be combined into a ``MultiIndex``.  If a
     subset of data is selected with ``usecols``, index_col
     is based on the subset.
-usecols : int, str, list-like, or callable default None
+
+    Missing values will be forward filled to allow roundtripping with
+    ``to_excel`` for ``merged_cells=True``. To avoid forward filling the
+    missing values use ``set_index`` after reading the data instead of
+    ``index_col``.
+usecols : str, list-like, or callable, default None
     * If None, then parse all columns.
     * If str, then indicates comma separated list of Excel column letters
       and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of
       both sides.
-    * If list of int, then indicates list of column numbers to be parsed.
+    * If list of int, then indicates list of column numbers to be parsed
+      (0-indexed).
     * If list of string, then indicates list of column names to be parsed.
     * If callable, then evaluate each column name against it and parse the
       column if the callable returns ``True``.
@@ -137,7 +146,7 @@
        Append ``.squeeze("columns")`` to the call to ``read_excel`` to squeeze
        the data.
 dtype : Type name or dict of column -> type, default None
-    Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}
+    Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32}}
     Use `object` to preserve data as stored in Excel and not interpret dtype.
     If converters are specified, they will be applied INSTEAD
     of dtype conversion.
@@ -221,7 +230,7 @@
       each as a separate date column.
     * list of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as
       a single date column.
-    * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call
+    * dict, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
       result 'foo'
 
     If a column or index contains an unparsable date, the entire column or
@@ -271,13 +280,12 @@
     Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than
     'X'...'X'. Passing in False will cause data to be overwritten if there
     are duplicate names in the columns.
-storage_options : dict, optional
-    Extra options that make sense for a particular storage connection, e.g.
-    host, port, username, password, etc., if using a URL that will
-    be parsed by ``fsspec``, e.g., starting "s3://", "gcs://". An error
-    will be raised if providing this argument with a local path or
-    a file-like buffer. See the fsspec and backend storage implementation
-    docs for the set of allowed keys and values.
+
+    .. deprecated:: 1.5.0
+        Not implemented, and a new argument to specify the pattern for the
+        names of duplicated columns will be added instead
+
+{storage_options}
 
     .. versionadded:: 1.2.0
 
@@ -323,7 +331,7 @@
 Column types are inferred but can be explicitly specified
 
 >>> pd.read_excel('tmp.xlsx', index_col=0,
-...               dtype={'Name': str, 'Value': float})  # doctest: +SKIP
+...               dtype={{'Name': str, 'Value': float}})  # doctest: +SKIP
        Name  Value
 0   string1    1.0
 1   string2    2.0
@@ -355,15 +363,20 @@
 def read_excel(
     io,
     # sheet name is str or int -> DataFrame
-    sheet_name: str | int,
+    sheet_name: str | int = ...,
     header: int | Sequence[int] | None = ...,
-    names=...,
+    names: list[str] | None = ...,
     index_col: int | Sequence[int] | None = ...,
-    usecols=...,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = ...,
     squeeze: bool | None = ...,
     dtype: DtypeArg | None = ...,
     engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb"] | None = ...,
-    converters=...,
+    converters: dict[str, Callable] | dict[int, Callable] | None = ...,
     true_values: Iterable[Hashable] | None = ...,
     false_values: Iterable[Hashable] | None = ...,
     skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
@@ -372,8 +385,8 @@ def read_excel(
     keep_default_na: bool = ...,
     na_filter: bool = ...,
     verbose: bool = ...,
-    parse_dates=...,
-    date_parser=...,
+    parse_dates: list | dict | bool = ...,
+    date_parser: Callable | None = ...,
     thousands: str | None = ...,
     decimal: str = ...,
     comment: str | None = ...,
@@ -391,13 +404,18 @@ def read_excel(
     # sheet name is list or None -> dict[IntStrT, DataFrame]
     sheet_name: list[IntStrT] | None,
     header: int | Sequence[int] | None = ...,
-    names=...,
+    names: list[str] | None = ...,
     index_col: int | Sequence[int] | None = ...,
-    usecols=...,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = ...,
     squeeze: bool | None = ...,
     dtype: DtypeArg | None = ...,
     engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb"] | None = ...,
-    converters=...,
+    converters: dict[str, Callable] | dict[int, Callable] | None = ...,
     true_values: Iterable[Hashable] | None = ...,
     false_values: Iterable[Hashable] | None = ...,
     skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
@@ -406,8 +424,8 @@ def read_excel(
     keep_default_na: bool = ...,
     na_filter: bool = ...,
     verbose: bool = ...,
-    parse_dates=...,
-    date_parser=...,
+    parse_dates: list | dict | bool = ...,
+    date_parser: Callable | None = ...,
     thousands: str | None = ...,
     decimal: str = ...,
     comment: str | None = ...,
@@ -419,19 +437,26 @@ def read_excel(
     ...
 
 
+@doc(storage_options=_shared_docs["storage_options"])
+@deprecate_kwarg(old_arg_name="mangle_dupe_cols", new_arg_name=None)
 @deprecate_nonkeyword_arguments(allowed_args=["io", "sheet_name"], version="2.0")
 @Appender(_read_excel_doc)
 def read_excel(
     io,
     sheet_name: str | int | list[IntStrT] | None = 0,
     header: int | Sequence[int] | None = 0,
-    names=None,
+    names: list[str] | None = None,
     index_col: int | Sequence[int] | None = None,
-    usecols=None,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = None,
     squeeze: bool | None = None,
     dtype: DtypeArg | None = None,
     engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb"] | None = None,
-    converters=None,
+    converters: dict[str, Callable] | dict[int, Callable] | None = None,
     true_values: Iterable[Hashable] | None = None,
     false_values: Iterable[Hashable] | None = None,
     skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
@@ -440,8 +465,8 @@ def read_excel(
     keep_default_na: bool = True,
     na_filter: bool = True,
     verbose: bool = False,
-    parse_dates=False,
-    date_parser=None,
+    parse_dates: list | dict | bool = False,
+    date_parser: Callable | None = None,
     thousands: str | None = None,
     decimal: str = ".",
     comment: str | None = None,
@@ -496,7 +521,9 @@ def read_excel(
 
 
 class BaseExcelReader(metaclass=abc.ABCMeta):
-    def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):
+    def __init__(
+        self, filepath_or_buffer, storage_options: StorageOptions = None
+    ) -> None:
         # First argument can also be bytes, so create a buffer
         if isinstance(filepath_or_buffer, bytes):
             filepath_or_buffer = BytesIO(filepath_or_buffer)
@@ -533,12 +560,17 @@ def _workbook_class(self):
     def load_workbook(self, filepath_or_buffer):
         pass
 
-    def close(self):
-        if hasattr(self, "book") and hasattr(self.book, "close"):
-            # pyxlsb: opens a TemporaryFile
-            # openpyxl: https://stackoverflow.com/questions/31416842/
-            #     openpyxl-does-not-close-excel-workbook-in-read-only-mode
-            self.book.close()
+    def close(self) -> None:
+        if hasattr(self, "book"):
+            if hasattr(self.book, "close"):
+                # pyxlsb: opens a TemporaryFile
+                # openpyxl: https://stackoverflow.com/questions/31416842/
+                #     openpyxl-does-not-close-excel-workbook-in-read-only-mode
+                self.book.close()
+            elif hasattr(self.book, "release_resources"):
+                # xlrd
+                # https://github.com/python-excel/xlrd/blob/2.0.1/xlrd/book.py#L548
+                self.book.release_resources()
         self.handles.close()
 
     @property
@@ -555,7 +587,7 @@ def get_sheet_by_index(self, index: int):
         pass
 
     @abc.abstractmethod
-    def get_sheet_data(self, sheet, convert_float: bool):
+    def get_sheet_data(self, sheet, convert_float: bool, rows: int | None = None):
         pass
 
     def raise_if_bad_sheet_by_index(self, index: int) -> None:
@@ -569,6 +601,99 @@ def raise_if_bad_sheet_by_name(self, name: str) -> None:
         if name not in self.sheet_names:
             raise ValueError(f"Worksheet named '{name}' not found")
 
+    def _check_skiprows_func(
+        self,
+        skiprows: Callable,
+        rows_to_use: int,
+    ) -> int:
+        """
+        Determine how many file rows are required to obtain `nrows` data
+        rows when `skiprows` is a function.
+
+        Parameters
+        ----------
+        skiprows : function
+            The function passed to read_excel by the user.
+        rows_to_use : int
+            The number of rows that will be needed for the header and
+            the data.
+
+        Returns
+        -------
+        int
+        """
+        i = 0
+        rows_used_so_far = 0
+        while rows_used_so_far < rows_to_use:
+            if not skiprows(i):
+                rows_used_so_far += 1
+            i += 1
+        return i
+
+    def _calc_rows(
+        self,
+        header: int | Sequence[int] | None,
+        index_col: int | Sequence[int] | None,
+        skiprows: Sequence[int] | int | Callable[[int], object] | None,
+        nrows: int | None,
+    ) -> int | None:
+        """
+        If nrows specified, find the number of rows needed from the
+        file, otherwise return None.
+
+
+        Parameters
+        ----------
+        header : int, list of int, or None
+            See read_excel docstring.
+        index_col : int, list of int, or None
+            See read_excel docstring.
+        skiprows : list-like, int, callable, or None
+            See read_excel docstring.
+        nrows : int or None
+            See read_excel docstring.
+
+        Returns
+        -------
+        int or None
+        """
+        if nrows is None:
+            return None
+        if header is None:
+            header_rows = 1
+        elif is_integer(header):
+            header = cast(int, header)
+            header_rows = 1 + header
+        else:
+            header = cast(Sequence, header)
+            header_rows = 1 + header[-1]
+        # If there is a MultiIndex header and an index then there is also
+        # a row containing just the index name(s)
+        if is_list_like(header) and index_col is not None:
+            header = cast(Sequence, header)
+            if len(header) > 1:
+                header_rows += 1
+        if skiprows is None:
+            return header_rows + nrows
+        if is_integer(skiprows):
+            skiprows = cast(int, skiprows)
+            return header_rows + nrows + skiprows
+        if is_list_like(skiprows):
+
+            def f(skiprows: Sequence, x: int) -> bool:
+                return x in skiprows
+
+            skiprows = cast(Sequence, skiprows)
+            return self._check_skiprows_func(partial(f, skiprows), header_rows + nrows)
+        if callable(skiprows):
+            return self._check_skiprows_func(
+                skiprows,
+                header_rows + nrows,
+            )
+        # else unexpected skiprows type: read_excel will not optimize
+        # the number of rows read from file
+        return None
+
     def parse(
         self,
         sheet_name: str | int | list[int] | list[str] | None = 0,
@@ -584,8 +709,8 @@ def parse(
         nrows: int | None = None,
         na_values=None,
         verbose: bool = False,
-        parse_dates=False,
-        date_parser=None,
+        parse_dates: list | dict | bool = False,
+        date_parser: Callable | None = None,
         thousands: str | None = None,
         decimal: str = ".",
         comment: str | None = None,
@@ -605,6 +730,7 @@ def parse(
             )
 
         validate_header_arg(header)
+        validate_integer("nrows", nrows)
 
         ret_dict = False
 
@@ -635,7 +761,8 @@ def parse(
             else:  # assume an integer if not a string
                 sheet = self.get_sheet_by_index(asheetname)
 
-            data = self.get_sheet_data(sheet, convert_float)
+            file_rows_needed = self._calc_rows(header, index_col, skiprows, nrows)
+            data = self.get_sheet_data(sheet, convert_float, file_rows_needed)
             if hasattr(sheet, "close"):
                 # pyxlsb opens two TemporaryFiles
                 sheet.close()
@@ -669,6 +796,12 @@ def parse(
                         assert isinstance(skiprows, int)
                         row += skiprows
 
+                    if row > len(data) - 1:
+                        raise ValueError(
+                            f"header index {row} exceeds maximum index "
+                            f"{len(data) - 1} of data.",
+                        )
+
                     data[row], control_row = fill_mi_header(data[row], control_row)
 
                     if index_col is not None:
@@ -677,9 +810,27 @@ def parse(
 
             # If there is a MultiIndex header and an index then there is also
             # a row containing just the index name(s)
-            has_index_names = (
-                is_list_header and not is_len_one_list_header and index_col is not None
-            )
+            has_index_names = False
+            if is_list_header and not is_len_one_list_header and index_col is not None:
+
+                index_col_list: Sequence[int]
+                if isinstance(index_col, int):
+                    index_col_list = [index_col]
+                else:
+                    assert isinstance(index_col, Sequence)
+                    index_col_list = index_col
+
+                # We have to handle mi without names. If any of the entries in the data
+                # columns are not empty, this is a regular row
+                assert isinstance(header, Sequence)
+                if len(header) < len(data):
+                    potential_index_names = data[len(header)]
+                    potential_data = [
+                        x
+                        for i, x in enumerate(potential_index_names)
+                        if not control_row[i] and i not in index_col_list
+                    ]
+                    has_index_names = all(x == "" or x is None for x in potential_data)
 
             if is_list_like(index_col):
                 # Forward fill values for MultiIndex index.
@@ -755,15 +906,19 @@ def parse(
             return output[asheetname]
 
 
+@doc(storage_options=_shared_docs["storage_options"])
 class ExcelWriter(metaclass=abc.ABCMeta):
     """
     Class for writing DataFrame objects into excel sheets.
 
-    Default is to use :
-    * xlwt for xls
-    * xlsxwriter for xlsx if xlsxwriter is installed otherwise openpyxl
-    * odf for ods.
-    See DataFrame.to_excel for typical usage.
+    Default is to use:
+
+    * `xlwt <https://pypi.org/project/xlwt/>`__ for xls files
+    * `xlsxwriter <https://pypi.org/project/XlsxWriter/>`__ for xlsx files if xlsxwriter
+      is installed otherwise `openpyxl <https://pypi.org/project/openpyxl/>`__
+    * `odswriter <https://pypi.org/project/odswriter/>`__ for ods files
+
+    See ``DataFrame.to_excel`` for typical usage.
 
     The writer should be used as a context manager. Otherwise, call `close()` to save
     and close any opened file handles.
@@ -788,16 +943,13 @@ class ExcelWriter(metaclass=abc.ABCMeta):
     datetime_format : str, default None
         Format string for datetime objects written into Excel files.
         (e.g. 'YYYY-MM-DD HH:MM:SS').
-    mode : {'w', 'a'}, default 'w'
+    mode : {{'w', 'a'}}, default 'w'
         File mode to use (write or append). Append does not work with fsspec URLs.
-    storage_options : dict, optional
-        Extra options that make sense for a particular storage connection, e.g.
-        host, port, username, password, etc., if using a URL that will
-        be parsed by ``fsspec``, e.g., starting "s3://", "gcs://".
+    {storage_options}
 
         .. versionadded:: 1.2.0
 
-    if_sheet_exists : {'error', 'new', 'replace', 'overlay'}, default 'error'
+    if_sheet_exists : {{'error', 'new', 'replace', 'overlay'}}, default 'error'
         How to behave when trying to write to a sheet that already
         exists (append mode only).
 
@@ -830,18 +982,8 @@ class ExcelWriter(metaclass=abc.ABCMeta):
 
             Use engine_kwargs instead.
 
-    Attributes
-    ----------
-    None
-
-    Methods
-    -------
-    None
-
     Notes
     -----
-    None of the methods and properties are considered public.
-
     For compatibility with CSV writers, ExcelWriter serializes lists
     and dicts to strings before writing.
 
@@ -928,7 +1070,7 @@ class ExcelWriter(metaclass=abc.ABCMeta):
     >>> with pd.ExcelWriter(
     ...     "path_to_file.xlsx",
     ...     engine="xlsxwriter",
-    ...     engine_kwargs={"options": {"nan_inf_to_errors": True}}
+    ...     engine_kwargs={{"options": {{"nan_inf_to_errors": True}}}}
     ... ) as writer:
     ...     df.to_excel(writer)  # doctest: +SKIP
 
@@ -939,7 +1081,7 @@ class ExcelWriter(metaclass=abc.ABCMeta):
     ...     "path_to_file.xlsx",
     ...     engine="openpyxl",
     ...     mode="a",
-    ...     engine_kwargs={"keep_vba": True}
+    ...     engine_kwargs={{"keep_vba": True}}
     ... ) as writer:
     ...     df.to_excel(writer, sheet_name="Sheet2")  # doctest: +SKIP
     """
@@ -949,9 +1091,9 @@ class ExcelWriter(metaclass=abc.ABCMeta):
     # - Mandatory
     #   - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``
     #     --> called to write additional DataFrames to disk
-    #   - ``supported_extensions`` (tuple of supported extensions), used to
+    #   - ``_supported_extensions`` (tuple of supported extensions), used to
     #      check that engine supports the given extension.
-    #   - ``engine`` - string that gives the engine name. Necessary to
+    #   - ``_engine`` - string that gives the engine name. Necessary to
     #     instantiate class directly and bypass ``ExcelWriterMeta`` engine
     #     lookup.
     #   - ``save(self)`` --> called to save file to disk
@@ -965,8 +1107,12 @@ class ExcelWriter(metaclass=abc.ABCMeta):
     # You also need to register the class with ``register_writer()``.
     # Technically, ExcelWriter implementations don't need to subclass
     # ExcelWriter.
+
+    _engine: str
+    _supported_extensions: tuple[str, ...]
+
     def __new__(
-        cls,
+        cls: type[ExcelWriter],
         path: FilePath | WriteExcelBuffer | ExcelWriter,
         engine: str | None = None,
         date_format: str | None = None,
@@ -976,7 +1122,7 @@ def __new__(
         if_sheet_exists: Literal["error", "new", "replace", "overlay"] | None = None,
         engine_kwargs: dict | None = None,
         **kwargs,
-    ):
+    ) -> ExcelWriter:
         if kwargs:
             if engine_kwargs is not None:
                 raise ValueError("Cannot use both engine_kwargs and **kwargs")
@@ -987,7 +1133,6 @@ def __new__(
             )
 
         # only switch class if generic(ExcelWriter)
-
         if cls is ExcelWriter:
             if engine is None or (isinstance(engine, str) and engine == "auto"):
                 if isinstance(path, str):
@@ -1028,21 +1173,46 @@ def __new__(
         return object.__new__(cls)
 
     # declare external properties you can count on
-    path = None
+    _path = None
 
     @property
-    @abc.abstractmethod
-    def supported_extensions(self) -> tuple[str, ...] | list[str]:
+    def supported_extensions(self) -> tuple[str, ...]:
         """Extensions that writer engine supports."""
-        pass
+        return self._supported_extensions
 
     @property
-    @abc.abstractmethod
     def engine(self) -> str:
         """Name of engine."""
+        return self._engine
+
+    @property
+    @abc.abstractmethod
+    def sheets(self) -> dict[str, Any]:
+        """Mapping of sheet names to sheet objects."""
+        pass
+
+    # mypy doesn't handle abstract setters prior to 0.981
+    # https://github.com/python/mypy/issues/4165
+    @property  # type: ignore[misc]
+    @abc.abstractmethod
+    def book(self):
+        """
+        Book instance. Class type will depend on the engine used.
+
+        This attribute can be used to access engine-specific features.
+        """
         pass
 
+    # mypy doesn't handle abstract setters prior to 0.981
+    # https://github.com/python/mypy/issues/4165
+    @book.setter  # type: ignore[misc]
     @abc.abstractmethod
+    def book(self, other) -> None:
+        """
+        Set book instance. Class type will depend on the engine used.
+        """
+        pass
+
     def write_cells(
         self,
         cells,
@@ -1054,6 +1224,8 @@ def write_cells(
         """
         Write given formatted cells into Excel an excel sheet
 
+        .. deprecated:: 1.5.0
+
         Parameters
         ----------
         cells : generator
@@ -1065,12 +1237,47 @@ def write_cells(
         freeze_panes: int tuple of length 2
             contains the bottom-most row and right-most column to freeze
         """
-        pass
+        self._deprecate("write_cells")
+        return self._write_cells(cells, sheet_name, startrow, startcol, freeze_panes)
 
     @abc.abstractmethod
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
+        """
+        Write given formatted cells into Excel an excel sheet
+
+        Parameters
+        ----------
+        cells : generator
+            cell of formatted data to save to Excel sheet
+        sheet_name : str, default None
+            Name of Excel sheet, if None, then use self.cur_sheet
+        startrow : upper left cell row to dump data frame
+        startcol : upper left cell column to dump data frame
+        freeze_panes: int tuple of length 2
+            contains the bottom-most row and right-most column to freeze
+        """
+        pass
+
     def save(self) -> None:
         """
         Save workbook to disk.
+
+        .. deprecated:: 1.5.0
+        """
+        self._deprecate("save")
+        return self._save()
+
+    @abc.abstractmethod
+    def _save(self) -> None:
+        """
+        Save workbook to disk.
         """
         pass
 
@@ -1083,9 +1290,9 @@ def __init__(
         mode: str = "w",
         storage_options: StorageOptions = None,
         if_sheet_exists: str | None = None,
-        engine_kwargs: dict | None = None,
+        engine_kwargs: dict[str, Any] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         # validate that this engine can handle the extension
         if isinstance(path, str):
             ext = os.path.splitext(path)[-1]
@@ -1099,26 +1306,25 @@ def __init__(
         mode = mode.replace("a", "r+")
 
         # cast ExcelWriter to avoid adding 'if self.handles is not None'
-        self.handles = IOHandles(
+        self._handles = IOHandles(
             cast(IO[bytes], path), compression={"compression": None}
         )
         if not isinstance(path, ExcelWriter):
-            self.handles = get_handle(
+            self._handles = get_handle(
                 path, mode, storage_options=storage_options, is_text=False
             )
-        self.sheets: dict[str, Any] = {}
-        self.cur_sheet = None
+        self._cur_sheet = None
 
         if date_format is None:
-            self.date_format = "YYYY-MM-DD"
+            self._date_format = "YYYY-MM-DD"
         else:
-            self.date_format = date_format
+            self._date_format = date_format
         if datetime_format is None:
-            self.datetime_format = "YYYY-MM-DD HH:MM:SS"
+            self._datetime_format = "YYYY-MM-DD HH:MM:SS"
         else:
-            self.datetime_format = datetime_format
+            self._datetime_format = datetime_format
 
-        self.mode = mode
+        self._mode = mode
 
         if if_sheet_exists not in (None, "error", "new", "replace", "overlay"):
             raise ValueError(
@@ -1129,16 +1335,90 @@ def __init__(
             raise ValueError("if_sheet_exists is only valid in append mode (mode='a')")
         if if_sheet_exists is None:
             if_sheet_exists = "error"
-        self.if_sheet_exists = if_sheet_exists
+        self._if_sheet_exists = if_sheet_exists
 
-    def __fspath__(self):
-        return getattr(self.handles.handle, "name", "")
+    def _deprecate(self, attr: str):
+        """
+        Deprecate attribute or method for ExcelWriter.
+        """
+        warnings.warn(
+            f"{attr} is not part of the public API, usage can give unexpected "
+            "results and will be removed in a future version",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    def _deprecate_set_book(self) -> None:
+        """
+        Deprecate setting the book attribute - GH#48780.
+        """
+        warnings.warn(
+            "Setting the `book` attribute is not part of the public API, "
+            "usage can give unexpected or corrupted results and will be "
+            "removed in a future version",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    @property
+    def date_format(self) -> str:
+        """
+        Format string for dates written into Excel files (e.g. ‘YYYY-MM-DD’).
+        """
+        return self._date_format
+
+    @property
+    def datetime_format(self) -> str:
+        """
+        Format string for dates written into Excel files (e.g. ‘YYYY-MM-DD’).
+        """
+        return self._datetime_format
+
+    @property
+    def if_sheet_exists(self) -> str:
+        """
+        How to behave when writing to a sheet that already exists in append mode.
+        """
+        return self._if_sheet_exists
+
+    @property
+    def cur_sheet(self):
+        """
+        Current sheet for writing.
+
+        .. deprecated:: 1.5.0
+        """
+        self._deprecate("cur_sheet")
+        return self._cur_sheet
+
+    @property
+    def handles(self) -> IOHandles[bytes]:
+        """
+        Handles to Excel sheets.
+
+        .. deprecated:: 1.5.0
+        """
+        self._deprecate("handles")
+        return self._handles
+
+    @property
+    def path(self):
+        """
+        Path to Excel file.
+
+        .. deprecated:: 1.5.0
+        """
+        self._deprecate("path")
+        return self._path
+
+    def __fspath__(self) -> str:
+        return getattr(self._handles.handle, "name", "")
 
     def _get_sheet_name(self, sheet_name: str | None) -> str:
         if sheet_name is None:
-            sheet_name = self.cur_sheet
+            sheet_name = self._cur_sheet
         if sheet_name is None:  # pragma: no cover
-            raise ValueError("Must pass explicit sheet_name or set cur_sheet property")
+            raise ValueError("Must pass explicit sheet_name or set _cur_sheet property")
         return sheet_name
 
     def _value_with_fmt(self, val) -> tuple[object, str | None]:
@@ -1164,9 +1444,9 @@ def _value_with_fmt(self, val) -> tuple[object, str | None]:
         elif is_bool(val):
             val = bool(val)
         elif isinstance(val, datetime.datetime):
-            fmt = self.datetime_format
+            fmt = self._datetime_format
         elif isinstance(val, datetime.date):
-            fmt = self.date_format
+            fmt = self._date_format
         elif isinstance(val, datetime.timedelta):
             val = val.total_seconds() / 86400
             fmt = "0"
@@ -1183,27 +1463,22 @@ def check_extension(cls, ext: str) -> Literal[True]:
         """
         if ext.startswith("."):
             ext = ext[1:]
-        # error: "Callable[[ExcelWriter], Any]" has no attribute "__iter__" (not
-        #  iterable)
-        if not any(
-            ext in extension
-            for extension in cls.supported_extensions  # type: ignore[attr-defined]
-        ):
+        if not any(ext in extension for extension in cls._supported_extensions):
             raise ValueError(f"Invalid extension for engine '{cls.engine}': '{ext}'")
         else:
             return True
 
     # Allow use as a contextmanager
-    def __enter__(self):
+    def __enter__(self) -> ExcelWriter:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
     def close(self) -> None:
         """synonym for save, to make it more file-like"""
-        self.save()
-        self.handles.close()
+        self._save()
+        self._handles.close()
 
 
 XLS_SIGNATURES = (
@@ -1265,11 +1540,12 @@ def inspect_excel_format(
         elif not peek.startswith(ZIP_SIGNATURE):
             return None
 
-        zf = zipfile.ZipFile(stream)
-
-        # Workaround for some third party files that use forward slashes and
-        # lower case names.
-        component_names = [name.replace("\\", "/").lower() for name in zf.namelist()]
+        with zipfile.ZipFile(stream) as zf:
+            # Workaround for some third party files that use forward slashes and
+            # lower case names.
+            component_names = [
+                name.replace("\\", "/").lower() for name in zf.namelist()
+            ]
 
         if "xl/workbook.xml" in component_names:
             return "xlsx"
@@ -1346,7 +1622,7 @@ def __init__(
         path_or_buffer,
         engine: str | None = None,
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         if engine is not None and engine not in self._engines:
             raise ValueError(f"Unknown engine: {engine}")
 
@@ -1435,8 +1711,8 @@ def parse(
         skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
         nrows: int | None = None,
         na_values=None,
-        parse_dates=False,
-        date_parser=None,
+        parse_dates: list | dict | bool = False,
+        date_parser: Callable | None = None,
         thousands: str | None = None,
         comment: str | None = None,
         skipfooter: int = 0,
@@ -1490,13 +1766,13 @@ def close(self) -> None:
         """close io if necessary"""
         self._reader.close()
 
-    def __enter__(self):
+    def __enter__(self) -> ExcelFile:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
-    def __del__(self):
+    def __del__(self) -> None:
         # Ensure we don't leak file descriptors, but put in try/except in case
         # attributes are already deleted
         try:
diff --git a/pandas/io/excel/_odfreader.py b/pandas/io/excel/_odfreader.py
index 952ad72b480b7..075590f3535fe 100644
--- a/pandas/io/excel/_odfreader.py
+++ b/pandas/io/excel/_odfreader.py
@@ -1,5 +1,10 @@
 from __future__ import annotations
 
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
+
 import numpy as np
 
 from pandas._typing import (
@@ -9,12 +14,18 @@
     StorageOptions,
 )
 from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
 
 import pandas as pd
+from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.excel._base import BaseExcelReader
 
+if TYPE_CHECKING:
+    from pandas._libs.tslibs.nattype import NaTType
+
 
+@doc(storage_options=_shared_docs["storage_options"])
 class ODFReader(BaseExcelReader):
     """
     Read tables out of OpenDocument formatted files.
@@ -23,15 +34,14 @@ class ODFReader(BaseExcelReader):
     ----------
     filepath_or_buffer : str, path to be parsed or
         an open readable stream.
-    storage_options : dict, optional
-        passed to fsspec for appropriate URLs (see ``_get_filepath_or_buffer``)
+    {storage_options}
     """
 
     def __init__(
         self,
         filepath_or_buffer: FilePath | ReadBuffer[bytes],
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         import_optional_dependency("odf")
         super().__init__(filepath_or_buffer, storage_options=storage_options)
 
@@ -79,7 +89,9 @@ def get_sheet_by_name(self, name: str):
         self.close()
         raise ValueError(f"sheet {name} not found")
 
-    def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
+    def get_sheet_data(
+        self, sheet, convert_float: bool, file_rows_needed: int | None = None
+    ) -> list[list[Scalar | NaTType]]:
         """
         Parse an ODF Table into a list of lists
         """
@@ -97,12 +109,16 @@ def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
         empty_rows = 0
         max_row_len = 0
 
-        table: list[list[Scalar]] = []
+        table: list[list[Scalar | NaTType]] = []
 
         for sheet_row in sheet_rows:
-            sheet_cells = [x for x in sheet_row.childNodes if x.qname in cell_names]
+            sheet_cells = [
+                x
+                for x in sheet_row.childNodes
+                if hasattr(x, "qname") and x.qname in cell_names
+            ]
             empty_cells = 0
-            table_row: list[Scalar] = []
+            table_row: list[Scalar | NaTType] = []
 
             for sheet_cell in sheet_cells:
                 if sheet_cell.qname == table_cell_name:
@@ -132,6 +148,8 @@ def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
                 empty_rows = 0
                 for _ in range(row_repeat):
                     table.append(table_row)
+            if file_rows_needed is not None and len(table) >= file_rows_needed:
+                break
 
         # Make our table square
         for row in table:
@@ -165,7 +183,7 @@ def _is_empty_row(self, row) -> bool:
 
         return True
 
-    def _get_cell_value(self, cell, convert_float: bool) -> Scalar:
+    def _get_cell_value(self, cell, convert_float: bool) -> Scalar | NaTType:
         from odf.namespaces import OFFICENS
 
         if str(cell) == "#N/A":
@@ -199,8 +217,8 @@ def _get_cell_value(self, cell, convert_float: bool) -> Scalar:
             return pd.to_datetime(cell_value)
         elif cell_type == "time":
             stamp = pd.to_datetime(str(cell))
-            # error: Item "str" of "Union[float, str, NaTType]" has no attribute "time"
-            return stamp.time()  # type: ignore[union-attr]
+            # cast needed here because Scalar doesn't include datetime.time
+            return cast(Scalar, stamp.time())
         else:
             self.close()
             raise ValueError(f"Unrecognized type {cell_type}")
@@ -229,5 +247,5 @@ def _get_cell_string_value(self, cell) -> str:
                     # https://github.com/pandas-dev/pandas/pull/36175#discussion_r484639704
                     value.append(self._get_cell_string_value(fragment))
             else:
-                value.append(str(fragment))
+                value.append(str(fragment).strip("\n"))
         return "".join(value)
diff --git a/pandas/io/excel/_odswriter.py b/pandas/io/excel/_odswriter.py
index d4fe3683c907e..5603c601e2c45 100644
--- a/pandas/io/excel/_odswriter.py
+++ b/pandas/io/excel/_odswriter.py
@@ -3,37 +3,48 @@
 from collections import defaultdict
 import datetime
 from typing import (
+    TYPE_CHECKING,
     Any,
     DefaultDict,
+    Tuple,
+    cast,
 )
 
 import pandas._libs.json as json
-from pandas._typing import StorageOptions
+from pandas._typing import (
+    FilePath,
+    StorageOptions,
+    WriteExcelBuffer,
+)
 
 from pandas.io.excel._base import ExcelWriter
 from pandas.io.excel._util import (
     combine_kwargs,
     validate_freeze_panes,
 )
-from pandas.io.formats.excel import ExcelCell
+
+if TYPE_CHECKING:
+    from odf.opendocument import OpenDocumentSpreadsheet
+
+    from pandas.io.formats.excel import ExcelCell
 
 
 class ODSWriter(ExcelWriter):
-    engine = "odf"
-    supported_extensions = (".ods",)
+    _engine = "odf"
+    _supported_extensions = (".ods",)
 
     def __init__(
         self,
-        path: str,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
         engine: str | None = None,
-        date_format=None,
+        date_format: str | None = None,
         datetime_format=None,
         mode: str = "w",
         storage_options: StorageOptions = None,
         if_sheet_exists: str | None = None,
         engine_kwargs: dict[str, Any] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         from odf.opendocument import OpenDocumentSpreadsheet
 
         if mode == "a":
@@ -49,18 +60,46 @@ def __init__(
 
         engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
 
-        self.book = OpenDocumentSpreadsheet(**engine_kwargs)
+        self._book = OpenDocumentSpreadsheet(**engine_kwargs)
         self._style_dict: dict[str, str] = {}
 
-    def save(self) -> None:
+    @property
+    def book(self):
+        """
+        Book instance of class odf.opendocument.OpenDocumentSpreadsheet.
+
+        This attribute can be used to access engine-specific features.
+        """
+        return self._book
+
+    @book.setter
+    def book(self, other: OpenDocumentSpreadsheet) -> None:
+        """
+        Set book instance. Class type will depend on the engine used.
+        """
+        self._deprecate_set_book()
+        self._book = other
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        """Mapping of sheet names to sheet objects."""
+        from odf.table import Table
+
+        result = {
+            sheet.getAttribute("name"): sheet
+            for sheet in self.book.getElementsByType(Table)
+        }
+        return result
+
+    def _save(self) -> None:
         """
         Save workbook to disk.
         """
         for sheet in self.sheets.values():
             self.book.spreadsheet.addElement(sheet)
-        self.book.save(self.handles.handle)
+        self.book.save(self._handles.handle)
 
-    def write_cells(
+    def _write_cells(
         self,
         cells: list[ExcelCell],
         sheet_name: str | None = None,
@@ -85,10 +124,10 @@ def write_cells(
             wks = self.sheets[sheet_name]
         else:
             wks = Table(name=sheet_name)
-            self.sheets[sheet_name] = wks
+            self.book.spreadsheet.addElement(wks)
 
         if validate_freeze_panes(freeze_panes):
-            assert freeze_panes is not None
+            freeze_panes = cast(Tuple[int, int], freeze_panes)
             self._create_freeze_panes(sheet_name, freeze_panes)
 
         for _ in range(startrow):
@@ -115,8 +154,9 @@ def write_cells(
             tc.addElement(p)
 
         # add all rows to the sheet
-        for row_nr in range(max(rows.keys()) + 1):
-            wks.addElement(rows[row_nr])
+        if len(rows) > 0:
+            for row_nr in range(max(rows.keys()) + 1):
+                wks.addElement(rows[row_nr])
 
     def _make_table_cell_attributes(self, cell) -> dict[str, int | str]:
         """Convert cell attributes to OpenDocument attributes
@@ -162,14 +202,18 @@ def _make_table_cell(self, cell) -> tuple[object, Any]:
             value = str(val).lower()
             pvalue = str(val).upper()
         if isinstance(val, datetime.datetime):
+            # Fast formatting
             value = val.isoformat()
+            # Slow but locale-dependent
             pvalue = val.strftime("%c")
             return (
                 pvalue,
                 TableCell(valuetype="date", datevalue=value, attributes=attributes),
             )
         elif isinstance(val, datetime.date):
-            value = val.strftime("%Y-%m-%d")
+            # Fast formatting
+            value = f"{val.year}-{val.month:02d}-{val.day:02d}"
+            # Slow but locale-dependent
             pvalue = val.strftime("%x")
             return (
                 pvalue,
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index 27c03d4a74bc1..6fde319b3a81e 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -4,6 +4,8 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Tuple,
+    cast,
 )
 
 import numpy as np
@@ -13,8 +15,12 @@
     ReadBuffer,
     Scalar,
     StorageOptions,
+    WriteExcelBuffer,
 )
 from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.excel._base import (
     BaseExcelReader,
@@ -27,24 +33,25 @@
 
 if TYPE_CHECKING:
     from openpyxl.descriptors.serialisable import Serialisable
+    from openpyxl.workbook import Workbook
 
 
 class OpenpyxlWriter(ExcelWriter):
-    engine = "openpyxl"
-    supported_extensions = (".xlsx", ".xlsm")
+    _engine = "openpyxl"
+    _supported_extensions = (".xlsx", ".xlsm")
 
     def __init__(
         self,
-        path,
-        engine=None,
-        date_format=None,
-        datetime_format=None,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
         mode: str = "w",
         storage_options: StorageOptions = None,
         if_sheet_exists: str | None = None,
         engine_kwargs: dict[str, Any] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         # Use the openpyxl module as the Excel writer.
         from openpyxl.workbook import Workbook
 
@@ -60,28 +67,49 @@ def __init__(
 
         # ExcelWriter replaced "a" by "r+" to allow us to first read the excel file from
         # the file and later write to it
-        if "r+" in self.mode:  # Load from existing workbook
+        if "r+" in self._mode:  # Load from existing workbook
             from openpyxl import load_workbook
 
-            self.book = load_workbook(self.handles.handle, **engine_kwargs)
-            self.handles.handle.seek(0)
-            self.sheets = {name: self.book[name] for name in self.book.sheetnames}
-
+            self._book = load_workbook(self._handles.handle, **engine_kwargs)
+            self._handles.handle.seek(0)
         else:
             # Create workbook object with default optimized_write=True.
-            self.book = Workbook(**engine_kwargs)
+            self._book = Workbook(**engine_kwargs)
 
             if self.book.worksheets:
                 self.book.remove(self.book.worksheets[0])
 
-    def save(self):
+    @property
+    def book(self) -> Workbook:
+        """
+        Book instance of class openpyxl.workbook.Workbook.
+
+        This attribute can be used to access engine-specific features.
+        """
+        return self._book
+
+    @book.setter
+    def book(self, other: Workbook) -> None:
+        """
+        Set book instance. Class type will depend on the engine used.
+        """
+        self._deprecate_set_book()
+        self._book = other
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        """Mapping of sheet names to sheet objects."""
+        result = {name: self.book[name] for name in self.book.sheetnames}
+        return result
+
+    def _save(self) -> None:
         """
         Save workbook to disk.
         """
-        self.book.save(self.handles.handle)
-        if "r+" in self.mode and not isinstance(self.handles.handle, mmap.mmap):
+        self.book.save(self._handles.handle)
+        if "r+" in self._mode and not isinstance(self._handles.handle, mmap.mmap):
             # truncate file to the written content
-            self.handles.handle.truncate()
+            self._handles.handle.truncate()
 
     @classmethod
     def _convert_to_style_kwargs(cls, style_dict: dict) -> dict[str, Serialisable]:
@@ -217,7 +245,7 @@ def _convert_to_stop(cls, stop_seq):
         return map(cls._convert_to_color, stop_seq)
 
     @classmethod
-    def _convert_to_fill(cls, fill_dict):
+    def _convert_to_fill(cls, fill_dict: dict[str, Any]):
         """
         Convert ``fill_dict`` to an openpyxl v2 Fill object.
 
@@ -417,32 +445,36 @@ def _convert_to_protection(cls, protection_dict):
 
         return Protection(**protection_dict)
 
-    def write_cells(
-        self, cells, sheet_name=None, startrow=0, startcol=0, freeze_panes=None
-    ):
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
         # Write the frame cells using openpyxl.
         sheet_name = self._get_sheet_name(sheet_name)
 
         _style_cache: dict[str, dict[str, Serialisable]] = {}
 
-        if sheet_name in self.sheets and self.if_sheet_exists != "new":
-            if "r+" in self.mode:
-                if self.if_sheet_exists == "replace":
+        if sheet_name in self.sheets and self._if_sheet_exists != "new":
+            if "r+" in self._mode:
+                if self._if_sheet_exists == "replace":
                     old_wks = self.sheets[sheet_name]
                     target_index = self.book.index(old_wks)
                     del self.book[sheet_name]
                     wks = self.book.create_sheet(sheet_name, target_index)
-                    self.sheets[sheet_name] = wks
-                elif self.if_sheet_exists == "error":
+                elif self._if_sheet_exists == "error":
                     raise ValueError(
                         f"Sheet '{sheet_name}' already exists and "
                         f"if_sheet_exists is set to 'error'."
                     )
-                elif self.if_sheet_exists == "overlay":
+                elif self._if_sheet_exists == "overlay":
                     wks = self.sheets[sheet_name]
                 else:
                     raise ValueError(
-                        f"'{self.if_sheet_exists}' is not valid for if_sheet_exists. "
+                        f"'{self._if_sheet_exists}' is not valid for if_sheet_exists. "
                         "Valid options are 'error', 'new', 'replace' and 'overlay'."
                     )
             else:
@@ -450,9 +482,9 @@ def write_cells(
         else:
             wks = self.book.create_sheet()
             wks.title = sheet_name
-            self.sheets[sheet_name] = wks
 
         if validate_freeze_panes(freeze_panes):
+            freeze_panes = cast(Tuple[int, int], freeze_panes)
             wks.freeze_panes = wks.cell(
                 row=freeze_panes[0] + 1, column=freeze_panes[1] + 1
             )
@@ -506,6 +538,7 @@ def write_cells(
 
 
 class OpenpyxlReader(BaseExcelReader):
+    @doc(storage_options=_shared_docs["storage_options"])
     def __init__(
         self,
         filepath_or_buffer: FilePath | ReadBuffer[bytes],
@@ -518,8 +551,7 @@ def __init__(
         ----------
         filepath_or_buffer : str, path object or Workbook
             Object to be parsed.
-        storage_options : dict, optional
-            passed to fsspec for appropriate URLs (see ``_get_filepath_or_buffer``)
+        {storage_options}
         """
         import_optional_dependency("openpyxl")
         super().__init__(filepath_or_buffer, storage_options=storage_options)
@@ -560,12 +592,20 @@ def _convert_cell(self, cell, convert_float: bool) -> Scalar:
             return ""  # compat with xlrd
         elif cell.data_type == TYPE_ERROR:
             return np.nan
-        elif not convert_float and cell.data_type == TYPE_NUMERIC:
-            return float(cell.value)
+        elif cell.data_type == TYPE_NUMERIC:
+            # GH5394, GH46988
+            if convert_float:
+                val = int(cell.value)
+                if val == cell.value:
+                    return val
+            else:
+                return float(cell.value)
 
         return cell.value
 
-    def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
+    def get_sheet_data(
+        self, sheet, convert_float: bool, file_rows_needed: int | None = None
+    ) -> list[list[Scalar]]:
 
         if self.book.read_only:
             sheet.reset_dimensions()
@@ -580,6 +620,8 @@ def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
             if converted_row:
                 last_row_with_data = row_number
             data.append(converted_row)
+            if file_rows_needed is not None and len(data) >= file_rows_needed:
+                break
 
         # Trim trailing empty rows
         data = data[: last_row_with_data + 1]
diff --git a/pandas/io/excel/_pyxlsb.py b/pandas/io/excel/_pyxlsb.py
index 9284cf917a48c..5d40ccdf2f8f3 100644
--- a/pandas/io/excel/_pyxlsb.py
+++ b/pandas/io/excel/_pyxlsb.py
@@ -8,16 +8,20 @@
     StorageOptions,
 )
 from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.excel._base import BaseExcelReader
 
 
 class PyxlsbReader(BaseExcelReader):
+    @doc(storage_options=_shared_docs["storage_options"])
     def __init__(
         self,
         filepath_or_buffer: FilePath | ReadBuffer[bytes],
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         """
         Reader using pyxlsb engine.
 
@@ -25,8 +29,7 @@ def __init__(
         ----------
         filepath_or_buffer : str, path object, or Workbook
             Object to be parsed.
-        storage_options : dict, optional
-            passed to fsspec for appropriate URLs (see ``_get_filepath_or_buffer``)
+        {storage_options}
         """
         import_optional_dependency("pyxlsb")
         # This will call load_workbook on the filepath or buffer
@@ -76,7 +79,12 @@ def _convert_cell(self, cell, convert_float: bool) -> Scalar:
 
         return cell.v
 
-    def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
+    def get_sheet_data(
+        self,
+        sheet,
+        convert_float: bool,
+        file_rows_needed: int | None = None,
+    ) -> list[list[Scalar]]:
         data: list[list[Scalar]] = []
         prevous_row_number = -1
         # When sparse=True the rows can have different lengths and empty rows are
@@ -91,6 +99,8 @@ def get_sheet_data(self, sheet, convert_float: bool) -> list[list[Scalar]]:
                 data.extend([[]] * (row_number - prevous_row_number - 1))
                 data.append(converted_row)
                 prevous_row_number = row_number
+            if file_rows_needed is not None and len(data) >= file_rows_needed:
+                break
         if data:
             # extend rows to max_width
             max_width = max(len(data_row) for data_row in data)
diff --git a/pandas/io/excel/_util.py b/pandas/io/excel/_util.py
index 6be5ef0f64e16..c315657170a97 100644
--- a/pandas/io/excel/_util.py
+++ b/pandas/io/excel/_util.py
@@ -41,9 +41,7 @@ def register_writer(klass: ExcelWriter_t) -> None:
     """
     if not callable(klass):
         raise ValueError("Can only register callables as engines")
-    engine_name = klass.engine
-    # for mypy
-    assert isinstance(engine_name, str)
+    engine_name = klass._engine
     _writers[engine_name] = klass
 
 
diff --git a/pandas/io/excel/_xlrd.py b/pandas/io/excel/_xlrd.py
index eea0f1c03b998..0bf3ac6134cf6 100644
--- a/pandas/io/excel/_xlrd.py
+++ b/pandas/io/excel/_xlrd.py
@@ -1,15 +1,26 @@
+from __future__ import annotations
+
 from datetime import time
 
 import numpy as np
 
-from pandas._typing import StorageOptions
+from pandas._typing import (
+    Scalar,
+    StorageOptions,
+)
 from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.excel._base import BaseExcelReader
 
 
 class XlrdReader(BaseExcelReader):
-    def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):
+    @doc(storage_options=_shared_docs["storage_options"])
+    def __init__(
+        self, filepath_or_buffer, storage_options: StorageOptions = None
+    ) -> None:
         """
         Reader using xlrd engine.
 
@@ -17,8 +28,7 @@ def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):
         ----------
         filepath_or_buffer : str, path object or Workbook
             Object to be parsed.
-        storage_options : dict, optional
-            passed to fsspec for appropriate URLs (see ``_get_filepath_or_buffer``)
+        {storage_options}
         """
         err_msg = "Install xlrd >= 1.0.0 for Excel support"
         import_optional_dependency("xlrd", extra=err_msg)
@@ -51,7 +61,9 @@ def get_sheet_by_index(self, index):
         self.raise_if_bad_sheet_by_index(index)
         return self.book.sheet_by_index(index)
 
-    def get_sheet_data(self, sheet, convert_float):
+    def get_sheet_data(
+        self, sheet, convert_float: bool, file_rows_needed: int | None = None
+    ) -> list[list[Scalar]]:
         from xlrd import (
             XL_CELL_BOOLEAN,
             XL_CELL_DATE,
@@ -102,7 +114,10 @@ def _parse_cell(cell_contents, cell_typ):
 
         data = []
 
-        for i in range(sheet.nrows):
+        nrows = sheet.nrows
+        if file_rows_needed is not None:
+            nrows = min(nrows, file_rows_needed)
+        for i in range(nrows):
             row = [
                 _parse_cell(value, typ)
                 for value, typ in zip(sheet.row_values(i), sheet.row_types(i))
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index 06c73f2c6199e..8d11896cb7374 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -1,9 +1,16 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
 
 import pandas._libs.json as json
-from pandas._typing import StorageOptions
+from pandas._typing import (
+    FilePath,
+    StorageOptions,
+    WriteExcelBuffer,
+)
 
 from pandas.io.excel._base import ExcelWriter
 from pandas.io.excel._util import (
@@ -11,6 +18,9 @@
     validate_freeze_panes,
 )
 
+if TYPE_CHECKING:
+    from xlsxwriter import Workbook
+
 
 class _XlsxStyler:
     # Map from openpyxl-oriented styles to flatter xlsxwriter representation
@@ -161,25 +171,29 @@ def convert(cls, style_dict, num_format_str=None):
                 "doubleAccounting": 34,
             }[props["underline"]]
 
+        # GH 30107 - xlsxwriter uses different name
+        if props.get("valign") == "center":
+            props["valign"] = "vcenter"
+
         return props
 
 
 class XlsxWriter(ExcelWriter):
-    engine = "xlsxwriter"
-    supported_extensions = (".xlsx",)
+    _engine = "xlsxwriter"
+    _supported_extensions = (".xlsx",)
 
     def __init__(
         self,
-        path,
-        engine=None,
-        date_format=None,
-        datetime_format=None,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
         mode: str = "w",
         storage_options: StorageOptions = None,
         if_sheet_exists: str | None = None,
         engine_kwargs: dict[str, Any] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         # Use the xlsxwriter module as the Excel writer.
         from xlsxwriter import Workbook
 
@@ -199,25 +213,50 @@ def __init__(
             engine_kwargs=engine_kwargs,
         )
 
-        self.book = Workbook(self.handles.handle, **engine_kwargs)
+        self._book = Workbook(self._handles.handle, **engine_kwargs)
 
-    def save(self):
+    @property
+    def book(self):
+        """
+        Book instance of class xlsxwriter.Workbook.
+
+        This attribute can be used to access engine-specific features.
+        """
+        return self._book
+
+    @book.setter
+    def book(self, other: Workbook) -> None:
+        """
+        Set book instance. Class type will depend on the engine used.
+        """
+        self._deprecate_set_book()
+        self._book = other
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        result = self.book.sheetnames
+        return result
+
+    def _save(self) -> None:
         """
         Save workbook to disk.
         """
-        return self.book.close()
+        self.book.close()
 
-    def write_cells(
-        self, cells, sheet_name=None, startrow=0, startcol=0, freeze_panes=None
-    ):
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
         # Write the frame cells using xlsxwriter.
         sheet_name = self._get_sheet_name(sheet_name)
 
-        if sheet_name in self.sheets:
-            wks = self.sheets[sheet_name]
-        else:
+        wks = self.book.get_worksheet_by_name(sheet_name)
+        if wks is None:
             wks = self.book.add_worksheet(sheet_name)
-            self.sheets[sheet_name] = wks
 
         style_dict = {"null": None}
 
diff --git a/pandas/io/excel/_xlwt.py b/pandas/io/excel/_xlwt.py
index a74c03f330cd9..f1455e472bb43 100644
--- a/pandas/io/excel/_xlwt.py
+++ b/pandas/io/excel/_xlwt.py
@@ -3,10 +3,16 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Tuple,
+    cast,
 )
 
 import pandas._libs.json as json
-from pandas._typing import StorageOptions
+from pandas._typing import (
+    FilePath,
+    StorageOptions,
+    WriteExcelBuffer,
+)
 
 from pandas.io.excel._base import ExcelWriter
 from pandas.io.excel._util import (
@@ -15,26 +21,29 @@
 )
 
 if TYPE_CHECKING:
-    from xlwt import XFStyle
+    from xlwt import (
+        Workbook,
+        XFStyle,
+    )
 
 
 class XlwtWriter(ExcelWriter):
-    engine = "xlwt"
-    supported_extensions = (".xls",)
+    _engine = "xlwt"
+    _supported_extensions = (".xls",)
 
     def __init__(
         self,
-        path,
-        engine=None,
-        date_format=None,
-        datetime_format=None,
-        encoding=None,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
+        encoding: str | None = None,
         mode: str = "w",
         storage_options: StorageOptions = None,
         if_sheet_exists: str | None = None,
         engine_kwargs: dict[str, Any] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         # Use the xlwt module as the Excel writer.
         import xlwt
 
@@ -53,21 +62,65 @@ def __init__(
 
         if encoding is None:
             encoding = "ascii"
-        self.book = xlwt.Workbook(encoding=encoding, **engine_kwargs)
-        self.fm_datetime = xlwt.easyxf(num_format_str=self.datetime_format)
-        self.fm_date = xlwt.easyxf(num_format_str=self.date_format)
+        self._book = xlwt.Workbook(encoding=encoding, **engine_kwargs)
+        self._fm_datetime = xlwt.easyxf(num_format_str=self._datetime_format)
+        self._fm_date = xlwt.easyxf(num_format_str=self._date_format)
+
+    @property
+    def book(self) -> Workbook:
+        """
+        Book instance of class xlwt.Workbook.
+
+        This attribute can be used to access engine-specific features.
+        """
+        return self._book
+
+    @book.setter
+    def book(self, other: Workbook) -> None:
+        """
+        Set book instance. Class type will depend on the engine used.
+        """
+        self._deprecate_set_book()
+        self._book = other
 
-    def save(self):
+    @property
+    def sheets(self) -> dict[str, Any]:
+        """Mapping of sheet names to sheet objects."""
+        result = {sheet.name: sheet for sheet in self.book._Workbook__worksheets}
+        return result
+
+    @property
+    def fm_date(self):
+        """
+        XFStyle formatter for dates.
+        """
+        self._deprecate("fm_date")
+        return self._fm_date
+
+    @property
+    def fm_datetime(self):
+        """
+        XFStyle formatter for dates.
+        """
+        self._deprecate("fm_datetime")
+        return self._fm_datetime
+
+    def _save(self) -> None:
         """
         Save workbook to disk.
         """
         if self.sheets:
             # fails when the ExcelWriter is just opened and then closed
-            self.book.save(self.handles.handle)
+            self.book.save(self._handles.handle)
 
-    def write_cells(
-        self, cells, sheet_name=None, startrow=0, startcol=0, freeze_panes=None
-    ):
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
 
         sheet_name = self._get_sheet_name(sheet_name)
 
@@ -78,6 +131,7 @@ def write_cells(
             self.sheets[sheet_name] = wks
 
         if validate_freeze_panes(freeze_panes):
+            freeze_panes = cast(Tuple[int, int], freeze_panes)
             wks.set_panes_frozen(True)
             wks.set_horz_split_pos(freeze_panes[0])
             wks.set_vert_split_pos(freeze_panes[1])
@@ -111,7 +165,7 @@ def write_cells(
 
     @classmethod
     def _style_to_xlwt(
-        cls, item, firstlevel: bool = True, field_sep=",", line_sep=";"
+        cls, item, firstlevel: bool = True, field_sep: str = ",", line_sep: str = ";"
     ) -> str:
         """
         helper which recursively generate an xlwt easy style string
@@ -150,7 +204,9 @@ def _style_to_xlwt(
             return item
 
     @classmethod
-    def _convert_to_style(cls, style_dict, num_format_str=None):
+    def _convert_to_style(
+        cls, style_dict, num_format_str: str | None = None
+    ) -> XFStyle:
         """
         converts a style_dict to an xlwt style object
 
diff --git a/pandas/io/feather_format.py b/pandas/io/feather_format.py
index 9813b91419060..4ecd5b7604088 100644
--- a/pandas/io/feather_format.py
+++ b/pandas/io/feather_format.py
@@ -31,7 +31,7 @@ def to_feather(
     path: FilePath | WriteBuffer[bytes],
     storage_options: StorageOptions = None,
     **kwargs,
-):
+) -> None:
     """
     Write a DataFrame to the binary Feather format.
 
diff --git a/pandas/io/formats/_color_data.py b/pandas/io/formats/_color_data.py
index e5b72b2befa4f..2e7cb7f29646e 100644
--- a/pandas/io/formats/_color_data.py
+++ b/pandas/io/formats/_color_data.py
@@ -3,6 +3,8 @@
 # This data has been copied here, instead of being imported from matplotlib,
 # not to have ``to_excel`` methods require matplotlib.
 # source: matplotlib._color_data (3.3.3)
+from __future__ import annotations
+
 CSS4_COLORS = {
     "aliceblue": "F0F8FF",
     "antiquewhite": "FAEBD7",
diff --git a/pandas/io/formats/console.py b/pandas/io/formats/console.py
index bdd2b3d6e4c6a..2a6cbe0762903 100644
--- a/pandas/io/formats/console.py
+++ b/pandas/io/formats/console.py
@@ -1,11 +1,12 @@
 """
 Internal module for console introspection
 """
+from __future__ import annotations
 
 from shutil import get_terminal_size
 
 
-def get_console_size():
+def get_console_size() -> tuple[int | None, int | None]:
     """
     Return console size as tuple = (width, height).
 
@@ -43,14 +44,14 @@ def get_console_size():
     # Note if the User sets width/Height to None (auto-detection)
     # and we're in a script (non-inter), this will return (None,None)
     # caller needs to deal.
-    return (display_width or terminal_width, display_height or terminal_height)
+    return display_width or terminal_width, display_height or terminal_height
 
 
 # ----------------------------------------------------------------------
 # Detect our environment
 
 
-def in_interactive_session():
+def in_interactive_session() -> bool:
     """
     Check if we're running in an interactive shell.
 
@@ -75,7 +76,7 @@ def check_main():
         return check_main()
 
 
-def in_ipython_frontend():
+def in_ipython_frontend() -> bool:
     """
     Check if we're inside an IPython zmq frontend.
 
diff --git a/pandas/io/formats/css.py b/pandas/io/formats/css.py
index 956951a6f2f3d..34626a0bdfdb7 100644
--- a/pandas/io/formats/css.py
+++ b/pandas/io/formats/css.py
@@ -4,22 +4,54 @@
 from __future__ import annotations
 
 import re
+from typing import (
+    Callable,
+    Generator,
+    Iterable,
+    Iterator,
+)
 import warnings
 
+from pandas.errors import CSSWarning
+from pandas.util._exceptions import find_stack_level
 
-class CSSWarning(UserWarning):
+
+def _side_expander(prop_fmt: str) -> Callable:
     """
-    This CSS syntax cannot currently be parsed.
+    Wrapper to expand shorthand property into top, right, bottom, left properties
+
+    Parameters
+    ----------
+    side : str
+        The border side to expand into properties
+
+    Returns
+    -------
+        function: Return to call when a 'border(-{side}): {value}' string is encountered
     """
 
+    def expand(self, prop, value: str) -> Generator[tuple[str, str], None, None]:
+        """
+        Expand shorthand property into side-specific property (top, right, bottom, left)
+
+        Parameters
+        ----------
+            prop (str): CSS property name
+            value (str): String token for property
 
-def _side_expander(prop_fmt: str):
-    def expand(self, prop, value: str):
+        Yields
+        ------
+            Tuple (str, str): Expanded property, value
+        """
         tokens = value.split()
         try:
             mapping = self.SIDE_SHORTHANDS[len(tokens)]
         except KeyError:
-            warnings.warn(f'Could not expand "{prop}: {value}"', CSSWarning)
+            warnings.warn(
+                f'Could not expand "{prop}: {value}"',
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
             return
         for key, idx in zip(self.SIDES, mapping):
             yield prop_fmt.format(key), tokens[idx]
@@ -27,12 +59,74 @@ def expand(self, prop, value: str):
     return expand
 
 
+def _border_expander(side: str = "") -> Callable:
+    """
+    Wrapper to expand 'border' property into border color, style, and width properties
+
+    Parameters
+    ----------
+    side : str
+        The border side to expand into properties
+
+    Returns
+    -------
+        function: Return to call when a 'border(-{side}): {value}' string is encountered
+    """
+    if side != "":
+        side = f"-{side}"
+
+    def expand(self, prop, value: str) -> Generator[tuple[str, str], None, None]:
+        """
+        Expand border into color, style, and width tuples
+
+        Parameters
+        ----------
+            prop : str
+                CSS property name passed to styler
+            value : str
+                Value passed to styler for property
+
+        Yields
+        ------
+            Tuple (str, str): Expanded property, value
+        """
+        tokens = value.split()
+        if len(tokens) == 0 or len(tokens) > 3:
+            warnings.warn(
+                f'Too many tokens provided to "{prop}" (expected 1-3)',
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        # TODO: Can we use current color as initial value to comply with CSS standards?
+        border_declarations = {
+            f"border{side}-color": "black",
+            f"border{side}-style": "none",
+            f"border{side}-width": "medium",
+        }
+        for token in tokens:
+            if token.lower() in self.BORDER_STYLES:
+                border_declarations[f"border{side}-style"] = token
+            elif any(ratio in token.lower() for ratio in self.BORDER_WIDTH_RATIOS):
+                border_declarations[f"border{side}-width"] = token
+            else:
+                border_declarations[f"border{side}-color"] = token
+            # TODO: Warn user if item entered more than once (e.g. "border: red green")
+
+        # Per CSS, "border" will reset previous "border-*" definitions
+        yield from self.atomize(border_declarations.items())
+
+    return expand
+
+
 class CSSResolver:
     """
     A callable for parsing and resolving CSS to atomic properties.
     """
 
     UNIT_RATIOS = {
+        "pt": ("pt", 1),
+        "em": ("em", 1),
         "rem": ("pt", 12),
         "ex": ("em", 0.5),
         # 'ch':
@@ -76,6 +170,26 @@ class CSSResolver:
         }
     )
 
+    BORDER_STYLES = [
+        "none",
+        "hidden",
+        "dotted",
+        "dashed",
+        "solid",
+        "double",
+        "groove",
+        "ridge",
+        "inset",
+        "outset",
+        "mediumdashdot",
+        "dashdotdot",
+        "hair",
+        "mediumdashdotdot",
+        "dashdot",
+        "slantdashdot",
+        "mediumdashed",
+    ]
+
     SIDE_SHORTHANDS = {
         1: [0, 0, 0, 0],
         2: [0, 1, 0, 1],
@@ -85,9 +199,24 @@ class CSSResolver:
 
     SIDES = ("top", "right", "bottom", "left")
 
+    CSS_EXPANSIONS = {
+        **{
+            "-".join(["border", prop] if prop else ["border"]): _border_expander(prop)
+            for prop in ["", "top", "right", "bottom", "left"]
+        },
+        **{
+            "-".join(["border", prop]): _side_expander("border-{:s}-" + prop)
+            for prop in ["color", "style", "width"]
+        },
+        **{
+            "margin": _side_expander("margin-{:s}"),
+            "padding": _side_expander("padding-{:s}"),
+        },
+    }
+
     def __call__(
         self,
-        declarations_str: str,
+        declarations: str | Iterable[tuple[str, str]],
         inherited: dict[str, str] | None = None,
     ) -> dict[str, str]:
         """
@@ -95,8 +224,10 @@ def __call__(
 
         Parameters
         ----------
-        declarations_str : str
-            A list of CSS declarations
+        declarations_str : str | Iterable[tuple[str, str]]
+            A CSS string or set of CSS declaration tuples
+            e.g. "font-weight: bold; background: blue" or
+            {("font-weight", "bold"), ("background", "blue")}
         inherited : dict, optional
             Atomic properties indicating the inherited style context in which
             declarations_str is to be resolved. ``inherited`` should already
@@ -127,7 +258,9 @@ def __call__(
          ('font-size', '24pt'),
          ('font-weight', 'bold')]
         """
-        props = dict(self.atomize(self.parse(declarations_str)))
+        if isinstance(declarations, str):
+            declarations = self.parse(declarations)
+        props = dict(self.atomize(declarations))
         if inherited is None:
             inherited = {}
 
@@ -205,7 +338,11 @@ def _update_other_units(self, props: dict[str, str]) -> dict[str, str]:
 
     def size_to_pt(self, in_val, em_pt=None, conversions=UNIT_RATIOS):
         def _error():
-            warnings.warn(f"Unhandled size: {repr(in_val)}", CSSWarning)
+            warnings.warn(
+                f"Unhandled size: {repr(in_val)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
             return self.size_to_pt("1!!default", conversions=conversions)
 
         match = re.match(r"^(\S*?)([a-zA-Z%!].*)", in_val)
@@ -244,24 +381,17 @@ def _error():
             size_fmt = f"{val:f}pt"
         return size_fmt
 
-    def atomize(self, declarations):
+    def atomize(self, declarations: Iterable) -> Generator[tuple[str, str], None, None]:
         for prop, value in declarations:
-            attr = "expand_" + prop.replace("-", "_")
-            try:
-                expand = getattr(self, attr)
-            except AttributeError:
-                yield prop, value
+            prop = prop.lower()
+            value = value.lower()
+            if prop in self.CSS_EXPANSIONS:
+                expand = self.CSS_EXPANSIONS[prop]
+                yield from expand(self, prop, value)
             else:
-                for prop, value in expand(prop, value):
-                    yield prop, value
-
-    expand_border_color = _side_expander("border-{:s}-color")
-    expand_border_style = _side_expander("border-{:s}-style")
-    expand_border_width = _side_expander("border-{:s}-width")
-    expand_margin = _side_expander("margin-{:s}")
-    expand_padding = _side_expander("padding-{:s}")
+                yield prop, value
 
-    def parse(self, declarations_str: str):
+    def parse(self, declarations_str: str) -> Iterator[tuple[str, str]]:
         """
         Generates (prop, value) pairs from declarations.
 
@@ -284,4 +414,5 @@ def parse(self, declarations_str: str):
                 warnings.warn(
                     f"Ill-formatted attribute: expected a colon in {repr(decl)}",
                     CSSWarning,
+                    stacklevel=find_stack_level(),
                 )
diff --git a/pandas/io/formats/csvs.py b/pandas/io/formats/csvs.py
index d2cc77af8eee5..6ab57b0cce2a4 100644
--- a/pandas/io/formats/csvs.py
+++ b/pandas/io/formats/csvs.py
@@ -59,21 +59,21 @@ def __init__(
         errors: str = "strict",
         compression: CompressionOptions = "infer",
         quoting: int | None = None,
-        line_terminator: str | None = "\n",
+        lineterminator: str | None = "\n",
         chunksize: int | None = None,
         quotechar: str | None = '"',
         date_format: str | None = None,
         doublequote: bool = True,
         escapechar: str | None = None,
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         self.fmt = formatter
 
         self.obj = self.fmt.frame
 
         self.filepath_or_buffer = path_or_buf
         self.encoding = encoding
-        self.compression = compression
+        self.compression: CompressionOptions = compression
         self.mode = mode
         self.storage_options = storage_options
 
@@ -84,7 +84,7 @@ def __init__(
         self.quotechar = self._initialize_quotechar(quotechar)
         self.doublequote = doublequote
         self.escapechar = escapechar
-        self.line_terminator = line_terminator or os.linesep
+        self.lineterminator = lineterminator or os.linesep
         self.date_format = date_format
         self.cols = self._initialize_columns(cols)
         self.chunksize = self._initialize_chunksize(chunksize)
@@ -118,16 +118,16 @@ def _initialize_index_label(self, index_label: IndexLabel | None) -> IndexLabel:
                 return [index_label]
         return index_label
 
-    def _get_index_label_from_obj(self) -> list[str]:
+    def _get_index_label_from_obj(self) -> Sequence[Hashable]:
         if isinstance(self.obj.index, ABCMultiIndex):
             return self._get_index_label_multiindex()
         else:
             return self._get_index_label_flat()
 
-    def _get_index_label_multiindex(self) -> list[str]:
+    def _get_index_label_multiindex(self) -> Sequence[Hashable]:
         return [name or "" for name in self.obj.index.names]
 
-    def _get_index_label_flat(self) -> list[str]:
+    def _get_index_label_flat(self) -> Sequence[Hashable]:
         index_label = self.obj.index.name
         return [""] if index_label is None else [index_label]
 
@@ -250,7 +250,7 @@ def save(self) -> None:
             # Note: self.encoding is irrelevant here
             self.writer = csvlib.writer(
                 handles.handle,
-                lineterminator=self.line_terminator,
+                lineterminator=self.lineterminator,
                 delimiter=self.sep,
                 quoting=self.quoting,
                 doublequote=self.doublequote,
diff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py
index 1f1ca434a22c0..b6e0f271f417b 100644
--- a/pandas/io/formats/excel.py
+++ b/pandas/io/formats/excel.py
@@ -3,7 +3,10 @@
 """
 from __future__ import annotations
 
-from functools import reduce
+from functools import (
+    lru_cache,
+    reduce,
+)
 import itertools
 import re
 from typing import (
@@ -25,6 +28,7 @@
     StorageOptions,
 )
 from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes import missing
 from pandas.core.dtypes.common import (
@@ -62,7 +66,7 @@ def __init__(
         style=None,
         mergestart: int | None = None,
         mergeend: int | None = None,
-    ):
+    ) -> None:
         self.row = row
         self.col = col
         self.val = val
@@ -83,12 +87,17 @@ def __init__(
         css_col: int,
         css_converter: Callable | None,
         **kwargs,
-    ):
+    ) -> None:
         if css_styles and css_converter:
-            css = ";".join(a + ":" + str(v) for (a, v) in css_styles[css_row, css_col])
-            style = css_converter(css)
+            # Use dict to get only one (case-insensitive) declaration per property
+            declaration_dict = {
+                prop.lower(): val for prop, val in css_styles[css_row, css_col]
+            }
+            # Convert to frozenset for order-invariant caching
+            unique_declarations = frozenset(declaration_dict.items())
+            style = css_converter(unique_declarations)
 
-        return super().__init__(row=row, col=col, val=val, style=style, **kwargs)
+        super().__init__(row=row, col=col, val=val, style=style, **kwargs)
 
 
 class CSSToExcelConverter:
@@ -150,29 +159,52 @@ class CSSToExcelConverter:
         "fantasy": 5,  # decorative
     }
 
+    BORDER_STYLE_MAP = {
+        style.lower(): style
+        for style in [
+            "dashed",
+            "mediumDashDot",
+            "dashDotDot",
+            "hair",
+            "dotted",
+            "mediumDashDotDot",
+            "double",
+            "dashDot",
+            "slantDashDot",
+            "mediumDashed",
+        ]
+    }
+
     # NB: Most of the methods here could be classmethods, as only __init__
     #     and __call__ make use of instance attributes.  We leave them as
     #     instancemethods so that users can easily experiment with extensions
     #     without monkey-patching.
     inherited: dict[str, str] | None
 
-    def __init__(self, inherited: str | None = None):
+    def __init__(self, inherited: str | None = None) -> None:
         if inherited is not None:
             self.inherited = self.compute_css(inherited)
         else:
             self.inherited = None
+        # We should avoid lru_cache on the __call__ method.
+        # Otherwise once the method __call__ has been called
+        # garbage collection no longer deletes the instance.
+        self._call_cached = lru_cache(maxsize=None)(self._call_uncached)
 
     compute_css = CSSResolver()
 
-    def __call__(self, declarations_str: str) -> dict[str, dict[str, str]]:
+    def __call__(
+        self, declarations: str | frozenset[tuple[str, str]]
+    ) -> dict[str, dict[str, str]]:
         """
         Convert CSS declarations to ExcelWriter style.
 
         Parameters
         ----------
-        declarations_str : str
-            List of CSS declarations.
-            e.g. "font-weight: bold; background: blue"
+        declarations : str | frozenset[tuple[str, str]]
+            CSS string or set of CSS declaration tuples.
+            e.g. "font-weight: bold; background: blue" or
+            {("font-weight", "bold"), ("background", "blue")}
 
         Returns
         -------
@@ -180,8 +212,12 @@ def __call__(self, declarations_str: str) -> dict[str, dict[str, str]]:
             A style as interpreted by ExcelWriter when found in
             ExcelCell.style.
         """
-        # TODO: memoize?
-        properties = self.compute_css(declarations_str, self.inherited)
+        return self._call_cached(declarations)
+
+    def _call_uncached(
+        self, declarations: str | frozenset[tuple[str, str]]
+    ) -> dict[str, dict[str, str]]:
+        properties = self.compute_css(declarations, self.inherited)
         return self.build_xlstyle(properties)
 
     def build_xlstyle(self, props: Mapping[str, str]) -> dict[str, dict[str, str]]:
@@ -195,7 +231,7 @@ def build_xlstyle(self, props: Mapping[str, str]) -> dict[str, dict[str, str]]:
 
         # TODO: handle cell width and height: needs support in pandas.io.excel
 
-        def remove_none(d: dict[str, str]) -> None:
+        def remove_none(d: dict[str, str | None]) -> None:
             """Remove key where value is None, through nested dicts"""
             for k, v in list(d.items()):
                 if v is None:
@@ -235,13 +271,14 @@ def build_border(
                 "style": self._border_style(
                     props.get(f"border-{side}-style"),
                     props.get(f"border-{side}-width"),
+                    self.color_to_excel(props.get(f"border-{side}-color")),
                 ),
                 "color": self.color_to_excel(props.get(f"border-{side}-color")),
             }
             for side in ["top", "right", "bottom", "left"]
         }
 
-    def _border_style(self, style: str | None, width: str | None):
+    def _border_style(self, style: str | None, width: str | None, color: str | None):
         # convert styles and widths to openxml, one of:
         #       'dashDot'
         #       'dashDotDot'
@@ -256,14 +293,20 @@ def _border_style(self, style: str | None, width: str | None):
         #       'slantDashDot'
         #       'thick'
         #       'thin'
-        if width is None and style is None:
+        if width is None and style is None and color is None:
+            # Return None will remove "border" from style dictionary
             return None
+
+        if width is None and style is None:
+            # Return "none" will keep "border" in style dictionary
+            return "none"
+
         if style == "none" or style == "hidden":
-            return None
+            return "none"
 
         width_name = self._get_width_name(width)
         if width_name is None:
-            return None
+            return "none"
 
         if style in (None, "groove", "ridge", "inset", "outset", "solid"):
             # not handled
@@ -279,6 +322,16 @@ def _border_style(self, style: str | None, width: str | None):
             if width_name in ("hair", "thin"):
                 return "dashed"
             return "mediumDashed"
+        elif style in self.BORDER_STYLE_MAP:
+            # Excel-specific styles
+            return self.BORDER_STYLE_MAP[style]
+        else:
+            warnings.warn(
+                f"Unhandled border style format: {repr(style)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+            return "none"
 
     def _get_width_name(self, width_input: str | None) -> str | None:
         width = self._width_to_float(width_input)
@@ -307,11 +360,13 @@ def build_fill(self, props: Mapping[str, str]):
             return {"fgColor": self.color_to_excel(fill_color), "patternType": "solid"}
 
     def build_number_format(self, props: Mapping[str, str]) -> dict[str, str | None]:
-        return {"format_code": props.get("number-format")}
+        fc = props.get("number-format")
+        fc = fc.replace("§", ";") if isinstance(fc, str) else fc
+        return {"format_code": fc}
 
     def build_font(
         self, props: Mapping[str, str]
-    ) -> dict[str, bool | int | float | str | None]:
+    ) -> dict[str, bool | float | str | None]:
         font_names = self._get_font_names(props)
         decoration = self._get_decoration(props)
         return {
@@ -407,7 +462,11 @@ def color_to_excel(self, val: str | None) -> str | None:
         try:
             return self.NAMED_COLORS[val]
         except KeyError:
-            warnings.warn(f"Unhandled color format: {repr(val)}", CSSWarning)
+            warnings.warn(
+                f"Unhandled color format: {repr(val)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
         return None
 
     def _is_hex_color(self, color_string: str) -> bool:
@@ -467,8 +526,8 @@ class ExcelFormatter:
         This is only called for body cells.
     """
 
-    max_rows = 2 ** 20
-    max_cols = 2 ** 14
+    max_rows = 2**20
+    max_cols = 2**14
 
     def __init__(
         self,
@@ -482,7 +541,7 @@ def __init__(
         merge_cells: bool = False,
         inf_rep: str = "inf",
         style_converter: Callable | None = None,
-    ):
+    ) -> None:
         self.rowcounter = 0
         self.na_rep = na_rep
         if not isinstance(df, DataFrame):
@@ -517,7 +576,7 @@ def __init__(
         self.inf_rep = inf_rep
 
     @property
-    def header_style(self):
+    def header_style(self) -> dict[str, dict[str, str | bool]]:
         return {
             "font": {"bold": True},
             "borders": {
@@ -623,7 +682,7 @@ def _format_header_regular(self) -> Iterable[ExcelCell]:
             if self.index:
                 coloffset = 1
                 if isinstance(self.df.index, MultiIndex):
-                    coloffset = len(self.df.index[0])
+                    coloffset = len(self.df.index.names)
 
             colnames = self.columns
             if self._has_aliases:
@@ -649,20 +708,21 @@ def _format_header_regular(self) -> Iterable[ExcelCell]:
                 )
 
     def _format_header(self) -> Iterable[ExcelCell]:
+        gen: Iterable[ExcelCell]
+
         if isinstance(self.columns, MultiIndex):
             gen = self._format_header_mi()
         else:
             gen = self._format_header_regular()
 
-        gen2 = ()
+        gen2: Iterable[ExcelCell] = ()
+
         if self.df.index.names:
             row = [x if x is not None else "" for x in self.df.index.names] + [
                 ""
             ] * len(self.columns)
             if reduce(lambda x, y: x and y, map(lambda x: x != "", row)):
-                # error: Incompatible types in assignment (expression has type
-                # "Generator[ExcelCell, None, None]", variable has type "Tuple[]")
-                gen2 = (  # type: ignore[assignment]
+                gen2 = (
                     ExcelCell(self.rowcounter, colindex, val, self.header_style)
                     for colindex, val in enumerate(row)
                 )
@@ -832,13 +892,13 @@ def get_formatted_cells(self) -> Iterable[ExcelCell]:
     def write(
         self,
         writer,
-        sheet_name="Sheet1",
-        startrow=0,
-        startcol=0,
-        freeze_panes=None,
-        engine=None,
+        sheet_name: str = "Sheet1",
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+        engine: str | None = None,
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         """
         writer : path-like, file-like, or ExcelWriter object
             File path or existing ExcelWriter
@@ -887,7 +947,7 @@ def write(
             need_save = True
 
         try:
-            writer.write_cells(
+            writer._write_cells(
                 formatted_cells,
                 sheet_name,
                 startrow=startrow,
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 616331bf80a44..ff631a95e6846 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -20,8 +20,10 @@
     TYPE_CHECKING,
     Any,
     Callable,
+    Final,
     Hashable,
     Iterable,
+    Iterator,
     List,
     Mapping,
     Sequence,
@@ -42,11 +44,14 @@
     NaT,
     Timedelta,
     Timestamp,
+    get_unit_from_dtype,
     iNaT,
+    periods_per_day,
 )
 from pandas._libs.tslibs.nattype import NaTType
 from pandas._typing import (
     ArrayLike,
+    Axes,
     ColspaceArgType,
     ColspaceType,
     CompressionOptions,
@@ -57,12 +62,12 @@
     StorageOptions,
     WriteBuffer,
 )
+from pandas.util._decorators import deprecate_kwarg
 
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
     is_complex_dtype,
     is_datetime64_dtype,
-    is_datetime64tz_dtype,
     is_extension_array_dtype,
     is_float,
     is_float_dtype,
@@ -73,6 +78,7 @@
     is_scalar,
     is_timedelta64_dtype,
 )
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
 from pandas.core.dtypes.missing import (
     isna,
     notna,
@@ -113,7 +119,7 @@
     )
 
 
-common_docstring = """
+common_docstring: Final = """
         Parameters
         ----------
         buf : str, Path or StringIO-like, optional, default None
@@ -186,7 +192,7 @@
     "unset",
 )
 
-return_docstring = """
+return_docstring: Final = """
         Returns
         -------
         str or None
@@ -203,7 +209,7 @@ def __init__(
         length: bool = True,
         na_rep: str = "NaN",
         footer: bool = True,
-    ):
+    ) -> None:
         self.categorical = categorical
         self.buf = buf if buf is not None else StringIO("")
         self.na_rep = na_rep
@@ -273,7 +279,7 @@ def __init__(
         dtype: bool = True,
         max_rows: int | None = None,
         min_rows: int | None = None,
-    ):
+    ) -> None:
         self.series = series
         self.buf = buf if buf is not None else StringIO()
         self.name = name
@@ -420,7 +426,7 @@ def to_string(self) -> str:
 
 
 class TextAdjustment:
-    def __init__(self):
+    def __init__(self) -> None:
         self.encoding = get_option("display.encoding")
 
     def len(self, text: str) -> int:
@@ -434,7 +440,7 @@ def adjoin(self, space: int, *lists, **kwargs) -> str:
 
 
 class EastAsianTextAdjustment(TextAdjustment):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         if get_option("display.unicode.ambiguous_as_wide"):
             self.ambiguous_width = 2
@@ -560,7 +566,7 @@ class DataFrameFormatter:
     def __init__(
         self,
         frame: DataFrame,
-        columns: Sequence[str] | None = None,
+        columns: Sequence[Hashable] | None = None,
         col_space: ColspaceArgType | None = None,
         header: bool | Sequence[str] = True,
         index: bool = True,
@@ -577,7 +583,7 @@ def __init__(
         decimal: str = ".",
         bold_rows: bool = False,
         escape: bool = True,
-    ):
+    ) -> None:
         self.frame = frame
         self.columns = self._initialize_columns(columns)
         self.col_space = self._initialize_colspace(col_space)
@@ -682,9 +688,11 @@ def _initialize_justify(self, justify: str | None) -> str:
         else:
             return justify
 
-    def _initialize_columns(self, columns: Sequence[str] | None) -> Index:
+    def _initialize_columns(self, columns: Sequence[Hashable] | None) -> Index:
         if columns is not None:
-            cols = ensure_index(columns)
+            # GH 47231 - columns doesn't have to be `Sequence[str]`
+            # Will fix in later PR
+            cols = ensure_index(cast(Axes, columns))
             self.frame = self.frame[cols]
             return cols
         else:
@@ -989,8 +997,8 @@ def _get_formatted_index(self, frame: DataFrame) -> list[str]:
         else:
             return adjoined
 
-    def _get_column_name_list(self) -> list[str]:
-        names: list[str] = []
+    def _get_column_name_list(self) -> list[Hashable]:
+        names: list[Hashable] = []
         columns = self.frame.columns
         if isinstance(columns, MultiIndex):
             names.extend("" if name is None else name for name in columns.names)
@@ -1016,7 +1024,7 @@ class DataFrameRenderer:
         Formatter with the formatting options.
     """
 
-    def __init__(self, fmt: DataFrameFormatter):
+    def __init__(self, fmt: DataFrameFormatter) -> None:
         self.fmt = fmt
 
     def to_latex(
@@ -1028,7 +1036,7 @@ def to_latex(
         multicolumn: bool = False,
         multicolumn_format: str | None = None,
         multirow: bool = False,
-        caption: str | None = None,
+        caption: str | tuple[str, str] | None = None,
         label: str | None = None,
         position: str | None = None,
     ) -> str | None:
@@ -1057,7 +1065,7 @@ def to_html(
         encoding: str | None = None,
         classes: str | list | tuple | None = None,
         notebook: bool = False,
-        border: int | None = None,
+        border: int | bool | None = None,
         table_id: str | None = None,
         render_links: bool = False,
     ) -> str | None:
@@ -1128,6 +1136,7 @@ def to_string(
         string = string_formatter.to_string()
         return save_to_buffer(string, buf=buf, encoding=encoding)
 
+    @deprecate_kwarg(old_arg_name="line_terminator", new_arg_name="lineterminator")
     def to_csv(
         self,
         path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None = None,
@@ -1139,7 +1148,7 @@ def to_csv(
         compression: CompressionOptions = "infer",
         quoting: int | None = None,
         quotechar: str = '"',
-        line_terminator: str | None = None,
+        lineterminator: str | None = None,
         chunksize: int | None = None,
         date_format: str | None = None,
         doublequote: bool = True,
@@ -1160,7 +1169,7 @@ def to_csv(
 
         csv_formatter = CSVFormatter(
             path_or_buf=path_or_buf,
-            line_terminator=line_terminator,
+            lineterminator=lineterminator,
             sep=sep,
             encoding=encoding,
             errors=errors,
@@ -1199,12 +1208,15 @@ def save_to_buffer(
     with get_buffer(buf, encoding=encoding) as f:
         f.write(string)
         if buf is None:
-            return f.getvalue()
+            # error: "WriteBuffer[str]" has no attribute "getvalue"
+            return f.getvalue()  # type: ignore[attr-defined]
         return None
 
 
 @contextmanager
-def get_buffer(buf: FilePath | WriteBuffer[str] | None, encoding: str | None = None):
+def get_buffer(
+    buf: FilePath | WriteBuffer[str] | None, encoding: str | None = None
+) -> Iterator[WriteBuffer[str]] | Iterator[StringIO]:
     """
     Context manager to open, yield and close buffer for filenames or Path-like
     objects, otherwise yield buf unchanged.
@@ -1278,7 +1290,7 @@ def format_array(
     fmt_klass: type[GenericArrayFormatter]
     if is_datetime64_dtype(values.dtype):
         fmt_klass = Datetime64Formatter
-    elif is_datetime64tz_dtype(values.dtype):
+    elif isinstance(values.dtype, DatetimeTZDtype):
         fmt_klass = Datetime64TZFormatter
     elif is_timedelta64_dtype(values.dtype):
         fmt_klass = Timedelta64Formatter
@@ -1292,7 +1304,7 @@ def format_array(
         fmt_klass = GenericArrayFormatter
 
     if space is None:
-        space = get_option("display.column_space")
+        space = 12
 
     if float_format is None:
         float_format = get_option("display.float_format")
@@ -1330,7 +1342,7 @@ def __init__(
         quoting: int | None = None,
         fixed_width: bool = True,
         leading_space: bool | None = True,
-    ):
+    ) -> None:
         self.values = values
         self.digits = digits
         self.na_rep = na_rep
@@ -1423,7 +1435,7 @@ def _format(x):
 
 
 class FloatArrayFormatter(GenericArrayFormatter):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
         # float_format is expected to be a string
@@ -1438,7 +1450,7 @@ def __init__(self, *args, **kwargs):
     def _value_formatter(
         self,
         float_format: FloatFormatType | None = None,
-        threshold: float | int | None = None,
+        threshold: float | None = None,
     ) -> Callable:
         """Returns a function to be applied on each value to format it"""
         # the float_format parameter supersedes self.float_format
@@ -1612,7 +1624,7 @@ def __init__(
         nat_rep: str = "NaT",
         date_format: None = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(values, **kwargs)
         self.nat_rep = nat_rep
         self.date_format = date_format
@@ -1639,9 +1651,7 @@ def _format_strings(self) -> list[str]:
 
         formatter = self.formatter
         if formatter is None:
-            # error: Item "ndarray" of "Union[Any, Union[ExtensionArray, ndarray]]" has
-            # no attribute "_formatter"
-            formatter = values._formatter(boxed=True)  # type: ignore[union-attr]
+            formatter = values._formatter(boxed=True)
 
         if isinstance(values, Categorical):
             # Categorical is special for now, so that we can preserve tzinfo
@@ -1665,7 +1675,7 @@ def _format_strings(self) -> list[str]:
 
 
 def format_percentiles(
-    percentiles: (np.ndarray | list[int | float] | list[float] | list[str | float]),
+    percentiles: (np.ndarray | Sequence[float]),
 ) -> list[str]:
     """
     Outputs rounded and formatted percentiles.
@@ -1738,16 +1748,21 @@ def is_dates_only(values: np.ndarray | DatetimeArray | Index | DatetimeIndex) ->
     if not isinstance(values, Index):
         values = values.ravel()
 
-    values = DatetimeIndex(values)
+    if not isinstance(values, (DatetimeArray, DatetimeIndex)):
+        values = DatetimeIndex(values)
+
     if values.tz is not None:
         return False
 
     values_int = values.asi8
     consider_values = values_int != iNaT
-    one_day_nanos = 86400 * 10 ** 9
-    even_days = (
-        np.logical_and(consider_values, values_int % int(one_day_nanos) != 0).sum() == 0
-    )
+    # error: Argument 1 to "py_get_unit_from_dtype" has incompatible type
+    # "Union[dtype[Any], ExtensionDtype]"; expected "dtype[Any]"
+    reso = get_unit_from_dtype(values.dtype)  # type: ignore[arg-type]
+    ppd = periods_per_day(reso)
+
+    # TODO: can we reuse is_date_array_normalized?  would need a skipna kwd
+    even_days = np.logical_and(consider_values, values_int % ppd != 0).sum() == 0
     if even_days:
         return True
     return False
@@ -1757,6 +1772,8 @@ def _format_datetime64(x: NaTType | Timestamp, nat_rep: str = "NaT") -> str:
     if x is NaT:
         return nat_rep
 
+    # Timestamp.__str__ falls back to datetime.datetime.__str__ = isoformat(sep=' ')
+    # so it already uses string formatting rather than strftime (faster).
     return str(x)
 
 
@@ -1765,21 +1782,21 @@ def _format_datetime64_dateonly(
     nat_rep: str = "NaT",
     date_format: str | None = None,
 ) -> str:
-    if x is NaT:
+    if isinstance(x, NaTType):
         return nat_rep
 
     if date_format:
         return x.strftime(date_format)
     else:
-        # error: Item "NaTType" of "Union[NaTType, Any]" has no attribute "_date_repr"
-        #  The underlying problem here is that mypy doesn't understand that NaT
-        #  is a singleton, so that the check above excludes it here.
-        return x._date_repr  # type: ignore[union-attr]
+        # Timestamp._date_repr relies on string formatting (faster than strftime)
+        return x._date_repr
 
 
 def get_format_datetime64(
     is_dates_only: bool, nat_rep: str = "NaT", date_format: str | None = None
 ) -> Callable:
+    """Return a formatter callable taking a datetime64 as input and providing
+    a string as output"""
 
     if is_dates_only:
         return lambda x: _format_datetime64_dateonly(
@@ -1800,6 +1817,7 @@ def get_format_datetime64_from_values(
 
     ido = is_dates_only(values)
     if ido:
+        # Only dates and no timezone: provide a default format
         return date_format or "%Y-%m-%d"
     return date_format
 
@@ -1824,7 +1842,7 @@ def __init__(
         nat_rep: str = "NaT",
         box: bool = False,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(values, **kwargs)
         self.nat_rep = nat_rep
         self.box = box
@@ -1851,7 +1869,7 @@ def get_format_timedelta64(
 
     consider_values = values_int != iNaT
 
-    one_day_nanos = 86400 * 10 ** 9
+    one_day_nanos = 86400 * 10**9
     # error: Unsupported operand types for % ("ExtensionArray" and "int")
     not_midnight = values_int % one_day_nanos != 0  # type: ignore[operator]
     # error: Argument 1 to "__call__" of "ufunc" has incompatible type
@@ -1873,6 +1891,8 @@ def _formatter(x):
 
         if not isinstance(x, Timedelta):
             x = Timedelta(x)
+
+        # Timedelta._repr_base uses string formatting (faster than strftime)
         result = x._repr_base(format=format)
         if box:
             result = f"'{result}'"
@@ -1962,7 +1982,7 @@ def _trim_zeros_float(
     necessary.
     """
     trimmed = str_floats
-    number_regex = re.compile(fr"^\s*[\+-]?[0-9]+\{decimal}[0-9]*$")
+    number_regex = re.compile(rf"^\s*[\+-]?[0-9]+\{decimal}[0-9]*$")
 
     def is_number_with_decimal(x):
         return re.match(number_regex, x) is not None
@@ -2024,11 +2044,13 @@ class EngFormatter:
         24: "Y",
     }
 
-    def __init__(self, accuracy: int | None = None, use_eng_prefix: bool = False):
+    def __init__(
+        self, accuracy: int | None = None, use_eng_prefix: bool = False
+    ) -> None:
         self.accuracy = accuracy
         self.use_eng_prefix = use_eng_prefix
 
-    def __call__(self, num: int | float) -> str:
+    def __call__(self, num: float) -> str:
         """
         Formats a number in engineering notation, appending a letter
         representing the power of 1000 of the original number. Some examples:
@@ -2079,7 +2101,7 @@ def __call__(self, num: int | float) -> str:
             else:
                 prefix = f"E+{int_pow10:02d}"
 
-        mant = sign * dnum / (10 ** pow10)
+        mant = sign * dnum / (10**pow10)
 
         if self.accuracy is None:  # pragma: no cover
             format_str = "{mant: g}{prefix}"
@@ -2100,7 +2122,6 @@ def set_eng_float_format(accuracy: int = 3, use_eng_prefix: bool = False) -> Non
     See also EngFormatter.
     """
     set_option("display.float_format", EngFormatter(accuracy, use_eng_prefix))
-    set_option("display.column_space", max(12, accuracy + 9))
 
 
 def get_level_lengths(
diff --git a/pandas/io/formats/html.py b/pandas/io/formats/html.py
index 0c927277e899a..e161c8ad16ab1 100644
--- a/pandas/io/formats/html.py
+++ b/pandas/io/formats/html.py
@@ -6,6 +6,8 @@
 from textwrap import dedent
 from typing import (
     Any,
+    Final,
+    Hashable,
     Iterable,
     Mapping,
     cast,
@@ -38,13 +40,13 @@ class HTMLFormatter:
     and this class responsible for only producing html markup.
     """
 
-    indent_delta = 2
+    indent_delta: Final = 2
 
     def __init__(
         self,
         formatter: DataFrameFormatter,
         classes: str | list[str] | tuple[str, ...] | None = None,
-        border: int | None = None,
+        border: int | bool | None = None,
         table_id: str | None = None,
         render_links: bool = False,
     ) -> None:
@@ -57,8 +59,11 @@ def __init__(
         self.bold_rows = self.fmt.bold_rows
         self.escape = self.fmt.escape
         self.show_dimensions = self.fmt.show_dimensions
-        if border is None:
+        if border is None or border is True:
             border = cast(int, get_option("display.html.border"))
+        elif not border:
+            border = None
+
         self.border = border
         self.table_id = table_id
         self.render_links = render_links
@@ -86,7 +91,7 @@ def render(self) -> list[str]:
         return self.elements
 
     @property
-    def should_show_dimensions(self):
+    def should_show_dimensions(self) -> bool:
         return self.fmt.should_show_dimensions
 
     @property
@@ -237,8 +242,13 @@ def _write_table(self, indent: int = 0) -> None:
         else:
             id_section = f' id="{self.table_id}"'
 
+        if self.border is None:
+            border_attr = ""
+        else:
+            border_attr = f' border="{self.border}"'
+
         self.write(
-            f'<table border="{self.border}" class="{" ".join(_classes)}"{id_section}>',
+            f'<table{border_attr} class="{" ".join(_classes)}"{id_section}>',
             indent,
         )
 
@@ -250,6 +260,7 @@ def _write_table(self, indent: int = 0) -> None:
         self.write("</table>", indent)
 
     def _write_col_header(self, indent: int) -> None:
+        row: list[Hashable]
         is_truncated_horizontally = self.fmt.is_truncated_horizontally
         if isinstance(self.columns, MultiIndex):
             template = 'colspan="{span:d}" halign="left"'
diff --git a/pandas/io/formats/info.py b/pandas/io/formats/info.py
index 4a9310c6dccf8..e0f6e01a65052 100644
--- a/pandas/io/formats/info.py
+++ b/pandas/io/formats/info.py
@@ -21,14 +21,13 @@
     WriteBuffer,
 )
 
-from pandas.core.indexes.api import Index
-
 from pandas.io.formats import format as fmt
 from pandas.io.formats.printing import pprint_thing
 
 if TYPE_CHECKING:
-    from pandas.core.frame import (
+    from pandas import (
         DataFrame,
+        Index,
         Series,
     )
 
@@ -258,8 +257,6 @@
 
     Parameters
     ----------
-    data : {klass}
-        {klass} to print information about.
     verbose : bool, optional
         Whether to print the full summary. By default, the setting in
         ``pandas.options.display.max_info_columns`` is followed.
@@ -280,7 +277,9 @@
         made based in column dtype and number of rows assuming values
         consume the same memory amount for corresponding dtypes. With deep
         memory introspection, a real memory usage calculation is performed
-        at the cost of computational resources.
+        at the cost of computational resources. See the
+        :ref:`Frequently Asked Questions <df-memory-usage>` for more
+        details.
     {show_counts_sub}{null_counts_sub}
 
     Returns
@@ -325,7 +324,7 @@ def _put_str(s: str | Dtype, space: int) -> str:
     return str(s)[:space].ljust(space)
 
 
-def _sizeof_fmt(num: int | float, size_qualifier: str) -> str:
+def _sizeof_fmt(num: float, size_qualifier: str) -> str:
     """
     Return size in human readable format.
 
@@ -457,7 +456,7 @@ def __init__(
         self,
         data: DataFrame,
         memory_usage: bool | str | None = None,
-    ):
+    ) -> None:
         self.data: DataFrame = data
         self.memory_usage = _initialize_memory_usage(memory_usage)
 
@@ -533,7 +532,7 @@ def __init__(
         self,
         data: Series,
         memory_usage: bool | str | None = None,
-    ):
+    ) -> None:
         self.data: Series = data
         self.memory_usage = _initialize_memory_usage(memory_usage)
 
@@ -566,7 +565,7 @@ def dtypes(self) -> Iterable[Dtype]:
         return [self.data.dtypes]
 
     @property
-    def dtype_counts(self):
+    def dtype_counts(self) -> Mapping[str, int]:
         from pandas.core.frame import DataFrame
 
         return _get_dataframe_dtype_counts(DataFrame(self.data))
@@ -627,7 +626,7 @@ def __init__(
         max_cols: int | None = None,
         verbose: bool | None = None,
         show_counts: bool | None = None,
-    ):
+    ) -> None:
         self.info = info
         self.data = info.data
         self.verbose = verbose
@@ -704,7 +703,7 @@ def __init__(
         info: SeriesInfo,
         verbose: bool | None = None,
         show_counts: bool | None = None,
-    ):
+    ) -> None:
         self.info = info
         self.data = info.data
         self.verbose = verbose
@@ -795,7 +794,7 @@ class DataFrameTableBuilder(TableBuilderAbstract):
         Instance of DataFrameInfo.
     """
 
-    def __init__(self, *, info: DataFrameInfo):
+    def __init__(self, *, info: DataFrameInfo) -> None:
         self.info: DataFrameInfo = info
 
     def get_lines(self) -> list[str]:
@@ -810,7 +809,7 @@ def _fill_empty_info(self) -> None:
         """Add lines to the info table, pertaining to empty dataframe."""
         self.add_object_type_line()
         self.add_index_range_line()
-        self._lines.append(f"Empty {type(self.data).__name__}")
+        self._lines.append(f"Empty {type(self.data).__name__}\n")
 
     @abstractmethod
     def _fill_non_empty_info(self) -> None:
@@ -957,7 +956,7 @@ def __init__(
         *,
         info: DataFrameInfo,
         with_counts: bool,
-    ):
+    ) -> None:
         self.info = info
         self.with_counts = with_counts
         self.strrows: Sequence[Sequence[str]] = list(self._gen_rows())
@@ -1023,7 +1022,7 @@ class SeriesTableBuilder(TableBuilderAbstract):
         Instance of SeriesInfo.
     """
 
-    def __init__(self, *, info: SeriesInfo):
+    def __init__(self, *, info: SeriesInfo) -> None:
         self.info: SeriesInfo = info
 
     def get_lines(self) -> list[str]:
@@ -1069,7 +1068,7 @@ def __init__(
         *,
         info: SeriesInfo,
         with_counts: bool,
-    ):
+    ) -> None:
         self.info = info
         self.with_counts = with_counts
         self.strrows: Sequence[Sequence[str]] = list(self._gen_rows())
@@ -1087,7 +1086,7 @@ def _fill_non_empty_info(self) -> None:
         if self.display_memory_usage:
             self.add_memory_usage_line()
 
-    def add_series_name_line(self):
+    def add_series_name_line(self) -> None:
         self._lines.append(f"Series name: {self.data.name}")
 
     @property
diff --git a/pandas/io/formats/latex.py b/pandas/io/formats/latex.py
index 3ffb60a042f69..6bf4412be95d4 100644
--- a/pandas/io/formats/latex.py
+++ b/pandas/io/formats/latex.py
@@ -8,6 +8,7 @@
     abstractmethod,
 )
 from typing import (
+    TYPE_CHECKING,
     Iterator,
     Sequence,
 )
@@ -16,7 +17,8 @@
 
 from pandas.core.dtypes.generic import ABCMultiIndex
 
-from pandas.io.formats.format import DataFrameFormatter
+if TYPE_CHECKING:
+    from pandas.io.formats.format import DataFrameFormatter
 
 
 def _split_into_full_short_caption(
@@ -74,7 +76,7 @@ def __init__(
         multicolumn: bool = False,
         multicolumn_format: str | None = None,
         multirow: bool = False,
-    ):
+    ) -> None:
         self.fmt = formatter
         self.frame = self.fmt.frame
         self.multicolumn = multicolumn
@@ -336,7 +338,7 @@ def __init__(
         short_caption: str | None = None,
         label: str | None = None,
         position: str | None = None,
-    ):
+    ) -> None:
         self.fmt = formatter
         self.column_format = column_format
         self.multicolumn = multicolumn
@@ -697,7 +699,7 @@ def __init__(
         caption: str | tuple[str, str] | None = None,
         label: str | None = None,
         position: str | None = None,
-    ):
+    ) -> None:
         self.fmt = formatter
         self.frame = self.fmt.frame
         self.longtable = longtable
diff --git a/pandas/io/formats/printing.py b/pandas/io/formats/printing.py
index 77431533e703a..abb341f6385c1 100644
--- a/pandas/io/formats/printing.py
+++ b/pandas/io/formats/printing.py
@@ -259,10 +259,14 @@ def enable_data_resource_formatter(enable: bool) -> None:
         if mimetype not in formatters:
             # define tableschema formatter
             from IPython.core.formatters import BaseFormatter
+            from traitlets import ObjectName
 
             class TableSchemaFormatter(BaseFormatter):
-                print_method = "_repr_data_resource_"
-                _return_type = (dict,)
+                print_method = ObjectName("_repr_data_resource_")
+                # Incompatible types in assignment (expression has type
+                # "Tuple[Type[Dict[Any, Any]]]", base class "BaseFormatter"
+                # defined the type as "Type[str]")
+                _return_type = (dict,)  # type: ignore[assignment]
 
             # register it:
             formatters[mimetype] = TableSchemaFormatter()
diff --git a/pandas/io/formats/string.py b/pandas/io/formats/string.py
index 90a4800c805b6..071afc059b166 100644
--- a/pandas/io/formats/string.py
+++ b/pandas/io/formats/string.py
@@ -4,18 +4,23 @@
 from __future__ import annotations
 
 from shutil import get_terminal_size
-from typing import Iterable
+from typing import (
+    TYPE_CHECKING,
+    Iterable,
+)
 
 import numpy as np
 
-from pandas.io.formats.format import DataFrameFormatter
 from pandas.io.formats.printing import pprint_thing
 
+if TYPE_CHECKING:
+    from pandas.io.formats.format import DataFrameFormatter
+
 
 class StringFormatter:
     """Formatter for string representation of a dataframe."""
 
-    def __init__(self, fmt: DataFrameFormatter, line_width: int | None = None):
+    def __init__(self, fmt: DataFrameFormatter, line_width: int | None = None) -> None:
         self.fmt = fmt
         self.adj = fmt.adj
         self.frame = fmt.frame
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 2e74ac93b1ced..59c586e0305c6 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -12,6 +12,7 @@
     Callable,
     Hashable,
     Sequence,
+    overload,
 )
 import warnings
 
@@ -19,12 +20,15 @@
 
 from pandas._config import get_option
 
+from pandas._libs import lib
 from pandas._typing import (
     Axis,
     FilePath,
     IndexLabel,
     Level,
+    QuantileInterpolation,
     Scalar,
+    StorageOptions,
     WriteBuffer,
 )
 from pandas.compat._optional import import_optional_dependency
@@ -85,18 +89,26 @@ def _mpl(func: Callable):
 ####
 # Shared Doc Strings
 
-subset = """
-        subset : label, array-like, IndexSlice, optional
+subset = """subset : label, array-like, IndexSlice, optional
             A valid 2d input to `DataFrame.loc[<subset>]`, or, in the case of a 1d input
             or single key, to `DataFrame.loc[:, <subset>]` where the columns are
-            prioritised, to limit ``data`` to *before* applying the function.
-"""
+            prioritised, to limit ``data`` to *before* applying the function."""
 
-props = """
-        props : str, default None
-            CSS properties to use for highlighting. If ``props`` is given, ``color``
-            is not used.
-"""
+props = """props : str, default None
+           CSS properties to use for highlighting. If ``props`` is given, ``color``
+           is not used."""
+
+color = """color : str, default 'yellow'
+           Background color to use for highlighting."""
+
+buf = """buf : str, path object, file-like object, optional
+         String, path object (implementing ``os.PathLike[str]``), or file-like
+         object implementing a string ``write()`` function. If ``None``, the result is
+         returned as a string."""
+
+encoding = """encoding : str, optional
+              Character encoding setting for file output (and meta tags if available).
+              Defaults to ``pandas.options.styler.render.encoding`` value of "utf-8"."""
 
 #
 ###
@@ -232,7 +244,7 @@ def __init__(
         thousands: str | None = None,
         escape: str | None = None,
         formatter: ExtFormatter | None = None,
-    ):
+    ) -> None:
         super().__init__(
             data=data,
             uuid=uuid,
@@ -263,6 +275,107 @@ def __init__(
             thousands=thousands,
         )
 
+    def concat(self, other: Styler) -> Styler:
+        """
+        Append another Styler to combine the output into a single table.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        other : Styler
+            The other Styler object which has already been styled and formatted. The
+            data for this Styler must have the same columns as the original, and the
+            number of index levels must also be the same to render correctly.
+
+        Returns
+        -------
+        self : Styler
+
+        Notes
+        -----
+        The purpose of this method is to extend existing styled dataframes with other
+        metrics that may be useful but may not conform to the original's structure.
+        For example adding a sub total row, or displaying metrics such as means,
+        variance or counts.
+
+        Styles that are applied using the ``apply``, ``applymap``, ``apply_index``
+        and ``applymap_index``, and formatting applied with ``format`` and
+        ``format_index`` will be preserved.
+
+        .. warning::
+            Only the output methods ``to_html``, ``to_string`` and ``to_latex``
+            currently work with concatenated Stylers.
+
+            Other output methods, including ``to_excel``, **do not** work with
+            concatenated Stylers.
+
+        The following should be noted:
+
+          - ``table_styles``, ``table_attributes``, ``caption`` and ``uuid`` are all
+            inherited from the original Styler and not ``other``.
+          - hidden columns and hidden index levels will be inherited from the
+            original Styler
+          - ``css`` will be inherited from the original Styler, and the value of
+            keys ``data``, ``row_heading`` and ``row`` will be prepended with
+            ``foot0_``. If more concats are chained, their styles will be prepended
+            with ``foot1_``, ''foot_2'', etc., and if a concatenated style have
+            another concatanated style, the second style will be prepended with
+            ``foot{parent}_foot{child}_``.
+
+        A common use case is to concatenate user defined functions with
+        ``DataFrame.agg`` or with described statistics via ``DataFrame.describe``.
+        See examples.
+
+        Examples
+        --------
+        A common use case is adding totals rows, or otherwise, via methods calculated
+        in ``DataFrame.agg``.
+
+        >>> df = DataFrame([[4, 6], [1, 9], [3, 4], [5, 5], [9,6]],
+        ...                columns=["Mike", "Jim"],
+        ...                index=["Mon", "Tue", "Wed", "Thurs", "Fri"])
+        >>> styler = df.style.concat(df.agg(["sum"]).style)  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/footer_simple.png
+
+        Since the concatenated object is a Styler the existing functionality can be
+        used to conditionally format it as well as the original.
+
+        >>> descriptors = df.agg(["sum", "mean", lambda s: s.dtype])
+        >>> descriptors.index = ["Total", "Average", "dtype"]
+        >>> other = (descriptors.style
+        ...          .highlight_max(axis=1, subset=(["Total", "Average"], slice(None)))
+        ...          .format(subset=("Average", slice(None)), precision=2, decimal=",")
+        ...          .applymap(lambda v: "font-weight: bold;"))
+        >>> styler = (df.style
+        ...             .highlight_max(color="salmon")
+        ...             .set_table_styles([{"selector": ".foot_row0",
+        ...                                 "props": "border-top: 1px solid black;"}]))
+        >>> styler.concat(other)  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/footer_extended.png
+
+        When ``other`` has fewer index levels than the original Styler it is possible
+        to extend the index in ``other``, with placeholder levels.
+
+        >>> df = DataFrame([[1], [2]], index=pd.MultiIndex.from_product([[0], [1, 2]]))
+        >>> descriptors = df.agg(["sum"])
+        >>> descriptors.index = pd.MultiIndex.from_product([[""], descriptors.index])
+        >>> df.style.concat(descriptors.style)  # doctest: +SKIP
+        """
+        if not isinstance(other, Styler):
+            raise TypeError("`other` must be of type `Styler`")
+        if not self.data.columns.equals(other.data.columns):
+            raise ValueError("`other.data` must have same columns as `Styler.data`")
+        if not self.data.index.nlevels == other.data.index.nlevels:
+            raise ValueError(
+                "number of index levels must be same in `other` "
+                "as in `Styler`. See documentation for suggestions."
+            )
+        self.concatenated.append(other)
+        return self
+
     def _repr_html_(self) -> str | None:
         """
         Hooks into Jupyter notebook rich display system, which calls _repr_html_ by
@@ -443,6 +556,7 @@ def set_tooltips(
         NDFrame.to_excel,
         klass="Styler",
         storage_options=_shared_docs["storage_options"],
+        storage_options_versionadded="1.5.0",
     )
     def to_excel(
         self,
@@ -462,6 +576,7 @@ def to_excel(
         inf_rep: str = "inf",
         verbose: bool = True,
         freeze_panes: tuple[int, int] | None = None,
+        storage_options: StorageOptions = None,
     ) -> None:
 
         from pandas.io.formats.excel import ExcelFormatter
@@ -484,8 +599,55 @@ def to_excel(
             startcol=startcol,
             freeze_panes=freeze_panes,
             engine=engine,
+            storage_options=storage_options,
         )
 
+    @overload
+    def to_latex(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        *,
+        column_format: str | None = ...,
+        position: str | None = ...,
+        position_float: str | None = ...,
+        hrules: bool | None = ...,
+        clines: str | None = ...,
+        label: str | None = ...,
+        caption: str | tuple | None = ...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        multirow_align: str | None = ...,
+        multicol_align: str | None = ...,
+        siunitx: bool = ...,
+        environment: str | None = ...,
+        encoding: str | None = ...,
+        convert_css: bool = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def to_latex(
+        self,
+        buf: None = ...,
+        *,
+        column_format: str | None = ...,
+        position: str | None = ...,
+        position_float: str | None = ...,
+        hrules: bool | None = ...,
+        clines: str | None = ...,
+        label: str | None = ...,
+        caption: str | tuple | None = ...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        multirow_align: str | None = ...,
+        multicol_align: str | None = ...,
+        siunitx: bool = ...,
+        environment: str | None = ...,
+        encoding: str | None = ...,
+        convert_css: bool = ...,
+    ) -> str:
+        ...
+
     def to_latex(
         self,
         buf: FilePath | WriteBuffer[str] | None = None,
@@ -494,6 +656,7 @@ def to_latex(
         position: str | None = None,
         position_float: str | None = None,
         hrules: bool | None = None,
+        clines: str | None = None,
         label: str | None = None,
         caption: str | tuple | None = None,
         sparse_index: bool | None = None,
@@ -504,7 +667,7 @@ def to_latex(
         environment: str | None = None,
         encoding: str | None = None,
         convert_css: bool = False,
-    ):
+    ) -> str | None:
         r"""
         Write Styler to a file, buffer or string in LaTeX format.
 
@@ -542,6 +705,22 @@ def to_latex(
             Defaults to ``pandas.options.styler.latex.hrules``, which is `False`.
 
             .. versionchanged:: 1.4.0
+        clines : str, optional
+            Use to control adding \\cline commands for the index labels separation.
+            Possible values are:
+
+              - `None`: no cline commands are added (default).
+              - `"all;data"`: a cline is added for every index value extending the
+                width of the table, including data entries.
+              - `"all;index"`: as above with lines extending only the width of the
+                index entries.
+              - `"skip-last;data"`: a cline is added for each index value except the
+                last level (which is never sparsified), extending the widtn of the
+                table.
+              - `"skip-last;index"`: as above with lines extending only the width of the
+                index entries.
+
+            .. versionadded:: 1.4.0
         label : str, optional
             The LaTeX label included as: \\label{<label>}.
             This is used with \\ref{<label>} in the main .tex file.
@@ -818,6 +997,124 @@ def to_latex(
         {} & {0} \\
         0 & {\bfseries}{\Huge{1}} \\
         \end{tabular}
+
+        Examples
+        --------
+        Below we give a complete step by step example adding some advanced features
+        and noting some common gotchas.
+
+        First we create the DataFrame and Styler as usual, including MultiIndex rows
+        and columns, which allow for more advanced formatting options:
+
+        >>> cidx = pd.MultiIndex.from_arrays([
+        ...     ["Equity", "Equity", "Equity", "Equity",
+        ...      "Stats", "Stats", "Stats", "Stats", "Rating"],
+        ...     ["Energy", "Energy", "Consumer", "Consumer", "", "", "", "", ""],
+        ...     ["BP", "Shell", "H&M", "Unilever",
+        ...      "Std Dev", "Variance", "52w High", "52w Low", ""]
+        ... ])
+        >>> iidx = pd.MultiIndex.from_arrays([
+        ...     ["Equity", "Equity", "Equity", "Equity"],
+        ...     ["Energy", "Energy", "Consumer", "Consumer"],
+        ...     ["BP", "Shell", "H&M", "Unilever"]
+        ... ])
+        >>> styler = pd.DataFrame([
+        ...     [1, 0.8, 0.66, 0.72, 32.1678, 32.1678**2, 335.12, 240.89, "Buy"],
+        ...     [0.8, 1.0, 0.69, 0.79, 1.876, 1.876**2, 14.12, 19.78, "Hold"],
+        ...     [0.66, 0.69, 1.0, 0.86, 7, 7**2, 210.9, 140.6, "Buy"],
+        ...     [0.72, 0.79, 0.86, 1.0, 213.76, 213.76**2, 2807, 3678, "Sell"],
+        ... ], columns=cidx, index=iidx).style
+
+        Second we will format the display and, since our table is quite wide, will
+        hide the repeated level-0 of the index:
+
+        >>> styler.format(subset="Equity", precision=2)
+        ...       .format(subset="Stats", precision=1, thousands=",")
+        ...       .format(subset="Rating", formatter=str.upper)
+        ...       .format_index(escape="latex", axis=1)
+        ...       .format_index(escape="latex", axis=0)
+        ...       .hide(level=0, axis=0)  # doctest: +SKIP
+
+        Note that one of the string entries of the index and column headers is "H&M".
+        Without applying the `escape="latex"` option to the `format_index` method the
+        resultant LaTeX will fail to render, and the error returned is quite
+        difficult to debug. Using the appropriate escape the "&" is converted to "\\&".
+
+        Thirdly we will apply some (CSS-HTML) styles to our object. We will use a
+        builtin method and also define our own method to highlight the stock
+        recommendation:
+
+        >>> def rating_color(v):
+        ...     if v == "Buy": color = "#33ff85"
+        ...     elif v == "Sell": color = "#ff5933"
+        ...     else: color = "#ffdd33"
+        ...     return f"color: {color}; font-weight: bold;"
+        >>> styler.background_gradient(cmap="inferno", subset="Equity", vmin=0, vmax=1)
+        ...       .applymap(rating_color, subset="Rating")  # doctest: +SKIP
+
+        All the above styles will work with HTML (see below) and LaTeX upon conversion:
+
+        .. figure:: ../../_static/style/latex_stocks_html.png
+
+        However, we finally want to add one LaTeX only style
+        (from the {graphicx} package), that is not easy to convert from CSS and
+        pandas does not support it. Notice the `--latex` flag used here,
+        as well as `--rwrap` to ensure this is formatted correctly and
+        not ignored upon conversion.
+
+        >>> styler.applymap_index(
+        ...     lambda v: "rotatebox:{45}--rwrap--latex;", level=2, axis=1
+        ... )  # doctest: +SKIP
+
+        Finally we render our LaTeX adding in other options as required:
+
+        >>> styler.to_latex(
+        ...     caption="Selected stock correlation and simple statistics.",
+        ...     clines="skip-last;data",
+        ...     convert_css=True,
+        ...     position_float="centering",
+        ...     multicol_align="|c|",
+        ...     hrules=True,
+        ... )  # doctest: +SKIP
+        \begin{table}
+        \centering
+        \caption{Selected stock correlation and simple statistics.}
+        \begin{tabular}{llrrrrrrrrl}
+        \toprule
+         &  & \multicolumn{4}{|c|}{Equity} & \multicolumn{4}{|c|}{Stats} & Rating \\
+         &  & \multicolumn{2}{|c|}{Energy} & \multicolumn{2}{|c|}{Consumer} &
+        \multicolumn{4}{|c|}{} &  \\
+         &  & \rotatebox{45}{BP} & \rotatebox{45}{Shell} & \rotatebox{45}{H\&M} &
+        \rotatebox{45}{Unilever} & \rotatebox{45}{Std Dev} & \rotatebox{45}{Variance} &
+        \rotatebox{45}{52w High} & \rotatebox{45}{52w Low} & \rotatebox{45}{} \\
+        \midrule
+        \multirow[c]{2}{*}{Energy} & BP & {\cellcolor[HTML]{FCFFA4}}
+        \color[HTML]{000000} 1.00 & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000}
+        0.80 & {\cellcolor[HTML]{EB6628}} \color[HTML]{F1F1F1} 0.66 &
+        {\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 & 32.2 & 1,034.8 & 335.1
+        & 240.9 & \color[HTML]{33FF85} \bfseries BUY \\
+         & Shell & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000} 0.80 &
+        {\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
+        {\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1} 0.69 &
+        {\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 & 1.9 & 3.5 & 14.1 &
+        19.8 & \color[HTML]{FFDD33} \bfseries HOLD \\
+        \cline{1-11}
+        \multirow[c]{2}{*}{Consumer} & H\&M & {\cellcolor[HTML]{EB6628}}
+        \color[HTML]{F1F1F1} 0.66 & {\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1}
+        0.69 & {\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
+        {\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 & 7.0 & 49.0 & 210.9 &
+        140.6 & \color[HTML]{33FF85} \bfseries BUY \\
+         & Unilever & {\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 &
+        {\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 &
+        {\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 &
+        {\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 & 213.8 & 45,693.3 &
+        2,807.0 & 3,678.0 & \color[HTML]{FF5933} \bfseries SELL \\
+        \cline{1-11}
+        \bottomrule
+        \end{tabular}
+        \end{table}
+
+        .. figure:: ../../_static/style/latex_stocks.png
         """
         obj = self._copy(deepcopy=True)  # manipulate table_styles on obj, not self
 
@@ -911,13 +1208,57 @@ def to_latex(
             environment=environment,
             convert_css=convert_css,
             siunitx=siunitx,
+            clines=clines,
         )
 
-        encoding = encoding or get_option("styler.render.encoding")
-        return save_to_buffer(
-            latex, buf=buf, encoding=None if buf is None else encoding
+        encoding = (
+            (encoding or get_option("styler.render.encoding"))
+            if isinstance(buf, str)  # i.e. a filepath
+            else encoding
         )
+        return save_to_buffer(latex, buf=buf, encoding=encoding)
+
+    @overload
+    def to_html(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        *,
+        table_uuid: str | None = ...,
+        table_attributes: str | None = ...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        bold_headers: bool = ...,
+        caption: str | None = ...,
+        max_rows: int | None = ...,
+        max_columns: int | None = ...,
+        encoding: str | None = ...,
+        doctype_html: bool = ...,
+        exclude_styles: bool = ...,
+        **kwargs,
+    ) -> None:
+        ...
+
+    @overload
+    def to_html(
+        self,
+        buf: None = ...,
+        *,
+        table_uuid: str | None = ...,
+        table_attributes: str | None = ...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        bold_headers: bool = ...,
+        caption: str | None = ...,
+        max_rows: int | None = ...,
+        max_columns: int | None = ...,
+        encoding: str | None = ...,
+        doctype_html: bool = ...,
+        exclude_styles: bool = ...,
+        **kwargs,
+    ) -> str:
+        ...
 
+    @Substitution(buf=buf, encoding=encoding)
     def to_html(
         self,
         buf: FilePath | WriteBuffer[str] | None = None,
@@ -934,7 +1275,7 @@ def to_html(
         doctype_html: bool = False,
         exclude_styles: bool = False,
         **kwargs,
-    ):
+    ) -> str | None:
         """
         Write Styler to a file, buffer or string in HTML-CSS format.
 
@@ -942,10 +1283,7 @@ def to_html(
 
         Parameters
         ----------
-        buf : str, path object, file-like object, or None, default None
-            String, path object (implementing ``os.PathLike[str]``), or file-like
-            object implementing a string ``write()`` function. If None, the result is
-            returned as a string.
+        %(buf)s
         table_uuid : str, optional
             Id attribute assigned to the <table> HTML element in the format:
 
@@ -992,9 +1330,7 @@ def to_html(
             which is 262144 (18 bit browser rendering).
 
             .. versionadded:: 1.4.0
-        encoding : str, optional
-            Character encoding setting for file output, and HTML meta tags.
-            Defaults to ``pandas.options.styler.render.encoding`` value of "utf-8".
+        %(encoding)s
         doctype_html : bool, default False
             Whether to output a fully structured HTML file including all
             HTML elements, or just the core ``<style>`` and ``<table>`` elements.
@@ -1037,7 +1373,6 @@ def to_html(
         if caption is not None:
             obj.set_caption(caption)
 
-        encoding = encoding or get_option("styler.render.encoding")
         # Build HTML string..
         html = obj._render_html(
             sparse_index=sparse_index,
@@ -1045,7 +1380,7 @@ def to_html(
             max_rows=max_rows,
             max_cols=max_columns,
             exclude_styles=exclude_styles,
-            encoding=encoding,
+            encoding=encoding or get_option("styler.render.encoding"),
             doctype_html=doctype_html,
             **kwargs,
         )
@@ -1054,10 +1389,102 @@ def to_html(
             html, buf=buf, encoding=(encoding if buf is not None else None)
         )
 
+    @overload
+    def to_string(
+        self,
+        buf: FilePath | WriteBuffer[str],
+        *,
+        encoding=...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        max_rows: int | None = ...,
+        max_columns: int | None = ...,
+        delimiter: str = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def to_string(
+        self,
+        buf: None = ...,
+        *,
+        encoding=...,
+        sparse_index: bool | None = ...,
+        sparse_columns: bool | None = ...,
+        max_rows: int | None = ...,
+        max_columns: int | None = ...,
+        delimiter: str = ...,
+    ) -> str:
+        ...
+
+    @Substitution(buf=buf, encoding=encoding)
+    def to_string(
+        self,
+        buf: FilePath | WriteBuffer[str] | None = None,
+        *,
+        encoding=None,
+        sparse_index: bool | None = None,
+        sparse_columns: bool | None = None,
+        max_rows: int | None = None,
+        max_columns: int | None = None,
+        delimiter: str = " ",
+    ) -> str | None:
+        """
+        Write Styler to a file, buffer or string in text format.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        %(buf)s
+        %(encoding)s
+        sparse_index : bool, optional
+            Whether to sparsify the display of a hierarchical index. Setting to False
+            will display each explicit level element in a hierarchical key for each row.
+            Defaults to ``pandas.options.styler.sparse.index`` value.
+        sparse_columns : bool, optional
+            Whether to sparsify the display of a hierarchical index. Setting to False
+            will display each explicit level element in a hierarchical key for each
+            column. Defaults to ``pandas.options.styler.sparse.columns`` value.
+        max_rows : int, optional
+            The maximum number of rows that will be rendered. Defaults to
+            ``pandas.options.styler.render.max_rows``, which is None.
+        max_columns : int, optional
+            The maximum number of columns that will be rendered. Defaults to
+            ``pandas.options.styler.render.max_columns``, which is None.
+
+            Rows and columns may be reduced if the number of total elements is
+            large. This value is set to ``pandas.options.styler.render.max_elements``,
+            which is 262144 (18 bit browser rendering).
+        delimiter : str, default single space
+            The separator between data elements.
+
+        Returns
+        -------
+        str or None
+            If `buf` is None, returns the result as a string. Otherwise returns `None`.
+        """
+        obj = self._copy(deepcopy=True)
+
+        if sparse_index is None:
+            sparse_index = get_option("styler.sparse.index")
+        if sparse_columns is None:
+            sparse_columns = get_option("styler.sparse.columns")
+
+        text = obj._render_string(
+            sparse_columns=sparse_columns,
+            sparse_index=sparse_index,
+            max_rows=max_rows,
+            max_cols=max_columns,
+            delimiter=delimiter,
+        )
+        return save_to_buffer(
+            text, buf=buf, encoding=(encoding if buf is not None else None)
+        )
+
     def set_td_classes(self, classes: DataFrame) -> Styler:
         """
-        Set the DataFrame of strings added to the ``class`` attribute of ``<td>``
-        HTML elements.
+        Set the ``class`` attribute of ``<td>`` HTML elements.
 
         Parameters
         ----------
@@ -1200,6 +1627,7 @@ def _copy(self, deepcopy: bool = False) -> Styler:
           - cell_context (cell css classes)
           - ctx (cell css styles)
           - caption
+          - concatenated stylers
 
         Non-data dependent attributes [copied and exported]:
           - css
@@ -1230,6 +1658,7 @@ def _copy(self, deepcopy: bool = False) -> Styler:
         ]
         deep = [  # nested lists or dicts
             "css",
+            "concatenated",
             "_display_funcs",
             "_display_funcs_index",
             "_display_funcs_columns",
@@ -1284,7 +1713,9 @@ def _apply(
         subset = slice(None) if subset is None else subset
         subset = non_reducing_slice(subset)
         data = self.data.loc[subset]
-        if axis is None:
+        if data.empty:
+            result = DataFrame()
+        elif axis is None:
             result = func(data, **kwargs)
             if not isinstance(result, DataFrame):
                 if not isinstance(result, np.ndarray):
@@ -1452,7 +1883,6 @@ def _apply_index(
         alt="applymap",
         altwise="elementwise",
         func="take a Series and return a string array of the same length",
-        axis='{0, 1, "index", "columns"}',
         input_note="the index as a Series, if an Index, or a level of a MultiIndex",
         output_note="an identically sized array of CSS styles as strings",
         var="s",
@@ -1477,7 +1907,7 @@ def apply_index(
         ----------
         func : function
             ``func`` should {func}.
-        axis : {axis}
+        axis : {{0, 1, "index", "columns"}}
             The headers over which to apply the function.
         level : int, str, list, optional
             If index is MultiIndex the level(s) over which to apply the function.
@@ -1538,7 +1968,6 @@ def apply_index(
         alt="apply",
         altwise="level-wise",
         func="take a scalar and return a string",
-        axis='{0, 1, "index", "columns"}',
         input_note="an index value, if an Index, or a level value of a MultiIndex",
         output_note="CSS styles as a string",
         var="v",
@@ -1979,7 +2408,7 @@ def set_sticky(
         obj = self.data.index if axis == 0 else self.data.columns
         pixel_size = (75 if axis == 0 else 25) if not pixel_size else pixel_size
 
-        props = "position:sticky; background-color:white;"
+        props = "position:sticky; background-color:inherit;"
         if not isinstance(obj, pd.MultiIndex):
             # handling MultiIndexes requires different CSS
 
@@ -2143,11 +2572,13 @@ def set_table_styles(
                                "col_heading": "col_heading",
                                "index_name": "index_name",
                                "col": "col",
+                               "row": "row",
                                "col_trim": "col_trim",
                                "row_trim": "row_trim",
                                "level": "level",
                                "data": "data",
-                               "blank": "blank}
+                               "blank": "blank",
+                               "foot": "foot"}
 
         Examples
         --------
@@ -2293,11 +2724,11 @@ def hide_index(
         Styler.hide: Hide the entire index / columns, or specific rows / columns.
         """
         warnings.warn(
-            "this method is deprecated in favour of `Styler.hide(axis='index')`",
+            'this method is deprecated in favour of `Styler.hide(axis="index")`',
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        return self.hide(axis=0, level=level, subset=subset, names=names)
+        return self.hide(axis="index", level=level, subset=subset, names=names)
 
     def hide_columns(
         self,
@@ -2346,11 +2777,11 @@ def hide_columns(
         Styler.hide: Hide the entire index / columns, or specific rows / columns.
         """
         warnings.warn(
-            "this method is deprecated in favour of `Styler.hide(axis='columns')`",
+            'this method is deprecated in favour of `Styler.hide(axis="columns")`',
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        return self.hide(axis=1, level=level, subset=subset, names=names)
+        return self.hide(axis="columns", level=level, subset=subset, names=names)
 
     def hide(
         self,
@@ -2385,6 +2816,13 @@ def hide(
 
         Notes
         -----
+        .. warning::
+           This method only works with the output methods ``to_html``, ``to_string``
+           and ``to_latex``.
+
+           Other output methods, including ``to_excel``, ignore this hiding method
+           and will display all data.
+
         This method has multiple functionality depending upon the combination
         of the ``subset``, ``level`` and ``names`` arguments (see examples). The
         ``axis`` argument is used only to control whether the method is applied to row
@@ -2543,12 +2981,20 @@ def hide(
     # A collection of "builtin" styles
     # -----------------------------------------------------------------------
 
+    def _get_numeric_subset_default(self):
+        # Returns a boolean mask indicating where `self.data` has numerical columns.
+        # Choosing a mask as opposed to the column names also works for
+        # boolean column labels (GH47838).
+        return self.data.columns.isin(self.data.select_dtypes(include=np.number))
+
     @doc(
         name="background",
         alt="text",
         image_prefix="bg",
-        axis="{0 or 'index', 1 or 'columns', None}",
-        text_threshold="",
+        text_threshold="""text_color_threshold : float or int\n
+            Luminance threshold for determining text color in [0, 1]. Facilitates text\n
+            visibility across varying background colors. All text is dark if 0, and\n
+            light if 1, defaults to 0.408.""",
     )
     @Substitution(subset=subset)
     def background_gradient(
@@ -2582,16 +3028,12 @@ def background_gradient(
             Compress the color range at the high end. This is a multiple of the data
             range to extend above the maximum; good values usually in [0, 1],
             defaults to 0.
-        axis : {axis}, default 0
+        axis : {{0, 1, "index", "columns", None}}, default 0
             Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         %(subset)s
-        text_color_threshold : float or int
-            {text_threshold}
-            Luminance threshold for determining text color in [0, 1]. Facilitates text
-            visibility across varying background colors. All text is dark if 0, and
-            light if 1, defaults to 0.408.
+        {text_threshold}
         vmin : float, optional
             Minimum data value that corresponds to colormap minimum value.
             If not specified the minimum value of the data (or gmap) will be used.
@@ -2687,7 +3129,7 @@ def background_gradient(
         .. figure:: ../../_static/style/{image_prefix}_axNone_gmap.png
         """
         if subset is None and gmap is None:
-            subset = self.data.select_dtypes(include=np.number).columns
+            subset = self._get_numeric_subset_default()
 
         self.apply(
             _background_gradient,
@@ -2708,8 +3150,7 @@ def background_gradient(
         name="text",
         alt="background",
         image_prefix="tg",
-        axis="{0 or 'index', 1 or 'columns', None}",
-        text_threshold="This argument is ignored (only used in `background_gradient`).",
+        text_threshold="",
     )
     def text_gradient(
         self,
@@ -2723,7 +3164,7 @@ def text_gradient(
         gmap: Sequence | None = None,
     ) -> Styler:
         if subset is None and gmap is None:
-            subset = self.data.select_dtypes(include=np.number).columns
+            subset = self._get_numeric_subset_default()
 
         return self.apply(
             _background_gradient,
@@ -2741,8 +3182,7 @@ def text_gradient(
     @Substitution(subset=subset)
     def set_properties(self, subset: Subset | None = None, **kwargs) -> Styler:
         """
-        Set defined CSS-properties to each ``<td>`` HTML element within the given
-        subset.
+        Set defined CSS-properties to each ``<td>`` HTML element for the given subset.
 
         Parameters
         ----------
@@ -2781,7 +3221,7 @@ def bar(
         cmap: Any | None = None,
         width: float = 100,
         height: float = 100,
-        align: str | float | int | Callable = "mid",
+        align: str | float | Callable = "mid",
         vmin: float | None = None,
         vmax: float | None = None,
         props: str = "width: 10em;",
@@ -2876,7 +3316,7 @@ def bar(
             raise ValueError(f"`height` must be a value in [0, 100], got {height}")
 
         if subset is None:
-            subset = self.data.select_dtypes(include=np.number).columns
+            subset = self._get_numeric_subset_default()
 
         self.apply(
             _bar,
@@ -2894,24 +3334,38 @@ def bar(
 
         return self
 
-    @Substitution(subset=subset, props=props)
+    @Substitution(subset=subset, props=props, color=color)
     def highlight_null(
         self,
-        null_color: str = "red",
+        color: str | None = None,
         subset: Subset | None = None,
         props: str | None = None,
+        null_color: str | lib.NoDefault = lib.no_default,
     ) -> Styler:
         """
         Highlight missing values with a style.
 
         Parameters
         ----------
-        null_color : str, default 'red'
+        %(color)s
+
+            .. versionadded:: 1.5.0
+
         %(subset)s
+
             .. versionadded:: 1.1.0
+
         %(props)s
+
             .. versionadded:: 1.3.0
 
+        null_color : str, default None
+            The background color for highlighting.
+
+            .. deprecated:: 1.5.0
+               Use ``color`` instead. If ``color`` is given ``null_color`` is
+               not used.
+
         Returns
         -------
         self : Styler
@@ -2927,11 +3381,22 @@ def highlight_null(
         def f(data: DataFrame, props: str) -> np.ndarray:
             return np.where(pd.isna(data).to_numpy(), props, "")
 
+        if null_color != lib.no_default:
+            warnings.warn(
+                "`null_color` is deprecated: use `color` instead",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        if color is None and null_color == lib.no_default:
+            color = "red"
+        elif color is None and null_color != lib.no_default:
+            color = null_color
         if props is None:
-            props = f"background-color: {null_color};"
+            props = f"background-color: {color};"
         return self.apply(f, axis=None, subset=subset, props=props)
 
-    @Substitution(subset=subset, props=props)
+    @Substitution(subset=subset, color=color, props=props)
     def highlight_max(
         self,
         subset: Subset | None = None,
@@ -2945,13 +3410,13 @@ def highlight_max(
         Parameters
         ----------
         %(subset)s
-        color : str, default 'yellow'
-            Background color to use for highlighting.
+        %(color)s
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         %(props)s
+
             .. versionadded:: 1.3.0
 
         Returns
@@ -2975,7 +3440,7 @@ def highlight_max(
             props=props,
         )
 
-    @Substitution(subset=subset, props=props)
+    @Substitution(subset=subset, color=color, props=props)
     def highlight_min(
         self,
         subset: Subset | None = None,
@@ -2989,13 +3454,13 @@ def highlight_min(
         Parameters
         ----------
         %(subset)s
-        color : str, default 'yellow'
-            Background color to use for highlighting.
+        %(color)s
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         %(props)s
+
             .. versionadded:: 1.3.0
 
         Returns
@@ -3019,7 +3484,7 @@ def highlight_min(
             props=props,
         )
 
-    @Substitution(subset=subset, props=props)
+    @Substitution(subset=subset, color=color, props=props)
     def highlight_between(
         self,
         subset: Subset | None = None,
@@ -3038,8 +3503,7 @@ def highlight_between(
         Parameters
         ----------
         %(subset)s
-        color : str, default 'yellow'
-            Background color to use for highlighting.
+        %(color)s
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             If ``left`` or ``right`` given as sequence, axis along which to apply those
             boundaries. See examples.
@@ -3050,6 +3514,7 @@ def highlight_between(
         inclusive : {'both', 'neither', 'left', 'right'}
             Identify whether bounds are closed or open.
         %(props)s
+
         Returns
         -------
         self : Styler
@@ -3088,7 +3553,7 @@ def highlight_between(
 
         .. figure:: ../../_static/style/hbetw_basic.png
 
-        Using a range input sequnce along an ``axis``, in this case setting a ``left``
+        Using a range input sequence along an ``axis``, in this case setting a ``left``
         and ``right`` for each column individually
 
         >>> df.style.highlight_between(left=[1.4, 2.4, 3.4], right=[1.6, 2.6, 3.6],
@@ -3123,7 +3588,7 @@ def highlight_between(
             inclusive=inclusive,
         )
 
-    @Substitution(subset=subset, props=props)
+    @Substitution(subset=subset, color=color, props=props)
     def highlight_quantile(
         self,
         subset: Subset | None = None,
@@ -3131,7 +3596,7 @@ def highlight_quantile(
         axis: Axis | None = 0,
         q_left: float = 0.0,
         q_right: float = 1.0,
-        interpolation: str = "linear",
+        interpolation: QuantileInterpolation = "linear",
         inclusive: str = "both",
         props: str | None = None,
     ) -> Styler:
@@ -3143,8 +3608,7 @@ def highlight_quantile(
         Parameters
         ----------
         %(subset)s
-        color : str, default 'yellow'
-            Background color to use for highlighting.
+        %(color)s
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             Axis along which to determine and highlight quantiles. If ``None`` quantiles
             are measured over the entire DataFrame. See examples.
@@ -3158,6 +3622,7 @@ def highlight_quantile(
         inclusive : {'both', 'neither', 'left', 'right'}
             Identify whether quantile bounds are closed or open.
         %(props)s
+
         Returns
         -------
         self : Styler
@@ -3203,13 +3668,17 @@ def highlight_quantile(
 
         # after quantile is found along axis, e.g. along rows,
         # applying the calculated quantile to alternate axis, e.g. to each column
-        kwargs = {"q": [q_left, q_right], "interpolation": interpolation}
+        quantiles = [q_left, q_right]
         if axis is None:
-            q = Series(data.to_numpy().ravel()).quantile(**kwargs)
+            q = Series(data.to_numpy().ravel()).quantile(
+                q=quantiles, interpolation=interpolation
+            )
             axis_apply: int | None = None
         else:
             axis = self.data._get_axis_number(axis)
-            q = data.quantile(axis=axis, numeric_only=False, **kwargs)
+            q = data.quantile(
+                axis=axis, numeric_only=False, q=quantiles, interpolation=interpolation
+            )
             axis_apply = 1 - axis
 
         if props is None:
@@ -3260,7 +3729,7 @@ def from_custom_template(
         # mypy doesn't like dynamically-defined classes
         # error: Variable "cls" is not valid as a type
         # error: Invalid base class "cls"
-        class MyStyler(cls):  # type:ignore[valid-type,misc]
+        class MyStyler(cls):  # type: ignore[valid-type,misc]
             env = jinja2.Environment(loader=loader)
             if html_table:
                 template_html_table = env.get_template(html_table)
@@ -3303,41 +3772,85 @@ def pipe(self, func: Callable, *args, **kwargs):
 
         .. code-block:: python
 
-            f(g(df.style.set_precision(3), arg1=a), arg2=b, arg3=c)
+            f(g(df.style.format(precision=3), arg1=a), arg2=b, arg3=c)
 
         users can write:
 
         .. code-block:: python
 
-            (df.style.set_precision(3)
+            (df.style.format(precision=3)
                .pipe(g, arg1=a)
                .pipe(f, arg2=b, arg3=c))
 
         In particular, this allows users to define functions that take a
         styler object, along with other parameters, and return the styler after
         making styling changes (such as calling :meth:`Styler.apply` or
-        :meth:`Styler.set_properties`).  Using ``.pipe``, these user-defined
-        style "transformations" can be interleaved with calls to the built-in
-        Styler interface.
+        :meth:`Styler.set_properties`).
 
         Examples
         --------
-        >>> def format_conversion(styler):
-        ...     return (styler.set_properties(**{'text-align': 'right'})
-        ...                   .format({'conversion': '{:.1%}'}))
-
-        The user-defined ``format_conversion`` function above can be called
-        within a sequence of other style modifications:
-
-        >>> df = pd.DataFrame({'trial': list(range(5)),
-        ...                    'conversion': [0.75, 0.85, np.nan, 0.7, 0.72]})
-        >>> (df.style
-        ...    .highlight_min(subset=['conversion'], color='yellow')
-        ...    .pipe(format_conversion)
-        ...    .set_caption("Results with minimum conversion highlighted."))
-        ...  # doctest: +SKIP
 
-        .. figure:: ../../_static/style/df_pipe.png
+        **Common Use**
+
+        A common usage pattern is to pre-define styling operations which
+        can be easily applied to a generic styler in a single ``pipe`` call.
+
+        >>> def some_highlights(styler, min_color="red", max_color="blue"):
+        ...      styler.highlight_min(color=min_color, axis=None)
+        ...      styler.highlight_max(color=max_color, axis=None)
+        ...      styler.highlight_null()
+        ...      return styler
+        >>> df = pd.DataFrame([[1, 2, 3, pd.NA], [pd.NA, 4, 5, 6]], dtype="Int64")
+        >>> df.style.pipe(some_highlights, min_color="green")  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/df_pipe_hl.png
+
+        Since the method returns a ``Styler`` object it can be chained with other
+        methods as if applying the underlying highlighters directly.
+
+        >>> df.style.format("{:.1f}")
+        ...         .pipe(some_highlights, min_color="green")
+        ...         .highlight_between(left=2, right=5)  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/df_pipe_hl2.png
+
+        **Advanced Use**
+
+        Sometimes it may be necessary to pre-define styling functions, but in the case
+        where those functions rely on the styler, data or context. Since
+        ``Styler.use`` and ``Styler.export`` are designed to be non-data dependent,
+        they cannot be used for this purpose. Additionally the ``Styler.apply``
+        and ``Styler.format`` type methods are not context aware, so a solution
+        is to use ``pipe`` to dynamically wrap this functionality.
+
+        Suppose we want to code a generic styling function that highlights the final
+        level of a MultiIndex. The number of levels in the Index is dynamic so we
+        need the ``Styler`` context to define the level.
+
+        >>> def highlight_last_level(styler):
+        ...     return styler.apply_index(
+        ...         lambda v: "background-color: pink; color: yellow", axis="columns",
+        ...         level=styler.columns.nlevels-1
+        ...     )  # doctest: +SKIP
+        >>> df.columns = pd.MultiIndex.from_product([["A", "B"], ["X", "Y"]])
+        >>> df.style.pipe(highlight_last_level)  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/df_pipe_applymap.png
+
+        Additionally suppose we want to highlight a column header if there is any
+        missing data in that column.
+        In this case we need the data object itself to determine the effect on the
+        column headers.
+
+        >>> def highlight_header_missing(styler, level):
+        ...     def dynamic_highlight(s):
+        ...         return np.where(
+        ...             styler.data.isna().any(), "background-color: red;", ""
+        ...         )
+        ...     return styler.apply_index(dynamic_highlight, axis=1, level=level)
+        >>> df.style.pipe(highlight_header_missing, level=1)  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/df_pipe_applydata.png
         """
         return com.pipe(self, func, *args, **kwargs)
 
@@ -3420,7 +3933,15 @@ def _background_gradient(
         rng = smax - smin
         # extend lower / upper bounds, compresses color range
         norm = mpl.colors.Normalize(smin - (rng * low), smax + (rng * high))
-        rgbas = plt.cm.get_cmap(cmap)(norm(gmap))
+        from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+
+        if mpl_ge_3_6_0():
+            if cmap is None:
+                rgbas = mpl.colormaps[mpl.rcParams["image.cmap"]](norm(gmap))
+            else:
+                rgbas = mpl.colormaps.get_cmap(cmap)(norm(gmap))
+        else:
+            rgbas = plt.cm.get_cmap(cmap)(norm(gmap))
 
         def relative_luminance(rgba) -> float:
             """
@@ -3475,14 +3996,10 @@ def _highlight_between(
     Return an array of css props based on condition of data values within given range.
     """
     if np.iterable(left) and not isinstance(left, str):
-        left = _validate_apply_axis_arg(
-            left, "left", None, data  # type: ignore[arg-type]
-        )
+        left = _validate_apply_axis_arg(left, "left", None, data)
 
     if np.iterable(right) and not isinstance(right, str):
-        right = _validate_apply_axis_arg(
-            right, "right", None, data  # type: ignore[arg-type]
-        )
+        right = _validate_apply_axis_arg(right, "right", None, data)
 
     # get ops with correct boundary attribution
     if inclusive == "both":
@@ -3500,15 +4017,27 @@ def _highlight_between(
         )
 
     g_left = (
-        ops[0](data, left)
+        # error: Argument 2 to "ge" has incompatible type "Union[str, float,
+        # Period, Timedelta, Interval[Any], datetime64, timedelta64, datetime,
+        # Sequence[Any], ndarray[Any, Any], NDFrame]"; expected "Union
+        # [SupportsDunderLE, SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+        ops[0](data, left)  # type: ignore[arg-type]
         if left is not None
         else np.full(data.shape, True, dtype=bool)
     )
+    if isinstance(g_left, (DataFrame, Series)):
+        g_left = g_left.where(pd.notna(g_left), False)
     l_right = (
-        ops[1](data, right)
+        # error: Argument 2 to "le" has incompatible type "Union[str, float,
+        # Period, Timedelta, Interval[Any], datetime64, timedelta64, datetime,
+        # Sequence[Any], ndarray[Any, Any], NDFrame]"; expected "Union
+        # [SupportsDunderLE, SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+        ops[1](data, right)  # type: ignore[arg-type]
         if right is not None
         else np.full(data.shape, True, dtype=bool)
     )
+    if isinstance(l_right, (DataFrame, Series)):
+        l_right = l_right.where(pd.notna(l_right), False)
     return np.where(g_left & l_right, props, "")
 
 
@@ -3519,12 +4048,14 @@ def _highlight_value(data: DataFrame | Series, op: str, props: str) -> np.ndarra
     value = getattr(data, op)(skipna=True)
     if isinstance(data, DataFrame):  # min/max must be done twice to return scalar
         value = getattr(value, op)(skipna=True)
-    return np.where(data == value, props, "")
+    cond = data == value
+    cond = cond.where(pd.notna(cond), False)
+    return np.where(cond, props, "")
 
 
 def _bar(
     data: NDFrame,
-    align: str | float | int | Callable,
+    align: str | float | Callable,
     colors: str | list | tuple,
     cmap: Any,
     width: float,
diff --git a/pandas/io/formats/style_render.py b/pandas/io/formats/style_render.py
index 67678347d256a..cc3c77fcec692 100644
--- a/pandas/io/formats/style_render.py
+++ b/pandas/io/formats/style_render.py
@@ -22,9 +22,17 @@
 from pandas._config import get_option
 
 from pandas._libs import lib
-from pandas._typing import Level
+from pandas._typing import (
+    Axis,
+    Level,
+)
 from pandas.compat._optional import import_optional_dependency
 
+from pandas.core.dtypes.common import (
+    is_complex,
+    is_float,
+    is_integer,
+)
 from pandas.core.dtypes.generic import ABCSeries
 
 from pandas import (
@@ -43,7 +51,7 @@
 
 BaseFormatter = Union[str, Callable]
 ExtFormatter = Union[BaseFormatter, Dict[Any, Optional[BaseFormatter]]]
-CSSPair = Tuple[str, Union[str, int, float]]
+CSSPair = Tuple[str, Union[str, float]]
 CSSList = List[CSSPair]
 CSSProperties = Union[str, CSSList]
 
@@ -57,23 +65,18 @@ class CSSDict(TypedDict):
 Subset = Union[slice, Sequence, Index]
 
 
-def _gl01_adjust(obj: Any) -> Any:
-    """Adjust docstrings for Numpydoc GLO1."""
-    obj.__doc__ = "\n" + obj.__doc__
-    return obj
-
-
 class StylerRenderer:
     """
     Base class to process rendering a Styler with a specified jinja2 template.
     """
 
-    loader = _gl01_adjust(jinja2.PackageLoader("pandas", "io/formats/templates"))
-    env = _gl01_adjust(jinja2.Environment(loader=loader, trim_blocks=True))
-    template_html = _gl01_adjust(env.get_template("html.tpl"))
-    template_html_table = _gl01_adjust(env.get_template("html_table.tpl"))
-    template_html_style = _gl01_adjust(env.get_template("html_style.tpl"))
-    template_latex = _gl01_adjust(env.get_template("latex.tpl"))
+    loader = jinja2.PackageLoader("pandas", "io/formats/templates")
+    env = jinja2.Environment(loader=loader, trim_blocks=True)
+    template_html = env.get_template("html.tpl")
+    template_html_table = env.get_template("html_table.tpl")
+    template_html_style = env.get_template("html_style.tpl")
+    template_latex = env.get_template("latex.tpl")
+    template_string = env.get_template("string.tpl")
 
     def __init__(
         self,
@@ -85,7 +88,7 @@ def __init__(
         caption: str | tuple | None = None,
         cell_ids: bool = True,
         precision: int | None = None,
-    ):
+    ) -> None:
 
         # validate ordered args
         if isinstance(data, Series):
@@ -114,8 +117,9 @@ def __init__(
             "level": "level",
             "data": "data",
             "blank": "blank",
+            "foot": "foot",
         }
-
+        self.concatenated: list[StylerRenderer] = []
         # add rendering variables
         self.hide_index_names: bool = False
         self.hide_column_names: bool = False
@@ -142,6 +146,51 @@ def __init__(
             tuple[int, int], Callable[[Any], str]
         ] = defaultdict(lambda: partial(_default_formatter, precision=precision))
 
+    def _render(
+        self,
+        sparse_index: bool,
+        sparse_columns: bool,
+        max_rows: int | None = None,
+        max_cols: int | None = None,
+        blank: str = "",
+    ):
+        """
+        Computes and applies styles and then generates the general render dicts.
+
+        Also extends the `ctx` and `ctx_index` attributes with those of concatenated
+        stylers for use within `_translate_latex`
+        """
+        self._compute()
+        dxs = []
+        ctx_len = len(self.index)
+        for i, concatenated in enumerate(self.concatenated):
+            concatenated.hide_index_ = self.hide_index_
+            concatenated.hidden_columns = self.hidden_columns
+            foot = f"{self.css['foot']}{i}"
+            concatenated.css = {
+                **self.css,
+                "data": f"{foot}_data",
+                "row_heading": f"{foot}_row_heading",
+                "row": f"{foot}_row",
+                "foot": f"{foot}_foot",
+            }
+            dx = concatenated._render(
+                sparse_index, sparse_columns, max_rows, max_cols, blank
+            )
+            dxs.append(dx)
+
+            for (r, c), v in concatenated.ctx.items():
+                self.ctx[(r + ctx_len, c)] = v
+            for (r, c), v in concatenated.ctx_index.items():
+                self.ctx_index[(r + ctx_len, c)] = v
+
+            ctx_len += len(concatenated.index)
+
+        d = self._translate(
+            sparse_index, sparse_columns, max_rows, max_cols, blank, dxs
+        )
+        return d
+
     def _render_html(
         self,
         sparse_index: bool,
@@ -154,9 +203,7 @@ def _render_html(
         Renders the ``Styler`` including all applied styles to HTML.
         Generates a dict with necessary kwargs passed to jinja2 template.
         """
-        self._compute()
-        # TODO: namespace all the pandas keys
-        d = self._translate(sparse_index, sparse_columns, max_rows, max_cols)
+        d = self._render(sparse_index, sparse_columns, max_rows, max_cols, "&nbsp;")
         d.update(kwargs)
         return self.template_html.render(
             **d,
@@ -164,23 +211,36 @@ def _render_html(
             html_style_tpl=self.template_html_style,
         )
 
-    def _render_latex(self, sparse_index: bool, sparse_columns: bool, **kwargs) -> str:
+    def _render_latex(
+        self, sparse_index: bool, sparse_columns: bool, clines: str | None, **kwargs
+    ) -> str:
         """
         Render a Styler in latex format
         """
-        self._compute()
-
-        d = self._translate(sparse_index, sparse_columns, blank="")
-        self._translate_latex(d)
-
+        d = self._render(sparse_index, sparse_columns, None, None)
+        self._translate_latex(d, clines=clines)
         self.template_latex.globals["parse_wrap"] = _parse_latex_table_wrapping
         self.template_latex.globals["parse_table"] = _parse_latex_table_styles
         self.template_latex.globals["parse_cell"] = _parse_latex_cell_styles
         self.template_latex.globals["parse_header"] = _parse_latex_header_span
-
         d.update(kwargs)
         return self.template_latex.render(**d)
 
+    def _render_string(
+        self,
+        sparse_index: bool,
+        sparse_columns: bool,
+        max_rows: int | None = None,
+        max_cols: int | None = None,
+        **kwargs,
+    ) -> str:
+        """
+        Render a Styler in string format
+        """
+        d = self._render(sparse_index, sparse_columns, max_rows, max_cols)
+        d.update(kwargs)
+        return self.template_string.render(**d)
+
     def _compute(self):
         """
         Execute the style functions built up in `self._todo`.
@@ -205,6 +265,7 @@ def _translate(
         max_rows: int | None = None,
         max_cols: int | None = None,
         blank: str = "&nbsp;",
+        dxs: list[dict] | None = None,
     ):
         """
         Process Styler data and settings into a dict for template rendering.
@@ -220,10 +281,12 @@ def _translate(
         sparse_cols : bool
             Whether to sparsify the columns or print all hierarchical column elements.
             Upstream defaults are typically to `pandas.options.styler.sparse.columns`.
-        blank : str
-            Entry to top-left blank cells.
         max_rows, max_cols : int, optional
             Specific max rows and cols. max_elements always take precedence in render.
+        blank : str
+            Entry to top-left blank cells.
+        dxs : list[dict]
+            The render dicts of the concatenated Stylers.
 
         Returns
         -------
@@ -231,6 +294,8 @@ def _translate(
             The following structure: {uuid, table_styles, caption, head, body,
             cellstyle, table_attributes}
         """
+        if dxs is None:
+            dxs = []
         self.css["blank_value"] = blank
 
         # construct render dict
@@ -257,13 +322,19 @@ def _translate(
         head = self._translate_header(sparse_cols, max_cols)
         d.update({"head": head})
 
+        # for sparsifying a MultiIndex and for use with latex clines
+        idx_lengths = _get_level_lengths(
+            self.index, sparse_index, max_rows, self.hidden_rows
+        )
+        d.update({"index_lengths": idx_lengths})
+
         self.cellstyle_map: DefaultDict[tuple[CSSPair, ...], list[str]] = defaultdict(
             list
         )
         self.cellstyle_map_index: DefaultDict[
             tuple[CSSPair, ...], list[str]
         ] = defaultdict(list)
-        body = self._translate_body(sparse_index, max_rows, max_cols)
+        body: list = self._translate_body(idx_lengths, max_rows, max_cols)
         d.update({"body": body})
 
         ctx_maps = {
@@ -278,6 +349,13 @@ def _translate(
             ]
             d.update({k: map})
 
+        for dx in dxs:  # self.concatenated is not empty
+            d["body"].extend(dx["body"])  # type: ignore[union-attr]
+            d["cellstyle"].extend(dx["cellstyle"])  # type: ignore[union-attr]
+            d["cellstyle_index"].extend(  # type: ignore[union-attr]
+                dx["cellstyle_index"]
+            )
+
         table_attr = self.table_attributes
         if not get_option("styler.html.mathjax"):
             table_attr = table_attr or ""
@@ -366,7 +444,7 @@ def _generate_col_header_row(self, iter: tuple, max_cols: int, col_lengths: dict
             Looping variables from outer scope
         max_cols : int
             Permissible number of columns
-        col_lenths :
+        col_lengths :
             c
 
         Returns
@@ -397,25 +475,20 @@ def _generate_col_header_row(self, iter: tuple, max_cols: int, col_lengths: dict
             )
         ]
 
-        column_headers, visible_col_count = [], 0
+        column_headers: list = []
+        visible_col_count: int = 0
         for c, value in enumerate(clabels[r]):
             header_element_visible = _is_visible(c, r, col_lengths)
             if header_element_visible:
                 visible_col_count += col_lengths.get((r, c), 0)
-            if visible_col_count > max_cols:
-                # add an extra column with `...` value to indicate trimming
-                column_headers.append(
-                    _element(
-                        "th",
-                        (
-                            f"{self.css['col_heading']} {self.css['level']}{r} "
-                            f"{self.css['col_trim']}"
-                        ),
-                        "...",
-                        True,
-                        attributes="",
-                    )
-                )
+            if self._check_trim(
+                visible_col_count,
+                max_cols,
+                column_headers,
+                "th",
+                f"{self.css['col_heading']} {self.css['level']}{r} "
+                f"{self.css['col_trim']}",
+            ):
                 break
 
             header_element = _element(
@@ -482,26 +555,22 @@ def _generate_index_names_row(self, iter: tuple, max_cols: int, col_lengths: dic
             for c, name in enumerate(self.data.index.names)
         ]
 
-        column_blanks, visible_col_count = [], 0
+        column_blanks: list = []
+        visible_col_count: int = 0
         if clabels:
             last_level = self.columns.nlevels - 1  # use last level since never sparsed
             for c, value in enumerate(clabels[last_level]):
                 header_element_visible = _is_visible(c, last_level, col_lengths)
                 if header_element_visible:
                     visible_col_count += 1
-                if visible_col_count > max_cols:
-                    column_blanks.append(
-                        _element(
-                            "th",
-                            (
-                                f"{self.css['blank']} {self.css['col']}{c} "
-                                f"{self.css['col_trim']}"
-                            ),
-                            self.css["blank_value"],
-                            True,
-                            attributes="",
-                        )
-                    )
+                if self._check_trim(
+                    visible_col_count,
+                    max_cols,
+                    column_blanks,
+                    "th",
+                    f"{self.css['blank']} {self.css['col']}{c} {self.css['col_trim']}",
+                    self.css["blank_value"],
+                ):
                     break
 
                 column_blanks.append(
@@ -515,7 +584,7 @@ def _generate_index_names_row(self, iter: tuple, max_cols: int, col_lengths: dic
 
         return index_names + column_blanks
 
-    def _translate_body(self, sparsify_index: bool, max_rows: int, max_cols: int):
+    def _translate_body(self, idx_lengths: dict, max_rows: int, max_cols: int):
         """
         Build each <tr> within table <body> as a list
 
@@ -537,30 +606,70 @@ def _translate_body(self, sparsify_index: bool, max_rows: int, max_cols: int):
         body : list
             The associated HTML elements needed for template rendering.
         """
-        # for sparsifying a MultiIndex
-        idx_lengths = _get_level_lengths(
-            self.index, sparsify_index, max_rows, self.hidden_rows
-        )
-
         rlabels = self.data.index.tolist()
         if not isinstance(self.data.index, MultiIndex):
             rlabels = [[x] for x in rlabels]
 
-        body, row_count = [], 0
+        body: list = []
+        visible_row_count: int = 0
         for r, row_tup in [
             z for z in enumerate(self.data.itertuples()) if z[0] not in self.hidden_rows
         ]:
-            row_count += 1
-            if row_count > max_rows:  # used only to add a '...' trimmed row:
-                trimmed_row = self._generate_trimmed_row(max_cols)
-                body.append(trimmed_row)
+            visible_row_count += 1
+            if self._check_trim(
+                visible_row_count,
+                max_rows,
+                body,
+                "row",
+            ):
                 break
+
             body_row = self._generate_body_row(
                 (r, row_tup, rlabels), max_cols, idx_lengths
             )
             body.append(body_row)
         return body
 
+    def _check_trim(
+        self,
+        count,
+        max,
+        obj,
+        element,
+        css=None,
+        value="...",
+    ):
+        """
+        Indicates whether to break render loops and append a trimming indicator
+
+        Parameters
+        ----------
+        count : int
+            The loop count of previous visible items.
+        max : int
+            The allowable rendered items in the loop.
+        obj : list
+            The current render collection of the rendered items.
+        element : str
+            The type of element to append in the case a trimming indicator is needed.
+        css : str, optional
+            The css to add to the trimming indicator element.
+        value : str, optional
+            The value of the elements display if necessary.
+
+        Returns
+        -------
+        result : bool
+            Whether a trimming element was required and appended.
+        """
+        if count > max:
+            if element == "row":
+                obj.append(self._generate_trimmed_row(max))
+            else:
+                obj.append(_element(element, css, value, True, attributes=""))
+            return True
+        return False
+
     def _generate_trimmed_row(self, max_cols: int) -> list:
         """
         When a render has too many rows we generate a trimming row containing "..."
@@ -588,24 +697,19 @@ def _generate_trimmed_row(self, max_cols: int) -> list:
             for c in range(self.data.index.nlevels)
         ]
 
-        data, visible_col_count = [], 0
+        data: list = []
+        visible_col_count: int = 0
         for c, _ in enumerate(self.columns):
             data_element_visible = c not in self.hidden_columns
             if data_element_visible:
                 visible_col_count += 1
-            if visible_col_count > max_cols:
-                data.append(
-                    _element(
-                        "td",
-                        (
-                            f"{self.css['data']} {self.css['row_trim']} "
-                            f"{self.css['col_trim']}"
-                        ),
-                        "...",
-                        True,
-                        attributes="",
-                    )
-                )
+            if self._check_trim(
+                visible_col_count,
+                max_cols,
+                data,
+                "td",
+                f"{self.css['data']} {self.css['row_trim']} {self.css['col_trim']}",
+            ):
                 break
 
             data.append(
@@ -686,26 +790,21 @@ def _generate_body_row(
 
             index_headers.append(header_element)
 
-        data, visible_col_count = [], 0
+        data: list = []
+        visible_col_count: int = 0
         for c, value in enumerate(row_tup[1:]):
             data_element_visible = (
                 c not in self.hidden_columns and r not in self.hidden_rows
             )
             if data_element_visible:
                 visible_col_count += 1
-            if visible_col_count > max_cols:
-                data.append(
-                    _element(
-                        "td",
-                        (
-                            f"{self.css['data']} {self.css['row']}{r} "
-                            f"{self.css['col_trim']}"
-                        ),
-                        "...",
-                        True,
-                        attributes="",
-                    )
-                )
+            if self._check_trim(
+                visible_col_count,
+                max_cols,
+                data,
+                "td",
+                f"{self.css['data']} {self.css['row']}{r} {self.css['col_trim']}",
+            ):
                 break
 
             # add custom classes from cell context
@@ -738,7 +837,7 @@ def _generate_body_row(
 
         return index_headers + data
 
-    def _translate_latex(self, d: dict) -> None:
+    def _translate_latex(self, d: dict, clines: str | None) -> None:
         r"""
         Post-process the default render dict for the LaTeX template format.
 
@@ -749,20 +848,37 @@ def _translate_latex(self, d: dict) -> None:
             or multirow sparsification (so that \multirow and \multicol work correctly).
         """
         index_levels = self.index.nlevels
-        visible_index_levels = index_levels - sum(self.hide_index_)
+        visible_index_level_n = index_levels - sum(self.hide_index_)
         d["head"] = [
             [
-                {**col, "cellstyle": self.ctx_columns[r, c - visible_index_levels]}
+                {**col, "cellstyle": self.ctx_columns[r, c - visible_index_level_n]}
                 for c, col in enumerate(row)
                 if col["is_visible"]
             ]
             for r, row in enumerate(d["head"])
         ]
+
+        def _concatenated_visible_rows(obj, n, row_indices):
+            """
+            Extract all visible row indices recursively from concatenated stylers.
+            """
+            row_indices.extend(
+                [r + n for r in range(len(obj.index)) if r not in obj.hidden_rows]
+            )
+            n += len(obj.index)
+            for concatenated in obj.concatenated:
+                n = _concatenated_visible_rows(concatenated, n, row_indices)
+            return n
+
+        def concatenated_visible_rows(obj):
+            row_indices: list[int] = []
+            _concatenated_visible_rows(obj, 0, row_indices)
+            # TODO try to consolidate the concat visible rows
+            # methods to a single function / recursion for simplicity
+            return row_indices
+
         body = []
-        for r, row in zip(
-            [r for r in range(len(self.data.index)) if r not in self.hidden_rows],
-            d["body"],
-        ):
+        for r, row in zip(concatenated_visible_rows(self), d["body"]):
             # note: cannot enumerate d["body"] because rows were dropped if hidden
             # during _translate_body so must zip to acquire the true r-index associated
             # with the ctx obj which contains the cell styles.
@@ -790,6 +906,39 @@ def _translate_latex(self, d: dict) -> None:
             body.append(row_body_headers + row_body_cells)
         d["body"] = body
 
+        # clines are determined from info on index_lengths and hidden_rows and input
+        # to a dict defining which row clines should be added in the template.
+        if clines not in [
+            None,
+            "all;data",
+            "all;index",
+            "skip-last;data",
+            "skip-last;index",
+        ]:
+            raise ValueError(
+                f"`clines` value of {clines} is invalid. Should either be None or one "
+                f"of 'all;data', 'all;index', 'skip-last;data', 'skip-last;index'."
+            )
+        elif clines is not None:
+            data_len = len(row_body_cells) if "data" in clines and d["body"] else 0
+
+            d["clines"] = defaultdict(list)
+            visible_row_indexes: list[int] = [
+                r for r in range(len(self.data.index)) if r not in self.hidden_rows
+            ]
+            visible_index_levels: list[int] = [
+                i for i in range(index_levels) if not self.hide_index_[i]
+            ]
+            for rn, r in enumerate(visible_row_indexes):
+                for lvln, lvl in enumerate(visible_index_levels):
+                    if lvl == index_levels - 1 and "skip-last" in clines:
+                        continue
+                    idx_len = d["index_lengths"].get((lvl, r), None)
+                    if idx_len is not None:  # i.e. not a sparsified entry
+                        d["clines"][rn + idx_len].append(
+                            f"\\cline{{{lvln+1}-{len(visible_index_levels)+data_len}}}"
+                        )
+
     def format(
         self,
         formatter: ExtFormatter | None = None,
@@ -855,6 +1004,10 @@ def format(
         -------
         self : Styler
 
+        See Also
+        --------
+        Styler.format_index: Format the text display value of index labels.
+
         Notes
         -----
         This method assigns a formatting function, ``formatter``, to each cell in the
@@ -890,6 +1043,12 @@ def format(
           - ``styler.format.thousands``: default None.
           - ``styler.format.escape``: default None.
 
+        .. warning::
+           `Styler.format` is ignored when using the output format `Styler.to_excel`,
+           since Excel and Python have inherrently different formatting structures.
+           However, it is possible to use the `number-format` pseudo CSS attribute
+           to force Excel permissible formatting. See examples.
+
         Examples
         --------
         Using ``na_rep`` and ``precision`` with the default ``formatter``
@@ -957,6 +1116,19 @@ def format(
         1 & \textbf{\textasciitilde \space \textasciicircum } \\
         2 & \textbf{\$\%\#} \\
         \end{tabular}
+
+        Pandas defines a `number-format` pseudo CSS attribute instead of the `.format`
+        method to create `to_excel` permissible formatting. Note that semi-colons are
+        CSS protected characters but used as separators in Excel's format string.
+        Replace semi-colons with the section separator character (ASCII-245) when
+        defining the formatting here.
+
+        >>> df = pd.DataFrame({"A": [1, 0, -1]})
+        >>> pseudo_css = "number-format: 0§[Red](0)§-§@;"
+        >>> df.style.applymap(lambda v: css).to_excel("formatted_file.xlsx")
+        ...  # doctest: +SKIP
+
+        .. figure:: ../../_static/style/format_excel_css.png
         """
         if all(
             (
@@ -1048,6 +1220,10 @@ def format_index(
         -------
         self : Styler
 
+        See Also
+        --------
+        Styler.format: Format the text display value of data cells.
+
         Notes
         -----
         This method assigns a formatting function, ``formatter``, to each level label
@@ -1074,6 +1250,13 @@ def format_index(
         When using a ``formatter`` string the dtypes must be compatible, otherwise a
         `ValueError` will be raised.
 
+        .. warning::
+           `Styler.format_index` is ignored when using the output format
+           `Styler.to_excel`, since Excel and Python have inherrently different
+           formatting structures.
+           However, it is possible to use the `number-format` pseudo CSS attribute
+           to force Excel permissible formatting. See documentation for `Styler.format`.
+
         Examples
         --------
         Using ``na_rep`` and ``precision`` with the default ``formatter``
@@ -1174,6 +1357,164 @@ def format_index(
 
         return self
 
+    def relabel_index(
+        self,
+        labels: Sequence | Index,
+        axis: Axis = 0,
+        level: Level | list[Level] | None = None,
+    ) -> StylerRenderer:
+        r"""
+        Relabel the index, or column header, keys to display a set of specified values.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        labels : list-like or Index
+            New labels to display. Must have same length as the underlying values not
+            hidden.
+        axis : {"index", 0, "columns", 1}
+            Apply to the index or columns.
+        level : int, str, list, optional
+            The level(s) over which to apply the new labels. If `None` will apply
+            to all levels of an Index or MultiIndex which are not hidden.
+
+        Returns
+        -------
+        self : Styler
+
+        See Also
+        --------
+        Styler.format_index: Format the text display value of index or column headers.
+        Styler.hide: Hide the index, column headers, or specified data from display.
+
+        Notes
+        -----
+        As part of Styler, this method allows the display of an index to be
+        completely user-specified without affecting the underlying DataFrame data,
+        index, or column headers. This means that the flexibility of indexing is
+        maintained whilst the final display is customisable.
+
+        Since Styler is designed to be progressively constructed with method chaining,
+        this method is adapted to react to the **currently specified hidden elements**.
+        This is useful because it means one does not have to specify all the new
+        labels if the majority of an index, or column headers, have already been hidden.
+        The following produce equivalent display (note the length of ``labels`` in
+        each case).
+
+        .. code-block:: python
+
+            # relabel first, then hide
+            df = pd.DataFrame({"col": ["a", "b", "c"]})
+            df.style.relabel_index(["A", "B", "C"]).hide([0,1])
+            # hide first, then relabel
+            df = pd.DataFrame({"col": ["a", "b", "c"]})
+            df.style.hide([0,1]).relabel_index(["C"])
+
+        This method should be used, rather than :meth:`Styler.format_index`, in one of
+        the following cases (see examples):
+
+          - A specified set of labels are required which are not a function of the
+            underlying index keys.
+          - The function of the underlying index keys requires a counter variable,
+            such as those available upon enumeration.
+
+        Examples
+        --------
+        Basic use
+
+        >>> df = pd.DataFrame({"col": ["a", "b", "c"]})
+        >>> df.style.relabel_index(["A", "B", "C"])  # doctest: +SKIP
+             col
+        A      a
+        B      b
+        C      c
+
+        Chaining with pre-hidden elements
+
+        >>> df.style.hide([0,1]).relabel_index(["C"])  # doctest: +SKIP
+             col
+        C      c
+
+        Using a MultiIndex
+
+        >>> midx = pd.MultiIndex.from_product([[0, 1], [0, 1], [0, 1]])
+        >>> df = pd.DataFrame({"col": list(range(8))}, index=midx)
+        >>> styler = df.style  # doctest: +SKIP
+                  col
+        0  0  0     0
+              1     1
+           1  0     2
+              1     3
+        1  0  0     4
+              1     5
+           1  0     6
+              1     7
+        >>> styler.hide((midx.get_level_values(0)==0)|(midx.get_level_values(1)==0))
+        ...  # doctest: +SKIP
+        >>> styler.hide(level=[0,1])  # doctest: +SKIP
+        >>> styler.relabel_index(["binary6", "binary7"])  # doctest: +SKIP
+                  col
+        binary6     6
+        binary7     7
+
+        We can also achieve the above by indexing first and then re-labeling
+
+        >>> styler = df.loc[[(1,1,0), (1,1,1)]].style
+        >>> styler.hide(level=[0,1]).relabel_index(["binary6", "binary7"])
+        ...  # doctest: +SKIP
+                  col
+        binary6     6
+        binary7     7
+
+        Defining a formatting function which uses an enumeration counter. Also note
+        that the value of the index key is passed in the case of string labels so it
+        can also be inserted into the label, using curly brackets (or double curly
+        brackets if the string if pre-formatted),
+
+        >>> df = pd.DataFrame({"samples": np.random.rand(10)})
+        >>> styler = df.loc[np.random.randint(0,10,3)].style
+        >>> styler.relabel_index([f"sample{i+1} ({{}})" for i in range(3)])
+        ...  # doctest: +SKIP
+                         samples
+        sample1 (5)     0.315811
+        sample2 (0)     0.495941
+        sample3 (2)     0.067946
+        """
+        axis = self.data._get_axis_number(axis)
+        if axis == 0:
+            display_funcs_, obj = self._display_funcs_index, self.index
+            hidden_labels, hidden_lvls = self.hidden_rows, self.hide_index_
+        else:
+            display_funcs_, obj = self._display_funcs_columns, self.columns
+            hidden_labels, hidden_lvls = self.hidden_columns, self.hide_columns_
+        visible_len = len(obj) - len(set(hidden_labels))
+        if len(labels) != visible_len:
+            raise ValueError(
+                "``labels`` must be of length equal to the number of "
+                f"visible labels along ``axis`` ({visible_len})."
+            )
+
+        if level is None:
+            level = [i for i in range(obj.nlevels) if not hidden_lvls[i]]
+        levels_ = refactor_levels(level, obj)
+
+        def alias_(x, value):
+            if isinstance(value, str):
+                return value.format(x)
+            return value
+
+        for ai, i in enumerate([i for i in range(len(obj)) if i not in hidden_labels]):
+            if len(levels_) == 1:
+                idx = (i, levels_[0]) if axis == 0 else (levels_[0], i)
+                display_funcs_[idx] = partial(alias_, value=labels[ai])
+            else:
+                for aj, lvl in enumerate(levels_):
+                    idx = (i, lvl) if axis == 0 else (lvl, i)
+                    display_funcs_[idx] = partial(alias_, value=labels[ai][aj])
+
+        return self
+
 
 def _element(
     html_element: str,
@@ -1361,9 +1702,9 @@ def _default_formatter(x: Any, precision: int, thousands: bool = False) -> Any:
     value : Any
         Matches input type, or string if input is float or complex or int with sep.
     """
-    if isinstance(x, (float, complex)):
+    if is_float(x) or is_complex(x):
         return f"{x:,.{precision}f}" if thousands else f"{x:.{precision}f}"
-    elif isinstance(x, int):
+    elif is_integer(x):
         return f"{x:,.0f}" if thousands else f"{x:.0f}"
     return x
 
@@ -1378,7 +1719,7 @@ def _wrap_decimal_thousands(
     """
 
     def wrapper(x):
-        if isinstance(x, (float, complex, int)):
+        if is_float(x) or is_integer(x) or is_complex(x):
             if decimal != "." and thousands is not None and thousands != ",":
                 return (
                     formatter(x)
@@ -1418,7 +1759,7 @@ def _render_href(x, format):
             href = r"\href{{{0}}}{{{0}}}"
         else:
             raise ValueError("``hyperlinks`` format can only be 'html' or 'latex'")
-        pat = r"(https?:\/\/|ftp:\/\/|www.)[\w/\-?=%.]+\.[\w/\-&?=%.]+"
+        pat = r"((http|ftp)s?:\/\/|www.)[\w/\-?=%.:@]+\.[\w/\-&?=%.,':;~!@#$*()\[\]]+"
         return re.sub(pat, lambda m: href.format(m.group(0)), x)
     return x
 
@@ -1618,7 +1959,7 @@ def __init__(
         ],
         css_name: str = "pd-t",
         tooltips: DataFrame = DataFrame(),
-    ):
+    ) -> None:
         self.class_name = css_name
         self.class_properties = css_props
         self.tt_data = tooltips
@@ -1884,7 +2225,7 @@ def _parse_latex_header_span(
         return display_val
 
 
-def _parse_latex_options_strip(value: str | int | float, arg: str) -> str:
+def _parse_latex_options_strip(value: str | float, arg: str) -> str:
     """
     Strip a css_value which may have latex wrapping arguments, css comment identifiers,
     and whitespaces, to a valid string for latex options parsing.
diff --git a/pandas/io/formats/templates/latex_longtable.tpl b/pandas/io/formats/templates/latex_longtable.tpl
index 593ad2d1a94b0..b97843eeb918d 100644
--- a/pandas/io/formats/templates/latex_longtable.tpl
+++ b/pandas/io/formats/templates/latex_longtable.tpl
@@ -59,7 +59,7 @@
 {% if midrule is not none %}
 \{{midrule}}
 {% endif %}
-\multicolumn{% raw %}{{% endraw %}{{column_format|length}}{% raw %}}{% endraw %}{r}{Continued on next page} \\
+\multicolumn{% raw %}{{% endraw %}{{body[0]|length}}{% raw %}}{% endraw %}{r}{Continued on next page} \\
 {% if midrule is not none %}
 \{{midrule}}
 {% endif %}
@@ -73,6 +73,10 @@
 {% for c in row %}{% if not loop.first %} & {% endif %}
   {%- if c.type == 'th' %}{{parse_header(c, multirow_align, multicol_align)}}{% else %}{{parse_cell(c.cellstyle, c.display_value, convert_css)}}{% endif %}
 {%- endfor %} \\
+{% if clines and clines[loop.index] | length > 0 %}
+  {%- for cline in clines[loop.index] %}{% if not loop.first %} {% endif %}{{ cline }}{% endfor %}
+
+{% endif %}
 {% endfor %}
 \end{longtable}
 {% raw %}{% endraw %}
diff --git a/pandas/io/formats/templates/latex_table.tpl b/pandas/io/formats/templates/latex_table.tpl
index 52387f03b6ce9..7858cb4c94553 100644
--- a/pandas/io/formats/templates/latex_table.tpl
+++ b/pandas/io/formats/templates/latex_table.tpl
@@ -41,6 +41,10 @@
 {% for c in row %}{% if not loop.first %} & {% endif %}
   {%- if c.type == 'th' %}{{parse_header(c, multirow_align, multicol_align, False, convert_css)}}{% else %}{{parse_cell(c.cellstyle, c.display_value, convert_css)}}{% endif %}
 {%- endfor %} \\
+{% if clines and clines[loop.index] | length > 0 %}
+  {%- for cline in clines[loop.index] %}{% if not loop.first %} {% endif %}{{ cline }}{% endfor %}
+
+{% endif %}
 {% endfor %}
 {% set bottomrule = parse_table(table_styles, 'bottomrule') %}
 {% if bottomrule is not none %}
diff --git a/pandas/io/formats/templates/string.tpl b/pandas/io/formats/templates/string.tpl
new file mode 100644
index 0000000000000..06aeb2b4e413c
--- /dev/null
+++ b/pandas/io/formats/templates/string.tpl
@@ -0,0 +1,12 @@
+{% for r in head %}
+{% for c in r %}{% if c["is_visible"] %}
+{{ c["display_value"] }}{% if not loop.last %}{{ delimiter }}{% endif %}
+{% endif %}{% endfor %}
+
+{% endfor %}
+{% for r in body %}
+{% for c in r %}{% if c["is_visible"] %}
+{{ c["display_value"] }}{% if not loop.last %}{{ delimiter }}{% endif %}
+{% endif %}{% endfor %}
+
+{% endfor %}
diff --git a/pandas/io/formats/xml.py b/pandas/io/formats/xml.py
index aa69792cb1db0..eb1835f0392b0 100644
--- a/pandas/io/formats/xml.py
+++ b/pandas/io/formats/xml.py
@@ -5,7 +5,10 @@
 
 import codecs
 import io
-from typing import Any
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
 
 from pandas._typing import (
     CompressionOptions,
@@ -20,7 +23,6 @@
 from pandas.core.dtypes.common import is_list_like
 from pandas.core.dtypes.missing import isna
 
-from pandas.core.frame import DataFrame
 from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.common import get_handle
@@ -29,8 +31,14 @@
     preprocess_data,
 )
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
-@doc(compression_options=_shared_docs["compression_options"] % "path_or_buffer")
+@doc(
+    storage_options=_shared_docs["storage_options"],
+    compression_options=_shared_docs["compression_options"] % "path_or_buffer",
+)
 class BaseXMLFormatter:
     """
     Subclass for formatting data in XML.
@@ -59,7 +67,7 @@ class BaseXMLFormatter:
     elem_cols : list
         List of columns to write as children in row element.
 
-    namespacess : dict
+    namespaces : dict
         The namespaces to define in XML document as dicts with key
         being namespace and value the URI.
 
@@ -82,9 +90,7 @@ class BaseXMLFormatter:
 
         .. versionchanged:: 1.4.0 Zstandard support.
 
-    storage_options : dict, optional
-        Extra options that make sense for a particular storage connection,
-        e.g. host, port, username, password, etc.,
+    {storage_options}
 
     See also
     --------
@@ -484,9 +490,9 @@ def build_tree(self) -> bytes:
 
     def convert_empty_str_key(self) -> None:
         """
-        Replace zero-lengh string in `namespaces`.
+        Replace zero-length string in `namespaces`.
 
-        This method will replce '' with None to align to `lxml`
+        This method will replace '' with None to align to `lxml`
         requirement that empty string prefixes are not allowed.
         """
 
diff --git a/pandas/io/gbq.py b/pandas/io/gbq.py
index 77ad40bac9319..ec2ffbcf9682c 100644
--- a/pandas/io/gbq.py
+++ b/pandas/io/gbq.py
@@ -29,7 +29,7 @@ def read_gbq(
     index_col: str | None = None,
     col_order: list[str] | None = None,
     reauth: bool = False,
-    auth_local_webserver: bool = False,
+    auth_local_webserver: bool = True,
     dialect: str | None = None,
     location: str | None = None,
     configuration: dict[str, Any] | None = None,
@@ -63,7 +63,7 @@ def read_gbq(
     reauth : bool, default False
         Force Google BigQuery to re-authenticate the user. This is useful
         if multiple accounts are used.
-    auth_local_webserver : bool, default False
+    auth_local_webserver : bool, default True
         Use the `local webserver flow`_ instead of the `console flow`_
         when getting user credentials.
 
@@ -73,6 +73,12 @@ def read_gbq(
             https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
 
         *New in version 0.2.0 of pandas-gbq*.
+
+        .. versionchanged:: 1.5.0
+           Default value is changed to ``True``. Google has deprecated the
+           ``auth_local_webserver = False`` `"out of band" (copy-paste)
+           flow
+           <https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html?m=1#disallowed-oob>`_.
     dialect : str, default 'legacy'
         Note: The default value is changing to 'standard' in a future version.
 
@@ -202,7 +208,7 @@ def to_gbq(
     chunksize: int | None = None,
     reauth: bool = False,
     if_exists: str = "fail",
-    auth_local_webserver: bool = False,
+    auth_local_webserver: bool = True,
     table_schema: list[dict[str, str]] | None = None,
     location: str | None = None,
     progress_bar: bool = True,
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 05d7c2998ef27..acf98a2f83921 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -10,6 +10,9 @@
 import numbers
 import re
 from typing import (
+    TYPE_CHECKING,
+    Iterable,
+    Literal,
     Pattern,
     Sequence,
     cast,
@@ -28,8 +31,10 @@
 
 from pandas.core.dtypes.common import is_list_like
 
+from pandas import isna
 from pandas.core.construction import create_series_with_explicit_dtype
-from pandas.core.frame import DataFrame
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.multi import MultiIndex
 
 from pandas.io.common import (
     file_exists,
@@ -42,6 +47,9 @@
 from pandas.io.formats.printing import pprint_thing
 from pandas.io.parsers import TextParser
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 _IMPORTS = False
 _HAS_BS4 = False
 _HAS_LXML = False
@@ -180,6 +188,12 @@ class _HtmlFrameParser:
     displayed_only : bool
         Whether or not items with "display:none" should be ignored
 
+    extract_links : {None, "all", "header", "body", "footer"}
+        Table elements in the specified section(s) with <a> tags will have their
+        href extracted.
+
+        .. versionadded:: 1.5.0
+
     Attributes
     ----------
     io : str or file-like
@@ -198,11 +212,18 @@ class _HtmlFrameParser:
     displayed_only : bool
         Whether or not items with "display:none" should be ignored
 
+    extract_links : {None, "all", "header", "body", "footer"}
+        Table elements in the specified section(s) with <a> tags will have their
+        href extracted.
+
+        .. versionadded:: 1.5.0
+
     Notes
     -----
     To subclass this class effectively you must override the following methods:
         * :func:`_build_doc`
         * :func:`_attr_getter`
+        * :func:`_href_getter`
         * :func:`_text_getter`
         * :func:`_parse_td`
         * :func:`_parse_thead_tr`
@@ -221,12 +242,14 @@ def __init__(
         attrs: dict[str, str] | None,
         encoding: str,
         displayed_only: bool,
-    ):
+        extract_links: Literal[None, "header", "footer", "body", "all"],
+    ) -> None:
         self.io = io
         self.match = match
         self.attrs = attrs
         self.encoding = encoding
         self.displayed_only = displayed_only
+        self.extract_links = extract_links
 
     def parse_tables(self):
         """
@@ -259,6 +282,22 @@ def _attr_getter(self, obj, attr):
         # Both lxml and BeautifulSoup have the same implementation:
         return obj.get(attr)
 
+    def _href_getter(self, obj):
+        """
+        Return a href if the DOM node contains a child <a> or None.
+
+        Parameters
+        ----------
+        obj : node-like
+            A DOM node.
+
+        Returns
+        -------
+        href : str or unicode
+            The href from the <a> child of the DOM node.
+        """
+        raise AbstractMethodError(self)
+
     def _text_getter(self, obj):
         """
         Return the text of an individual DOM node.
@@ -435,13 +474,15 @@ def row_is_all_th(row):
             while body_rows and row_is_all_th(body_rows[0]):
                 header_rows.append(body_rows.pop(0))
 
-        header = self._expand_colspan_rowspan(header_rows)
-        body = self._expand_colspan_rowspan(body_rows)
-        footer = self._expand_colspan_rowspan(footer_rows)
+        header = self._expand_colspan_rowspan(header_rows, section="header")
+        body = self._expand_colspan_rowspan(body_rows, section="body")
+        footer = self._expand_colspan_rowspan(footer_rows, section="footer")
 
         return header, body, footer
 
-    def _expand_colspan_rowspan(self, rows):
+    def _expand_colspan_rowspan(
+        self, rows, section: Literal["header", "footer", "body"]
+    ):
         """
         Given a list of <tr>s, return a list of text rows.
 
@@ -449,11 +490,13 @@ def _expand_colspan_rowspan(self, rows):
         ----------
         rows : list of node-like
             List of <tr>s
+        section : the section that the rows belong to (header, body or footer).
 
         Returns
         -------
         list of list
-            Each returned row is a list of str text.
+            Each returned row is a list of str text, or tuple (text, link)
+            if extract_links is not None.
 
         Notes
         -----
@@ -461,7 +504,10 @@ def _expand_colspan_rowspan(self, rows):
         to subsequent cells.
         """
         all_texts = []  # list of rows, each a list of str
-        remainder: list[tuple[int, str, int]] = []  # list of (index, text, nrows)
+        text: str | tuple
+        remainder: list[
+            tuple[int, str | tuple, int]
+        ] = []  # list of (index, text, nrows)
 
         for tr in rows:
             texts = []  # the output for this row
@@ -481,6 +527,9 @@ def _expand_colspan_rowspan(self, rows):
 
                 # Append the text from this <td>, colspan times
                 text = _remove_whitespace(self._text_getter(td))
+                if self.extract_links == "all" or self.extract_links == section:
+                    href = self._href_getter(td)
+                    text = (text, href)
                 rowspan = int(self._attr_getter(td, "rowspan") or 1)
                 colspan = int(self._attr_getter(td, "colspan") or 1)
 
@@ -555,7 +604,7 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
     :class:`pandas.io.html._HtmlFrameParser`.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         from bs4 import SoupStrainer
 
@@ -577,7 +626,7 @@ def _parse_tables(self, doc, match, attrs):
                 for elem in table.find_all(style=re.compile(r"display:\s*none")):
                     elem.decompose()
 
-            if table not in unique_tables and table.find(text=match) is not None:
+            if table not in unique_tables and table.find(string=match) is not None:
                 result.append(table)
             unique_tables.add(table)
 
@@ -585,6 +634,10 @@ def _parse_tables(self, doc, match, attrs):
             raise ValueError(f"No tables found matching pattern {repr(match.pattern)}")
         return result
 
+    def _href_getter(self, obj) -> str | None:
+        a = obj.find("a", href=True)
+        return None if not a else a["href"]
+
     def _text_getter(self, obj):
         return obj.text
 
@@ -622,7 +675,13 @@ def _build_doc(self):
         else:
             udoc = bdoc
             from_encoding = self.encoding
-        return BeautifulSoup(udoc, features="html5lib", from_encoding=from_encoding)
+
+        soup = BeautifulSoup(udoc, features="html5lib", from_encoding=from_encoding)
+
+        for br in soup.find_all("br"):
+            br.replace_with("\n" + br.text)
+
+        return soup
 
 
 def _build_xpath_expr(attrs) -> str:
@@ -670,6 +729,10 @@ class _LxmlFrameParser(_HtmlFrameParser):
     :class:`_HtmlFrameParser`.
     """
 
+    def _href_getter(self, obj) -> str | None:
+        href = obj.xpath(".//a/@href")
+        return None if not href else href[0]
+
     def _text_getter(self, obj):
         return obj.text_content()
 
@@ -759,6 +822,10 @@ def _build_doc(self):
         else:
             if not hasattr(r, "text_content"):
                 raise XMLSyntaxError("no text parsed from document", 0, 0, 0)
+
+        for br in r.xpath("*//br"):
+            br.tail = "\n" + (br.tail or "")
+
         return r
 
     def _parse_thead_tr(self, table):
@@ -906,14 +973,14 @@ def _validate_flavor(flavor):
     return flavor
 
 
-def _parse(flavor, io, match, attrs, encoding, displayed_only, **kwargs):
+def _parse(flavor, io, match, attrs, encoding, displayed_only, extract_links, **kwargs):
     flavor = _validate_flavor(flavor)
     compiled_match = re.compile(match)  # you can pass a compiled regex here
 
     retained = None
     for flav in flavor:
         parser = _parser_dispatch(flav)
-        p = parser(io, compiled_match, attrs, encoding, displayed_only)
+        p = parser(io, compiled_match, attrs, encoding, displayed_only, extract_links)
 
         try:
             tables = p.parse_tables()
@@ -941,7 +1008,19 @@ def _parse(flavor, io, match, attrs, encoding, displayed_only, **kwargs):
     ret = []
     for table in tables:
         try:
-            ret.append(_data_to_frame(data=table, **kwargs))
+            df = _data_to_frame(data=table, **kwargs)
+            # Cast MultiIndex header to an Index of tuples when extracting header
+            # links and replace nan with None (therefore can't use mi.to_flat_index()).
+            # This maintains consistency of selection (e.g. df.columns.str[1])
+            if extract_links in ("all", "header") and isinstance(
+                df.columns, MultiIndex
+            ):
+                df.columns = Index(
+                    ((col[0], None if isna(col[1]) else col[1]) for col in df.columns),
+                    tupleize_cols=False,
+                )
+
+            ret.append(df)
         except EmptyDataError:  # empty table
             continue
     return ret
@@ -961,9 +1040,10 @@ def read_html(
     encoding: str | None = None,
     decimal: str = ".",
     converters: dict | None = None,
-    na_values=None,
+    na_values: Iterable[object] | None = None,
     keep_default_na: bool = True,
     displayed_only: bool = True,
+    extract_links: Literal[None, "header", "footer", "body", "all"] = None,
 ) -> list[DataFrame]:
     r"""
     Read HTML tables into a ``list`` of ``DataFrame`` objects.
@@ -1058,6 +1138,12 @@ def read_html(
     displayed_only : bool, default True
         Whether elements with "display: none" should be parsed.
 
+    extract_links : {None, "all", "header", "body", "footer"}
+        Table elements in the specified section(s) with <a> tags will have their
+        href extracted.
+
+        .. versionadded:: 1.5.0
+
     Returns
     -------
     dfs
@@ -1106,6 +1192,12 @@ def read_html(
             "cannot skip rows starting from the end of the "
             "data (you passed a negative value)"
         )
+    if extract_links not in [None, "header", "footer", "body", "all"]:
+        raise ValueError(
+            "`extract_links` must be one of "
+            '{None, "header", "footer", "body", "all"}, got '
+            f'"{extract_links}"'
+        )
     validate_header_arg(header)
 
     io = stringify_path(io)
@@ -1126,4 +1218,5 @@ def read_html(
         na_values=na_values,
         keep_default_na=keep_default_na,
         displayed_only=displayed_only,
+        extract_links=extract_links,
     )
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index 9d4998784222f..02a0b27f82ef8 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -9,9 +9,14 @@
 from io import StringIO
 from itertools import islice
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
+    Generic,
+    Literal,
     Mapping,
+    TypeVar,
+    overload,
 )
 
 import numpy as np
@@ -21,9 +26,12 @@
 from pandas._typing import (
     CompressionOptions,
     DtypeArg,
+    FilePath,
     IndexLabel,
     JSONSerializable,
+    ReadBuffer,
     StorageOptions,
+    WriteBuffer,
 )
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import (
@@ -46,12 +54,12 @@
     to_datetime,
 )
 from pandas.core.construction import create_series_with_explicit_dtype
-from pandas.core.generic import NDFrame
 from pandas.core.reshape.concat import concat
 from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.common import (
     IOHandles,
+    _extension_to_compression,
     file_exists,
     get_handle,
     is_fsspec_url,
@@ -65,13 +73,56 @@
 )
 from pandas.io.parsers.readers import validate_integer
 
+if TYPE_CHECKING:
+    from pandas.core.generic import NDFrame
+
+FrameSeriesStrT = TypeVar("FrameSeriesStrT", bound=Literal["frame", "series"])
+
 loads = json.loads
 dumps = json.dumps
 
 
 # interface to/from
+@overload
+def to_json(
+    path_or_buf: FilePath | WriteBuffer[str] | WriteBuffer[bytes],
+    obj: NDFrame,
+    orient: str | None = ...,
+    date_format: str = ...,
+    double_precision: int = ...,
+    force_ascii: bool = ...,
+    date_unit: str = ...,
+    default_handler: Callable[[Any], JSONSerializable] | None = ...,
+    lines: bool = ...,
+    compression: CompressionOptions = ...,
+    index: bool = ...,
+    indent: int = ...,
+    storage_options: StorageOptions = ...,
+) -> None:
+    ...
+
+
+@overload
+def to_json(
+    path_or_buf: None,
+    obj: NDFrame,
+    orient: str | None = ...,
+    date_format: str = ...,
+    double_precision: int = ...,
+    force_ascii: bool = ...,
+    date_unit: str = ...,
+    default_handler: Callable[[Any], JSONSerializable] | None = ...,
+    lines: bool = ...,
+    compression: CompressionOptions = ...,
+    index: bool = ...,
+    indent: int = ...,
+    storage_options: StorageOptions = ...,
+) -> str:
+    ...
+
+
 def to_json(
-    path_or_buf,
+    path_or_buf: FilePath | WriteBuffer[str] | WriteBuffer[bytes] | None,
     obj: NDFrame,
     orient: str | None = None,
     date_format: str = "epoch",
@@ -84,7 +135,7 @@ def to_json(
     index: bool = True,
     indent: int = 0,
     storage_options: StorageOptions = None,
-):
+) -> str | None:
 
     if not index and orient not in ["split", "table"]:
         raise ValueError(
@@ -130,6 +181,7 @@ def to_json(
             handles.handle.write(s)
     else:
         return s
+    return None
 
 
 class Writer(ABC):
@@ -146,7 +198,7 @@ def __init__(
         index: bool,
         default_handler: Callable[[Any], JSONSerializable] | None = None,
         indent: int = 0,
-    ):
+    ) -> None:
         self.obj = obj
 
         if orient is None:
@@ -167,7 +219,7 @@ def __init__(
     def _format_axes(self):
         raise AbstractMethodError(self)
 
-    def write(self):
+    def write(self) -> str:
         iso_dates = self.date_format == "iso"
         return dumps(
             self.obj_to_write,
@@ -246,7 +298,7 @@ def __init__(
         index: bool,
         default_handler: Callable[[Any], JSONSerializable] | None = None,
         indent: int = 0,
-    ):
+    ) -> None:
         """
         Adds a `schema` attribute with the Table Schema, resets
         the index (can't do in caller, because the schema inference needs
@@ -312,33 +364,126 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
         return {"schema": self.schema, "data": self.obj}
 
 
+@overload
+def read_json(
+    path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes],
+    *,
+    orient: str | None = ...,
+    typ: Literal["frame"] = ...,
+    dtype: DtypeArg | None = ...,
+    convert_axes=...,
+    convert_dates: bool | list[str] = ...,
+    keep_default_dates: bool = ...,
+    numpy: bool = ...,
+    precise_float: bool = ...,
+    date_unit: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    lines: bool = ...,
+    chunksize: int,
+    compression: CompressionOptions = ...,
+    nrows: int | None = ...,
+    storage_options: StorageOptions = ...,
+) -> JsonReader[Literal["frame"]]:
+    ...
+
+
+@overload
+def read_json(
+    path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes],
+    *,
+    orient: str | None = ...,
+    typ: Literal["series"],
+    dtype: DtypeArg | None = ...,
+    convert_axes=...,
+    convert_dates: bool | list[str] = ...,
+    keep_default_dates: bool = ...,
+    numpy: bool = ...,
+    precise_float: bool = ...,
+    date_unit: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    lines: bool = ...,
+    chunksize: int,
+    compression: CompressionOptions = ...,
+    nrows: int | None = ...,
+    storage_options: StorageOptions = ...,
+) -> JsonReader[Literal["series"]]:
+    ...
+
+
+@overload
+def read_json(
+    path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes],
+    *,
+    orient: str | None = ...,
+    typ: Literal["series"],
+    dtype: DtypeArg | None = ...,
+    convert_axes=...,
+    convert_dates: bool | list[str] = ...,
+    keep_default_dates: bool = ...,
+    numpy: bool = ...,
+    precise_float: bool = ...,
+    date_unit: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    lines: bool = ...,
+    chunksize: None = ...,
+    compression: CompressionOptions = ...,
+    nrows: int | None = ...,
+    storage_options: StorageOptions = ...,
+) -> Series:
+    ...
+
+
+@overload
+def read_json(
+    path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes],
+    orient: str | None = ...,
+    typ: Literal["frame"] = ...,
+    dtype: DtypeArg | None = ...,
+    convert_axes=...,
+    convert_dates: bool | list[str] = ...,
+    keep_default_dates: bool = ...,
+    numpy: bool = ...,
+    precise_float: bool = ...,
+    date_unit: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    lines: bool = ...,
+    chunksize: None = ...,
+    compression: CompressionOptions = ...,
+    nrows: int | None = ...,
+    storage_options: StorageOptions = ...,
+) -> DataFrame:
+    ...
+
+
 @doc(
     storage_options=_shared_docs["storage_options"],
     decompression_options=_shared_docs["decompression_options"] % "path_or_buf",
 )
 @deprecate_kwarg(old_arg_name="numpy", new_arg_name=None)
-@deprecate_nonkeyword_arguments(
-    version="2.0", allowed_args=["path_or_buf"], stacklevel=3
-)
+@deprecate_nonkeyword_arguments(version="2.0", allowed_args=["path_or_buf"])
 def read_json(
-    path_or_buf=None,
-    orient=None,
-    typ="frame",
+    path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes],
+    orient: str | None = None,
+    typ: Literal["frame", "series"] = "frame",
     dtype: DtypeArg | None = None,
     convert_axes=None,
-    convert_dates=True,
+    convert_dates: bool | list[str] = True,
     keep_default_dates: bool = True,
     numpy: bool = False,
     precise_float: bool = False,
-    date_unit=None,
-    encoding=None,
+    date_unit: str | None = None,
+    encoding: str | None = None,
     encoding_errors: str | None = "strict",
     lines: bool = False,
     chunksize: int | None = None,
     compression: CompressionOptions = "infer",
     nrows: int | None = None,
     storage_options: StorageOptions = None,
-):
+) -> DataFrame | Series | JsonReader:
     """
     Convert a JSON string to pandas object.
 
@@ -612,7 +757,7 @@ def read_json(
         return json_reader.read()
 
 
-class JsonReader(abc.Iterator):
+class JsonReader(abc.Iterator, Generic[FrameSeriesStrT]):
     """
     JsonReader provides an interface for reading in a JSON file.
 
@@ -625,7 +770,7 @@ def __init__(
         self,
         filepath_or_buffer,
         orient,
-        typ,
+        typ: FrameSeriesStrT,
         dtype,
         convert_axes,
         convert_dates,
@@ -640,7 +785,7 @@ def __init__(
         nrows: int | None,
         storage_options: StorageOptions = None,
         encoding_errors: str | None = "strict",
-    ):
+    ) -> None:
 
         self.orient = orient
         self.typ = typ
@@ -698,6 +843,9 @@ def _get_data_from_filepath(self, filepath_or_buffer):
 
         This method turns (1) into (2) to simplify the rest of the processing.
         It returns input types (2) and (3) unchanged.
+
+        It raises FileNotFoundError if the input is a string ending in
+        one of .json, .json.gz, .json.bz2, etc. but no such file exists.
         """
         # if it is a string but the file does not exist, it might be a JSON string
         filepath_or_buffer = stringify_path(filepath_or_buffer)
@@ -716,6 +864,14 @@ def _get_data_from_filepath(self, filepath_or_buffer):
                 errors=self.encoding_errors,
             )
             filepath_or_buffer = self.handles.handle
+        elif (
+            isinstance(filepath_or_buffer, str)
+            and filepath_or_buffer.lower().endswith(
+                (".json",) + tuple(f".json{c}" for c in _extension_to_compression)
+            )
+            and not file_exists(filepath_or_buffer)
+        ):
+            raise FileNotFoundError(f"File {filepath_or_buffer} does not exist")
 
         return filepath_or_buffer
 
@@ -724,13 +880,26 @@ def _combine_lines(self, lines) -> str:
         Combines a list of JSON objects into one JSON object.
         """
         return (
-            f'[{",".join((line for line in (line.strip() for line in lines) if line))}]'
+            f'[{",".join([line for line in (line.strip() for line in lines) if line])}]'
         )
 
-    def read(self):
+    @overload
+    def read(self: JsonReader[Literal["frame"]]) -> DataFrame:
+        ...
+
+    @overload
+    def read(self: JsonReader[Literal["series"]]) -> Series:
+        ...
+
+    @overload
+    def read(self: JsonReader[Literal["frame", "series"]]) -> DataFrame | Series:
+        ...
+
+    def read(self) -> DataFrame | Series:
         """
         Read the whole JSON input into a pandas object.
         """
+        obj: DataFrame | Series
         if self.lines:
             if self.chunksize:
                 obj = concat(self)
@@ -747,7 +916,7 @@ def read(self):
         self.close()
         return obj
 
-    def _get_object_parser(self, json):
+    def _get_object_parser(self, json) -> DataFrame | Series:
         """
         Parses a json document into a pandas object.
         """
@@ -774,7 +943,7 @@ def _get_object_parser(self, json):
 
         return obj
 
-    def close(self):
+    def close(self) -> None:
         """
         If we opened a stream earlier, in _get_data_from_filepath, we should
         close it.
@@ -784,7 +953,22 @@ def close(self):
         if self.handles is not None:
             self.handles.close()
 
-    def __next__(self):
+    def __iter__(self: JsonReader[FrameSeriesStrT]) -> JsonReader[FrameSeriesStrT]:
+        return self
+
+    @overload
+    def __next__(self: JsonReader[Literal["frame"]]) -> DataFrame:
+        ...
+
+    @overload
+    def __next__(self: JsonReader[Literal["series"]]) -> Series:
+        ...
+
+    @overload
+    def __next__(self: JsonReader[Literal["frame", "series"]]) -> DataFrame | Series:
+        ...
+
+    def __next__(self) -> DataFrame | Series:
         if self.nrows:
             if self.nrows_seen >= self.nrows:
                 self.close()
@@ -804,10 +988,10 @@ def __next__(self):
         self.close()
         raise StopIteration
 
-    def __enter__(self):
+    def __enter__(self) -> JsonReader[FrameSeriesStrT]:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
 
@@ -828,13 +1012,13 @@ def __init__(
         json,
         orient,
         dtype: DtypeArg | None = None,
-        convert_axes=True,
-        convert_dates=True,
-        keep_default_dates=False,
-        numpy=False,
-        precise_float=False,
+        convert_axes: bool = True,
+        convert_dates: bool | list[str] = True,
+        keep_default_dates: bool = False,
+        numpy: bool = False,
+        precise_float: bool = False,
         date_unit=None,
-    ):
+    ) -> None:
         self.json = json
 
         if orient is None:
@@ -863,7 +1047,7 @@ def __init__(
         self.keep_default_dates = keep_default_dates
         self.obj: DataFrame | Series | None = None
 
-    def check_keys_split(self, decoded):
+    def check_keys_split(self, decoded) -> None:
         """
         Checks that dict has only the appropriate keys for orient='split'.
         """
@@ -912,7 +1096,11 @@ def _try_convert_types(self):
         raise AbstractMethodError(self)
 
     def _try_convert_data(
-        self, name, data, use_dtypes: bool = True, convert_dates: bool = True
+        self,
+        name,
+        data,
+        use_dtypes: bool = True,
+        convert_dates: bool | list[str] = True,
     ):
         """
         Try to parse a ndarray like into a column by inferring dtype.
@@ -1067,7 +1255,7 @@ def _parse_numpy(self):
             #  gets multiple values for keyword argument "dtype_if_empty
             self.obj = create_series_with_explicit_dtype(
                 *data, dtype_if_empty=object
-            )  # type:ignore[misc]
+            )  # type: ignore[misc]
         else:
             self.obj = create_series_with_explicit_dtype(data, dtype_if_empty=object)
 
@@ -1194,10 +1382,10 @@ def _try_convert_dates(self):
             return
 
         # our columns to parse
-        convert_dates = self.convert_dates
-        if convert_dates is True:
-            convert_dates = []
-        convert_dates = set(convert_dates)
+        convert_dates_list_bool = self.convert_dates
+        if isinstance(convert_dates_list_bool, bool):
+            convert_dates_list_bool = []
+        convert_dates = set(convert_dates_list_bool)
 
         def is_ok(col) -> bool:
             """
diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index 36a7949a9f1e3..e77d60d2d4950 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -16,7 +16,10 @@
 import numpy as np
 
 from pandas._libs.writers import convert_json_to_lines
-from pandas._typing import Scalar
+from pandas._typing import (
+    IgnoreRaise,
+    Scalar,
+)
 from pandas.util._decorators import deprecate
 
 import pandas as pd
@@ -244,7 +247,7 @@ def _json_normalize(
     meta: str | list[str | list[str]] | None = None,
     meta_prefix: str | None = None,
     record_prefix: str | None = None,
-    errors: str = "raise",
+    errors: IgnoreRaise = "raise",
     sep: str = ".",
     max_level: int | None = None,
 ) -> DataFrame:
@@ -517,11 +520,7 @@ def _recursive_extract(data, path, seen_meta, level=0):
     result = DataFrame(records)
 
     if record_prefix is not None:
-        # Incompatible types in assignment (expression has type "Optional[DataFrame]",
-        # variable has type "DataFrame")
-        result = result.rename(  # type: ignore[assignment]
-            columns=lambda x: f"{record_prefix}{x}"
-        )
+        result = result.rename(columns=lambda x: f"{record_prefix}{x}")
 
     # Data types, a problem
     for k, v in meta_vals.items():
diff --git a/pandas/io/json/_table_schema.py b/pandas/io/json/_table_schema.py
index c630f0d7613e0..0d6cab20f2a59 100644
--- a/pandas/io/json/_table_schema.py
+++ b/pandas/io/json/_table_schema.py
@@ -17,6 +17,7 @@
     DtypeObj,
     JSONSerializable,
 )
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.base import _registry as registry
 from pandas.core.dtypes.common import (
@@ -100,10 +101,14 @@ def set_default_names(data):
     if com.all_not_none(*data.index.names):
         nms = data.index.names
         if len(nms) == 1 and data.index.name == "index":
-            warnings.warn("Index name of 'index' is not round-trippable.")
+            warnings.warn(
+                "Index name of 'index' is not round-trippable.",
+                stacklevel=find_stack_level(),
+            )
         elif len(nms) > 1 and any(x.startswith("level_") for x in nms):
             warnings.warn(
-                "Index names beginning with 'level_' are not round-trippable."
+                "Index names beginning with 'level_' are not round-trippable.",
+                stacklevel=find_stack_level(),
             )
         return data
 
@@ -115,8 +120,9 @@ def set_default_names(data):
     return data
 
 
-def convert_pandas_type_to_json_field(arr):
+def convert_pandas_type_to_json_field(arr) -> dict[str, JSONSerializable]:
     dtype = arr.dtype
+    name: JSONSerializable
     if arr.name is None:
         name = "values"
     else:
@@ -141,7 +147,7 @@ def convert_pandas_type_to_json_field(arr):
     return field
 
 
-def convert_json_field_to_pandas_type(field):
+def convert_json_field_to_pandas_type(field) -> str | CategoricalDtype:
     """
     Converts a JSON field descriptor into its corresponding NumPy / pandas type
 
@@ -196,6 +202,9 @@ def convert_json_field_to_pandas_type(field):
     elif typ == "datetime":
         if field.get("tz"):
             return f"datetime64[ns, {field['tz']}]"
+        elif field.get("freq"):
+            # GH#47747 using datetime over period to minimize the change surface
+            return f"period[{field['freq']}]"
         else:
             return "datetime64[ns]"
     elif typ == "any":
diff --git a/pandas/io/orc.py b/pandas/io/orc.py
index 6dd4de597c29d..40754a56bbe8b 100644
--- a/pandas/io/orc.py
+++ b/pandas/io/orc.py
@@ -1,14 +1,28 @@
 """ orc compat """
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import io
+from types import ModuleType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+)
 
 from pandas._typing import (
     FilePath,
     ReadBuffer,
+    WriteBuffer,
 )
 from pandas.compat._optional import import_optional_dependency
 
+from pandas.core.dtypes.common import (
+    is_categorical_dtype,
+    is_interval_dtype,
+    is_period_dtype,
+    is_unsigned_integer_dtype,
+)
+
 from pandas.io.common import get_handle
 
 if TYPE_CHECKING:
@@ -41,7 +55,7 @@ def read_orc(
     DataFrame
 
     Notes
-    -------
+    -----
     Before using this function you should read the :ref:`user guide about ORC <io.orc>`
     and :ref:`install optional dependencies <install.warn_orc>`.
     """
@@ -52,3 +66,111 @@ def read_orc(
     with get_handle(path, "rb", is_text=False) as handles:
         orc_file = orc.ORCFile(handles.handle)
         return orc_file.read(columns=columns, **kwargs).to_pandas()
+
+
+def to_orc(
+    df: DataFrame,
+    path: FilePath | WriteBuffer[bytes] | None = None,
+    *,
+    engine: Literal["pyarrow"] = "pyarrow",
+    index: bool | None = None,
+    engine_kwargs: dict[str, Any] | None = None,
+) -> bytes | None:
+    """
+    Write a DataFrame to the ORC format.
+
+    .. versionadded:: 1.5.0
+
+    Parameters
+    ----------
+    df : DataFrame
+        The dataframe to be written to ORC. Raises NotImplementedError
+        if dtype of one or more columns is category, unsigned integers,
+        intervals, periods or sparse.
+    path : str, file-like object or None, default None
+        If a string, it will be used as Root Directory path
+        when writing a partitioned dataset. By file-like object,
+        we refer to objects with a write() method, such as a file handle
+        (e.g. via builtin open function). If path is None,
+        a bytes object is returned.
+    engine : str, default 'pyarrow'
+        ORC library to use. Pyarrow must be >= 7.0.0.
+    index : bool, optional
+        If ``True``, include the dataframe's index(es) in the file output. If
+        ``False``, they will not be written to the file.
+        If ``None``, similar to ``infer`` the dataframe's index(es)
+        will be saved. However, instead of being saved as values,
+        the RangeIndex will be stored as a range in the metadata so it
+        doesn't require much space and is faster. Other indexes will
+        be included as columns in the file output.
+    engine_kwargs : dict[str, Any] or None, default None
+        Additional keyword arguments passed to :func:`pyarrow.orc.write_table`.
+
+    Returns
+    -------
+    bytes if no path argument is provided else None
+
+    Raises
+    ------
+    NotImplementedError
+        Dtype of one or more columns is category, unsigned integers, interval,
+        period or sparse.
+    ValueError
+        engine is not pyarrow.
+
+    Notes
+    -----
+    * Before using this function you should read the
+      :ref:`user guide about ORC <io.orc>` and
+      :ref:`install optional dependencies <install.warn_orc>`.
+    * This function requires `pyarrow <https://arrow.apache.org/docs/python/>`_
+      library.
+    * For supported dtypes please refer to `supported ORC features in Arrow
+      <https://arrow.apache.org/docs/cpp/orc.html#data-types>`__.
+    * Currently timezones in datetime columns are not preserved when a
+      dataframe is converted into ORC files.
+    """
+    if index is None:
+        index = df.index.names[0] is not None
+    if engine_kwargs is None:
+        engine_kwargs = {}
+
+    # If unsupported dtypes are found raise NotImplementedError
+    # In Pyarrow 9.0.0 this check will no longer be needed
+    for dtype in df.dtypes:
+        if (
+            is_categorical_dtype(dtype)
+            or is_interval_dtype(dtype)
+            or is_period_dtype(dtype)
+            or is_unsigned_integer_dtype(dtype)
+        ):
+            raise NotImplementedError(
+                "The dtype of one or more columns is not supported yet."
+            )
+
+    if engine != "pyarrow":
+        raise ValueError("engine must be 'pyarrow'")
+    engine = import_optional_dependency(engine, min_version="7.0.0")
+    orc = import_optional_dependency("pyarrow.orc")
+
+    was_none = path is None
+    if was_none:
+        path = io.BytesIO()
+    assert path is not None  # For mypy
+    with get_handle(path, "wb", is_text=False) as handles:
+        assert isinstance(engine, ModuleType)  # For mypy
+        try:
+            orc.write_table(
+                engine.Table.from_pandas(df, preserve_index=index),
+                handles.handle,
+                **engine_kwargs,
+            )
+        except TypeError as e:
+            raise NotImplementedError(
+                "The dtype of one or more columns is not supported yet."
+            ) from e
+
+    if was_none:
+        assert isinstance(path, io.BytesIO)  # For mypy
+        return path.getvalue()
+    return None
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index 4880c7730ff07..6f3a7608b49c3 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -144,14 +144,14 @@ def read(self, path, columns=None, **kwargs) -> DataFrame:
 
 
 class PyArrowImpl(BaseImpl):
-    def __init__(self):
+    def __init__(self) -> None:
         import_optional_dependency(
             "pyarrow", extra="pyarrow is required for parquet support."
         )
         import pyarrow.parquet
 
         # import utils to register the pyarrow extension types
-        import pandas.core.arrays._arrow_utils  # noqa:F401
+        import pandas.core.arrays.arrow.extension_types  # pyright: ignore # noqa:F401
 
         self.api = pyarrow
 
@@ -180,6 +180,15 @@ def write(
             mode="wb",
             is_dir=partition_cols is not None,
         )
+        if (
+            isinstance(path_or_handle, io.BufferedWriter)
+            and hasattr(path_or_handle, "name")
+            and isinstance(path_or_handle.name, (str, bytes))
+        ):
+            path_or_handle = path_or_handle.name
+            if isinstance(path_or_handle, bytes):
+                path_or_handle = path_or_handle.decode()
+
         try:
             if partition_cols is not None:
                 # writes to multiple files under the given path
@@ -224,6 +233,8 @@ def read(
                 self.api.uint64(): pd.UInt64Dtype(),
                 self.api.bool_(): pd.BooleanDtype(),
                 self.api.string(): pd.StringDtype(),
+                self.api.float32(): pd.Float32Dtype(),
+                self.api.float64(): pd.Float64Dtype(),
             }
             to_pandas_kwargs["types_mapper"] = mapping.get
         manager = get_option("mode.data_manager")
@@ -249,7 +260,7 @@ def read(
 
 
 class FastParquetImpl(BaseImpl):
-    def __init__(self):
+    def __init__(self) -> None:
         # since pandas is a dependency of fastparquet
         # we need to import on first use
         fastparquet = import_optional_dependency(
@@ -342,13 +353,12 @@ def read(
             )
             path = handles.handle
 
-        parquet_file = self.api.ParquetFile(path, **parquet_kwargs)
-
-        result = parquet_file.to_pandas(columns=columns, **kwargs)
-
-        if handles is not None:
-            handles.close()
-        return result
+        try:
+            parquet_file = self.api.ParquetFile(path, **parquet_kwargs)
+            return parquet_file.to_pandas(columns=columns, **kwargs)
+        finally:
+            if handles is not None:
+                handles.close()
 
 
 @doc(storage_options=_shared_docs["storage_options"])
@@ -436,9 +446,9 @@ def to_parquet(
 
 @doc(storage_options=_shared_docs["storage_options"])
 def read_parquet(
-    path,
+    path: FilePath | ReadBuffer[bytes],
     engine: str = "auto",
-    columns=None,
+    columns: list[str] | None = None,
     storage_options: StorageOptions = None,
     use_nullable_dtypes: bool = False,
     **kwargs,
diff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py
index 96f7f9b1738b8..2305c209936b6 100644
--- a/pandas/io/parsers/arrow_parser_wrapper.py
+++ b/pandas/io/parsers/arrow_parser_wrapper.py
@@ -1,30 +1,28 @@
 from __future__ import annotations
 
-from pandas._typing import (
-    FilePath,
-    ReadBuffer,
-)
+from typing import TYPE_CHECKING
+
+from pandas._typing import ReadBuffer
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.dtypes.inference import is_integer
 
-from pandas.core.frame import DataFrame
-
-from pandas.io.common import get_handle
 from pandas.io.parsers.base_parser import ParserBase
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
 class ArrowParserWrapper(ParserBase):
     """
     Wrapper for the pyarrow engine for read_csv()
     """
 
-    def __init__(self, src: FilePath | ReadBuffer[bytes], **kwds):
+    def __init__(self, src: ReadBuffer[bytes], **kwds) -> None:
+        super().__init__(kwds)
         self.kwds = kwds
         self.src = src
 
-        ParserBase.__init__(self, kwds)
-
         self._parse_kwds()
 
     def _parse_kwds(self):
@@ -110,12 +108,7 @@ def _finalize_output(self, frame: DataFrame) -> DataFrame:
                 multi_index_named = False
             frame.columns = self.names
         # we only need the frame not the names
-        # error: Incompatible types in assignment (expression has type
-        # "Union[List[Union[Union[str, int, float, bool], Union[Period, Timestamp,
-        # Timedelta, Any]]], Index]", variable has type "Index")  [assignment]
-        frame.columns, frame = self._do_date_conversions(  # type: ignore[assignment]
-            frame.columns, frame
-        )
+        frame.columns, frame = self._do_date_conversions(frame.columns, frame)
         if self.index_col is not None:
             for i, item in enumerate(self.index_col):
                 if is_integer(item):
@@ -151,15 +144,12 @@ def read(self) -> DataFrame:
         pyarrow_csv = import_optional_dependency("pyarrow.csv")
         self._get_pyarrow_options()
 
-        with get_handle(
-            self.src, "rb", encoding=self.encoding, is_text=False
-        ) as handles:
-            table = pyarrow_csv.read_csv(
-                handles.handle,
-                read_options=pyarrow_csv.ReadOptions(**self.read_options),
-                parse_options=pyarrow_csv.ParseOptions(**self.parse_options),
-                convert_options=pyarrow_csv.ConvertOptions(**self.convert_options),
-            )
+        table = pyarrow_csv.read_csv(
+            self.src,
+            read_options=pyarrow_csv.ReadOptions(**self.read_options),
+            parse_options=pyarrow_csv.ParseOptions(**self.parse_options),
+            convert_options=pyarrow_csv.ConvertOptions(**self.convert_options),
+        )
 
-            frame = table.to_pandas()
-            return self._finalize_output(frame)
+        frame = table.to_pandas()
+        return self._finalize_output(frame)
diff --git a/pandas/io/parsers/base_parser.py b/pandas/io/parsers/base_parser.py
index 318dd659d46bf..0e40e47bf7cb1 100644
--- a/pandas/io/parsers/base_parser.py
+++ b/pandas/io/parsers/base_parser.py
@@ -7,6 +7,7 @@
 from enum import Enum
 import itertools
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     DefaultDict,
@@ -32,8 +33,7 @@
 from pandas._typing import (
     ArrayLike,
     DtypeArg,
-    FilePath,
-    ReadCsvBuffer,
+    Scalar,
 )
 from pandas.errors import (
     ParserError,
@@ -41,7 +41,7 @@
 )
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.dtypes.cast import astype_nansafe
+from pandas.core.dtypes.astype import astype_nansafe
 from pandas.core.dtypes.common import (
     ensure_object,
     is_bool_dtype,
@@ -60,7 +60,6 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype
 from pandas.core.dtypes.missing import isna
 
-from pandas import DataFrame
 from pandas.core import algorithms
 from pandas.core.arrays import Categorical
 from pandas.core.indexes.api import (
@@ -71,12 +70,11 @@
 from pandas.core.series import Series
 from pandas.core.tools import datetimes as tools
 
-from pandas.io.common import (
-    IOHandles,
-    get_handle,
-)
 from pandas.io.date_converters import generic_parser
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
 class ParserBase:
     class BadLineHandleMethod(Enum):
@@ -87,7 +85,7 @@ class BadLineHandleMethod(Enum):
     _implicit_index: bool = False
     _first_chunk: bool
 
-    def __init__(self, kwds):
+    def __init__(self, kwds) -> None:
 
         self.names = kwds.get("names")
         self.orig_names: list | None = None
@@ -95,7 +93,7 @@ def __init__(self, kwds):
 
         self.index_col = kwds.get("index_col", None)
         self.unnamed_cols: set = set()
-        self.index_names: list | None = None
+        self.index_names: Sequence[Hashable] | None = None
         self.col_names = None
 
         self.parse_dates = _validate_parse_dates_arg(kwds.pop("parse_dates", False))
@@ -110,6 +108,7 @@ def __init__(self, kwds):
         self.keep_default_na = kwds.get("keep_default_na", True)
 
         self.dtype = copy(kwds.get("dtype", None))
+        self.converters = kwds.get("converters")
 
         self.true_values = kwds.get("true_values")
         self.false_values = kwds.get("false_values")
@@ -126,13 +125,7 @@ def __init__(self, kwds):
 
         # validate header options for mi
         self.header = kwds.get("header")
-        if isinstance(self.header, (list, tuple, np.ndarray)):
-            if not all(map(is_integer, self.header)):
-                raise ValueError("header must be integer or list of integers")
-            if any(i < 0 for i in self.header):
-                raise ValueError(
-                    "cannot specify multi-index header with negative integers"
-                )
+        if is_list_like(self.header, allow_sets=False):
             if kwds.get("usecols"):
                 raise ValueError(
                     "cannot specify usecols when specifying a multi-index header"
@@ -144,9 +137,8 @@ def __init__(self, kwds):
 
             # validate index_col that only contains integers
             if self.index_col is not None:
-                is_sequence = isinstance(self.index_col, (list, tuple, np.ndarray))
                 if not (
-                    is_sequence
+                    is_list_like(self.index_col, allow_sets=False)
                     and all(map(is_integer, self.index_col))
                     or is_integer(self.index_col)
                 ):
@@ -154,21 +146,11 @@ def __init__(self, kwds):
                         "index_col must only contain row numbers "
                         "when specifying a multi-index header"
                     )
-        elif self.header is not None:
+        elif self.header is not None and self.prefix is not None:
             # GH 27394
-            if self.prefix is not None:
-                raise ValueError(
-                    "Argument prefix must be None if argument header is not None"
-                )
-            # GH 16338
-            elif not is_integer(self.header):
-                raise ValueError("header must be integer or list of integers")
-            # GH 27779
-            elif self.header < 0:
-                raise ValueError(
-                    "Passing negative integer to header is invalid. "
-                    "For no header, use header=None instead"
-                )
+            raise ValueError(
+                "Argument prefix must be None if argument header is not None"
+            )
 
         self._name_processed = False
 
@@ -176,30 +158,10 @@ def __init__(self, kwds):
 
         self.usecols, self.usecols_dtype = self._validate_usecols_arg(kwds["usecols"])
 
-        self.handles: IOHandles[str] | None = None
-
         # Fallback to error to pass a sketchy test(test_override_set_noconvert_columns)
         # Normally, this arg would get pre-processed earlier on
         self.on_bad_lines = kwds.get("on_bad_lines", self.BadLineHandleMethod.ERROR)
 
-    def _open_handles(
-        self,
-        src: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
-        kwds: dict[str, Any],
-    ) -> None:
-        """
-        Let the readers open IOHandles after they are done with their potential raises.
-        """
-        self.handles = get_handle(
-            src,
-            "r",
-            encoding=kwds.get("encoding", None),
-            compression=kwds.get("compression", None),
-            memory_map=kwds.get("memory_map", False),
-            storage_options=kwds.get("storage_options", None),
-            errors=kwds.get("encoding_errors", "strict"),
-        )
-
     def _validate_parse_dates_presence(self, columns: Sequence[Hashable]) -> Iterable:
         """
         Check if parse_dates are in columns.
@@ -261,9 +223,8 @@ def _validate_parse_dates_presence(self, columns: Sequence[Hashable]) -> Iterabl
             for col in cols_needed
         ]
 
-    def close(self):
-        if self.handles is not None:
-            self.handles.close()
+    def close(self) -> None:
+        pass
 
     @final
     @property
@@ -331,9 +292,7 @@ def _extract_multi_indexer_columns(
 
         # clean the index_names
         index_names = header.pop(-1)
-        index_names, _, _ = self._clean_index_names(
-            index_names, self.index_col, self.unnamed_cols
-        )
+        index_names, _, _ = self._clean_index_names(index_names, self.index_col)
 
         # extract the columns
         field_count = len(header[0])
@@ -409,21 +368,24 @@ def _maybe_make_multi_index_columns(
         return columns
 
     @final
-    def _make_index(self, data, alldata, columns, indexnamerow=False):
+    def _make_index(
+        self, data, alldata, columns, indexnamerow: list[Scalar] | None = None
+    ) -> tuple[Index | None, Sequence[Hashable] | MultiIndex]:
+        index: Index | None
         if not is_index_col(self.index_col) or not self.index_col:
             index = None
 
         elif not self._has_complex_date_col:
-            index = self._get_simple_index(alldata, columns)
-            index = self._agg_index(index)
+            simple_index = self._get_simple_index(alldata, columns)
+            index = self._agg_index(simple_index)
         elif self._has_complex_date_col:
             if not self._name_processed:
                 (self.index_names, _, self.index_col) = self._clean_index_names(
-                    list(columns), self.index_col, self.unnamed_cols
+                    list(columns), self.index_col
                 )
                 self._name_processed = True
-            index = self._get_complex_date_index(data, columns)
-            index = self._agg_index(index, try_parse_dates=False)
+            date_index = self._get_complex_date_index(data, columns)
+            index = self._agg_index(date_index, try_parse_dates=False)
 
         # add names for the index
         if indexnamerow:
@@ -492,17 +454,22 @@ def _clean_mapping(self, mapping):
         if not isinstance(mapping, dict):
             return mapping
         clean = {}
+        # for mypy
+        assert self.orig_names is not None
+
         for col, v in mapping.items():
-            # for mypy
-            assert self.orig_names is not None
             if isinstance(col, int) and col not in self.orig_names:
                 col = self.orig_names[col]
             clean[col] = v
+        if isinstance(mapping, defaultdict):
+            remaining_cols = set(self.orig_names) - set(clean.keys())
+            clean.update({col: mapping[col] for col in remaining_cols})
         return clean
 
     @final
     def _agg_index(self, index, try_parse_dates: bool = True) -> Index:
         arrays = []
+        converters = self._clean_mapping(self.converters)
 
         for i, arr in enumerate(index):
 
@@ -527,10 +494,17 @@ def _agg_index(self, index, try_parse_dates: bool = True) -> Index:
             clean_dtypes = self._clean_mapping(self.dtype)
 
             cast_type = None
-            if isinstance(clean_dtypes, dict) and self.index_names is not None:
-                cast_type = clean_dtypes.get(self.index_names[i], None)
+            index_converter = False
+            if self.index_names is not None:
+                if isinstance(clean_dtypes, dict):
+                    cast_type = clean_dtypes.get(self.index_names[i], None)
 
-            try_num_bool = not (cast_type and is_string_dtype(cast_type))
+                if isinstance(converters, dict):
+                    index_converter = converters.get(self.index_names[i]) is not None
+
+            try_num_bool = not (
+                cast_type and is_string_dtype(cast_type) or index_converter
+            )
 
             arr, _ = self._infer_types(
                 arr, col_na_values | col_na_fvalues, try_num_bool
@@ -873,9 +847,11 @@ def _check_data_length(
         data: list of array-likes containing the data column-wise.
         """
         if not self.index_col and len(columns) != len(data) and columns:
-            if len(columns) == len(data) - 1 and np.all(
-                (is_object_dtype(data[-1]) and data[-1] == "") | isna(data[-1])
-            ):
+            empty_str = is_object_dtype(data[-1]) and data[-1] == ""
+            # error: No overload variant of "__ror__" of "ndarray" matches
+            # argument type "ExtensionArray"
+            empty_str_or_na = empty_str | isna(data[-1])  # type: ignore[operator]
+            if len(columns) == len(data) - 1 and np.all(empty_str_or_na):
                 return
             warnings.warn(
                 "Length of header or names does not match length of data. This leads "
@@ -994,7 +970,7 @@ def _validate_usecols_arg(self, usecols):
             return usecols, usecols_dtype
         return usecols, None
 
-    def _clean_index_names(self, columns, index_col, unnamed_cols):
+    def _clean_index_names(self, columns, index_col):
         if not is_index_col(index_col):
             return None, columns, index_col
 
@@ -1026,7 +1002,7 @@ def _clean_index_names(self, columns, index_col, unnamed_cols):
 
         # Only clean index names that were placeholders.
         for i, name in enumerate(index_names):
-            if isinstance(name, str) and name in unnamed_cols:
+            if isinstance(name, str) and name in self.unnamed_cols:
                 index_names[i] = None
 
         return index_names, columns, index_col
@@ -1039,26 +1015,14 @@ def _get_empty_meta(
         # Convert `dtype` to a defaultdict of some kind.
         # This will enable us to write `dtype[col_name]`
         # without worrying about KeyError issues later on.
+        dtype_dict: defaultdict[Hashable, Any]
         if not is_dict_like(dtype):
             # if dtype == None, default will be object.
             default_dtype = dtype or object
-            # error: Argument 1 to "defaultdict" has incompatible type "Callable[[],
-            # Union[ExtensionDtype, str, dtype[Any], Type[object], Dict[Hashable,
-            # Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
-            # Type[int], Type[complex], Type[bool], Type[object]]]]]"; expected
-            # "Optional[Callable[[], Union[ExtensionDtype, str, dtype[Any],
-            # Type[object]]]]"
-            # error: Incompatible return value type (got "Union[ExtensionDtype, str,
-            # dtype[Any], Type[object], Dict[Hashable, Union[ExtensionDtype, Union[str,
-            # dtype[Any]], Type[str], Type[float], Type[int], Type[complex], Type[bool],
-            # Type[object]]]]", expected "Union[ExtensionDtype, str, dtype[Any],
-            # Type[object]]")
-            dtype = defaultdict(
-                lambda: default_dtype  # type: ignore[arg-type, return-value]
-            )
+            dtype_dict = defaultdict(lambda: default_dtype)
         else:
             dtype = cast(dict, dtype)
-            dtype = defaultdict(
+            dtype_dict = defaultdict(
                 lambda: object,
                 {columns[k] if is_integer(k) else k: v for k, v in dtype.items()},
             )
@@ -1075,14 +1039,16 @@ def _get_empty_meta(
         if (index_col is None or index_col is False) or index_names is None:
             index = Index([])
         else:
-            data = [Series([], dtype=dtype[name]) for name in index_names]
+            data = [Series([], dtype=dtype_dict[name]) for name in index_names]
             index = ensure_index_from_sequences(data, names=index_names)
             index_col.sort()
 
             for i, n in enumerate(index_col):
                 columns.pop(n - i)
 
-        col_dict = {col_name: Series([], dtype=dtype[col_name]) for col_name in columns}
+        col_dict = {
+            col_name: Series([], dtype=dtype_dict[col_name]) for col_name in columns
+        }
 
         return index, columns, col_dict
 
diff --git a/pandas/io/parsers/c_parser_wrapper.py b/pandas/io/parsers/c_parser_wrapper.py
index 988dcd3d8a124..874eaee184d28 100644
--- a/pandas/io/parsers/c_parser_wrapper.py
+++ b/pandas/io/parsers/c_parser_wrapper.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+from collections import defaultdict
 from typing import (
+    TYPE_CHECKING,
     Hashable,
     Mapping,
     Sequence,
@@ -14,7 +16,6 @@
     ArrayLike,
     DtypeArg,
     DtypeObj,
-    FilePath,
     ReadCsvBuffer,
 )
 from pandas.errors import DtypeWarning
@@ -27,10 +28,6 @@
 from pandas.core.dtypes.concat import union_categoricals
 from pandas.core.dtypes.dtypes import ExtensionDtype
 
-from pandas import (
-    Index,
-    MultiIndex,
-)
 from pandas.core.indexes.api import ensure_index_from_sequences
 
 from pandas.io.parsers.base_parser import (
@@ -38,17 +35,21 @@
     is_index_col,
 )
 
+if TYPE_CHECKING:
+    from pandas import (
+        Index,
+        MultiIndex,
+    )
+
 
 class CParserWrapper(ParserBase):
     low_memory: bool
     _reader: parsers.TextReader
 
-    def __init__(
-        self, src: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], **kwds
-    ):
+    def __init__(self, src: ReadCsvBuffer[str], **kwds) -> None:
+        super().__init__(kwds)
         self.kwds = kwds
         kwds = kwds.copy()
-        ParserBase.__init__(self, kwds)
 
         self.low_memory = kwds.pop("low_memory", False)
 
@@ -61,10 +62,6 @@ def __init__(
         # GH20529, validate usecol arg before TextReader
         kwds["usecols"] = self.usecols
 
-        # open handles
-        self._open_handles(src, kwds)
-        assert self.handles is not None
-
         # Have to pass int, would break tests using TextReader directly otherwise :(
         kwds["on_bad_lines"] = self.on_bad_lines.value
 
@@ -79,11 +76,7 @@ def __init__(
             kwds.pop(key, None)
 
         kwds["dtype"] = ensure_dtype_objs(kwds.get("dtype", None))
-        try:
-            self._reader = parsers.TextReader(self.handles.handle, **kwds)
-        except Exception:
-            self.handles.close()
-            raise
+        self._reader = parsers.TextReader(src, **kwds)
 
         self.unnamed_cols = self._reader.unnamed_cols
 
@@ -183,7 +176,6 @@ def __init__(
                     self.names,  # type: ignore[has-type]
                     # error: Cannot determine type of 'index_col'
                     self.index_col,  # type: ignore[has-type]
-                    self.unnamed_cols,
                 )
 
                 if self.index_names is None:
@@ -196,9 +188,7 @@ def __init__(
         self._implicit_index = self._reader.leading_cols > 0
 
     def close(self) -> None:
-        super().close()
-
-        # close additional handles opened by C parser
+        # close handles opened by C parser
         try:
             self._reader.close()
         except ValueError:
@@ -233,6 +223,8 @@ def read(
         Sequence[Hashable] | MultiIndex,
         Mapping[Hashable, ArrayLike],
     ]:
+        index: Index | MultiIndex | None
+        column_names: Sequence[Hashable] | MultiIndex
         try:
             if self.low_memory:
                 chunks = self._reader.read_low_memory(nrows)
@@ -297,7 +289,12 @@ def read(
             data_tups = sorted(data.items())
             data = {k: v for k, (i, v) in zip(names, data_tups)}
 
-            names, date_data = self._do_date_conversions(names, data)
+            column_names, date_data = self._do_date_conversions(names, data)
+
+            # maybe create a mi on the columns
+            column_names = self._maybe_make_multi_index_columns(
+                column_names, self.col_names
+            )
 
         else:
             # rename dict keys
@@ -321,12 +318,9 @@ def read(
             data = {k: v for k, (i, v) in zip(names, data_tups)}
 
             names, date_data = self._do_date_conversions(names, data)
-            index, names = self._make_index(date_data, alldata, names)
-
-        # maybe create a mi on the columns
-        conv_names = self._maybe_make_multi_index_columns(names, self.col_names)
+            index, column_names = self._make_index(date_data, alldata, names)
 
-        return index, conv_names, date_data
+        return index, column_names, date_data
 
     def _filter_usecols(self, names: Sequence[Hashable]) -> Sequence[Hashable]:
         # hackish
@@ -343,7 +337,7 @@ def _get_index_names(self):
 
         if self._reader.leading_cols == 0 and self.index_col is not None:
             (idx_names, names, self.index_col) = self._clean_index_names(
-                names, self.index_col, self.unnamed_cols
+                names, self.index_col
             )
 
         return names, idx_names
@@ -364,7 +358,7 @@ def _concatenate_chunks(chunks: list[dict[int, ArrayLike]]) -> dict:
     names = list(chunks[0].keys())
     warning_columns = []
 
-    result = {}
+    result: dict = {}
     for name in names:
         arrs = [chunk.pop(name) for chunk in chunks]
         # Check each arr for consistent types.
@@ -380,9 +374,7 @@ def _concatenate_chunks(chunks: list[dict[int, ArrayLike]]) -> dict:
                 numpy_dtypes,  # type: ignore[arg-type]
                 [],
             )
-            # error: Non-overlapping equality check (left operand type: "dtype[Any]",
-            # right operand type: "Type[object]")
-            if common_type == object:  # type: ignore[comparison-overlap]
+            if common_type == np.dtype(object):
                 warning_columns.append(str(name))
 
         dtype = dtypes.pop()
@@ -399,7 +391,15 @@ def _concatenate_chunks(chunks: list[dict[int, ArrayLike]]) -> dict:
                     arrs  # type: ignore[arg-type]
                 )
             else:
-                result[name] = np.concatenate(arrs)
+                # error: Argument 1 to "concatenate" has incompatible
+                # type "List[Union[ExtensionArray, ndarray[Any, Any]]]"
+                # ; expected "Union[_SupportsArray[dtype[Any]],
+                # Sequence[_SupportsArray[dtype[Any]]],
+                # Sequence[Sequence[_SupportsArray[dtype[Any]]]],
+                # Sequence[Sequence[Sequence[_SupportsArray[dtype[Any]]]]]
+                # , Sequence[Sequence[Sequence[Sequence[
+                # _SupportsArray[dtype[Any]]]]]]]"
+                result[name] = np.concatenate(arrs)  # type: ignore[arg-type]
 
     if warning_columns:
         warning_names = ",".join(warning_columns)
@@ -420,7 +420,14 @@ def ensure_dtype_objs(
     Ensure we have either None, a dtype object, or a dictionary mapping to
     dtype objects.
     """
-    if isinstance(dtype, dict):
+    if isinstance(dtype, defaultdict):
+        # "None" not callable  [misc]
+        default_dtype = pandas_dtype(dtype.default_factory())  # type: ignore[misc]
+        dtype_converted: defaultdict = defaultdict(lambda: default_dtype)
+        for key in dtype.keys():
+            dtype_converted[key] = pandas_dtype(dtype[key])
+        return dtype_converted
+    elif isinstance(dtype, dict):
         return {k: pandas_dtype(dtype[k]) for k in dtype}
     elif dtype is not None:
         return pandas_dtype(dtype)
diff --git a/pandas/io/parsers/python_parser.py b/pandas/io/parsers/python_parser.py
index 12d5e4599cee0..7c03a81dbc0e6 100644
--- a/pandas/io/parsers/python_parser.py
+++ b/pandas/io/parsers/python_parser.py
@@ -10,9 +10,11 @@
 import sys
 from typing import (
     IO,
+    TYPE_CHECKING,
     DefaultDict,
     Hashable,
     Iterator,
+    List,
     Literal,
     Mapping,
     Sequence,
@@ -25,7 +27,6 @@
 import pandas._libs.lib as lib
 from pandas._typing import (
     ArrayLike,
-    FilePath,
     ReadCsvBuffer,
     Scalar,
 )
@@ -43,6 +44,12 @@
     parser_defaults,
 )
 
+if TYPE_CHECKING:
+    from pandas import (
+        Index,
+        MultiIndex,
+    )
+
 # BOM character (byte order mark)
 # This exists at the beginning of a file to indicate endianness
 # of a file (stream). Unfortunately, this marker screws up parsing,
@@ -51,13 +58,11 @@
 
 
 class PythonParser(ParserBase):
-    def __init__(
-        self, f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list, **kwds
-    ):
+    def __init__(self, f: ReadCsvBuffer[str] | list, **kwds) -> None:
         """
         Workhorse function for processing nested list into DataFrame
         """
-        ParserBase.__init__(self, kwds)
+        super().__init__(kwds)
 
         self.data: Iterator[str] | None = None
         self.buf: list = []
@@ -92,7 +97,6 @@ def __init__(
             self.has_index_names = kwds["has_index_names"]
 
         self.verbose = kwds["verbose"]
-        self.converters = kwds["converters"]
 
         self.thousands = kwds["thousands"]
         self.decimal = kwds["decimal"]
@@ -104,28 +108,18 @@ def __init__(
             # read_excel: f is a list
             self.data = cast(Iterator[str], f)
         else:
-            self._open_handles(f, kwds)
-            assert self.handles is not None
-            assert hasattr(self.handles.handle, "readline")
-            try:
-                self._make_reader(self.handles.handle)
-            except (csv.Error, UnicodeDecodeError):
-                self.close()
-                raise
+            assert hasattr(f, "readline")
+            self._make_reader(f)
 
         # Get columns in two steps: infer from data, then
         # infer column indices from self.usecols if it is specified.
         self._col_indices: list[int] | None = None
         columns: list[list[Scalar | None]]
-        try:
-            (
-                columns,
-                self.num_original_columns,
-                self.unnamed_cols,
-            ) = self._infer_columns()
-        except (TypeError, ValueError):
-            self.close()
-            raise
+        (
+            columns,
+            self.num_original_columns,
+            self.unnamed_cols,
+        ) = self._infer_columns()
 
         # Now self.columns has the set of columns that we will process.
         # The original set is stored in self.original_columns.
@@ -171,16 +165,16 @@ def __init__(
 
         decimal = re.escape(self.decimal)
         if self.thousands is None:
-            regex = fr"^[\-\+]?[0-9]*({decimal}[0-9]*)?([0-9]?(E|e)\-?[0-9]+)?$"
+            regex = rf"^[\-\+]?[0-9]*({decimal}[0-9]*)?([0-9]?(E|e)\-?[0-9]+)?$"
         else:
             thousands = re.escape(self.thousands)
             regex = (
-                fr"^[\-\+]?([0-9]+{thousands}|[0-9])*({decimal}[0-9]*)?"
-                fr"([0-9]?(E|e)\-?[0-9]+)?$"
+                rf"^[\-\+]?([0-9]+{thousands}|[0-9])*({decimal}[0-9]*)?"
+                rf"([0-9]?(E|e)\-?[0-9]+)?$"
             )
         self.num = re.compile(regex)
 
-    def _make_reader(self, f) -> None:
+    def _make_reader(self, f: IO[str] | ReadCsvBuffer[str]) -> None:
         sep = self.delimiter
 
         if sep is None or len(sep) == 1:
@@ -211,10 +205,11 @@ class MyDialect(csv.Dialect):
                     self.pos += 1
                     line = f.readline()
                     lines = self._check_comments([[line]])[0]
+                lines_str = cast(List[str], lines)
 
                 # since `line` was a string, lines will be a list containing
                 # only a single string
-                line = lines[0]
+                line = lines_str[0]
 
                 self.pos += 1
                 self.line_pos += 1
@@ -246,7 +241,11 @@ def _read():
         # TextIOWrapper, mmap, None]")
         self.data = reader  # type: ignore[assignment]
 
-    def read(self, rows: int | None = None):
+    def read(
+        self, rows: int | None = None
+    ) -> tuple[
+        Index | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, ArrayLike]
+    ]:
         try:
             content = self._get_lines(rows)
         except StopIteration:
@@ -286,9 +285,11 @@ def read(self, rows: int | None = None):
         conv_data = self._convert_data(data)
         columns, conv_data = self._do_date_conversions(columns, conv_data)
 
-        index, columns = self._make_index(conv_data, alldata, columns, indexnamerow)
+        index, result_columns = self._make_index(
+            conv_data, alldata, columns, indexnamerow
+        )
 
-        return index, columns, conv_data
+        return index, result_columns, conv_data
 
     def _exclude_implicit_index(
         self,
@@ -309,7 +310,11 @@ def _exclude_implicit_index(
         }, names
 
     # legacy
-    def get_chunk(self, size=None):
+    def get_chunk(
+        self, size: int | None = None
+    ) -> tuple[
+        Index | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, ArrayLike]
+    ]:
         if size is None:
             # error: "PythonParser" has no attribute "chunksize"
             size = self.chunksize  # type: ignore[attr-defined]
@@ -380,10 +385,16 @@ def _infer_columns(
                         line = self._next_line()
 
                 except StopIteration as err:
-                    if self.line_pos < hr:
+                    if 0 < self.line_pos <= hr and (
+                        not have_mi_columns or hr != header[-1]
+                    ):
+                        # If no rows we want to raise a different message and if
+                        # we have mi columns, the last line is not part of the header
+                        joi = list(map(str, header[:-1] if have_mi_columns else header))
+                        msg = f"[{','.join(joi)}], len of {len(joi)}, "
                         raise ValueError(
-                            f"Passed header={hr} but only {self.line_pos + 1} lines in "
-                            "file"
+                            f"Passed header={msg}"
+                            f"but only {self.line_pos} lines in file"
                         ) from err
 
                     # We have an empty file, so check
@@ -599,7 +610,7 @@ def _handle_usecols(
             self._col_indices = sorted(col_indices)
         return columns
 
-    def _buffered_line(self):
+    def _buffered_line(self) -> list[Scalar]:
         """
         Return a line from buffer, filling buffer if required.
         """
@@ -680,6 +691,8 @@ def _is_line_empty(self, line: list[Scalar]) -> bool:
     def _next_line(self) -> list[Scalar]:
         if isinstance(self.data, list):
             while self.skipfunc(self.pos):
+                if self.pos >= len(self.data):
+                    break
                 self.pos += 1
 
             while True:
@@ -889,7 +902,9 @@ def _clear_buffer(self) -> None:
 
     _implicit_index = False
 
-    def _get_index_name(self, columns: list[Hashable]):
+    def _get_index_name(
+        self, columns: list[Hashable]
+    ) -> tuple[Sequence[Hashable] | None, list[Hashable], list[Hashable]]:
         """
         Try several cases to get lines:
 
@@ -930,7 +945,11 @@ def _get_index_name(self, columns: list[Hashable]):
                 implicit_first_cols = len(line) - self.num_original_columns
 
             # Case 0
-            if next_line is not None:
+            if (
+                next_line is not None
+                and self.header is not None
+                and index_col is not False
+            ):
                 if len(next_line) == len(line) + self.num_original_columns:
                     # column and index names on diff rows
                     self.index_col = list(range(len(line)))
@@ -954,8 +973,8 @@ def _get_index_name(self, columns: list[Hashable]):
 
         else:
             # Case 2
-            (index_name, columns_, self.index_col) = self._clean_index_names(
-                columns, self.index_col, self.unnamed_cols
+            (index_name, _, self.index_col) = self._clean_index_names(
+                columns, self.index_col
             )
 
         return index_name, orig_names, columns
@@ -990,7 +1009,11 @@ def _rows_to_cols(self, content: list[list[Scalar]]) -> list[np.ndarray]:
                 actual_len = len(l)
 
                 if actual_len > col_len:
-                    if (
+                    if callable(self.on_bad_lines):
+                        new_l = self.on_bad_lines(l)
+                        if new_l is not None:
+                            content.append(new_l)
+                    elif (
                         self.on_bad_lines == self.BadLineHandleMethod.ERROR
                         or self.on_bad_lines == self.BadLineHandleMethod.WARN
                     ):
@@ -1043,7 +1066,7 @@ def _rows_to_cols(self, content: list[list[Scalar]]) -> list[np.ndarray]:
                 ]
         return zipped_content
 
-    def _get_lines(self, rows: int | None = None):
+    def _get_lines(self, rows: int | None = None) -> list[list[Scalar]]:
         lines = self.buf
         new_rows = None
 
@@ -1140,7 +1163,7 @@ class FixedWidthReader(abc.Iterator):
 
     def __init__(
         self,
-        f: IO[str],
+        f: IO[str] | ReadCsvBuffer[str],
         colspecs: list[tuple[int, int]] | Literal["infer"],
         delimiter: str | None,
         comment: str | None,
@@ -1218,7 +1241,7 @@ def detect_colspecs(
         self, infer_nrows: int = 100, skiprows: set[int] | None = None
     ) -> list[tuple[int, int]]:
         # Regex escape the delimiters
-        delimiters = "".join([fr"\{x}" for x in self.delimiter])
+        delimiters = "".join([rf"\{x}" for x in self.delimiter])
         pattern = re.compile(f"([^{delimiters}]+)")
         rows = self.get_rows(infer_nrows, skiprows)
         if not rows:
@@ -1237,14 +1260,16 @@ def detect_colspecs(
         return edge_pairs
 
     def __next__(self) -> list[str]:
+        # Argument 1 to "next" has incompatible type "Union[IO[str],
+        # ReadCsvBuffer[str]]"; expected "SupportsNext[str]"
         if self.buffer is not None:
             try:
                 line = next(self.buffer)
             except StopIteration:
                 self.buffer = None
-                line = next(self.f)
+                line = next(self.f)  # type: ignore[arg-type]
         else:
-            line = next(self.f)
+            line = next(self.f)  # type: ignore[arg-type]
         # Note: 'colspecs' is a sequence of half-open intervals.
         return [line[fromm:to].strip(self.delimiter) for (fromm, to) in self.colspecs]
 
@@ -1255,15 +1280,13 @@ class FixedWidthFieldParser(PythonParser):
     See PythonParser for details.
     """
 
-    def __init__(
-        self, f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], **kwds
-    ) -> None:
+    def __init__(self, f: ReadCsvBuffer[str], **kwds) -> None:
         # Support iterators, convert to a list.
         self.colspecs = kwds.pop("colspecs")
         self.infer_nrows = kwds.pop("infer_nrows")
         PythonParser.__init__(self, f, **kwds)
 
-    def _make_reader(self, f: IO[str]) -> None:
+    def _make_reader(self, f: IO[str] | ReadCsvBuffer[str]) -> None:
         self.data = FixedWidthReader(
             f,
             self.colspecs,
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 464a9b0b9f88e..356c357f2f967 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -8,8 +8,14 @@
 import sys
 from textwrap import fill
 from typing import (
+    IO,
     Any,
+    Callable,
+    Hashable,
+    Literal,
     NamedTuple,
+    Sequence,
+    overload,
 )
 import warnings
 
@@ -18,10 +24,11 @@
 import pandas._libs.lib as lib
 from pandas._libs.parsers import STR_NA_VALUES
 from pandas._typing import (
-    ArrayLike,
     CompressionOptions,
+    CSVEngine,
     DtypeArg,
     FilePath,
+    IndexLabel,
     ReadCsvBuffer,
     StorageOptions,
 )
@@ -31,6 +38,7 @@
 )
 from pandas.util._decorators import (
     Appender,
+    deprecate_kwarg,
     deprecate_nonkeyword_arguments,
 )
 from pandas.util._exceptions import find_stack_level
@@ -47,7 +55,12 @@
 from pandas.core.indexes.api import RangeIndex
 from pandas.core.shared_docs import _shared_docs
 
-from pandas.io.common import validate_header_arg
+from pandas.io.common import (
+    IOHandles,
+    get_handle,
+    stringify_path,
+    validate_header_arg,
+)
 from pandas.io.parsers.arrow_parser_wrapper import ArrowParserWrapper
 from pandas.io.parsers.base_parser import (
     ParserBase,
@@ -151,6 +164,10 @@
     Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than
     'X'...'X'. Passing in False will cause data to be overwritten if there
     are duplicate names in the columns.
+
+    .. deprecated:: 1.5.0
+        Not implemented, and a new argument to specify the pattern for the
+        names of duplicated columns will be added instead
 dtype : Type name or dict of column -> type, optional
     Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32,
     'c': 'Int64'}}
@@ -158,6 +175,12 @@
     to preserve and not interpret dtype.
     If converters are specified, they will be applied INSTEAD
     of dtype conversion.
+
+    .. versionadded:: 1.5.0
+
+        Support for defaultdict was added. Specify a defaultdict as input where
+        the default determines the dtype of the columns which are not explicitly
+        listed.
 engine : {{'c', 'python', 'pyarrow'}}, optional
     Parser engine to use. The C and pyarrow engines are faster, while the python engine
     is currently more feature-complete. Multithreading is currently only supported by
@@ -354,7 +377,7 @@
     .. deprecated:: 1.3.0
        The ``on_bad_lines`` parameter should be used instead to specify behavior upon
        encountering a bad line instead.
-on_bad_lines : {{'error', 'warn', 'skip'}}, default 'error'
+on_bad_lines : {{'error', 'warn', 'skip'}} or callable, default 'error'
     Specifies what to do upon encountering a bad line (a line with too many fields).
     Allowed values are :
 
@@ -364,6 +387,16 @@
 
     .. versionadded:: 1.3.0
 
+    .. versionadded:: 1.4.0
+
+        - callable, function with signature
+          ``(bad_line: list[str]) -> list[str] | None`` that will process a single
+          bad line. ``bad_line`` is a list of strings split by the ``sep``.
+          If the function returns ``None``, the bad line will be ignored.
+          If the function returns a new list of strings with more elements than
+          expected, a ``ParserWarning`` will be emitted while dropping extra elements.
+          Only supported when ``engine="python"``
+
 delim_whitespace : bool, default False
     Specifies whether or not whitespace (e.g. ``' '`` or ``'\t'``) will be
     used as the sep. Equivalent to setting ``sep='\\s+'``. If this option
@@ -466,7 +499,22 @@ class _DeprecationConfig(NamedTuple):
 }
 
 
-def validate_integer(name, val, min_val=0):
+@overload
+def validate_integer(name, val: None, min_val=...) -> None:
+    ...
+
+
+@overload
+def validate_integer(name, val: float, min_val=...) -> int:
+    ...
+
+
+@overload
+def validate_integer(name, val: int | None, min_val=...) -> int | None:
+    ...
+
+
+def validate_integer(name, val: int | float | None, min_val=0) -> int | None:
     """
     Checks whether the 'name' parameter for parsing is either
     an integer OR float that can SAFELY be cast to an integer
@@ -482,20 +530,21 @@ def validate_integer(name, val, min_val=0):
     min_val : int
         Minimum allowed value (val < min_val will result in a ValueError)
     """
-    msg = f"'{name:s}' must be an integer >={min_val:d}"
+    if val is None:
+        return val
 
-    if val is not None:
-        if is_float(val):
-            if int(val) != val:
-                raise ValueError(msg)
-            val = int(val)
-        elif not (is_integer(val) and val >= min_val):
+    msg = f"'{name:s}' must be an integer >={min_val:d}"
+    if is_float(val):
+        if int(val) != val:
             raise ValueError(msg)
+        val = int(val)
+    elif not (is_integer(val) and val >= min_val):
+        raise ValueError(msg)
 
-    return val
+    return int(val)
 
 
-def _validate_names(names):
+def _validate_names(names: Sequence[Hashable] | None) -> None:
     """
     Raise ValueError if the `names` parameter contains duplicates or has an
     invalid data type.
@@ -521,17 +570,15 @@ def _validate_names(names):
 
 def _read(
     filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], kwds
-):
+) -> DataFrame | TextFileReader:
     """Generic reader of line files."""
     # if we pass a date_parser and parse_dates=False, we should not parse the
     # dates GH#44366
-    if (
-        kwds.get("date_parser", None) is not None
-        and kwds.get("parse_dates", None) is None
-    ):
-        kwds["parse_dates"] = True
-    elif kwds.get("parse_dates", None) is None:
-        kwds["parse_dates"] = False
+    if kwds.get("parse_dates", None) is None:
+        if kwds.get("date_parser", None) is None:
+            kwds["parse_dates"] = False
+        else:
+            kwds["parse_dates"] = True
 
     # Extract some of the arguments (pass chunksize on).
     iterator = kwds.get("iterator", False)
@@ -547,7 +594,7 @@ def _read(
                 "The 'chunksize' option is not supported with the 'pyarrow' engine"
             )
     else:
-        chunksize = validate_integer("chunksize", kwds.get("chunksize", None), 1)
+        chunksize = validate_integer("chunksize", chunksize, 1)
 
     nrows = kwds.get("nrows", None)
 
@@ -564,82 +611,322 @@ def _read(
         return parser.read(nrows)
 
 
-@deprecate_nonkeyword_arguments(
-    version=None, allowed_args=["filepath_or_buffer"], stacklevel=3
-)
+# iterator=True -> TextFileReader
+@overload
+def read_csv(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: Literal[True],
+    chunksize: int | None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace: bool = ...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: Literal["high", "legacy"] | None = ...,
+    storage_options: StorageOptions = ...,
+) -> TextFileReader:
+    ...
+
+
+# chunksize=int -> TextFileReader
+@overload
+def read_csv(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: bool = ...,
+    chunksize: int,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace: bool = ...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: Literal["high", "legacy"] | None = ...,
+    storage_options: StorageOptions = ...,
+) -> TextFileReader:
+    ...
+
+
+# default case -> DataFrame
+@overload
+def read_csv(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: Literal[False] = ...,
+    chunksize: None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace: bool = ...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: Literal["high", "legacy"] | None = ...,
+    storage_options: StorageOptions = ...,
+) -> DataFrame:
+    ...
+
+
+# Unions -> DataFrame | TextFileReader
+@overload
+def read_csv(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: bool = ...,
+    chunksize: int | None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace: bool = ...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: Literal["high", "legacy"] | None = ...,
+    storage_options: StorageOptions = ...,
+) -> DataFrame | TextFileReader:
+    ...
+
+
+@deprecate_kwarg(old_arg_name="mangle_dupe_cols", new_arg_name=None)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["filepath_or_buffer"])
 @Appender(
     _doc_read_csv_and_table.format(
         func_name="read_csv",
         summary="Read a comma-separated values (csv) file into DataFrame.",
         _default_sep="','",
         storage_options=_shared_docs["storage_options"],
-        decompression_options=_shared_docs["decompression_options"],
+        decompression_options=_shared_docs["decompression_options"]
+        % "filepath_or_buffer",
     )
 )
 def read_csv(
     filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
-    sep=lib.no_default,
-    delimiter=None,
+    sep: str | None | lib.NoDefault = lib.no_default,
+    delimiter: str | None | lib.NoDefault = None,
     # Column and Index Locations and Names
-    header="infer",
-    names=lib.no_default,
-    index_col=None,
+    header: int | Sequence[int] | None | Literal["infer"] = "infer",
+    names: Sequence[Hashable] | None | lib.NoDefault = lib.no_default,
+    index_col: IndexLabel | Literal[False] | None = None,
     usecols=None,
-    squeeze=None,
-    prefix=lib.no_default,
-    mangle_dupe_cols=True,
+    squeeze: bool | None = None,
+    prefix: str | lib.NoDefault = lib.no_default,
+    mangle_dupe_cols: bool = True,
     # General Parsing Configuration
     dtype: DtypeArg | None = None,
-    engine=None,
+    engine: CSVEngine | None = None,
     converters=None,
     true_values=None,
     false_values=None,
-    skipinitialspace=False,
+    skipinitialspace: bool = False,
     skiprows=None,
-    skipfooter=0,
-    nrows=None,
+    skipfooter: int = 0,
+    nrows: int | None = None,
     # NA and Missing Data Handling
     na_values=None,
-    keep_default_na=True,
-    na_filter=True,
-    verbose=False,
-    skip_blank_lines=True,
+    keep_default_na: bool = True,
+    na_filter: bool = True,
+    verbose: bool = False,
+    skip_blank_lines: bool = True,
     # Datetime Handling
     parse_dates=None,
-    infer_datetime_format=False,
-    keep_date_col=False,
+    infer_datetime_format: bool = False,
+    keep_date_col: bool = False,
     date_parser=None,
-    dayfirst=False,
-    cache_dates=True,
+    dayfirst: bool = False,
+    cache_dates: bool = True,
     # Iteration
-    iterator=False,
-    chunksize=None,
+    iterator: bool = False,
+    chunksize: int | None = None,
     # Quoting, Compression, and File Format
     compression: CompressionOptions = "infer",
-    thousands=None,
+    thousands: str | None = None,
     decimal: str = ".",
-    lineterminator=None,
-    quotechar='"',
-    quoting=csv.QUOTE_MINIMAL,
-    doublequote=True,
-    escapechar=None,
-    comment=None,
-    encoding=None,
+    lineterminator: str | None = None,
+    quotechar: str = '"',
+    quoting: int = csv.QUOTE_MINIMAL,
+    doublequote: bool = True,
+    escapechar: str | None = None,
+    comment: str | None = None,
+    encoding: str | None = None,
     encoding_errors: str | None = "strict",
-    dialect=None,
+    dialect: str | csv.Dialect | None = None,
     # Error Handling
-    error_bad_lines=None,
-    warn_bad_lines=None,
+    error_bad_lines: bool | None = None,
+    warn_bad_lines: bool | None = None,
     # TODO(2.0): set on_bad_lines to "error".
     # See _refine_defaults_read comment for why we do this.
     on_bad_lines=None,
     # Internal
-    delim_whitespace=False,
+    delim_whitespace: bool = False,
     low_memory=_c_parser_defaults["low_memory"],
-    memory_map=False,
-    float_precision=None,
+    memory_map: bool = False,
+    float_precision: Literal["high", "legacy"] | None = None,
     storage_options: StorageOptions = None,
-):
+) -> DataFrame | TextFileReader:
     # locals() should never be modified
     kwds = locals().copy()
     del kwds["filepath_or_buffer"]
@@ -663,82 +950,322 @@ def read_csv(
     return _read(filepath_or_buffer, kwds)
 
 
-@deprecate_nonkeyword_arguments(
-    version=None, allowed_args=["filepath_or_buffer"], stacklevel=3
-)
+# iterator=True -> TextFileReader
+@overload
+def read_table(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: Literal[True],
+    chunksize: int | None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace=...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: str | None = ...,
+    storage_options: StorageOptions = ...,
+) -> TextFileReader:
+    ...
+
+
+# chunksize=int -> TextFileReader
+@overload
+def read_table(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: bool = ...,
+    chunksize: int,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace=...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: str | None = ...,
+    storage_options: StorageOptions = ...,
+) -> TextFileReader:
+    ...
+
+
+# default -> DataFrame
+@overload
+def read_table(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: Literal[False] = ...,
+    chunksize: None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace=...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: str | None = ...,
+    storage_options: StorageOptions = ...,
+) -> DataFrame:
+    ...
+
+
+# Unions -> DataFrame | TextFileReader
+@overload
+def read_table(
+    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
+    *,
+    sep: str | None | lib.NoDefault = ...,
+    delimiter: str | None | lib.NoDefault = ...,
+    header: int | Sequence[int] | None | Literal["infer"] = ...,
+    names: Sequence[Hashable] | None | lib.NoDefault = ...,
+    index_col: IndexLabel | Literal[False] | None = ...,
+    usecols=...,
+    squeeze: bool | None = ...,
+    prefix: str | lib.NoDefault = ...,
+    mangle_dupe_cols: bool = ...,
+    dtype: DtypeArg | None = ...,
+    engine: CSVEngine | None = ...,
+    converters=...,
+    true_values=...,
+    false_values=...,
+    skipinitialspace: bool = ...,
+    skiprows=...,
+    skipfooter: int = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    skip_blank_lines: bool = ...,
+    parse_dates=...,
+    infer_datetime_format: bool = ...,
+    keep_date_col: bool = ...,
+    date_parser=...,
+    dayfirst: bool = ...,
+    cache_dates: bool = ...,
+    iterator: bool = ...,
+    chunksize: int | None = ...,
+    compression: CompressionOptions = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    lineterminator: str | None = ...,
+    quotechar: str = ...,
+    quoting: int = ...,
+    doublequote: bool = ...,
+    escapechar: str | None = ...,
+    comment: str | None = ...,
+    encoding: str | None = ...,
+    encoding_errors: str | None = ...,
+    dialect: str | csv.Dialect | None = ...,
+    error_bad_lines: bool | None = ...,
+    warn_bad_lines: bool | None = ...,
+    on_bad_lines=...,
+    delim_whitespace=...,
+    low_memory=...,
+    memory_map: bool = ...,
+    float_precision: str | None = ...,
+    storage_options: StorageOptions = ...,
+) -> DataFrame | TextFileReader:
+    ...
+
+
+@deprecate_kwarg(old_arg_name="mangle_dupe_cols", new_arg_name=None)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["filepath_or_buffer"])
 @Appender(
     _doc_read_csv_and_table.format(
         func_name="read_table",
         summary="Read general delimited file into DataFrame.",
         _default_sep=r"'\\t' (tab-stop)",
         storage_options=_shared_docs["storage_options"],
-        decompression_options=_shared_docs["decompression_options"],
+        decompression_options=_shared_docs["decompression_options"]
+        % "filepath_or_buffer",
     )
 )
 def read_table(
     filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
-    sep=lib.no_default,
-    delimiter=None,
+    sep: str | None | lib.NoDefault = lib.no_default,
+    delimiter: str | None | lib.NoDefault = None,
     # Column and Index Locations and Names
-    header="infer",
-    names=lib.no_default,
-    index_col=None,
+    header: int | Sequence[int] | None | Literal["infer"] = "infer",
+    names: Sequence[Hashable] | None | lib.NoDefault = lib.no_default,
+    index_col: IndexLabel | Literal[False] | None = None,
     usecols=None,
-    squeeze=None,
-    prefix=lib.no_default,
-    mangle_dupe_cols=True,
+    squeeze: bool | None = None,
+    prefix: str | lib.NoDefault = lib.no_default,
+    mangle_dupe_cols: bool = True,
     # General Parsing Configuration
     dtype: DtypeArg | None = None,
-    engine=None,
+    engine: CSVEngine | None = None,
     converters=None,
     true_values=None,
     false_values=None,
-    skipinitialspace=False,
+    skipinitialspace: bool = False,
     skiprows=None,
-    skipfooter=0,
-    nrows=None,
+    skipfooter: int = 0,
+    nrows: int | None = None,
     # NA and Missing Data Handling
     na_values=None,
-    keep_default_na=True,
-    na_filter=True,
-    verbose=False,
-    skip_blank_lines=True,
+    keep_default_na: bool = True,
+    na_filter: bool = True,
+    verbose: bool = False,
+    skip_blank_lines: bool = True,
     # Datetime Handling
     parse_dates=False,
-    infer_datetime_format=False,
-    keep_date_col=False,
+    infer_datetime_format: bool = False,
+    keep_date_col: bool = False,
     date_parser=None,
-    dayfirst=False,
-    cache_dates=True,
+    dayfirst: bool = False,
+    cache_dates: bool = True,
     # Iteration
-    iterator=False,
-    chunksize=None,
+    iterator: bool = False,
+    chunksize: int | None = None,
     # Quoting, Compression, and File Format
     compression: CompressionOptions = "infer",
-    thousands=None,
+    thousands: str | None = None,
     decimal: str = ".",
-    lineterminator=None,
-    quotechar='"',
-    quoting=csv.QUOTE_MINIMAL,
-    doublequote=True,
-    escapechar=None,
-    comment=None,
-    encoding=None,
+    lineterminator: str | None = None,
+    quotechar: str = '"',
+    quoting: int = csv.QUOTE_MINIMAL,
+    doublequote: bool = True,
+    escapechar: str | None = None,
+    comment: str | None = None,
+    encoding: str | None = None,
     encoding_errors: str | None = "strict",
-    dialect=None,
+    dialect: str | csv.Dialect | None = None,
     # Error Handling
-    error_bad_lines=None,
-    warn_bad_lines=None,
+    error_bad_lines: bool | None = None,
+    warn_bad_lines: bool | None = None,
     # TODO(2.0): set on_bad_lines to "error".
     # See _refine_defaults_read comment for why we do this.
     on_bad_lines=None,
     # Internal
     delim_whitespace=False,
     low_memory=_c_parser_defaults["low_memory"],
-    memory_map=False,
-    float_precision=None,
+    memory_map: bool = False,
+    float_precision: str | None = None,
     storage_options: StorageOptions = None,
-):
+) -> DataFrame | TextFileReader:
     # locals() should never be modified
     kwds = locals().copy()
     del kwds["filepath_or_buffer"]
@@ -762,13 +1289,11 @@ def read_table(
     return _read(filepath_or_buffer, kwds)
 
 
-@deprecate_nonkeyword_arguments(
-    version=None, allowed_args=["filepath_or_buffer"], stacklevel=2
-)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["filepath_or_buffer"])
 def read_fwf(
     filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
-    colspecs: list[tuple[int, int]] | str | None = "infer",
-    widths: list[int] | None = None,
+    colspecs: Sequence[tuple[int, int]] | str | None = "infer",
+    widths: Sequence[int] | None = None,
     infer_nrows: int = 100,
     **kwds,
 ) -> DataFrame | TextFileReader:
@@ -839,7 +1364,7 @@ def read_fwf(
     # Ensure length of `colspecs` matches length of `names`
     names = kwds.get("names")
     if names is not None:
-        if len(names) != len(colspecs):
+        if len(names) != len(colspecs) and colspecs != "infer":
             # need to check len(index_col) as it might contain
             # unnamed indices, in which case it's name is not required
             len_index = 0
@@ -850,7 +1375,8 @@ def read_fwf(
                         len_index = 1
                     else:
                         len_index = len(index_col)
-            if len(names) + len_index != len(colspecs):
+            if kwds.get("usecols") is None and len(names) + len_index != len(colspecs):
+                # If usecols is used colspec may be longer than names
                 raise ValueError("Length of colspecs must match length of names")
 
     kwds["colspecs"] = colspecs
@@ -866,10 +1392,12 @@ class TextFileReader(abc.Iterator):
 
     """
 
-    def __init__(self, f, engine=None, **kwds):
-
-        self.f = f
-
+    def __init__(
+        self,
+        f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list,
+        engine: CSVEngine | None = None,
+        **kwds,
+    ) -> None:
         if engine is not None:
             engine_specified = True
         else:
@@ -910,12 +1438,15 @@ def __init__(self, f, engine=None, **kwds):
         if "has_index_names" in kwds:
             self.options["has_index_names"] = kwds["has_index_names"]
 
-        self._engine = self._make_engine(self.engine)
+        self.handles: IOHandles | None = None
+        self._engine = self._make_engine(f, self.engine)
 
-    def close(self):
+    def close(self) -> None:
+        if self.handles is not None:
+            self.handles.close()
         self._engine.close()
 
-    def _get_options_with_defaults(self, engine):
+    def _get_options_with_defaults(self, engine: CSVEngine) -> dict[str, Any]:
         kwds = self.orig_options
 
         options = {}
@@ -982,7 +1513,7 @@ def _get_options_with_defaults(self, engine):
 
         return options
 
-    def _check_file_or_buffer(self, f, engine):
+    def _check_file_or_buffer(self, f, engine: CSVEngine) -> None:
         # see gh-16530
         if is_file_like(f) and engine != "c" and not hasattr(f, "__iter__"):
             # The C engine doesn't need the file-like to have the "__iter__"
@@ -993,7 +1524,9 @@ def _check_file_or_buffer(self, f, engine):
                 "The 'python' engine cannot iterate through this file buffer."
             )
 
-    def _clean_options(self, options, engine):
+    def _clean_options(
+        self, options: dict[str, Any], engine: CSVEngine
+    ) -> tuple[dict[str, Any], CSVEngine]:
         result = options.copy()
 
         fallback_reason = None
@@ -1160,14 +1693,18 @@ def _clean_options(self, options, engine):
 
         return result, engine
 
-    def __next__(self):
+    def __next__(self) -> DataFrame:
         try:
             return self.get_chunk()
         except StopIteration:
             self.close()
             raise
 
-    def _make_engine(self, engine="c"):
+    def _make_engine(
+        self,
+        f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list | IO,
+        engine: CSVEngine = "c",
+    ) -> ParserBase:
         mapping: dict[str, type[ParserBase]] = {
             "c": CParserWrapper,
             "python": PythonParser,
@@ -1178,17 +1715,72 @@ def _make_engine(self, engine="c"):
             raise ValueError(
                 f"Unknown engine: {engine} (valid options are {mapping.keys()})"
             )
-        return mapping[engine](self.f, **self.options)
+        if not isinstance(f, list):
+            # open file here
+            is_text = True
+            mode = "r"
+            if engine == "pyarrow":
+                is_text = False
+                mode = "rb"
+            elif (
+                engine == "c"
+                and self.options.get("encoding", "utf-8") == "utf-8"
+                and isinstance(stringify_path(f), str)
+            ):
+                # c engine can decode utf-8 bytes, adding TextIOWrapper makes
+                # the c-engine especially for memory_map=True far slower
+                is_text = False
+                if "b" not in mode:
+                    mode += "b"
+            self.handles = get_handle(
+                f,
+                mode,
+                encoding=self.options.get("encoding", None),
+                compression=self.options.get("compression", None),
+                memory_map=self.options.get("memory_map", False),
+                is_text=is_text,
+                errors=self.options.get("encoding_errors", "strict"),
+                storage_options=self.options.get("storage_options", None),
+            )
+            assert self.handles is not None
+            f = self.handles.handle
+
+        elif engine != "python":
+            msg = f"Invalid file path or buffer object type: {type(f)}"
+            raise ValueError(msg)
+
+        try:
+            return mapping[engine](f, **self.options)
+        except Exception:
+            if self.handles is not None:
+                self.handles.close()
+            raise
 
-    def _failover_to_python(self):
+    def _failover_to_python(self) -> None:
         raise AbstractMethodError(self)
 
-    def read(self, nrows=None):
+    def read(self, nrows: int | None = None) -> DataFrame:
         if self.engine == "pyarrow":
-            df = self._engine.read()
+            try:
+                # error: "ParserBase" has no attribute "read"
+                df = self._engine.read()  # type: ignore[attr-defined]
+            except Exception:
+                self.close()
+                raise
         else:
             nrows = validate_integer("nrows", nrows)
-            index, columns, col_dict = self._engine.read(nrows)
+            try:
+                # error: "ParserBase" has no attribute "read"
+                (
+                    index,
+                    columns,
+                    col_dict,
+                ) = self._engine.read(  # type: ignore[attr-defined]
+                    nrows
+                )
+            except Exception:
+                self.close()
+                raise
 
             if index is None:
                 if col_dict:
@@ -1208,7 +1800,7 @@ def read(self, nrows=None):
             return df.squeeze("columns").copy()
         return df
 
-    def get_chunk(self, size=None):
+    def get_chunk(self, size: int | None = None) -> DataFrame:
         if size is None:
             size = self.chunksize
         if self.nrows is not None:
@@ -1217,14 +1809,14 @@ def get_chunk(self, size=None):
             size = min(size, self.nrows - self._currow)
         return self.read(nrows=size)
 
-    def __enter__(self):
+    def __enter__(self) -> TextFileReader:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
 
-def TextParser(*args, **kwds):
+def TextParser(*args, **kwds) -> TextFileReader:
     """
     Converts lists of lists/tuples into DataFrames with proper type inference
     and optional (e.g. string to datetime) conversion. Also enables iterating
@@ -1336,7 +1928,7 @@ def _floatify_na_values(na_values):
 
 def _stringify_na_values(na_values):
     """return a stringified and numeric for these values"""
-    result: list[int | str | float] = []
+    result: list[str | float] = []
     for x in na_values:
         result.append(str(x))
         result.append(x)
@@ -1360,16 +1952,16 @@ def _stringify_na_values(na_values):
 
 
 def _refine_defaults_read(
-    dialect: str | csv.Dialect,
-    delimiter: str | object,
+    dialect: str | csv.Dialect | None,
+    delimiter: str | None | lib.NoDefault,
     delim_whitespace: bool,
-    engine: str,
-    sep: str | object,
+    engine: CSVEngine | None,
+    sep: str | None | lib.NoDefault,
     error_bad_lines: bool | None,
     warn_bad_lines: bool | None,
-    on_bad_lines: str | None,
-    names: ArrayLike | None | object,
-    prefix: str | None | object,
+    on_bad_lines: str | Callable | None,
+    names: Sequence[Hashable] | None | lib.NoDefault,
+    prefix: str | None | lib.NoDefault,
     defaults: dict[str, Any],
 ):
     """Validate/refine default values of input parameters of read_csv, read_table.
@@ -1399,7 +1991,7 @@ def _refine_defaults_read(
         Whether to error on a bad line or not.
     warn_bad_lines : str or None
         Whether to warn on a bad line or not.
-    on_bad_lines : str or None
+    on_bad_lines : str, callable or None
         An option for handling bad lines or a sentinel value(None).
     names : array-like, optional
         List of column names to use. If the file contains a header row,
@@ -1503,6 +2095,12 @@ def _refine_defaults_read(
             kwds["on_bad_lines"] = ParserBase.BadLineHandleMethod.WARN
         elif on_bad_lines == "skip":
             kwds["on_bad_lines"] = ParserBase.BadLineHandleMethod.SKIP
+        elif callable(on_bad_lines):
+            if engine != "python":
+                raise ValueError(
+                    "on_bad_line can only be a callable function if engine='python'"
+                )
+            kwds["on_bad_lines"] = on_bad_lines
         else:
             raise ValueError(f"Argument {on_bad_lines} is invalid for on_bad_lines")
     else:
diff --git a/pandas/io/pickle.py b/pandas/io/pickle.py
index 2928d8c6520b0..373d608876c3e 100644
--- a/pandas/io/pickle.py
+++ b/pandas/io/pickle.py
@@ -160,11 +160,14 @@ def read_pickle(
 
     Notes
     -----
-    read_pickle is only guaranteed to be backwards compatible to pandas 0.20.3.
+    read_pickle is only guaranteed to be backwards compatible to pandas 0.20.3
+    provided the object was serialized with to_pickle.
 
     Examples
     --------
-    >>> original_df = pd.DataFrame({{"foo": range(5), "bar": range(5, 10)}})  # doctest: +SKIP
+    >>> original_df = pd.DataFrame(
+    ...     {{"foo": range(5), "bar": range(5, 10)}}
+    ...    )  # doctest: +SKIP
     >>> original_df  # doctest: +SKIP
        foo  bar
     0    0    5
@@ -182,7 +185,7 @@ def read_pickle(
     2    2    7
     3    3    8
     4    4    9
-    """  # noqa: E501
+    """
     excs_to_catch = (AttributeError, ImportError, ModuleNotFoundError, TypeError)
     with get_handle(
         filepath_or_buffer,
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 3ce5cb31a127a..6b0cfc51dbdd4 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -18,10 +18,13 @@
     TYPE_CHECKING,
     Any,
     Callable,
+    Final,
     Hashable,
+    Iterator,
     Literal,
     Sequence,
     cast,
+    overload,
 )
 import warnings
 
@@ -38,18 +41,28 @@
 )
 from pandas._libs.tslibs import timezones
 from pandas._typing import (
+    AnyArrayLike,
     ArrayLike,
     DtypeArg,
+    FilePath,
     Shape,
+    npt,
 )
 from pandas.compat._optional import import_optional_dependency
 from pandas.compat.pickle_compat import patch_pickle
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    AttributeConflictWarning,
+    ClosedFileError,
+    IncompatibilityWarning,
+    PerformanceWarning,
+    PossibleDataLossError,
+)
 from pandas.util._decorators import cache_readonly
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     ensure_object,
+    is_bool_dtype,
     is_categorical_dtype,
     is_complex_dtype,
     is_datetime64_dtype,
@@ -165,44 +178,18 @@ def _ensure_term(where, scope_level: int):
     return where if where is None or len(where) else None
 
 
-class PossibleDataLossError(Exception):
-    pass
-
-
-class ClosedFileError(Exception):
-    pass
-
-
-class IncompatibilityWarning(Warning):
-    pass
-
-
-incompatibility_doc = """
+incompatibility_doc: Final = """
 where criteria is being ignored as this version [%s] is too old (or
 not-defined), read the file in and write it out to a new file to upgrade (with
 the copy_to method)
 """
 
-
-class AttributeConflictWarning(Warning):
-    pass
-
-
-attribute_conflict_doc = """
+attribute_conflict_doc: Final = """
 the [%s] attribute of the existing index is [%s] which conflicts with the new
 [%s], resetting the attribute to None
 """
 
-
-class DuplicateWarning(Warning):
-    pass
-
-
-duplicate_doc = """
-duplicate entries in table, taking most recently appended
-"""
-
-performance_doc = """
+performance_doc: Final = """
 your performance may suffer as PyTables will pickle object types that it cannot
 map directly to c-types [inferred_type->%s,key->%s] [items->%s]
 """
@@ -214,11 +201,11 @@ class DuplicateWarning(Warning):
 _AXES_MAP = {DataFrame: [0]}
 
 # register our configuration options
-dropna_doc = """
+dropna_doc: Final = """
 : boolean
     drop ALL nan rows when appending to a table
 """
-format_doc = """
+format_doc: Final = """
 : format
     default format writing format, if None, then
     put will default to 'fixed' and append will default to 'table'
@@ -261,7 +248,7 @@ def _tables():
 
 
 def to_hdf(
-    path_or_buf,
+    path_or_buf: FilePath | HDFStore,
     key: str,
     value: DataFrame | Series,
     mode: str = "a",
@@ -317,15 +304,15 @@ def to_hdf(
 
 
 def read_hdf(
-    path_or_buf,
+    path_or_buf: FilePath | HDFStore,
     key=None,
     mode: str = "r",
     errors: str = "strict",
-    where=None,
+    where: str | list | None = None,
     start: int | None = None,
     stop: int | None = None,
-    columns=None,
-    iterator=False,
+    columns: list[str] | None = None,
+    iterator: bool = False,
     chunksize: int | None = None,
     **kwargs,
 ):
@@ -564,7 +551,7 @@ def __init__(
         complib=None,
         fletcher32: bool = False,
         **kwargs,
-    ):
+    ) -> None:
 
         if "format" in kwargs:
             raise ValueError("format is not a defined argument for HDFStore")
@@ -590,7 +577,7 @@ def __init__(
         self._filters = None
         self.open(mode=mode, **kwargs)
 
-    def __fspath__(self):
+    def __fspath__(self) -> str:
         return self._path
 
     @property
@@ -601,16 +588,16 @@ def root(self):
         return self._handle.root
 
     @property
-    def filename(self):
+    def filename(self) -> str:
         return self._path
 
     def __getitem__(self, key: str):
         return self.get(key)
 
-    def __setitem__(self, key: str, value):
+    def __setitem__(self, key: str, value) -> None:
         self.put(key, value)
 
-    def __delitem__(self, key: str):
+    def __delitem__(self, key: str) -> None:
         return self.remove(key)
 
     def __getattr__(self, name: str):
@@ -642,10 +629,10 @@ def __repr__(self) -> str:
         pstr = pprint_thing(self._path)
         return f"{type(self)}\nFile path: {pstr}\n"
 
-    def __enter__(self):
+    def __enter__(self) -> HDFStore:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
     def keys(self, include: str = "pandas") -> list[str]:
@@ -682,19 +669,29 @@ def keys(self, include: str = "pandas") -> list[str]:
             f"`include` should be either 'pandas' or 'native' but is '{include}'"
         )
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return iter(self.keys())
 
-    def items(self):
+    def items(self) -> Iterator[tuple[str, list]]:
         """
         iterate on key->group
         """
         for g in self.groups():
             yield g._v_pathname, g
 
-    iteritems = items
+    def iteritems(self):
+        """
+        iterate on key->group
+        """
+        warnings.warn(
+            "iteritems is deprecated and will be removed in a future version. "
+            "Use .items instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        yield from self.items()
 
-    def open(self, mode: str = "a", **kwargs):
+    def open(self, mode: str = "a", **kwargs) -> None:
         """
         Open the file in the specified mode
 
@@ -739,7 +736,7 @@ def open(self, mode: str = "a", **kwargs):
 
         self._handle = tables.open_file(self._path, self._mode, **kwargs)
 
-    def close(self):
+    def close(self) -> None:
         """
         Close the PyTables file handle
         """
@@ -756,7 +753,7 @@ def is_open(self) -> bool:
             return False
         return bool(self._handle.isopen)
 
-    def flush(self, fsync: bool = False):
+    def flush(self, fsync: bool = False) -> None:
         """
         Force all buffered modifications to be written to disk.
 
@@ -1084,7 +1081,7 @@ def put(
         errors: str = "strict",
         track_times: bool = True,
         dropna: bool = False,
-    ):
+    ) -> None:
         """
         Store object in HDFStore.
 
@@ -1101,6 +1098,8 @@ def put(
                 Table format.  Write as a PyTables Table structure which may perform
                 worse but allow more flexible operations like searching / selecting
                 subsets of the data.
+        index : bool, default True
+            Write DataFrame index as a column.
         append : bool, default False
             This will force Table format, append the input data to the existing.
         data_columns : list of columns or True, default None
@@ -1113,6 +1112,8 @@ def put(
             Parameter is propagated to 'create_table' method of 'PyTables'.
             If set to False it enables to have the same h5 files (same hashes)
             independent on creation time.
+        dropna : bool, default False, optional
+            Remove missing values.
 
             .. versionadded:: 1.1.0
         """
@@ -1136,7 +1137,7 @@ def put(
             dropna=dropna,
         )
 
-    def remove(self, key: str, where=None, start=None, stop=None):
+    def remove(self, key: str, where=None, start=None, stop=None) -> None:
         """
         Remove pandas object partially by specifying the where condition
 
@@ -1212,10 +1213,11 @@ def append(
         data_columns: Literal[True] | list[str] | None = None,
         encoding=None,
         errors: str = "strict",
-    ):
+    ) -> None:
         """
-        Append to Table in file. Node must already exist and be Table
-        format.
+        Append to Table in file.
+
+        Node must already exist and be Table format.
 
         Parameters
         ----------
@@ -1228,6 +1230,8 @@ def append(
                 Table format. Write as a PyTables Table structure which may perform
                 worse but allow more flexible operations like searching / selecting
                 subsets of the data.
+        index : bool, default True
+            Write DataFrame index as a column.
         append       : bool, default True
             Append the input data to the existing.
         data_columns : list of columns, or True, default None
@@ -1240,7 +1244,7 @@ def append(
         chunksize    : size to chunk the writing
         expectedrows : expected TOTAL row size of this table
         encoding     : default None, provide an encoding for str
-        dropna : bool, default False
+        dropna : bool, default False, optional
             Do not write an ALL nan row to the store settable
             by the option 'io.hdf.dropna_table'.
 
@@ -1287,7 +1291,7 @@ def append_to_multiple(
         axes=None,
         dropna=False,
         **kwargs,
-    ):
+    ) -> None:
         """
         Append to multiple tables
 
@@ -1381,7 +1385,7 @@ def create_table_index(
         columns=None,
         optlevel: int | None = None,
         kind: str | None = None,
-    ):
+    ) -> None:
         """
         Create a pytables index on the table.
 
@@ -1415,7 +1419,7 @@ def create_table_index(
             raise TypeError("cannot create table index on a Fixed format store")
         s.create_index(columns=columns, optlevel=optlevel, kind=kind)
 
-    def groups(self):
+    def groups(self) -> list:
         """
         Return a list of all the top-level nodes.
 
@@ -1443,7 +1447,7 @@ def groups(self):
             )
         ]
 
-    def walk(self, where="/"):
+    def walk(self, where: str = "/") -> Iterator[tuple[str, list[str], list[str]]]:
         """
         Walk the pytables group hierarchy for pandas objects.
 
@@ -1527,7 +1531,7 @@ def copy(
         complevel: int | None = None,
         fletcher32: bool = False,
         overwrite=True,
-    ):
+    ) -> HDFStore:
         """
         Copy the existing store to a new file, updating in place.
 
@@ -1869,7 +1873,7 @@ def __init__(
         iterator: bool = False,
         chunksize: int | None = None,
         auto_close: bool = False,
-    ):
+    ) -> None:
         self.store = store
         self.s = s
         self.func = func
@@ -1915,7 +1919,7 @@ def __iter__(self):
 
         self.close()
 
-    def close(self):
+    def close(self) -> None:
         if self.auto_close:
             self.store.close()
 
@@ -1959,8 +1963,8 @@ class IndexCol:
 
     """
 
-    is_an_indexable = True
-    is_data_indexable = True
+    is_an_indexable: bool = True
+    is_data_indexable: bool = True
     _info_fields = ["freq", "tz", "index_name"]
 
     name: str
@@ -1982,7 +1986,7 @@ def __init__(
         table=None,
         meta=None,
         metadata=None,
-    ):
+    ) -> None:
 
         if not isinstance(name, str):
             raise ValueError("`name` must be a str.")
@@ -2019,7 +2023,7 @@ def itemsize(self) -> int:
     def kind_attr(self) -> str:
         return f"{self.name}_kind"
 
-    def set_pos(self, pos: int):
+    def set_pos(self, pos: int) -> None:
         """set the position of this column in the Table"""
         self.pos = pos
         if pos is not None and self.typ is not None:
@@ -2030,10 +2034,10 @@ def __repr__(self) -> str:
             map(pprint_thing, (self.name, self.cname, self.axis, self.pos, self.kind))
         )
         return ",".join(
-            (
+            [
                 f"{key}->{value}"
                 for key, value in zip(["name", "cname", "axis", "pos", "kind"], temp)
-            )
+            ]
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -2054,7 +2058,9 @@ def is_indexed(self) -> bool:
             return False
         return getattr(self.table.cols, self.cname).is_indexed
 
-    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
+    def convert(
+        self, values: np.ndarray, nan_rep, encoding: str, errors: str
+    ) -> tuple[np.ndarray, np.ndarray] | tuple[DatetimeIndex, DatetimeIndex]:
         """
         Convert the data from this selection to the appropriate pandas type.
         """
@@ -2122,7 +2128,7 @@ def cvalues(self):
     def __iter__(self):
         return iter(self.values)
 
-    def maybe_set_size(self, min_itemsize=None):
+    def maybe_set_size(self, min_itemsize=None) -> None:
         """
         maybe set a string col itemsize:
             min_itemsize can be an integer or a dict with this columns name
@@ -2135,10 +2141,10 @@ def maybe_set_size(self, min_itemsize=None):
             if min_itemsize is not None and self.typ.itemsize < min_itemsize:
                 self.typ = _tables().StringCol(itemsize=min_itemsize, pos=self.pos)
 
-    def validate_names(self):
+    def validate_names(self) -> None:
         pass
 
-    def validate_and_set(self, handler: AppendableTable, append: bool):
+    def validate_and_set(self, handler: AppendableTable, append: bool) -> None:
         self.table = handler.table
         self.validate_col()
         self.validate_attr(append)
@@ -2165,7 +2171,7 @@ def validate_col(self, itemsize=None):
 
         return None
 
-    def validate_attr(self, append: bool):
+    def validate_attr(self, append: bool) -> None:
         # check for backwards incompatibility
         if append:
             existing_kind = getattr(self.attrs, self.kind_attr, None)
@@ -2174,7 +2180,7 @@ def validate_attr(self, append: bool):
                     f"incompatible kind in col [{existing_kind} - {self.kind}]"
                 )
 
-    def update_info(self, info):
+    def update_info(self, info) -> None:
         """
         set/update the info for this indexable with the key/value
         if there is a conflict raise/warn as needed
@@ -2207,17 +2213,17 @@ def update_info(self, info):
                 if value is not None or existing_value is not None:
                     idx[key] = value
 
-    def set_info(self, info):
+    def set_info(self, info) -> None:
         """set my state from the passed info"""
         idx = info.get(self.name)
         if idx is not None:
             self.__dict__.update(idx)
 
-    def set_attr(self):
+    def set_attr(self) -> None:
         """set the kind for this column"""
         setattr(self.attrs, self.kind_attr, self.kind)
 
-    def validate_metadata(self, handler: AppendableTable):
+    def validate_metadata(self, handler: AppendableTable) -> None:
         """validate that kind=category does not change the categories"""
         if self.meta == "category":
             new_metadata = self.metadata
@@ -2232,7 +2238,7 @@ def validate_metadata(self, handler: AppendableTable):
                     "different categories to the existing"
                 )
 
-    def write_metadata(self, handler: AppendableTable):
+    def write_metadata(self, handler: AppendableTable) -> None:
         """set the meta data"""
         if self.metadata is not None:
             handler.write_metadata(self.cname, self.metadata)
@@ -2245,7 +2251,13 @@ class GenericIndexCol(IndexCol):
     def is_indexed(self) -> bool:
         return False
 
-    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
+    # error: Return type "Tuple[Int64Index, Int64Index]" of "convert"
+    # incompatible with return type "Union[Tuple[ndarray[Any, Any],
+    # ndarray[Any, Any]], Tuple[DatetimeIndex, DatetimeIndex]]" in
+    # supertype "IndexCol"
+    def convert(  # type: ignore[override]
+        self, values: np.ndarray, nan_rep, encoding: str, errors: str
+    ) -> tuple[Int64Index, Int64Index]:
         """
         Convert the data from this selection to the appropriate pandas type.
 
@@ -2258,12 +2270,10 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
         """
         assert isinstance(values, np.ndarray), type(values)
 
-        # error: Incompatible types in assignment (expression has type
-        # "Int64Index", variable has type "ndarray")
-        values = Int64Index(np.arange(len(values)))  # type: ignore[assignment]
-        return values, values
+        index = Int64Index(np.arange(len(values)))
+        return index, index
 
-    def set_attr(self):
+    def set_attr(self) -> None:
         pass
 
 
@@ -2299,7 +2309,7 @@ def __init__(
         metadata=None,
         dtype: DtypeArg | None = None,
         data=None,
-    ):
+    ) -> None:
         super().__init__(
             name=name,
             values=values,
@@ -2331,10 +2341,10 @@ def __repr__(self) -> str:
             )
         )
         return ",".join(
-            (
+            [
                 f"{key}->{value}"
                 for key, value in zip(["name", "cname", "dtype", "kind", "shape"], temp)
-            )
+            ]
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -2344,7 +2354,7 @@ def __eq__(self, other: Any) -> bool:
             for a in ["name", "cname", "dtype", "pos"]
         )
 
-    def set_data(self, data: ArrayLike):
+    def set_data(self, data: ArrayLike) -> None:
         assert data is not None
         assert self.dtype is None
 
@@ -2430,7 +2440,7 @@ def cvalues(self):
         """return my cython values"""
         return self.data
 
-    def validate_attr(self, append):
+    def validate_attr(self, append) -> None:
         """validate that we have the same order as the existing & same dtype"""
         if append:
             existing_fields = getattr(self.attrs, self.kind_attr, None)
@@ -2544,7 +2554,7 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
 
         return self.values, converted
 
-    def set_attr(self):
+    def set_attr(self) -> None:
         """set the data for this column"""
         setattr(self.attrs, self.kind_attr, self.values)
         setattr(self.attrs, self.meta_attr, self.meta)
@@ -2557,7 +2567,7 @@ class DataIndexableCol(DataCol):
 
     is_data_indexable = True
 
-    def validate_names(self):
+    def validate_names(self) -> None:
         if not Index(self.values).is_object():
             # TODO: should the message here be more specifically non-str?
             raise ValueError("cannot have non-object label DataIndexableCol")
@@ -2606,7 +2616,7 @@ class Fixed:
     parent: HDFStore
     group: Node
     errors: str
-    is_table = False
+    is_table: bool = False
 
     def __init__(
         self,
@@ -2614,7 +2624,7 @@ def __init__(
         group: Node,
         encoding: str = "UTF-8",
         errors: str = "strict",
-    ):
+    ) -> None:
         assert isinstance(parent, HDFStore), type(parent)
         assert _table_mod is not None  # needed for mypy
         assert isinstance(group, _table_mod.Node), type(group)
@@ -2654,12 +2664,12 @@ def __repr__(self) -> str:
             return f"{self.pandas_type:12.12} (shape->{s})"
         return self.pandas_type
 
-    def set_object_info(self):
+    def set_object_info(self) -> None:
         """set my pandas type & version"""
         self.attrs.pandas_type = str(self.pandas_kind)
         self.attrs.pandas_version = str(_version)
 
-    def copy(self):
+    def copy(self) -> Fixed:
         new_self = copy.copy(self)
         return new_self
 
@@ -2691,11 +2701,11 @@ def _fletcher32(self) -> bool:
     def attrs(self):
         return self.group._v_attrs
 
-    def set_attrs(self):
+    def set_attrs(self) -> None:
         """set our object attributes"""
         pass
 
-    def get_attrs(self):
+    def get_attrs(self) -> None:
         """get our object attributes"""
         pass
 
@@ -2712,17 +2722,17 @@ def is_exists(self) -> bool:
     def nrows(self):
         return getattr(self.storable, "nrows", None)
 
-    def validate(self, other):
+    def validate(self, other) -> Literal[True] | None:
         """validate against an existing storable"""
         if other is None:
-            return
+            return None
         return True
 
-    def validate_version(self, where=None):
+    def validate_version(self, where=None) -> None:
         """are we trying to operate on an old version?"""
-        return True
+        pass
 
-    def infer_axes(self):
+    def infer_axes(self) -> bool:
         """
         infer the axes of my storer
         return a boolean indicating if we have a valid storer or not
@@ -2749,7 +2759,9 @@ def write(self, **kwargs):
             "cannot write on an abstract storer: subclasses should implement"
         )
 
-    def delete(self, where=None, start: int | None = None, stop: int | None = None):
+    def delete(
+        self, where=None, start: int | None = None, stop: int | None = None
+    ) -> None:
         """
         support fully deleting the node in its entirety (only) - where
         specification must be None
@@ -2824,7 +2836,7 @@ def f(values, freq=None, tz=None):
 
         return factory, kwargs
 
-    def validate_read(self, columns, where):
+    def validate_read(self, columns, where) -> None:
         """
         raise if any keywords are passed which are not-None
         """
@@ -2843,19 +2855,20 @@ def validate_read(self, columns, where):
     def is_exists(self) -> bool:
         return True
 
-    def set_attrs(self):
+    def set_attrs(self) -> None:
         """set our object attributes"""
         self.attrs.encoding = self.encoding
         self.attrs.errors = self.errors
 
-    def get_attrs(self):
+    def get_attrs(self) -> None:
         """retrieve our attributes"""
         self.encoding = _ensure_encoding(getattr(self.attrs, "encoding", None))
         self.errors = _ensure_decoded(getattr(self.attrs, "errors", "strict"))
         for n in self.attributes:
             setattr(self, n, _ensure_decoded(getattr(self.attrs, n, None)))
 
-    def write(self, obj, **kwargs):
+    # error: Signature of "write" incompatible with supertype "Fixed"
+    def write(self, obj, **kwargs) -> None:  # type: ignore[override]
         self.set_attrs()
 
     def read_array(self, key: str, start: int | None = None, stop: int | None = None):
@@ -2906,7 +2919,7 @@ def read_index(
         else:  # pragma: no cover
             raise TypeError(f"unrecognized index variety: {variety}")
 
-    def write_index(self, key: str, index: Index):
+    def write_index(self, key: str, index: Index) -> None:
         if isinstance(index, MultiIndex):
             setattr(self.attrs, f"{key}_variety", "multi")
             self.write_multi_index(key, index)
@@ -2929,7 +2942,7 @@ def write_index(self, key: str, index: Index):
             if isinstance(index, DatetimeIndex) and index.tz is not None:
                 node._v_attrs.tz = _get_tz(index.tz)
 
-    def write_multi_index(self, key: str, index: MultiIndex):
+    def write_multi_index(self, key: str, index: MultiIndex) -> None:
         setattr(self.attrs, f"{key}_nlevels", index.nlevels)
 
         for i, (lev, level_codes, name) in enumerate(
@@ -3015,7 +3028,7 @@ def read_index_node(
 
         return index
 
-    def write_array_empty(self, key: str, value: ArrayLike):
+    def write_array_empty(self, key: str, value: ArrayLike) -> None:
         """write a 0-len array"""
         # ugly hack for length 0 axes
         arr = np.empty((1,) * value.ndim)
@@ -3025,7 +3038,7 @@ def write_array_empty(self, key: str, value: ArrayLike):
         node._v_attrs.shape = value.shape
 
     def write_array(
-        self, key: str, obj: DataFrame | Series, items: Index | None = None
+        self, key: str, obj: AnyArrayLike, items: Index | None = None
     ) -> None:
         # TODO: we only have a few tests that get here, the only EA
         #  that gets passed is DatetimeArray, and we never have
@@ -3134,13 +3147,14 @@ def read(
         columns=None,
         start: int | None = None,
         stop: int | None = None,
-    ):
+    ) -> Series:
         self.validate_read(columns, where)
         index = self.read_index("index", start=start, stop=stop)
         values = self.read_array("values", start=start, stop=stop)
         return Series(values, index=index, name=self.name)
 
-    def write(self, obj, **kwargs):
+    # error: Signature of "write" incompatible with supertype "Fixed"
+    def write(self, obj, **kwargs) -> None:  # type: ignore[override]
         super().write(obj, **kwargs)
         self.write_index("index", obj.index)
         self.write_array("values", obj)
@@ -3185,7 +3199,7 @@ def read(
         columns=None,
         start: int | None = None,
         stop: int | None = None,
-    ):
+    ) -> DataFrame:
         # start, stop applied to rows, so 0th axis only
         self.validate_read(columns, where)
         select_axis = self.obj_type()._get_block_manager_axis(0)
@@ -3216,7 +3230,8 @@ def read(
 
         return DataFrame(columns=axes[0], index=axes[1])
 
-    def write(self, obj, **kwargs):
+    # error: Signature of "write" incompatible with supertype "Fixed"
+    def write(self, obj, **kwargs) -> None:  # type: ignore[override]
         super().write(obj, **kwargs)
 
         # TODO(ArrayManager) HDFStore relies on accessing the blocks
@@ -3296,7 +3311,7 @@ def __init__(
         data_columns=None,
         info=None,
         nan_rep=None,
-    ):
+    ) -> None:
         super().__init__(parent, group, encoding=encoding, errors=errors)
         self.index_axes = index_axes or []
         self.non_index_axes = non_index_axes or []
@@ -3334,7 +3349,7 @@ def __getitem__(self, c: str):
                 return a
         return None
 
-    def validate(self, other):
+    def validate(self, other) -> None:
         """validate against an existing table"""
         if other is None:
             return
@@ -3431,7 +3446,7 @@ def is_transposed(self) -> bool:
         return False
 
     @property
-    def data_orientation(self):
+    def data_orientation(self) -> tuple[int, ...]:
         """return a tuple of my permutated axes, non_indexable at the front"""
         return tuple(
             itertools.chain(
@@ -3470,7 +3485,7 @@ def _get_metadata_path(self, key: str) -> str:
         group = self.group._v_pathname
         return f"{group}/meta/{key}/meta"
 
-    def write_metadata(self, key: str, values: np.ndarray):
+    def write_metadata(self, key: str, values: np.ndarray) -> None:
         """
         Write out a metadata array to the key as a fixed-format Series.
 
@@ -3494,7 +3509,7 @@ def read_metadata(self, key: str):
             return self.parent.select(self._get_metadata_path(key))
         return None
 
-    def set_attrs(self):
+    def set_attrs(self) -> None:
         """set our table type & indexables"""
         self.attrs.table_type = str(self.table_type)
         self.attrs.index_cols = self.index_cols()
@@ -3507,7 +3522,7 @@ def set_attrs(self):
         self.attrs.levels = self.levels
         self.attrs.info = self.info
 
-    def get_attrs(self):
+    def get_attrs(self) -> None:
         """retrieve our attributes"""
         self.non_index_axes = getattr(self.attrs, "non_index_axes", None) or []
         self.data_columns = getattr(self.attrs, "data_columns", None) or []
@@ -3519,14 +3534,18 @@ def get_attrs(self):
         self.index_axes = [a for a in self.indexables if a.is_an_indexable]
         self.values_axes = [a for a in self.indexables if not a.is_an_indexable]
 
-    def validate_version(self, where=None):
+    def validate_version(self, where=None) -> None:
         """are we trying to operate on an old version?"""
         if where is not None:
-            if self.version[0] <= 0 and self.version[1] <= 10 and self.version[2] < 1:
+            if self.is_old_version:
                 ws = incompatibility_doc % ".".join([str(x) for x in self.version])
-                warnings.warn(ws, IncompatibilityWarning)
+                warnings.warn(
+                    ws,
+                    IncompatibilityWarning,
+                    stacklevel=find_stack_level(),
+                )
 
-    def validate_min_itemsize(self, min_itemsize):
+    def validate_min_itemsize(self, min_itemsize) -> None:
         """
         validate the min_itemsize doesn't contain items that are not in the
         axes this needs data_columns to be defined
@@ -3624,7 +3643,9 @@ def f(i, c):
 
         return _indexables
 
-    def create_index(self, columns=None, optlevel=None, kind: str | None = None):
+    def create_index(
+        self, columns=None, optlevel=None, kind: str | None = None
+    ) -> None:
         """
         Create a pytables index on the specified columns.
 
@@ -4082,7 +4103,7 @@ def get_blk_items(mgr):
 
         return blocks, blk_items
 
-    def process_axes(self, obj, selection: Selection, columns=None):
+    def process_axes(self, obj, selection: Selection, columns=None) -> DataFrame:
         """process axes filters"""
         # make a copy to avoid side effects
         if columns is not None:
@@ -4262,7 +4283,7 @@ def read(
         """
         raise NotImplementedError("WORMTable needs to implement read")
 
-    def write(self, **kwargs):
+    def write(self, **kwargs) -> None:
         """
         write in a format that we can search later on (but cannot append
         to): write out the indices and the values using _write_array
@@ -4276,22 +4297,23 @@ class AppendableTable(Table):
 
     table_type = "appendable"
 
-    def write(
+    # error: Signature of "write" incompatible with supertype "Fixed"
+    def write(  # type: ignore[override]
         self,
         obj,
         axes=None,
-        append=False,
+        append: bool = False,
         complib=None,
         complevel=None,
         fletcher32=None,
         min_itemsize=None,
         chunksize=None,
         expectedrows=None,
-        dropna=False,
+        dropna: bool = False,
         nan_rep=None,
         data_columns=None,
         track_times=True,
-    ):
+    ) -> None:
         if not append and self.is_exists:
             self._handle.remove_node(self.group, "table")
 
@@ -4336,7 +4358,7 @@ def write(
         # add the rows
         table.write_data(chunksize, dropna=dropna)
 
-    def write_data(self, chunksize: int | None, dropna: bool = False):
+    def write_data(self, chunksize: int | None, dropna: bool = False) -> None:
         """
         we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
         """
@@ -4399,9 +4421,9 @@ def write_data_chunk(
         self,
         rows: np.ndarray,
         indexes: list[np.ndarray],
-        mask: np.ndarray | None,
+        mask: npt.NDArray[np.bool_] | None,
         values: list[np.ndarray],
-    ):
+    ) -> None:
         """
         Parameters
         ----------
@@ -4683,7 +4705,7 @@ def pandas_type(self) -> str:
     def storable(self):
         return getattr(self.group, "table", None) or self.group
 
-    def get_attrs(self):
+    def get_attrs(self) -> None:
         """retrieve our attributes"""
         self.non_index_axes = []
         self.nan_rep = None
@@ -4805,10 +4827,20 @@ def _get_tz(tz: tzinfo) -> str | tzinfo:
     return zone
 
 
+@overload
+def _set_tz(
+    values: np.ndarray | Index, tz: str | tzinfo, coerce: bool = False
+) -> DatetimeIndex:
+    ...
+
+
+@overload
+def _set_tz(values: np.ndarray | Index, tz: None, coerce: bool = False) -> np.ndarray:
+    ...
+
+
 def _set_tz(
-    values: np.ndarray | Index,
-    tz: str | tzinfo | None,
-    coerce: bool = False,
+    values: np.ndarray | Index, tz: str | tzinfo | None, coerce: bool = False
 ) -> np.ndarray | DatetimeIndex:
     """
     coerce the values to a DatetimeIndex if tz is set
@@ -4855,7 +4887,11 @@ def _convert_index(name: str, index: Index, encoding: str, errors: str) -> Index
     kind = _dtype_to_kind(dtype_name)
     atom = DataIndexableCol._get_atom(converted)
 
-    if isinstance(index, Int64Index) or needs_i8_conversion(index.dtype):
+    if (
+        isinstance(index, Int64Index)
+        or needs_i8_conversion(index.dtype)
+        or is_bool_dtype(index.dtype)
+    ):
         # Includes Int64Index, RangeIndex, DatetimeIndex, TimedeltaIndex, PeriodIndex,
         #  in which case "kind" is "integer", "integer", "datetime64",
         #  "timedelta64", and "integer", respectively.
@@ -4918,7 +4954,7 @@ def _unconvert_index(data, kind: str, encoding: str, errors: str) -> np.ndarray
             index = np.asarray([date.fromordinal(v) for v in data], dtype=object)
         except (ValueError):
             index = np.asarray([date.fromtimestamp(v) for v in data], dtype=object)
-    elif kind in ("integer", "float"):
+    elif kind in ("integer", "float", "bool"):
         index = np.asarray(data)
     elif kind in ("string"):
         index = _unconvert_string_array(
@@ -5199,7 +5235,7 @@ def __init__(
         where=None,
         start: int | None = None,
         stop: int | None = None,
-    ):
+    ) -> None:
         self.table = table
         self.where = where
         self.start = start
diff --git a/pandas/io/sas/__init__.py b/pandas/io/sas/__init__.py
index 71027fd064f3d..317730745b6e3 100644
--- a/pandas/io/sas/__init__.py
+++ b/pandas/io/sas/__init__.py
@@ -1 +1,3 @@
-from pandas.io.sas.sasreader import read_sas  # noqa:F401
+from pandas.io.sas.sasreader import read_sas
+
+__all__ = ["read_sas"]
diff --git a/pandas/io/sas/_sas.pyi b/pandas/io/sas/_sas.pyi
new file mode 100644
index 0000000000000..527193dd71e57
--- /dev/null
+++ b/pandas/io/sas/_sas.pyi
@@ -0,0 +1,5 @@
+from pandas.io.sas.sas7bdat import SAS7BDATReader
+
+class Parser:
+    def __init__(self, parser: SAS7BDATReader) -> None: ...
+    def read(self, nrows: int) -> None: ...
diff --git a/pandas/io/sas/sas.pyx b/pandas/io/sas/sas.pyx
index 17b41fd2b4379..d8591c0b033a6 100644
--- a/pandas/io/sas/sas.pyx
+++ b/pandas/io/sas/sas.pyx
@@ -1,6 +1,6 @@
 # cython: profile=False
 # cython: boundscheck=False, initializedcheck=False
-from cython import Py_ssize_t
+from cython cimport Py_ssize_t
 import numpy as np
 
 import pandas.io.sas.sas_constants as const
@@ -13,7 +13,7 @@ ctypedef unsigned short     uint16_t
 # algorithm.  It is partially documented here:
 #
 # https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf
-cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff):
+cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff) except *:
 
     cdef:
         uint8_t control_byte, x
@@ -28,9 +28,7 @@ cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff)
         ipos += 1
 
         if control_byte == 0x00:
-            if end_of_first_byte != 0:
-                raise ValueError("Unexpected non-zero end_of_first_byte")
-            nbytes = <int>(inbuff[ipos]) + 64
+            nbytes = <int>(inbuff[ipos]) + 64 + end_of_first_byte * 256
             ipos += 1
             for _ in range(nbytes):
                 result[rpos] = inbuff[ipos]
@@ -38,8 +36,7 @@ cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff)
                 ipos += 1
         elif control_byte == 0x40:
             # not documented
-            nbytes = end_of_first_byte * 16
-            nbytes += <int>(inbuff[ipos])
+            nbytes = (inbuff[ipos] & 0xFF) + 18 + end_of_first_byte * 256
             ipos += 1
             for _ in range(nbytes):
                 result[rpos] = inbuff[ipos]
@@ -116,7 +113,7 @@ cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff)
 # rdc_decompress decompresses data using the Ross Data Compression algorithm:
 #
 # http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
-cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff):
+cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff) except *:
 
     cdef:
         uint8_t cmd
@@ -177,7 +174,7 @@ cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff)
             rpos += cnt
 
         # short pattern
-        elif (cmd >= 3) & (cmd <= 15):
+        else:
             ofs = cnt + 3
             ofs += <uint16_t>inbuff[ipos] << 4
             ipos += 1
@@ -185,9 +182,6 @@ cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff)
                 outbuff[rpos + k] = outbuff[rpos - <int>ofs + k]
             rpos += cmd
 
-        else:
-            raise ValueError("unknown RDC command")
-
     # In py37 cython/clang sees `len(outbuff)` as size_t and not Py_ssize_t
     if <Py_ssize_t>len(outbuff) != <Py_ssize_t>result_length:
         raise ValueError(f"RDC: {len(outbuff)} != {result_length}\n")
@@ -201,10 +195,11 @@ cdef enum ColumnTypes:
 
 
 # type the page_data types
+assert len(const.page_meta_types) == 2
 cdef:
-    int page_meta_type = const.page_meta_type
-    int page_mix_types_0 = const.page_mix_types[0]
-    int page_mix_types_1 = const.page_mix_types[1]
+    int page_meta_types_0 = const.page_meta_types[0]
+    int page_meta_types_1 = const.page_meta_types[1]
+    int page_mix_type = const.page_mix_type
     int page_data_type = const.page_data_type
     int subheader_pointers_offset = const.subheader_pointers_offset
 
@@ -231,7 +226,7 @@ cdef class Parser:
         int subheader_pointer_length
         int current_page_type
         bint is_little_endian
-        const uint8_t[:] (*decompress)(int result_length, const uint8_t[:] inbuff)
+        const uint8_t[:] (*decompress)(int result_length, const uint8_t[:] inbuff) except *
         object parser
 
     def __init__(self, object parser):
@@ -294,8 +289,8 @@ cdef class Parser:
         self.parser._current_row_in_chunk_index = self.current_row_in_chunk_index
         self.parser._current_row_in_file_index = self.current_row_in_file_index
 
-    cdef bint read_next_page(self):
-        cdef done
+    cdef bint read_next_page(self) except? True:
+        cdef bint done
 
         done = self.parser._read_next_page()
         if done:
@@ -316,7 +311,7 @@ cdef class Parser:
         )
         self.current_page_subheaders_count = self.parser._current_page_subheaders_count
 
-    cdef readline(self):
+    cdef bint readline(self) except? True:
 
         cdef:
             int offset, bit_offset, align_correction
@@ -335,7 +330,7 @@ cdef class Parser:
 
         # Loop until a data row is read
         while True:
-            if self.current_page_type == page_meta_type:
+            if self.current_page_type in (page_meta_types_0, page_meta_types_1):
                 flag = self.current_row_on_page_index >=\
                     self.current_page_data_subheader_pointers_len
                 if flag:
@@ -350,8 +345,7 @@ cdef class Parser:
                     current_subheader_pointer.offset,
                     current_subheader_pointer.length)
                 return False
-            elif (self.current_page_type == page_mix_types_0 or
-                    self.current_page_type == page_mix_types_1):
+            elif self.current_page_type == page_mix_type:
                 align_correction = (
                     bit_offset
                     + subheader_pointers_offset
@@ -369,7 +363,7 @@ cdef class Parser:
                     if done:
                         return True
                 return False
-            elif self.current_page_type & page_data_type == page_data_type:
+            elif self.current_page_type == page_data_type:
                 self.process_byte_array_with_data(
                     bit_offset
                     + subheader_pointers_offset
@@ -385,7 +379,7 @@ cdef class Parser:
             else:
                 raise ValueError(f"unknown page type: {self.current_page_type}")
 
-    cdef void process_byte_array_with_data(self, int offset, int length):
+    cdef void process_byte_array_with_data(self, int offset, int length) except *:
 
         cdef:
             Py_ssize_t j
@@ -430,8 +424,11 @@ cdef class Parser:
                 jb += 1
             elif column_types[j] == column_type_string:
                 # string
-                string_chunk[js, current_row] = np.array(source[start:(
-                    start + lngt)]).tobytes().rstrip(b"\x00 ")
+                # Skip trailing whitespace. This is equivalent to calling
+                # .rstrip(b"\x00 ") but without Python call overhead.
+                while lngt > 0 and source[start+lngt-1] in b"\x00 ":
+                    lngt -= 1
+                string_chunk[js, current_row] = (&source[start])[:lngt]
                 js += 1
 
         self.current_row_on_page_index += 1
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index ef77ff286c780..7282affe1b5e6 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -26,6 +26,7 @@
 import numpy as np
 
 from pandas._typing import (
+    CompressionOptions,
     FilePath,
     ReadBuffer,
 )
@@ -92,7 +93,7 @@ class _SubheaderPointer:
     compression: int
     ptype: int
 
-    def __init__(self, offset: int, length: int, compression: int, ptype: int):
+    def __init__(self, offset: int, length: int, compression: int, ptype: int) -> None:
         self.offset = offset
         self.length = length
         self.compression = compression
@@ -116,7 +117,7 @@ def __init__(
         format: str | bytes,
         ctype: bytes,
         length: int,
-    ):
+    ) -> None:
         self.col_id = col_id
         self.name = name
         self.label = label
@@ -162,13 +163,14 @@ def __init__(
         self,
         path_or_buf: FilePath | ReadBuffer[bytes],
         index=None,
-        convert_dates=True,
-        blank_missing=True,
-        chunksize=None,
-        encoding=None,
-        convert_text=True,
-        convert_header_text=True,
-    ):
+        convert_dates: bool = True,
+        blank_missing: bool = True,
+        chunksize: int | None = None,
+        encoding: str | None = None,
+        convert_text: bool = True,
+        convert_header_text: bool = True,
+        compression: CompressionOptions = "infer",
+    ) -> None:
 
         self.index = index
         self.convert_dates = convert_dates
@@ -180,9 +182,9 @@ def __init__(
 
         self.default_encoding = "latin-1"
         self.compression = b""
-        self.column_names_strings: list[str] = []
-        self.column_names: list[str] = []
-        self.column_formats: list[str] = []
+        self.column_names_raw: list[bytes] = []
+        self.column_names: list[str | bytes] = []
+        self.column_formats: list[str | bytes] = []
         self.columns: list[_Column] = []
 
         self._current_page_data_subheader_pointers: list[_SubheaderPointer] = []
@@ -195,7 +197,9 @@ def __init__(
         self._current_row_on_page_index = 0
         self._current_row_in_file_index = 0
 
-        self.handles = get_handle(path_or_buf, "rb", is_text=False)
+        self.handles = get_handle(
+            path_or_buf, "rb", is_text=False, compression=compression
+        )
 
         self._path_or_buf = self.handles.handle
 
@@ -274,17 +278,13 @@ def _get_properties(self) -> None:
         else:
             self.platform = "unknown"
 
-        buf = self._read_bytes(const.dataset_offset, const.dataset_length)
-        self.name = buf.rstrip(b"\x00 ")
-        if self.convert_header_text:
-            self.name = self.name.decode(self.encoding or self.default_encoding)
+        self.name = self._read_and_convert_header_text(
+            const.dataset_offset, const.dataset_length
+        )
 
-        buf = self._read_bytes(const.file_type_offset, const.file_type_length)
-        self.file_type = buf.rstrip(b"\x00 ")
-        if self.convert_header_text:
-            self.file_type = self.file_type.decode(
-                self.encoding or self.default_encoding
-            )
+        self.file_type = self._read_and_convert_header_text(
+            const.file_type_offset, const.file_type_length
+        )
 
         # Timestamp is epoch 01/01/1960
         epoch = datetime(1960, 1, 1)
@@ -316,50 +316,29 @@ def _get_properties(self) -> None:
             const.page_count_offset + align1, const.page_count_length
         )
 
-        buf = self._read_bytes(
+        self.sas_release_offset = self._read_and_convert_header_text(
             const.sas_release_offset + total_align, const.sas_release_length
         )
-        self.sas_release = buf.rstrip(b"\x00 ")
-        if self.convert_header_text:
-            self.sas_release = self.sas_release.decode(
-                self.encoding or self.default_encoding
-            )
 
-        buf = self._read_bytes(
+        self.server_type = self._read_and_convert_header_text(
             const.sas_server_type_offset + total_align, const.sas_server_type_length
         )
-        self.server_type = buf.rstrip(b"\x00 ")
-        if self.convert_header_text:
-            self.server_type = self.server_type.decode(
-                self.encoding or self.default_encoding
-            )
 
-        buf = self._read_bytes(
+        self.os_version = self._read_and_convert_header_text(
             const.os_version_number_offset + total_align, const.os_version_number_length
         )
-        self.os_version = buf.rstrip(b"\x00 ")
-        if self.convert_header_text:
-            self.os_version = self.os_version.decode(
-                self.encoding or self.default_encoding
-            )
 
-        buf = self._read_bytes(const.os_name_offset + total_align, const.os_name_length)
-        buf = buf.rstrip(b"\x00 ")
-        if len(buf) > 0:
-            self.os_name = buf.decode(self.encoding or self.default_encoding)
-        else:
-            buf = self._read_bytes(
+        self.os_name = self._read_and_convert_header_text(
+            const.os_name_offset + total_align, const.os_name_length
+        )
+        if not self.os_name:
+            self.os_name = self._read_and_convert_header_text(
                 const.os_maker_offset + total_align, const.os_maker_length
             )
-            self.os_name = buf.rstrip(b"\x00 ")
-            if self.convert_header_text:
-                self.os_name = self.os_name.decode(
-                    self.encoding or self.default_encoding
-                )
 
-    def __next__(self):
+    def __next__(self) -> DataFrame:
         da = self.read(nrows=self.chunksize or 1)
-        if da is None:
+        if da.empty:
             self.close()
             raise StopIteration
         return da
@@ -398,6 +377,11 @@ def _read_bytes(self, offset: int, length: int):
                 raise ValueError("The cached page is too small.")
             return self._cached_page[offset : offset + length]
 
+    def _read_and_convert_header_text(self, offset: int, length: int) -> str | bytes:
+        return self._convert_header_text(
+            self._read_bytes(offset, length).rstrip(b"\x00 ")
+        )
+
     def _parse_metadata(self) -> None:
         done = False
         while not done:
@@ -410,11 +394,11 @@ def _parse_metadata(self) -> None:
 
     def _process_page_meta(self) -> bool:
         self._read_page_header()
-        pt = [const.page_meta_type, const.page_amd_type] + const.page_mix_types
+        pt = const.page_meta_types + [const.page_amd_type, const.page_mix_type]
         if self._current_page_type in pt:
             self._process_page_metadata()
-        is_data_page = self._current_page_type & const.page_data_type
-        is_mix_page = self._current_page_type in const.page_mix_types
+        is_data_page = self._current_page_type == const.page_data_type
+        is_mix_page = self._current_page_type == const.page_mix_type
         return bool(
             is_data_page
             or is_mix_page
@@ -424,7 +408,9 @@ def _process_page_meta(self) -> bool:
     def _read_page_header(self):
         bit_offset = self._page_bit_offset
         tx = const.page_type_offset + bit_offset
-        self._current_page_type = self._read_int(tx, const.page_type_length)
+        self._current_page_type = (
+            self._read_int(tx, const.page_type_length) & const.page_type_mask2
+        )
         tx = const.block_count_offset + bit_offset
         self._current_page_block_count = self._read_int(tx, const.block_count_length)
         tx = const.subheader_count_offset + bit_offset
@@ -570,12 +556,9 @@ def _process_columntext_subheader(self, offset: int, length: int) -> None:
 
         buf = self._read_bytes(offset, text_block_size)
         cname_raw = buf[0:text_block_size].rstrip(b"\x00 ")
-        cname = cname_raw
-        if self.convert_header_text:
-            cname = cname.decode(self.encoding or self.default_encoding)
-        self.column_names_strings.append(cname)
+        self.column_names_raw.append(cname_raw)
 
-        if len(self.column_names_strings) == 1:
+        if len(self.column_names_raw) == 1:
             compression_literal = b""
             for cl in const.compression_literals:
                 if cl in cname_raw:
@@ -609,11 +592,8 @@ def _process_columntext_subheader(self, offset: int, length: int) -> None:
                     offset1 += 4
                 buf = self._read_bytes(offset1, self._lcs)
                 self.creator_proc = buf[0 : self._lcp]
-            if self.convert_header_text:
-                if hasattr(self, "creator_proc"):
-                    self.creator_proc = self.creator_proc.decode(
-                        self.encoding or self.default_encoding
-                    )
+            if hasattr(self, "creator_proc"):
+                self.creator_proc = self._convert_header_text(self.creator_proc)
 
     def _process_columnname_subheader(self, offset: int, length: int) -> None:
         int_len = self._int_length
@@ -644,8 +624,9 @@ def _process_columnname_subheader(self, offset: int, length: int) -> None:
             )
             col_len = self._read_int(col_name_length, const.column_name_length_length)
 
-            name_str = self.column_names_strings[idx]
-            self.column_names.append(name_str[col_offset : col_offset + col_len])
+            name_raw = self.column_names_raw[idx]
+            cname = name_raw[col_offset : col_offset + col_len]
+            self.column_names.append(self._convert_header_text(cname))
 
     def _process_columnattributes_subheader(self, offset: int, length: int) -> None:
         int_len = self._int_length
@@ -693,7 +674,7 @@ def _process_format_subheader(self, offset: int, length: int) -> None:
         x = self._read_int(
             text_subheader_format, const.column_format_text_subheader_index_length
         )
-        format_idx = min(x, len(self.column_names_strings) - 1)
+        format_idx = min(x, len(self.column_names_raw) - 1)
 
         format_start = self._read_int(
             col_format_offset, const.column_format_offset_length
@@ -703,15 +684,19 @@ def _process_format_subheader(self, offset: int, length: int) -> None:
         label_idx = self._read_int(
             text_subheader_label, const.column_label_text_subheader_index_length
         )
-        label_idx = min(label_idx, len(self.column_names_strings) - 1)
+        label_idx = min(label_idx, len(self.column_names_raw) - 1)
 
         label_start = self._read_int(col_label_offset, const.column_label_offset_length)
         label_len = self._read_int(col_label_len, const.column_label_length_length)
 
-        label_names = self.column_names_strings[label_idx]
-        column_label = label_names[label_start : label_start + label_len]
-        format_names = self.column_names_strings[format_idx]
-        column_format = format_names[format_start : format_start + format_len]
+        label_names = self.column_names_raw[label_idx]
+        column_label = self._convert_header_text(
+            label_names[label_start : label_start + label_len]
+        )
+        format_names = self.column_names_raw[format_idx]
+        column_format = self._convert_header_text(
+            format_names[format_start : format_start + format_len]
+        )
         current_column_number = len(self.columns)
 
         col = _Column(
@@ -726,7 +711,7 @@ def _process_format_subheader(self, offset: int, length: int) -> None:
         self.column_formats.append(column_format)
         self.columns.append(col)
 
-    def read(self, nrows: int | None = None) -> DataFrame | None:
+    def read(self, nrows: int | None = None) -> DataFrame:
 
         if (nrows is None) and (self.chunksize is not None):
             nrows = self.chunksize
@@ -737,8 +722,8 @@ def read(self, nrows: int | None = None) -> DataFrame | None:
             self.close()
             raise EmptyDataError("No columns to parse from file")
 
-        if self._current_row_in_file_index >= self.row_count:
-            return None
+        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
+            return DataFrame()
 
         m = self.row_count - self._current_row_in_file_index
         if nrows > m:
@@ -774,13 +759,13 @@ def _read_next_page(self):
             raise ValueError(msg)
 
         self._read_page_header()
-        page_type = self._current_page_type
-        if page_type == const.page_meta_type:
+        if self._current_page_type in const.page_meta_types:
             self._process_page_metadata()
 
-        is_data_page = page_type & const.page_data_type
-        pt = [const.page_meta_type] + const.page_mix_types
-        if not is_data_page and self._current_page_type not in pt:
+        if self._current_page_type not in const.page_meta_types + [
+            const.page_data_type,
+            const.page_mix_type,
+        ]:
             return self._read_next_page()
 
         return False
@@ -809,9 +794,7 @@ def _chunk_to_dataframe(self) -> DataFrame:
             elif self._column_types[j] == b"s":
                 rslt[name] = pd.Series(self._string_chunk[js, :], index=ix)
                 if self.convert_text and (self.encoding is not None):
-                    rslt[name] = rslt[name].str.decode(
-                        self.encoding or self.default_encoding
-                    )
+                    rslt[name] = self._decode_string(rslt[name].str)
                 if self.blank_missing:
                     ii = rslt[name].str.len() == 0
                     rslt[name][ii] = np.nan
@@ -822,3 +805,12 @@ def _chunk_to_dataframe(self) -> DataFrame:
 
         df = DataFrame(rslt, columns=self.column_names, index=ix, copy=False)
         return df
+
+    def _decode_string(self, b):
+        return b.decode(self.encoding or self.default_encoding)
+
+    def _convert_header_text(self, b: bytes) -> str | bytes:
+        if self.convert_header_text:
+            return self._decode_string(b)
+        else:
+            return b
diff --git a/pandas/io/sas/sas_constants.py b/pandas/io/sas/sas_constants.py
index 23b23a1bf09c0..69bc16e6d294f 100644
--- a/pandas/io/sas/sas_constants.py
+++ b/pandas/io/sas/sas_constants.py
@@ -1,106 +1,114 @@
-magic = (
+from __future__ import annotations
+
+from typing import Final
+
+magic: Final = (
     b"\x00\x00\x00\x00\x00\x00\x00\x00"
     + b"\x00\x00\x00\x00\xc2\xea\x81\x60"
     + b"\xb3\x14\x11\xcf\xbd\x92\x08\x00"
     + b"\x09\xc7\x31\x8c\x18\x1f\x10\x11"
 )
 
-align_1_checker_value = b"3"
-align_1_offset = 32
-align_1_length = 1
-align_1_value = 4
-u64_byte_checker_value = b"3"
-align_2_offset = 35
-align_2_length = 1
-align_2_value = 4
-endianness_offset = 37
-endianness_length = 1
-platform_offset = 39
-platform_length = 1
-encoding_offset = 70
-encoding_length = 1
-dataset_offset = 92
-dataset_length = 64
-file_type_offset = 156
-file_type_length = 8
-date_created_offset = 164
-date_created_length = 8
-date_modified_offset = 172
-date_modified_length = 8
-header_size_offset = 196
-header_size_length = 4
-page_size_offset = 200
-page_size_length = 4
-page_count_offset = 204
-page_count_length = 4
-sas_release_offset = 216
-sas_release_length = 8
-sas_server_type_offset = 224
-sas_server_type_length = 16
-os_version_number_offset = 240
-os_version_number_length = 16
-os_maker_offset = 256
-os_maker_length = 16
-os_name_offset = 272
-os_name_length = 16
-page_bit_offset_x86 = 16
-page_bit_offset_x64 = 32
-subheader_pointer_length_x86 = 12
-subheader_pointer_length_x64 = 24
-page_type_offset = 0
-page_type_length = 2
-block_count_offset = 2
-block_count_length = 2
-subheader_count_offset = 4
-subheader_count_length = 2
-page_meta_type = 0
-page_data_type = 256
-page_amd_type = 1024
-page_metc_type = 16384
-page_comp_type = -28672
-page_mix_types = [512, 640]
-subheader_pointers_offset = 8
-truncated_subheader_id = 1
-compressed_subheader_id = 4
-compressed_subheader_type = 1
-text_block_size_length = 2
-row_length_offset_multiplier = 5
-row_count_offset_multiplier = 6
-col_count_p1_multiplier = 9
-col_count_p2_multiplier = 10
-row_count_on_mix_page_offset_multiplier = 15
-column_name_pointer_length = 8
-column_name_text_subheader_offset = 0
-column_name_text_subheader_length = 2
-column_name_offset_offset = 2
-column_name_offset_length = 2
-column_name_length_offset = 4
-column_name_length_length = 2
-column_data_offset_offset = 8
-column_data_length_offset = 8
-column_data_length_length = 4
-column_type_offset = 14
-column_type_length = 1
-column_format_text_subheader_index_offset = 22
-column_format_text_subheader_index_length = 2
-column_format_offset_offset = 24
-column_format_offset_length = 2
-column_format_length_offset = 26
-column_format_length_length = 2
-column_label_text_subheader_index_offset = 28
-column_label_text_subheader_index_length = 2
-column_label_offset_offset = 30
-column_label_offset_length = 2
-column_label_length_offset = 32
-column_label_length_length = 2
-rle_compression = b"SASYZCRL"
-rdc_compression = b"SASYZCR2"
+align_1_checker_value: Final = b"3"
+align_1_offset: Final = 32
+align_1_length: Final = 1
+align_1_value: Final = 4
+u64_byte_checker_value: Final = b"3"
+align_2_offset: Final = 35
+align_2_length: Final = 1
+align_2_value: Final = 4
+endianness_offset: Final = 37
+endianness_length: Final = 1
+platform_offset: Final = 39
+platform_length: Final = 1
+encoding_offset: Final = 70
+encoding_length: Final = 1
+dataset_offset: Final = 92
+dataset_length: Final = 64
+file_type_offset: Final = 156
+file_type_length: Final = 8
+date_created_offset: Final = 164
+date_created_length: Final = 8
+date_modified_offset: Final = 172
+date_modified_length: Final = 8
+header_size_offset: Final = 196
+header_size_length: Final = 4
+page_size_offset: Final = 200
+page_size_length: Final = 4
+page_count_offset: Final = 204
+page_count_length: Final = 4
+sas_release_offset: Final = 216
+sas_release_length: Final = 8
+sas_server_type_offset: Final = 224
+sas_server_type_length: Final = 16
+os_version_number_offset: Final = 240
+os_version_number_length: Final = 16
+os_maker_offset: Final = 256
+os_maker_length: Final = 16
+os_name_offset: Final = 272
+os_name_length: Final = 16
+page_bit_offset_x86: Final = 16
+page_bit_offset_x64: Final = 32
+subheader_pointer_length_x86: Final = 12
+subheader_pointer_length_x64: Final = 24
+page_type_offset: Final = 0
+page_type_length: Final = 2
+block_count_offset: Final = 2
+block_count_length: Final = 2
+subheader_count_offset: Final = 4
+subheader_count_length: Final = 2
+page_type_mask: Final = 0x0F00
+# Keep "page_comp_type" bits
+page_type_mask2: Final = 0xF000 | page_type_mask
+page_meta_type: Final = 0x0000
+page_data_type: Final = 0x0100
+page_mix_type: Final = 0x0200
+page_amd_type: Final = 0x0400
+page_meta2_type: Final = 0x4000
+page_comp_type: Final = 0x9000
+page_meta_types: Final = [page_meta_type, page_meta2_type]
+subheader_pointers_offset: Final = 8
+truncated_subheader_id: Final = 1
+compressed_subheader_id: Final = 4
+compressed_subheader_type: Final = 1
+text_block_size_length: Final = 2
+row_length_offset_multiplier: Final = 5
+row_count_offset_multiplier: Final = 6
+col_count_p1_multiplier: Final = 9
+col_count_p2_multiplier: Final = 10
+row_count_on_mix_page_offset_multiplier: Final = 15
+column_name_pointer_length: Final = 8
+column_name_text_subheader_offset: Final = 0
+column_name_text_subheader_length: Final = 2
+column_name_offset_offset: Final = 2
+column_name_offset_length: Final = 2
+column_name_length_offset: Final = 4
+column_name_length_length: Final = 2
+column_data_offset_offset: Final = 8
+column_data_length_offset: Final = 8
+column_data_length_length: Final = 4
+column_type_offset: Final = 14
+column_type_length: Final = 1
+column_format_text_subheader_index_offset: Final = 22
+column_format_text_subheader_index_length: Final = 2
+column_format_offset_offset: Final = 24
+column_format_offset_length: Final = 2
+column_format_length_offset: Final = 26
+column_format_length_length: Final = 2
+column_label_text_subheader_index_offset: Final = 28
+column_label_text_subheader_index_length: Final = 2
+column_label_offset_offset: Final = 30
+column_label_offset_length: Final = 2
+column_label_length_offset: Final = 32
+column_label_length_length: Final = 2
+rle_compression: Final = b"SASYZCRL"
+rdc_compression: Final = b"SASYZCR2"
 
-compression_literals = [rle_compression, rdc_compression]
+compression_literals: Final = [rle_compression, rdc_compression]
 
 # Incomplete list of encodings, using SAS nomenclature:
 # http://support.sas.com/documentation/cdl/en/nlsref/61893/HTML/default/viewer.htm#a002607278.htm
-encoding_names = {
+encoding_names: Final = {
     29: "latin1",
     20: "utf-8",
     33: "cyrillic",
@@ -112,18 +120,18 @@
 
 
 class SASIndex:
-    row_size_index = 0
-    column_size_index = 1
-    subheader_counts_index = 2
-    column_text_index = 3
-    column_name_index = 4
-    column_attributes_index = 5
-    format_and_label_index = 6
-    column_list_index = 7
-    data_subheader_index = 8
+    row_size_index: Final = 0
+    column_size_index: Final = 1
+    subheader_counts_index: Final = 2
+    column_text_index: Final = 3
+    column_name_index: Final = 4
+    column_attributes_index: Final = 5
+    format_and_label_index: Final = 6
+    column_list_index: Final = 7
+    data_subheader_index: Final = 8
 
 
-subheader_signature_to_index = {
+subheader_signature_to_index: Final = {
     b"\xF7\xF7\xF7\xF7": SASIndex.row_size_index,
     b"\x00\x00\x00\x00\xF7\xF7\xF7\xF7": SASIndex.row_size_index,
     b"\xF7\xF7\xF7\xF7\x00\x00\x00\x00": SASIndex.row_size_index,
@@ -160,7 +168,7 @@ class SASIndex:
 # List of frequently used SAS date and datetime formats
 # http://support.sas.com/documentation/cdl/en/etsug/60372/HTML/default/viewer.htm#etsug_intervals_sect009.htm
 # https://github.com/epam/parso/blob/master/src/main/java/com/epam/parso/impl/SasFileConstants.java
-sas_date_formats = (
+sas_date_formats: Final = (
     "DATE",
     "DAY",
     "DDMMYY",
@@ -229,7 +237,7 @@ class SASIndex:
     "MINGUO",
 )
 
-sas_datetime_formats = (
+sas_datetime_formats: Final = (
     "DATETIME",
     "DTWKDATX",
     "B8601DN",
diff --git a/pandas/io/sas/sas_xport.py b/pandas/io/sas/sas_xport.py
index d8a3412e05d05..c188e8d1b03c3 100644
--- a/pandas/io/sas/sas_xport.py
+++ b/pandas/io/sas/sas_xport.py
@@ -5,7 +5,7 @@
 
 The file format is defined here:
 
-https://support.sas.com/techsup/technote/ts140.pdf
+https://support.sas.com/content/dam/SAS/support/en/technical-papers/record-layout-of-a-sas-version-5-or-6-data-set-in-sas-transport-xport-format.pdf
 """
 from __future__ import annotations
 
@@ -17,10 +17,13 @@
 import numpy as np
 
 from pandas._typing import (
+    CompressionOptions,
+    DatetimeNaTType,
     FilePath,
     ReadBuffer,
 )
 from pandas.util._decorators import Appender
+from pandas.util._exceptions import find_stack_level
 
 import pandas as pd
 
@@ -139,7 +142,7 @@
 """
 
 
-def _parse_date(datestr: str) -> datetime:
+def _parse_date(datestr: str) -> DatetimeNaTType:
     """Given a date in xport format, return Python date."""
     try:
         # e.g. "16FEB11:10:07:55"
@@ -255,7 +258,8 @@ def __init__(
         index=None,
         encoding: str | None = "ISO-8859-1",
         chunksize=None,
-    ):
+        compression: CompressionOptions = "infer",
+    ) -> None:
 
         self._encoding = encoding
         self._lines_read = 0
@@ -263,7 +267,11 @@ def __init__(
         self._chunksize = chunksize
 
         self.handles = get_handle(
-            filepath_or_buffer, "rb", encoding=encoding, is_text=False
+            filepath_or_buffer,
+            "rb",
+            encoding=encoding,
+            is_text=False,
+            compression=compression,
         )
         self.filepath_or_buffer = self.handles.handle
 
@@ -273,7 +281,7 @@ def __init__(
             self.close()
             raise
 
-    def close(self):
+    def close(self) -> None:
         self.handles.close()
 
     def _get_row(self):
@@ -389,7 +397,7 @@ def _read_header(self):
         dtype = np.dtype(dtypel)
         self._dtype = dtype
 
-    def __next__(self):
+    def __next__(self) -> pd.DataFrame:
         return self.read(nrows=self._chunksize or 1)
 
     def _record_count(self) -> int:
@@ -405,7 +413,10 @@ def _record_count(self) -> int:
         total_records_length = self.filepath_or_buffer.tell() - self.record_start
 
         if total_records_length % 80 != 0:
-            warnings.warn("xport file may be corrupted.")
+            warnings.warn(
+                "xport file may be corrupted.",
+                stacklevel=find_stack_level(),
+            )
 
         if self.record_length > 80:
             self.filepath_or_buffer.seek(self.record_start)
@@ -427,7 +438,7 @@ def _record_count(self) -> int:
 
         return (total_records_length - tail_pad) // self.record_length
 
-    def get_chunk(self, size=None):
+    def get_chunk(self, size=None) -> pd.DataFrame:
         """
         Reads lines from Xport file and returns as dataframe
 
@@ -456,7 +467,7 @@ def _missing_double(self, vec):
         return miss
 
     @Appender(_read_method_doc)
-    def read(self, nrows=None):
+    def read(self, nrows: int | None = None) -> pd.DataFrame:
 
         if nrows is None:
             nrows = self.nobs
diff --git a/pandas/io/sas/sasreader.py b/pandas/io/sas/sasreader.py
index f50fc777f55e9..359174166f980 100644
--- a/pandas/io/sas/sasreader.py
+++ b/pandas/io/sas/sasreader.py
@@ -14,9 +14,16 @@
 )
 
 from pandas._typing import (
+    CompressionOptions,
     FilePath,
     ReadBuffer,
 )
+from pandas.util._decorators import (
+    deprecate_nonkeyword_arguments,
+    doc,
+)
+
+from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.common import stringify_path
 
@@ -31,17 +38,17 @@ class ReaderBase(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def read(self, nrows=None):
+    def read(self, nrows: int | None = None) -> DataFrame:
         pass
 
     @abstractmethod
-    def close(self):
+    def close(self) -> None:
         pass
 
-    def __enter__(self):
+    def __enter__(self) -> ReaderBase:
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.close()
 
 
@@ -53,6 +60,7 @@ def read_sas(
     encoding: str | None = ...,
     chunksize: int = ...,
     iterator: bool = ...,
+    compression: CompressionOptions = ...,
 ) -> ReaderBase:
     ...
 
@@ -65,10 +73,13 @@ def read_sas(
     encoding: str | None = ...,
     chunksize: None = ...,
     iterator: bool = ...,
+    compression: CompressionOptions = ...,
 ) -> DataFrame | ReaderBase:
     ...
 
 
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["filepath_or_buffer"])
+@doc(decompression_options=_shared_docs["decompression_options"] % "filepath_or_buffer")
 def read_sas(
     filepath_or_buffer: FilePath | ReadBuffer[bytes],
     format: str | None = None,
@@ -76,6 +87,7 @@ def read_sas(
     encoding: str | None = None,
     chunksize: int | None = None,
     iterator: bool = False,
+    compression: CompressionOptions = "infer",
 ) -> DataFrame | ReaderBase:
     """
     Read SAS files stored as either XPORT or SAS7BDAT format files.
@@ -88,7 +100,7 @@ def read_sas(
         Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
         expected. A local file could be:
         ``file://localhost/path/to/table.sas``.
-    format : str {'xport', 'sas7bdat'} or None
+    format : str {{'xport', 'sas7bdat'}} or None
         If None, file format is inferred from file extension. If 'xport' or
         'sas7bdat', uses the corresponding format.
     index : identifier of index column, defaults to None
@@ -107,6 +119,7 @@ def read_sas(
         .. versionchanged:: 1.2
 
             ``TextFileReader`` is a context manager.
+    {decompression_options}
 
     Returns
     -------
@@ -122,12 +135,14 @@ def read_sas(
         if not isinstance(filepath_or_buffer, str):
             raise ValueError(buffer_error_msg)
         fname = filepath_or_buffer.lower()
-        if fname.endswith(".xpt"):
+        if ".xpt" in fname:
             format = "xport"
-        elif fname.endswith(".sas7bdat"):
+        elif ".sas7bdat" in fname:
             format = "sas7bdat"
         else:
-            raise ValueError("unable to infer format of SAS file")
+            raise ValueError(
+                f"unable to infer format of SAS file from filename: {repr(fname)}"
+            )
 
     reader: ReaderBase
     if format.lower() == "xport":
@@ -138,6 +153,7 @@ def read_sas(
             index=index,
             encoding=encoding,
             chunksize=chunksize,
+            compression=compression,
         )
     elif format.lower() == "sas7bdat":
         from pandas.io.sas.sas7bdat import SAS7BDATReader
@@ -147,6 +163,7 @@ def read_sas(
             index=index,
             encoding=encoding,
             chunksize=chunksize,
+            compression=compression,
         )
     else:
         raise ValueError("unknown SAS format")
diff --git a/pandas/io/spss.py b/pandas/io/spss.py
index 533cf7a7a6331..1b83d339a2990 100644
--- a/pandas/io/spss.py
+++ b/pandas/io/spss.py
@@ -1,16 +1,20 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Sequence
+from typing import (
+    TYPE_CHECKING,
+    Sequence,
+)
 
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.dtypes.inference import is_list_like
 
-from pandas.core.api import DataFrame
-
 from pandas.io.common import stringify_path
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
 def read_spss(
     path: str | Path,
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 022ed2df8598d..b5036e113f8c6 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -14,9 +14,9 @@
 from functools import partial
 import re
 from typing import (
+    TYPE_CHECKING,
     Any,
     Iterator,
-    Sequence,
     cast,
     overload,
 )
@@ -25,14 +25,22 @@
 import numpy as np
 
 import pandas._libs.lib as lib
-from pandas._typing import DtypeArg
+from pandas._typing import (
+    DateTimeErrorChoices,
+    DtypeArg,
+    IndexLabel,
+)
 from pandas.compat._optional import import_optional_dependency
-from pandas.errors import AbstractMethodError
+from pandas.errors import (
+    AbstractMethodError,
+    DatabaseError,
+)
 from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     is_datetime64tz_dtype,
     is_dict_like,
+    is_integer,
     is_list_like,
 )
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
@@ -46,27 +54,15 @@
 from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.tools.datetimes import to_datetime
-from pandas.util.version import Version
-
 
-class DatabaseError(OSError):
-    pass
+if TYPE_CHECKING:
+    from sqlalchemy import Table
 
 
 # -----------------------------------------------------------------------------
 # -- Helper functions
 
 
-def _gt14() -> bool:
-    """
-    Check if sqlalchemy.__version__ is at least 1.4.0, when several
-    deprecations were made.
-    """
-    import sqlalchemy
-
-    return Version(sqlalchemy.__version__) >= Version("1.4.0")
-
-
 def _convert_params(sql, params):
     """Convert SQL and params args to DBAPI2.0 compliant format."""
     args = [sql]
@@ -97,7 +93,7 @@ def _handle_date_column(
         # read_sql like functions.
         # Format can take on custom to_datetime argument values such as
         # {"errors": "coerce"} or {"dayfirst": True}
-        error = format.pop("errors", None) or "ignore"
+        error: DateTimeErrorChoices = format.pop("errors", None) or "ignore"
         return to_datetime(col, errors=error, **format)
     else:
         # Allow passing of formatting string for integers
@@ -193,10 +189,10 @@ def read_sql_table(
     table_name,
     con,
     schema=...,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
-    parse_dates=...,
-    columns=...,
+    parse_dates: list[str] | dict[str, str] | None = ...,
+    columns: list[str] | None = ...,
     chunksize: None = ...,
 ) -> DataFrame:
     ...
@@ -207,10 +203,10 @@ def read_sql_table(
     table_name,
     con,
     schema=...,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
-    parse_dates=...,
-    columns=...,
+    parse_dates: list[str] | dict[str, str] | None = ...,
+    columns: list[str] | None = ...,
     chunksize: int = ...,
 ) -> Iterator[DataFrame]:
     ...
@@ -220,10 +216,10 @@ def read_sql_table(
     table_name: str,
     con,
     schema: str | None = None,
-    index_col: str | Sequence[str] | None = None,
+    index_col: str | list[str] | None = None,
     coerce_float: bool = True,
-    parse_dates=None,
-    columns=None,
+    parse_dates: list[str] | dict[str, str] | None = None,
+    columns: list[str] | None = None,
     chunksize: int | None = None,
 ) -> DataFrame | Iterator[DataFrame]:
     """
@@ -285,7 +281,9 @@ def read_sql_table(
     if not pandas_sql.has_table(table_name):
         raise ValueError(f"Table {table_name} not found")
 
-    table = pandas_sql.read_table(
+    # error: Item "SQLiteDatabase" of "Union[SQLDatabase, SQLiteDatabase]"
+    # has no attribute "read_table"
+    table = pandas_sql.read_table(  # type: ignore[union-attr]
         table_name,
         index_col=index_col,
         coerce_float=coerce_float,
@@ -304,10 +302,10 @@ def read_sql_table(
 def read_sql_query(
     sql,
     con,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
-    params=...,
-    parse_dates=...,
+    params: list[str] | dict[str, str] | None = ...,
+    parse_dates: list[str] | dict[str, str] | None = ...,
     chunksize: None = ...,
     dtype: DtypeArg | None = ...,
 ) -> DataFrame:
@@ -318,10 +316,10 @@ def read_sql_query(
 def read_sql_query(
     sql,
     con,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
-    params=...,
-    parse_dates=...,
+    params: list[str] | dict[str, str] | None = ...,
+    parse_dates: list[str] | dict[str, str] | None = ...,
     chunksize: int = ...,
     dtype: DtypeArg | None = ...,
 ) -> Iterator[DataFrame]:
@@ -331,10 +329,10 @@ def read_sql_query(
 def read_sql_query(
     sql,
     con,
-    index_col=None,
+    index_col: str | list[str] | None = None,
     coerce_float: bool = True,
-    params=None,
-    parse_dates=None,
+    params: list[str] | dict[str, str] | None = None,
+    parse_dates: list[str] | dict[str, str] | None = None,
     chunksize: int | None = None,
     dtype: DtypeArg | None = None,
 ) -> DataFrame | Iterator[DataFrame]:
@@ -411,11 +409,11 @@ def read_sql_query(
 def read_sql(
     sql,
     con,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
     params=...,
     parse_dates=...,
-    columns=...,
+    columns: list[str] = ...,
     chunksize: None = ...,
 ) -> DataFrame:
     ...
@@ -425,11 +423,11 @@ def read_sql(
 def read_sql(
     sql,
     con,
-    index_col=...,
+    index_col: str | list[str] | None = ...,
     coerce_float=...,
     params=...,
     parse_dates=...,
-    columns=...,
+    columns: list[str] = ...,
     chunksize: int = ...,
 ) -> Iterator[DataFrame]:
     ...
@@ -438,11 +436,11 @@ def read_sql(
 def read_sql(
     sql,
     con,
-    index_col: str | Sequence[str] | None = None,
+    index_col: str | list[str] | None = None,
     coerce_float: bool = True,
     params=None,
     parse_dates=None,
-    columns=None,
+    columns: list[str] | None = None,
     chunksize: int | None = None,
 ) -> DataFrame | Iterator[DataFrame]:
     """
@@ -606,7 +604,7 @@ def to_sql(
     schema: str | None = None,
     if_exists: str = "fail",
     index: bool = True,
-    index_label=None,
+    index_label: IndexLabel = None,
     chunksize: int | None = None,
     dtype: DtypeArg | None = None,
     method: str | None = None,
@@ -670,7 +668,7 @@ def to_sql(
     -------
     None or int
         Number of rows affected by to_sql. None is returned if the callable
-        passed into ``method`` does not return the number of rows.
+        passed into ``method`` does not return an integer number of rows.
 
         .. versionadded:: 1.4.0
 
@@ -709,7 +707,7 @@ def to_sql(
     )
 
 
-def has_table(table_name: str, con, schema: str | None = None):
+def has_table(table_name: str, con, schema: str | None = None) -> bool:
     """
     Check if DataBase has named table.
 
@@ -736,28 +734,36 @@ def has_table(table_name: str, con, schema: str | None = None):
 table_exists = has_table
 
 
-def pandasSQL_builder(con, schema: str | None = None):
+def pandasSQL_builder(con, schema: str | None = None) -> SQLDatabase | SQLiteDatabase:
     """
     Convenience function to return the correct PandasSQL subclass based on the
     provided parameters.
     """
     import sqlite3
+    import warnings
 
     if isinstance(con, sqlite3.Connection) or con is None:
         return SQLiteDatabase(con)
 
-    sqlalchemy = import_optional_dependency("sqlalchemy")
+    sqlalchemy = import_optional_dependency("sqlalchemy", errors="ignore")
 
     if isinstance(con, str):
-        con = sqlalchemy.create_engine(con)
+        if sqlalchemy is None:
+            raise ImportError("Using URI string without sqlalchemy installed.")
+        else:
+            con = sqlalchemy.create_engine(con)
 
-    if isinstance(con, sqlalchemy.engine.Connectable):
+    if sqlalchemy is not None and isinstance(con, sqlalchemy.engine.Connectable):
         return SQLDatabase(con, schema=schema)
 
-    raise ValueError(
-        "pandas only support SQLAlchemy connectable(engine/connection) or"
-        "database string URI or sqlite3 DBAPI2 connection"
+    warnings.warn(
+        "pandas only supports SQLAlchemy connectable (engine/connection) or "
+        "database string URI or sqlite3 DBAPI2 connection. "
+        "Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.",
+        UserWarning,
+        stacklevel=find_stack_level(),
     )
+    return SQLiteDatabase(con)
 
 
 class SQLTable(PandasObject):
@@ -776,14 +782,14 @@ def __init__(
         name: str,
         pandas_sql_engine,
         frame=None,
-        index=True,
-        if_exists="fail",
-        prefix="pandas",
+        index: bool | str | list[str] | None = True,
+        if_exists: str = "fail",
+        prefix: str = "pandas",
         index_label=None,
         schema=None,
         keys=None,
         dtype: DtypeArg | None = None,
-    ):
+    ) -> None:
         self.name = name
         self.pd_sql = pandas_sql_engine
         self.prefix = prefix
@@ -807,20 +813,17 @@ def __init__(
     def exists(self):
         return self.pd_sql.has_table(self.name, self.schema)
 
-    def sql_schema(self):
+    def sql_schema(self) -> str:
         from sqlalchemy.schema import CreateTable
 
         return str(CreateTable(self.table).compile(self.pd_sql.connectable))
 
     def _execute_create(self):
         # Inserting table into database, add to MetaData object
-        if _gt14():
-            self.table = self.table.to_metadata(self.pd_sql.meta)
-        else:
-            self.table = self.table.tometadata(self.pd_sql.meta)
+        self.table = self.table.to_metadata(self.pd_sql.meta)
         self.table.create(bind=self.pd_sql.connectable)
 
-    def create(self):
+    def create(self) -> None:
         if self.exists():
             if self.if_exists == "fail":
                 raise ValueError(f"Table '{self.name}' already exists.")
@@ -866,7 +869,7 @@ def _execute_insert_multi(self, conn, keys: list[str], data_iter) -> int:
         result = conn.execute(stmt)
         return result.rowcount
 
-    def insert_data(self):
+    def insert_data(self) -> tuple[list[str], list[np.ndarray]]:
         if self.index is not None:
             temp = self.frame.copy()
             temp.index.names = self.index
@@ -879,7 +882,9 @@ def insert_data(self):
 
         column_names = list(map(str, temp.columns))
         ncols = len(column_names)
-        data_list = [None] * ncols
+        # this just pre-allocates the list: None's will be replaced with ndarrays
+        # error: List item 0 has incompatible type "None"; expected "ndarray"
+        data_list: list[np.ndarray] = [None] * ncols  # type: ignore[list-item]
 
         for i, (_, ser) in enumerate(temp.items()):
             vals = ser._values
@@ -898,9 +903,7 @@ def insert_data(self):
                 mask = isna(d)
                 d[mask] = None
 
-            # error: No overload variant of "__setitem__" of "list" matches
-            # argument types "int", "ndarray"
-            data_list[i] = d  # type: ignore[call-overload]
+            data_list[i] = d
 
         return column_names, data_list
 
@@ -931,7 +934,7 @@ def insert(
             raise ValueError("chunksize argument should be non-zero")
 
         chunks = (nrows // chunksize) + 1
-        total_inserted = 0
+        total_inserted = None
         with self.pd_sql.run_transaction() as conn:
             for i in range(chunks):
                 start_i = i * chunksize
@@ -941,10 +944,12 @@ def insert(
 
                 chunk_iter = zip(*(arr[start_i:end_i] for arr in data_list))
                 num_inserted = exec_insert(conn, keys, chunk_iter)
-                if num_inserted is None:
-                    total_inserted = None
-                else:
-                    total_inserted += num_inserted
+                # GH 46891
+                if is_integer(num_inserted):
+                    if total_inserted is None:
+                        total_inserted = num_inserted
+                    else:
+                        total_inserted += num_inserted
         return total_inserted
 
     def _query_iterator(
@@ -978,7 +983,13 @@ def _query_iterator(
 
                 yield self.frame
 
-    def read(self, coerce_float=True, parse_dates=None, columns=None, chunksize=None):
+    def read(
+        self,
+        coerce_float: bool = True,
+        parse_dates=None,
+        columns=None,
+        chunksize=None,
+    ) -> DataFrame | Iterator[DataFrame]:
         from sqlalchemy import select
 
         if columns is not None and len(columns) > 0:
@@ -986,10 +997,9 @@ def read(self, coerce_float=True, parse_dates=None, columns=None, chunksize=None
             if self.index is not None:
                 for idx in self.index[::-1]:
                     cols.insert(0, self.table.c[idx])
-            sql_select = select(*cols) if _gt14() else select(cols)
+            sql_select = select(*cols)
         else:
-            sql_select = select(self.table) if _gt14() else self.table.select()
-
+            sql_select = select(self.table)
         result = self.pd_sql.execute(sql_select)
         column_names = result.keys()
 
@@ -1258,8 +1268,8 @@ def to_sql(
         self,
         frame,
         name,
-        if_exists="fail",
-        index=True,
+        if_exists: str = "fail",
+        index: bool = True,
         index_label=None,
         schema=None,
         chunksize=None,
@@ -1292,7 +1302,7 @@ def insert_records(
 
 
 class SQLAlchemyEngine(BaseEngine):
-    def __init__(self):
+    def __init__(self) -> None:
         import_optional_dependency(
             "sqlalchemy", extra="sqlalchemy is required for SQL support."
         )
@@ -1373,12 +1383,11 @@ class SQLDatabase(PandasSQL):
 
     """
 
-    def __init__(self, engine, schema: str | None = None):
+    def __init__(self, engine, schema: str | None = None) -> None:
         from sqlalchemy.schema import MetaData
 
         self.connectable = engine
         self.meta = MetaData(schema=schema)
-        self.meta.reflect(bind=engine)
 
     @contextmanager
     def run_transaction(self):
@@ -1398,13 +1407,13 @@ def execute(self, *args, **kwargs):
     def read_table(
         self,
         table_name: str,
-        index_col: str | Sequence[str] | None = None,
+        index_col: str | list[str] | None = None,
         coerce_float: bool = True,
         parse_dates=None,
         columns=None,
         schema: str | None = None,
         chunksize: int | None = None,
-    ):
+    ) -> DataFrame | Iterator[DataFrame]:
         """
         Read SQL database table into a DataFrame.
 
@@ -1493,13 +1502,13 @@ def _query_iterator(
     def read_query(
         self,
         sql: str,
-        index_col: str | None = None,
+        index_col: str | list[str] | None = None,
         coerce_float: bool = True,
         parse_dates=None,
         params=None,
         chunksize: int | None = None,
         dtype: DtypeArg | None = None,
-    ):
+    ) -> DataFrame | Iterator[DataFrame]:
         """
         Read SQL query into a DataFrame.
 
@@ -1624,9 +1633,9 @@ def prep_table(
 
     def check_case_sensitive(
         self,
-        name,
-        schema,
-    ):
+        name: str,
+        schema: str | None,
+    ) -> None:
         """
         Checks table name for issues with case-sensitivity.
         Method is called after data is inserted.
@@ -1634,19 +1643,11 @@ def check_case_sensitive(
         if not name.isdigit() and not name.islower():
             # check for potentially case sensitivity issues (GH7815)
             # Only check when name is not a number and name is not lower case
-            engine = self.connectable.engine
-            with self.connectable.connect() as conn:
-                if _gt14():
-                    from sqlalchemy import inspect
+            from sqlalchemy import inspect as sqlalchemy_inspect
 
-                    insp = inspect(conn)
-                    table_names = insp.get_table_names(
-                        schema=schema or self.meta.schema
-                    )
-                else:
-                    table_names = engine.table_names(
-                        schema=schema or self.meta.schema, connection=conn
-                    )
+            with self.connectable.connect() as conn:
+                insp = sqlalchemy_inspect(conn)
+                table_names = insp.get_table_names(schema=schema or self.meta.schema)
             if name not in table_names:
                 msg = (
                     f"The provided table name '{name}' is not found exactly as "
@@ -1654,16 +1655,20 @@ def check_case_sensitive(
                     "due to case sensitivity issues. Consider using lower "
                     "case table names."
                 )
-                warnings.warn(msg, UserWarning)
+                warnings.warn(
+                    msg,
+                    UserWarning,
+                    stacklevel=find_stack_level(),
+                )
 
     def to_sql(
         self,
         frame,
-        name,
-        if_exists="fail",
-        index=True,
+        name: str,
+        if_exists: str = "fail",
+        index: bool = True,
         index_label=None,
-        schema=None,
+        schema: str | None = None,
         chunksize=None,
         dtype: DtypeArg | None = None,
         method=None,
@@ -1750,33 +1755,27 @@ def tables(self):
         return self.meta.tables
 
     def has_table(self, name: str, schema: str | None = None):
-        if _gt14():
-            from sqlalchemy import inspect
+        from sqlalchemy import inspect as sqlalchemy_inspect
 
-            insp = inspect(self.connectable)
-            return insp.has_table(name, schema or self.meta.schema)
-        else:
-            return self.connectable.run_callable(
-                self.connectable.dialect.has_table, name, schema or self.meta.schema
-            )
-
-    def get_table(self, table_name: str, schema: str | None = None):
-        schema = schema or self.meta.schema
-        if schema:
-            tbl = self.meta.tables.get(".".join([schema, table_name]))
-        else:
-            tbl = self.meta.tables.get(table_name)
+        insp = sqlalchemy_inspect(self.connectable)
+        return insp.has_table(name, schema or self.meta.schema)
 
-        # Avoid casting double-precision floats into decimals
-        from sqlalchemy import Numeric
+    def get_table(self, table_name: str, schema: str | None = None) -> Table:
+        from sqlalchemy import (
+            Numeric,
+            Table,
+        )
 
+        schema = schema or self.meta.schema
+        tbl = Table(
+            table_name, self.meta, autoload_with=self.connectable, schema=schema
+        )
         for column in tbl.columns:
             if isinstance(column.type, Numeric):
                 column.type.asdecimal = False
-
         return tbl
 
-    def drop_table(self, table_name: str, schema: str | None = None):
+    def drop_table(self, table_name: str, schema: str | None = None) -> None:
         schema = schema or self.meta.schema
         if self.has_table(table_name, schema):
             self.meta.reflect(bind=self.connectable, only=[table_name], schema=schema)
@@ -1849,17 +1848,21 @@ class SQLiteTable(SQLTable):
     Instead of a table variable just use the Create Table statement.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         # GH 8341
         # register an adapter callable for datetime.time object
         import sqlite3
 
         # this will transform time(12,34,56,789) into '12:34:56.000789'
         # (this is what sqlalchemy does)
-        sqlite3.register_adapter(time, lambda _: _.strftime("%H:%M:%S.%f"))
+        def _adapt_time(t):
+            # This is faster than strftime
+            return f"{t.hour:02d}:{t.minute:02d}:{t.second:02d}.{t.microsecond:06d}"
+
+        sqlite3.register_adapter(time, _adapt_time)
         super().__init__(*args, **kwargs)
 
-    def sql_schema(self):
+    def sql_schema(self) -> str:
         return str(";\n".join(self.table))
 
     def _execute_create(self):
@@ -1867,7 +1870,7 @@ def _execute_create(self):
             for stmt in self.table:
                 conn.execute(stmt)
 
-    def insert_statement(self, *, num_rows: int):
+    def insert_statement(self, *, num_rows: int) -> str:
         names = list(map(str, self.frame.columns))
         wld = "?"  # wildcard char
         escape = _get_valid_sqlite_name
@@ -1994,7 +1997,7 @@ class SQLiteDatabase(PandasSQL):
 
     """
 
-    def __init__(self, con):
+    def __init__(self, con) -> None:
         self.con = con
 
     @contextmanager
@@ -2069,7 +2072,7 @@ def read_query(
         parse_dates=None,
         chunksize: int | None = None,
         dtype: DtypeArg | None = None,
-    ):
+    ) -> DataFrame | Iterator[DataFrame]:
 
         args = _convert_params(sql, params)
         cursor = self.execute(*args)
@@ -2109,8 +2112,8 @@ def to_sql(
         self,
         frame,
         name,
-        if_exists="fail",
-        index=True,
+        if_exists: str = "fail",
+        index: bool = True,
         index_label=None,
         schema=None,
         chunksize=None,
@@ -2184,17 +2187,17 @@ def to_sql(
         table.create()
         return table.insert(chunksize, method)
 
-    def has_table(self, name: str, schema: str | None = None):
+    def has_table(self, name: str, schema: str | None = None) -> bool:
 
         wld = "?"
         query = f"SELECT name FROM sqlite_master WHERE type='table' AND name={wld};"
 
         return len(self.execute(query, [name]).fetchall()) > 0
 
-    def get_table(self, table_name: str, schema: str | None = None):
+    def get_table(self, table_name: str, schema: str | None = None) -> None:
         return None  # not supported in fallback mode
 
-    def drop_table(self, name: str, schema: str | None = None):
+    def drop_table(self, name: str, schema: str | None = None) -> None:
         drop_sql = f"DROP TABLE {_get_valid_sqlite_name(name)}"
         self.execute(drop_sql)
 
@@ -2225,7 +2228,7 @@ def get_schema(
     con=None,
     dtype: DtypeArg | None = None,
     schema: str | None = None,
-):
+) -> str:
     """
     Get the SQL db table schema for the given frame.
 
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 451ab170e149d..fd4d2c2354398 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -22,6 +22,7 @@
     TYPE_CHECKING,
     Any,
     AnyStr,
+    Final,
     Hashable,
     Sequence,
     cast,
@@ -40,10 +41,18 @@
     StorageOptions,
     WriteBuffer,
 )
+from pandas.errors import (
+    CategoricalConversionWarning,
+    InvalidColumnName,
+    PossiblePrecisionLoss,
+    ValueLabelTypeMismatch,
+)
 from pandas.util._decorators import (
     Appender,
+    deprecate_nonkeyword_arguments,
     doc,
 )
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     ensure_object,
@@ -62,7 +71,7 @@
     to_timedelta,
 )
 from pandas.core.arrays.boolean import BooleanDtype
-from pandas.core.arrays.integer import _IntegerDtype
+from pandas.core.arrays.integer import IntegerDtype
 from pandas.core.frame import DataFrame
 from pandas.core.indexes.base import Index
 from pandas.core.series import Series
@@ -140,7 +149,7 @@
 {_statafile_processing_params2}
 {_chunksize_params}
 {_iterator_params}
-{_shared_docs["decompression_options"]}
+{_shared_docs["decompression_options"] % "filepath_or_buffer"}
 {_shared_docs["storage_options"]}
 
 Returns
@@ -214,7 +223,7 @@
 _date_formats = ["%tc", "%tC", "%td", "%d", "%tw", "%tm", "%tq", "%th", "%ty"]
 
 
-stata_epoch = datetime.datetime(1960, 1, 1)
+stata_epoch: Final = datetime.datetime(1960, 1, 1)
 
 
 # TODO: Add typing. As of January 2020 it is not possible to type this function since
@@ -331,8 +340,10 @@ def convert_delta_safe(base, deltas, unit) -> Series:
     has_bad_values = False
     if bad_locs.any():
         has_bad_values = True
-        data_col = Series(dates)
-        data_col[bad_locs] = 1.0  # Replace with NaT
+        # reset cache to avoid SettingWithCopy checks (we own the DataFrame and the
+        # `dates` Series is used to overwrite itself in the DataFramae)
+        dates._reset_cacher()
+        dates[bad_locs] = 1.0  # Replace with NaT
     dates = dates.astype(np.int64)
 
     if fmt.startswith(("%tc", "tc")):  # Delta ms relative to base
@@ -341,7 +352,10 @@ def convert_delta_safe(base, deltas, unit) -> Series:
         conv_dates = convert_delta_safe(base, ms, "ms")
     elif fmt.startswith(("%tC", "tC")):
 
-        warnings.warn("Encountered %tC format. Leaving in Stata Internal Format.")
+        warnings.warn(
+            "Encountered %tC format. Leaving in Stata Internal Format.",
+            stacklevel=find_stack_level(),
+        )
         conv_dates = Series(dates, dtype=object)
         if has_bad_values:
             conv_dates[bad_locs] = NaT
@@ -455,7 +469,10 @@ def g(x: datetime.datetime) -> int:
         d = parse_dates_safe(dates, delta=True)
         conv_dates = d.delta / 1000
     elif fmt in ["%tC", "tC"]:
-        warnings.warn("Stata Internal Format tC not supported.")
+        warnings.warn(
+            "Stata Internal Format tC not supported.",
+            stacklevel=find_stack_level(),
+        )
         conv_dates = dates
     elif fmt in ["%td", "td"]:
         d = parse_dates_safe(dates, delta=True)
@@ -485,39 +502,27 @@ def g(x: datetime.datetime) -> int:
     return Series(conv_dates, index=index)
 
 
-excessive_string_length_error = """
+excessive_string_length_error: Final = """
 Fixed width strings in Stata .dta files are limited to 244 (or fewer)
 characters.  Column '{0}' does not satisfy this restriction. Use the
 'version=117' parameter to write the newer (Stata 13 and later) format.
 """
 
 
-class PossiblePrecisionLoss(Warning):
-    pass
-
-
-precision_loss_doc = """
+precision_loss_doc: Final = """
 Column converted from {0} to {1}, and some data are outside of the lossless
 conversion range. This may result in a loss of precision in the saved data.
 """
 
 
-class ValueLabelTypeMismatch(Warning):
-    pass
-
-
-value_label_mismatch_doc = """
+value_label_mismatch_doc: Final = """
 Stata value labels (pandas categories) must be strings. Column {0} contains
 non-string labels which will be converted to strings.  Please check that the
 Stata data file created has not lost information due to duplicate labels.
 """
 
 
-class InvalidColumnName(Warning):
-    pass
-
-
-invalid_name_doc = """
+invalid_name_doc: Final = """
 Not all pandas column names were valid Stata variable names.
 The following replacements have been made:
 
@@ -529,11 +534,7 @@ class InvalidColumnName(Warning):
 """
 
 
-class CategoricalConversionWarning(Warning):
-    pass
-
-
-categorical_conversion_warning = """
+categorical_conversion_warning: Final = """
 One or more series with value labels are not fully labeled. Reading this
 dataset with an iterator results in categorical variable with different
 categories. This occurs since it is not possible to know all possible values
@@ -572,7 +573,13 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
     """
     ws = ""
     # original, if small, if large
-    conversion_data = (
+    conversion_data: tuple[
+        tuple[type, type, type],
+        tuple[type, type, type],
+        tuple[type, type, type],
+        tuple[type, type, type],
+        tuple[type, type, type],
+    ] = (
         (np.bool_, np.int8, np.int8),
         (np.uint8, np.int8, np.int16),
         (np.uint16, np.int16, np.int32),
@@ -585,7 +592,7 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
 
     for col in data:
         # Cast from unsupported types to supported types
-        is_nullable_int = isinstance(data[col].dtype, (_IntegerDtype, BooleanDtype))
+        is_nullable_int = isinstance(data[col].dtype, (IntegerDtype, BooleanDtype))
         orig = data[col]
         # We need to find orig_missing before altering data below
         orig_missing = orig.isna()
@@ -593,7 +600,8 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
             missing_loc = data[col].isna()
             if missing_loc.any():
                 # Replace with always safe value
-                data.loc[missing_loc, col] = 0
+                fv = 0 if isinstance(data[col].dtype, IntegerDtype) else False
+                data.loc[missing_loc, col] = fv
             # Replace with NumPy-compatible column
             data[col] = data[col].astype(data[col].dtype.numpy_dtype)
         dtype = data[col].dtype
@@ -604,7 +612,7 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
                 else:
                     dtype = c_data[2]
                 if c_data[2] == np.int64:  # Warn if necessary
-                    if data[col].max() >= 2 ** 53:
+                    if data[col].max() >= 2**53:
                         ws = precision_loss_doc.format("uint64", "float64")
 
                 data[col] = data[col].astype(dtype)
@@ -621,15 +629,15 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
                 data[col] = data[col].astype(np.int32)
             else:
                 data[col] = data[col].astype(np.float64)
-                if data[col].max() >= 2 ** 53 or data[col].min() <= -(2 ** 53):
+                if data[col].max() >= 2**53 or data[col].min() <= -(2**53):
                     ws = precision_loss_doc.format("int64", "float64")
         elif dtype in (np.float32, np.float64):
-            value = data[col].max()
-            if np.isinf(value):
+            if np.isinf(data[col]).any():
                 raise ValueError(
-                    f"Column {col} has a maximum value of infinity which is outside "
-                    "the range supported by Stata."
+                    f"Column {col} contains infinity or -infinity"
+                    "which is outside the range supported by Stata."
                 )
+            value = data[col].max()
             if dtype == np.float32 and value > float32_max:
                 data[col] = data[col].astype(np.float64)
             elif dtype == np.float64:
@@ -644,7 +652,11 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
                 sentinel = StataMissingValue.BASE_MISSING_VALUES[data[col].dtype.name]
                 data.loc[orig_missing, col] = sentinel
     if ws:
-        warnings.warn(ws, PossiblePrecisionLoss)
+        warnings.warn(
+            ws,
+            PossiblePrecisionLoss,
+            stacklevel=find_stack_level(),
+        )
 
     return data
 
@@ -661,14 +673,16 @@ class StataValueLabel:
         Encoding to use for value labels.
     """
 
-    def __init__(self, catarray: Series, encoding: str = "latin-1"):
+    def __init__(
+        self, catarray: Series, encoding: Literal["latin-1", "utf-8"] = "latin-1"
+    ) -> None:
 
         if encoding not in ("latin-1", "utf-8"):
             raise ValueError("Only latin-1 and utf-8 are supported.")
         self.labname = catarray.name
         self._encoding = encoding
         categories = catarray.cat.categories
-        self.value_labels: list[tuple[int | float, str]] = list(
+        self.value_labels: list[tuple[float, str]] = list(
             zip(np.arange(len(categories)), categories)
         )
         self.value_labels.sort(key=lambda x: x[0])
@@ -689,7 +703,7 @@ def _prepare_value_labels(self):
 
         # Compute lengths and setup lists of offsets and labels
         offsets: list[int] = []
-        values: list[int | float] = []
+        values: list[float] = []
         for vl in self.value_labels:
             category: str | bytes = vl[1]
             if not isinstance(category, str):
@@ -697,6 +711,7 @@ def _prepare_value_labels(self):
                 warnings.warn(
                     value_label_mismatch_doc.format(self.labname),
                     ValueLabelTypeMismatch,
+                    stacklevel=find_stack_level(),
                 )
             category = category.encode(self._encoding)
             offsets.append(self.text_len)
@@ -788,16 +803,16 @@ class StataNonCatValueLabel(StataValueLabel):
     def __init__(
         self,
         labname: str,
-        value_labels: dict[float | int, str],
+        value_labels: dict[float, str],
         encoding: Literal["latin-1", "utf-8"] = "latin-1",
-    ):
+    ) -> None:
 
         if encoding not in ("latin-1", "utf-8"):
             raise ValueError("Only latin-1 and utf-8 are supported.")
 
         self.labname = labname
         self._encoding = encoding
-        self.value_labels: list[tuple[int | float, str]] = sorted(
+        self.value_labels: list[tuple[float, str]] = sorted(
             value_labels.items(), key=lambda x: x[0]
         )
         self._prepare_value_labels()
@@ -842,15 +857,15 @@ class StataMissingValue:
 
     # Construct a dictionary of missing values
     MISSING_VALUES: dict[float, str] = {}
-    bases = (101, 32741, 2147483621)
+    bases: Final = (101, 32741, 2147483621)
     for b in bases:
         # Conversion to long to avoid hash issues on 32 bit platforms #8968
         MISSING_VALUES[b] = "."
         for i in range(1, 27):
             MISSING_VALUES[i + b] = "." + chr(96 + i)
 
-    float32_base = b"\x00\x00\x00\x7f"
-    increment = struct.unpack("<i", b"\x00\x08\x00\x00")[0]
+    float32_base: bytes = b"\x00\x00\x00\x7f"
+    increment: int = struct.unpack("<i", b"\x00\x08\x00\x00")[0]
     for i in range(27):
         key = struct.unpack("<f", float32_base)[0]
         MISSING_VALUES[key] = "."
@@ -859,7 +874,7 @@ class StataMissingValue:
         int_value = struct.unpack("<i", struct.pack("<f", key))[0] + increment
         float32_base = struct.pack("<i", int_value)
 
-    float64_base = b"\x00\x00\x00\x00\x00\x00\xe0\x7f"
+    float64_base: bytes = b"\x00\x00\x00\x00\x00\x00\xe0\x7f"
     increment = struct.unpack("q", b"\x00\x00\x00\x00\x00\x01\x00\x00")[0]
     for i in range(27):
         key = struct.unpack("<d", float64_base)[0]
@@ -869,7 +884,7 @@ class StataMissingValue:
         int_value = struct.unpack("q", struct.pack("<d", key))[0] + increment
         float64_base = struct.pack("q", int_value)
 
-    BASE_MISSING_VALUES = {
+    BASE_MISSING_VALUES: Final = {
         "int8": 101,
         "int16": 32741,
         "int32": 2147483621,
@@ -877,7 +892,7 @@ class StataMissingValue:
         "float64": struct.unpack("<d", float64_base)[0],
     }
 
-    def __init__(self, value: int | float):
+    def __init__(self, value: float) -> None:
         self._value = value
         # Conversion to int to avoid hash issues on 32 bit platforms #8968
         value = int(value) if value < 2147483648 else float(value)
@@ -896,7 +911,7 @@ def string(self) -> str:
         return self._str
 
     @property
-    def value(self) -> int | float:
+    def value(self) -> float:
         """
         The binary representation of the missing value.
 
@@ -921,7 +936,7 @@ def __eq__(self, other: Any) -> bool:
         )
 
     @classmethod
-    def get_base_missing_value(cls, dtype: np.dtype) -> int | float:
+    def get_base_missing_value(cls, dtype: np.dtype) -> float:
         if dtype.type is np.int8:
             value = cls.BASE_MISSING_VALUES["int8"]
         elif dtype.type is np.int16:
@@ -938,7 +953,7 @@ def get_base_missing_value(cls, dtype: np.dtype) -> int | float:
 
 
 class StataParser:
-    def __init__(self):
+    def __init__(self) -> None:
 
         # type          code.
         # --------------------
@@ -965,7 +980,7 @@ def __init__(self):
                 (255, np.dtype(np.float64)),
             ]
         )
-        self.DTYPE_MAP_XML = {
+        self.DTYPE_MAP_XML: dict[int, np.dtype] = {
             32768: np.dtype(np.uint8),  # Keys to GSO
             65526: np.dtype(np.float64),
             65527: np.dtype(np.float32),
@@ -973,9 +988,7 @@ def __init__(self):
             65529: np.dtype(np.int16),
             65530: np.dtype(np.int8),
         }
-        # error: Argument 1 to "list" has incompatible type "str";
-        #  expected "Iterable[int]"  [arg-type]
-        self.TYPE_MAP = list(range(251)) + list("bhlfd")  # type: ignore[arg-type]
+        self.TYPE_MAP = list(tuple(range(251)) + tuple("bhlfd"))
         self.TYPE_MAP_XML = {
             # Not really a Q, unclear how to handle byteswap
             32768: "Q",
@@ -1115,7 +1128,7 @@ def __init__(
         chunksize: int | None = None,
         compression: CompressionOptions = "infer",
         storage_options: StorageOptions = None,
-    ):
+    ) -> None:
         super().__init__()
         self.col_sizes: list[int] = []
 
@@ -1294,9 +1307,7 @@ def g(typ: int) -> str | np.dtype:
             if typ <= 2045:
                 return str(typ)
             try:
-                # error: Incompatible return value type (got "Type[number]", expected
-                # "Union[str, dtype]")
-                return self.DTYPE_MAP_XML[typ]  # type: ignore[return-value]
+                return self.DTYPE_MAP_XML[typ]
             except KeyError as err:
                 raise ValueError(f"cannot convert stata dtype [{typ}]") from err
 
@@ -1510,7 +1521,11 @@ def _decode(self, s: bytes) -> str:
 so the fallback encoding of latin-1 is being used.  This can happen when a file
 has been incorrectly encoded by Stata or some other software. You should verify
 the string values returned are correct."""
-            warnings.warn(msg, UnicodeWarning)
+            warnings.warn(
+                msg,
+                UnicodeWarning,
+                stacklevel=find_stack_level(),
+            )
             return s.decode("latin-1")
 
     def _read_value_labels(self) -> None:
@@ -1520,7 +1535,7 @@ def _read_value_labels(self) -> None:
         if self.format_version <= 108:
             # Value labels are not supported in version 108 and earlier.
             self._value_labels_read = True
-            self.value_label_dict: dict[str, dict[float | int, str]] = {}
+            self.value_label_dict: dict[str, dict[float, str]] = {}
             return
 
         if self.format_version >= 117:
@@ -1880,7 +1895,7 @@ def _do_select_columns(self, data: DataFrame, columns: Sequence[str]) -> DataFra
     def _do_convert_categoricals(
         self,
         data: DataFrame,
-        value_label_dict: dict[str, dict[float | int, str]],
+        value_label_dict: dict[str, dict[float, str]],
         lbllist: Sequence[str],
         order_categoricals: bool,
     ) -> DataFrame:
@@ -1906,7 +1921,9 @@ def _do_convert_categoricals(
                     if self._using_iterator:
                         # warn is using an iterator
                         warnings.warn(
-                            categorical_conversion_warning, CategoricalConversionWarning
+                            categorical_conversion_warning,
+                            CategoricalConversionWarning,
+                            stacklevel=find_stack_level(),
                         )
                     initial_categories = None
                 cat_data = Categorical(
@@ -1925,7 +1942,8 @@ def _do_convert_categoricals(
                     categories = list(vl.values())
                 try:
                     # Try to catch duplicate categories
-                    cat_data.categories = categories
+                    # TODO: if we get a non-copying rename_categories, use that
+                    cat_data = cat_data.rename_categories(categories)
                 except ValueError as err:
                     vc = Series(categories).value_counts()
                     repeated_cats = list(vc.index[vc > 1])
@@ -1960,8 +1978,7 @@ def data_label(self) -> str:
 
     def variable_labels(self) -> dict[str, str]:
         """
-        Return variable labels as a dict, associating each variable name
-        with corresponding label.
+        Return a dict associating each variable name with corresponding label.
 
         Returns
         -------
@@ -1969,10 +1986,9 @@ def variable_labels(self) -> dict[str, str]:
         """
         return dict(zip(self.varlist, self._variable_labels))
 
-    def value_labels(self) -> dict[str, dict[float | int, str]]:
+    def value_labels(self) -> dict[str, dict[float, str]]:
         """
-        Return a dict, associating each variable name a dict, associating
-        each value its corresponding label.
+        Return a nested dict associating each variable name to its value and label.
 
         Returns
         -------
@@ -1985,6 +2001,7 @@ def value_labels(self) -> dict[str, dict[float | int, str]]:
 
 
 @Appender(_read_stata_doc)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["filepath_or_buffer"])
 def read_stata(
     filepath_or_buffer: FilePath | ReadBuffer[bytes],
     convert_dates: bool = True,
@@ -2247,7 +2264,7 @@ class StataWriter(StataParser):
     """
 
     _max_string_length = 244
-    _encoding = "latin-1"
+    _encoding: Literal["latin-1", "utf-8"] = "latin-1"
 
     def __init__(
         self,
@@ -2262,8 +2279,8 @@ def __init__(
         compression: CompressionOptions = "infer",
         storage_options: StorageOptions = None,
         *,
-        value_labels: dict[Hashable, dict[float | int, str]] | None = None,
-    ):
+        value_labels: dict[Hashable, dict[float, str]] | None = None,
+    ) -> None:
         super().__init__()
         self.data = data
         self._convert_dates = {} if convert_dates is None else convert_dates
@@ -2328,7 +2345,7 @@ def _prepare_non_cat_value_labels(
                     f"Can't create value labels for {labname}, value labels "
                     "can only be applied to numeric columns."
                 )
-            svl = StataNonCatValueLabel(colname, labels)
+            svl = StataNonCatValueLabel(colname, labels, self._encoding)
             non_cat_value_labels.append(svl)
         return non_cat_value_labels
 
@@ -2487,7 +2504,11 @@ def _check_column_names(self, data: DataFrame) -> DataFrame:
                 conversion_warning.append(msg)
 
             ws = invalid_name_doc.format("\n    ".join(conversion_warning))
-            warnings.warn(ws, InvalidColumnName)
+            warnings.warn(
+                ws,
+                InvalidColumnName,
+                stacklevel=find_stack_level(),
+            )
 
         self._converted_names = converted_names
         self._update_strl_names()
@@ -2605,6 +2626,9 @@ def _encode_strings(self) -> None:
                     self.data[col] = encoded
 
     def write_file(self) -> None:
+        """
+        Export DataFrame object to Stata dta format.
+        """
         with get_handle(
             self._fname,
             "wb",
@@ -2651,6 +2675,7 @@ def write_file(self) -> None:
                             f"This save was not successful but {self._fname} could not "
                             "be deleted. This file is not valid.",
                             ResourceWarning,
+                            stacklevel=find_stack_level(),
                         )
                 raise exc
 
@@ -2938,7 +2963,7 @@ def __init__(
         columns: Sequence[str],
         version: int = 117,
         byteorder: str | None = None,
-    ):
+    ) -> None:
         if version not in (117, 118, 119):
             raise ValueError("Only dta versions 117, 118 and 119 supported")
         self._dta_ver = version
@@ -3153,21 +3178,22 @@ class StataWriter117(StataWriter):
 
     Examples
     --------
-    >>> from pandas.io.stata import StataWriter117
     >>> data = pd.DataFrame([[1.0, 1, 'a']], columns=['a', 'b', 'c'])
-    >>> writer = StataWriter117('./data_file.dta', data)
+    >>> writer = pd.io.stata.StataWriter117('./data_file.dta', data)
     >>> writer.write_file()
 
     Directly write a zip file
     >>> compression = {"method": "zip", "archive_name": "data_file.dta"}
-    >>> writer = StataWriter117('./data_file.zip', data, compression=compression)
+    >>> writer = pd.io.stata.StataWriter117(
+    ...     './data_file.zip', data, compression=compression
+    ...     )
     >>> writer.write_file()
 
     Or with long strings stored in strl format
     >>> data = pd.DataFrame([['A relatively long string'], [''], ['']],
     ...                     columns=['strls'])
-    >>> writer = StataWriter117('./data_file_with_long_strings.dta', data,
-    ...                         convert_strl=['strls'])
+    >>> writer = pd.io.stata.StataWriter117(
+    ...     './data_file_with_long_strings.dta', data, convert_strl=['strls'])
     >>> writer.write_file()
     """
 
@@ -3188,8 +3214,8 @@ def __init__(
         compression: CompressionOptions = "infer",
         storage_options: StorageOptions = None,
         *,
-        value_labels: dict[Hashable, dict[float | int, str]] | None = None,
-    ):
+        value_labels: dict[Hashable, dict[float, str]] | None = None,
+    ) -> None:
         # Copy to new list since convert_strl might be modified later
         self._convert_strl: list[Hashable] = []
         if convert_strl is not None:
@@ -3568,7 +3594,7 @@ class StataWriterUTF8(StataWriter117):
     >>> writer.write_file()
     """
 
-    _encoding = "utf-8"
+    _encoding: Literal["utf-8"] = "utf-8"
 
     def __init__(
         self,
@@ -3585,8 +3611,8 @@ def __init__(
         compression: CompressionOptions = "infer",
         storage_options: StorageOptions = None,
         *,
-        value_labels: dict[Hashable, dict[float | int, str]] | None = None,
-    ):
+        value_labels: dict[Hashable, dict[float, str]] | None = None,
+    ) -> None:
         if version is None:
             version = 118 if data.shape[1] <= 32767 else 119
         elif version not in (118, 119):
@@ -3637,12 +3663,16 @@ def _validate_variable_name(self, name: str) -> str:
         # High code points appear to be acceptable
         for c in name:
             if (
-                ord(c) < 128
-                and (c < "A" or c > "Z")
-                and (c < "a" or c > "z")
-                and (c < "0" or c > "9")
-                and c != "_"
-            ) or 128 <= ord(c) < 256:
+                (
+                    ord(c) < 128
+                    and (c < "A" or c > "Z")
+                    and (c < "a" or c > "z")
+                    and (c < "0" or c > "9")
+                    and c != "_"
+                )
+                or 128 <= ord(c) < 192
+                or c in {"×", "÷"}
+            ):
                 name = name.replace(c, "_")
 
         return name
diff --git a/pandas/io/xml.py b/pandas/io/xml.py
index ad87b18bd1683..fbe3e41be88a9 100644
--- a/pandas/io/xml.py
+++ b/pandas/io/xml.py
@@ -5,11 +5,19 @@
 from __future__ import annotations
 
 import io
-from typing import Sequence
+from typing import (
+    Any,
+    Callable,
+    Sequence,
+)
 
 from pandas._typing import (
+    TYPE_CHECKING,
     CompressionOptions,
+    ConvertersArg,
+    DtypeArg,
     FilePath,
+    ParseDatesArg,
     ReadBuffer,
     StorageOptions,
     XMLParsers,
@@ -26,20 +34,33 @@
 
 from pandas.core.dtypes.common import is_list_like
 
-from pandas.core.frame import DataFrame
 from pandas.core.shared_docs import _shared_docs
 
 from pandas.io.common import (
     file_exists,
     get_handle,
+    infer_compression,
     is_fsspec_url,
     is_url,
     stringify_path,
 )
 from pandas.io.parsers import TextParser
 
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+    from lxml.etree import (
+        _Element,
+        _XSLTResultTree,
+    )
+
+    from pandas import DataFrame
+
 
-@doc(decompression_options=_shared_docs["decompression_options"] % "path_or_buffer")
+@doc(
+    storage_options=_shared_docs["storage_options"],
+    decompression_options=_shared_docs["decompression_options"] % "path_or_buffer",
+)
 class _XMLFrameParser:
     """
     Internal subclass to parse XML into DataFrames.
@@ -54,7 +75,7 @@ class _XMLFrameParser:
         The XPath expression to parse required set of nodes for
         migration to `Data Frame`. `etree` supports limited XPath.
 
-    namespacess : dict
+    namespaces : dict
         The namespaces defined in XML document (`xmlns:namespace='URI')
         as dicts with key being namespace and value the URI.
 
@@ -67,6 +88,23 @@ class _XMLFrameParser:
     names : list
         Column names for Data Frame of parsed XML data.
 
+    dtype : dict
+        Data type for data or columns. E.g. {{'a': np.float64,
+        'b': np.int32, 'c': 'Int64'}}
+
+        .. versionadded:: 1.5.0
+
+    converters : dict, optional
+        Dict of functions for converting values in certain columns. Keys can
+        either be integers or column labels.
+
+        .. versionadded:: 1.5.0
+
+    parse_dates : bool or list of int or names or list of lists or dict
+        Converts either index or select columns to datetimes
+
+        .. versionadded:: 1.5.0
+
     encoding : str
         Encoding of xml object or document.
 
@@ -74,13 +112,18 @@ class _XMLFrameParser:
         URL, file, file-like object, or a raw string containing XSLT,
         `etree` does not support XSLT but retained for consistency.
 
+    iterparse : dict, optional
+        Dict with row element as key and list of descendant elements
+        and/or attributes as value to be retrieved in iterparsing of
+        XML document.
+
+        .. versionadded:: 1.5.0
+
     {decompression_options}
 
         .. versionchanged:: 1.4.0 Zstandard support.
 
-    storage_options : dict, optional
-        Extra options that make sense for a particular storage connection,
-        e.g. host, port, username, password, etc.,
+    {storage_options}
 
     See also
     --------
@@ -92,6 +135,7 @@ class _XMLFrameParser:
     To subclass this class effectively you must override the following methods:`
         * :func:`parse_data`
         * :func:`_parse_nodes`
+        * :func:`_iterparse_nodes`
         * :func:`_parse_doc`
         * :func:`_validate_names`
         * :func:`_validate_path`
@@ -109,19 +153,27 @@ def __init__(
         elems_only: bool,
         attrs_only: bool,
         names: Sequence[str] | None,
+        dtype: DtypeArg | None,
+        converters: ConvertersArg | None,
+        parse_dates: ParseDatesArg | None,
         encoding: str | None,
         stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None,
+        iterparse: dict[str, list[str]] | None,
         compression: CompressionOptions,
         storage_options: StorageOptions,
-    ):
+    ) -> None:
         self.path_or_buffer = path_or_buffer
         self.xpath = xpath
         self.namespaces = namespaces
         self.elems_only = elems_only
         self.attrs_only = attrs_only
         self.names = names
+        self.dtype = dtype
+        self.converters = converters
+        self.parse_dates = parse_dates
         self.encoding = encoding
         self.stylesheet = stylesheet
+        self.iterparse = iterparse
         self.is_style = None
         self.compression = compression
         self.storage_options = storage_options
@@ -136,7 +188,7 @@ def parse_data(self) -> list[dict[str, str | None]]:
 
         raise AbstractMethodError(self)
 
-    def _parse_nodes(self) -> list[dict[str, str | None]]:
+    def _parse_nodes(self, elems: list[Any]) -> list[dict[str, str | None]]:
         """
         Parse xml nodes.
 
@@ -151,77 +203,11 @@ def _parse_nodes(self) -> list[dict[str, str | None]]:
 
         Notes
         -----
-        Namespace URIs will be removed from return node values.Also,
+        Namespace URIs will be removed from return node values. Also,
         elements with missing children or attributes compared to siblings
-        will have optional keys filled withi None values.
+        will have optional keys filled with None values.
         """
 
-        raise AbstractMethodError(self)
-
-    def _validate_path(self) -> None:
-        """
-        Validate xpath.
-
-        This method checks for syntax, evaluation, or empty nodes return.
-
-        Raises
-        ------
-        SyntaxError
-            * If xpah is not supported or issues with namespaces.
-
-        ValueError
-            * If xpah does not return any nodes.
-        """
-
-        raise AbstractMethodError(self)
-
-    def _validate_names(self) -> None:
-        """
-        Validate names.
-
-        This method will check if names is a list-like and aligns
-        with length of parse nodes.
-
-        Raises
-        ------
-        ValueError
-            * If value is not a list and less then length of nodes.
-        """
-        raise AbstractMethodError(self)
-
-    def _parse_doc(self, raw_doc) -> bytes:
-        """
-        Build tree from path_or_buffer.
-
-        This method will parse XML object into tree
-        either from string/bytes or file location.
-        """
-        raise AbstractMethodError(self)
-
-
-class _EtreeFrameParser(_XMLFrameParser):
-    """
-    Internal class to parse XML into DataFrames with the Python
-    standard library XML module: `xml.etree.ElementTree`.
-    """
-
-    def parse_data(self) -> list[dict[str, str | None]]:
-        from xml.etree.ElementTree import XML
-
-        if self.stylesheet is not None:
-            raise ValueError(
-                "To use stylesheet, you need lxml installed and selected as parser."
-            )
-
-        self.xml_doc = XML(self._parse_doc(self.path_or_buffer))
-
-        self._validate_path()
-        self._validate_names()
-
-        return self._parse_nodes()
-
-    def _parse_nodes(self) -> list[dict[str, str | None]]:
-        elems = self.xml_doc.findall(self.xpath, namespaces=self.namespaces)
         dicts: list[dict[str, str | None]]
 
         if self.elems_only and self.attrs_only:
@@ -304,6 +290,175 @@ def _parse_nodes(self) -> list[dict[str, str | None]]:
 
         return dicts
 
+    def _iterparse_nodes(self, iterparse: Callable) -> list[dict[str, str | None]]:
+        """
+        Iterparse xml nodes.
+
+        This method will read in local disk, decompressed XML files for elements
+        and underlying descendants using iterparse, a method to iterate through
+        an XML tree without holding entire XML tree in memory.
+
+        Raises
+        ------
+        TypeError
+            * If `iterparse` is not a dict or its dict value is not list-like.
+        ParserError
+            * If `path_or_buffer` is not a physical, decompressed file on disk.
+            * If no data is returned from selected items in `iterparse`.
+
+        Notes
+        -----
+        Namespace URIs will be removed from return node values. Also,
+        elements with missing children or attributes in submitted list
+        will have optional keys filled with None values.
+        """
+
+        dicts: list[dict[str, str | None]] = []
+        row: dict[str, str | None] | None = None
+
+        if not isinstance(self.iterparse, dict):
+            raise TypeError(
+                f"{type(self.iterparse).__name__} is not a valid type for iterparse"
+            )
+
+        row_node = next(iter(self.iterparse.keys())) if self.iterparse else ""
+        if not is_list_like(self.iterparse[row_node]):
+            raise TypeError(
+                f"{type(self.iterparse[row_node])} is not a valid type "
+                "for value in iterparse"
+            )
+
+        if (
+            not isinstance(self.path_or_buffer, str)
+            or is_url(https://github.com/self.path_or_buffer)
+            or is_fsspec_url(https://github.com/self.path_or_buffer)
+            or self.path_or_buffer.startswith(("<?xml", "<"))
+            or infer_compression(self.path_or_buffer, "infer") is not None
+        ):
+            raise ParserError(
+                "iterparse is designed for large XML files that are fully extracted on "
+                "local disk and not as compressed files or online sources."
+            )
+
+        for event, elem in iterparse(self.path_or_buffer, events=("start", "end")):
+            curr_elem = elem.tag.split("}")[1] if "}" in elem.tag else elem.tag
+
+            if event == "start":
+                if curr_elem == row_node:
+                    row = {}
+
+            if row is not None:
+                if self.names:
+                    for col, nm in zip(self.iterparse[row_node], self.names):
+                        if curr_elem == col:
+                            elem_val = elem.text.strip() if elem.text else None
+                            if row.get(nm) != elem_val and nm not in row:
+                                row[nm] = elem_val
+                        if col in elem.attrib:
+                            if elem.attrib[col] not in row.values() and nm not in row:
+                                row[nm] = elem.attrib[col]
+                else:
+                    for col in self.iterparse[row_node]:
+                        if curr_elem == col:
+                            row[col] = elem.text.strip() if elem.text else None
+                        if col in elem.attrib:
+                            row[col] = elem.attrib[col]
+
+            if event == "end":
+                if curr_elem == row_node and row is not None:
+                    dicts.append(row)
+                    row = None
+
+                elem.clear()
+                if hasattr(elem, "getprevious"):
+                    while (
+                        elem.getprevious() is not None and elem.getparent() is not None
+                    ):
+                        del elem.getparent()[0]
+
+        if dicts == []:
+            raise ParserError("No result from selected items in iterparse.")
+
+        keys = list(dict.fromkeys([k for d in dicts for k in d.keys()]))
+        dicts = [{k: d[k] if k in d.keys() else None for k in keys} for d in dicts]
+
+        if self.names:
+            dicts = [{nm: v for nm, v in zip(self.names, d.values())} for d in dicts]
+
+        return dicts
+
+    def _validate_path(self) -> None:
+        """
+        Validate xpath.
+
+        This method checks for syntax, evaluation, or empty nodes return.
+
+        Raises
+        ------
+        SyntaxError
+            * If xpah is not supported or issues with namespaces.
+
+        ValueError
+            * If xpah does not return any nodes.
+        """
+
+        raise AbstractMethodError(self)
+
+    def _validate_names(self) -> None:
+        """
+        Validate names.
+
+        This method will check if names is a list-like and aligns
+        with length of parse nodes.
+
+        Raises
+        ------
+        ValueError
+            * If value is not a list and less then length of nodes.
+        """
+        raise AbstractMethodError(self)
+
+    def _parse_doc(
+        self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]
+    ) -> Element | _Element:
+        """
+        Build tree from path_or_buffer.
+
+        This method will parse XML object into tree
+        either from string/bytes or file location.
+        """
+        raise AbstractMethodError(self)
+
+
+class _EtreeFrameParser(_XMLFrameParser):
+    """
+    Internal class to parse XML into DataFrames with the Python
+    standard library XML module: `xml.etree.ElementTree`.
+    """
+
+    def parse_data(self) -> list[dict[str, str | None]]:
+        from xml.etree.ElementTree import iterparse
+
+        if self.stylesheet is not None:
+            raise ValueError(
+                "To use stylesheet, you need lxml installed and selected as parser."
+            )
+
+        if self.iterparse is None:
+            self.xml_doc = self._parse_doc(self.path_or_buffer)
+            self._validate_path()
+            elems = self.xml_doc.findall(self.xpath, namespaces=self.namespaces)
+
+        self._validate_names()
+
+        xml_dicts: list[dict[str, str | None]] = (
+            self._parse_nodes(elems)
+            if self.iterparse is None
+            else self._iterparse_nodes(iterparse)
+        )
+
+        return xml_dicts
+
     def _validate_path(self) -> None:
         """
         Notes
@@ -334,9 +489,14 @@ def _validate_path(self) -> None:
             )
 
     def _validate_names(self) -> None:
+        children: list[Any]
+
         if self.names:
-            parent = self.xml_doc.find(self.xpath, namespaces=self.namespaces)
-            children = parent.findall("*") if parent else []
+            if self.iterparse:
+                children = self.iterparse[next(iter(self.iterparse))]
+            else:
+                parent = self.xml_doc.find(self.xpath, namespaces=self.namespaces)
+                children = parent.findall("*") if parent else []
 
             if is_list_like(self.names):
                 if len(self.names) < len(children):
@@ -348,11 +508,12 @@ def _validate_names(self) -> None:
                     f"{type(self.names).__name__} is not a valid type for names"
                 )
 
-    def _parse_doc(self, raw_doc) -> bytes:
+    def _parse_doc(
+        self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]
+    ) -> Element:
         from xml.etree.ElementTree import (
             XMLParser,
             parse,
-            tostring,
         )
 
         handle_data = get_data_from_filepath(
@@ -364,9 +525,9 @@ def _parse_doc(self, raw_doc) -> bytes:
 
         with preprocess_data(handle_data) as xml_data:
             curr_parser = XMLParser(encoding=self.encoding)
-            r = parse(xml_data, parser=curr_parser)
+            doc = parse(xml_data, parser=curr_parser)
 
-        return tostring(r.getroot())
+        return doc.getroot()
 
 
 class _LxmlFrameParser(_XMLFrameParser):
@@ -384,101 +545,27 @@ def parse_data(self) -> list[dict[str, str | None]]:
         validate xpath, names, optionally parse and run XSLT,
         and parse original or transformed XML and return specific nodes.
         """
-        from lxml.etree import XML
-
-        self.xml_doc = XML(self._parse_doc(self.path_or_buffer))
-
-        if self.stylesheet is not None:
-            self.xsl_doc = XML(self._parse_doc(self.stylesheet))
-            self.xml_doc = XML(self._transform_doc())
-
-        self._validate_path()
-        self._validate_names()
-
-        return self._parse_nodes()
-
-    def _parse_nodes(self) -> list[dict[str, str | None]]:
-        elems = self.xml_doc.xpath(self.xpath, namespaces=self.namespaces)
-        dicts: list[dict[str, str | None]]
-
-        if self.elems_only and self.attrs_only:
-            raise ValueError("Either element or attributes can be parsed not both.")
-
-        elif self.elems_only:
-            if self.names:
-                dicts = [
-                    {
-                        **(
-                            {el.tag: el.text.strip()}
-                            if el.text and not el.text.isspace()
-                            else {}
-                        ),
-                        **{
-                            nm: ch.text.strip() if ch.text else None
-                            for nm, ch in zip(self.names, el.xpath("*"))
-                        },
-                    }
-                    for el in elems
-                ]
-            else:
-                dicts = [
-                    {
-                        ch.tag: ch.text.strip() if ch.text else None
-                        for ch in el.xpath("*")
-                    }
-                    for el in elems
-                ]
+        from lxml.etree import iterparse
 
-        elif self.attrs_only:
-            dicts = [el.attrib for el in elems]
+        if self.iterparse is None:
+            self.xml_doc = self._parse_doc(self.path_or_buffer)
 
-        else:
-            if self.names:
-                dicts = [
-                    {
-                        **el.attrib,
-                        **(
-                            {el.tag: el.text.strip()}
-                            if el.text and not el.text.isspace()
-                            else {}
-                        ),
-                        **{
-                            nm: ch.text.strip() if ch.text else None
-                            for nm, ch in zip(self.names, el.xpath("*"))
-                        },
-                    }
-                    for el in elems
-                ]
-            else:
-                dicts = [
-                    {
-                        **el.attrib,
-                        **(
-                            {el.tag: el.text.strip()}
-                            if el.text and not el.text.isspace()
-                            else {}
-                        ),
-                        **{
-                            ch.tag: ch.text.strip() if ch.text else None
-                            for ch in el.xpath("*")
-                        },
-                    }
-                    for el in elems
-                ]
+            if self.stylesheet:
+                self.xsl_doc = self._parse_doc(self.stylesheet)
+                self.xml_doc = self._transform_doc()
 
-        if self.namespaces or "}" in list(dicts[0].keys())[0]:
-            dicts = [
-                {k.split("}")[1] if "}" in k else k: v for k, v in d.items()}
-                for d in dicts
-            ]
+            self._validate_path()
+            elems = self.xml_doc.xpath(self.xpath, namespaces=self.namespaces)
 
-        keys = list(dict.fromkeys([k for d in dicts for k in d.keys()]))
-        dicts = [{k: d[k] if k in d.keys() else None for k in keys} for d in dicts]
+        self._validate_names()
 
-        if self.names:
-            dicts = [{nm: v for nm, v in zip(self.names, d.values())} for d in dicts]
+        xml_dicts: list[dict[str, str | None]] = (
+            self._parse_nodes(elems)
+            if self.iterparse is None
+            else self._iterparse_nodes(iterparse)
+        )
 
-        return dicts
+        return xml_dicts
 
     def _validate_path(self) -> None:
 
@@ -501,21 +588,15 @@ def _validate_path(self) -> None:
             raise ValueError(msg)
 
     def _validate_names(self) -> None:
-        """
-        Validate names.
+        children: list[Any]
 
-        This method will check if names is a list and aligns with
-        length of parse nodes.
-
-        Raises
-        ------
-        ValueError
-            * If value is not a list and less then length of nodes.
-        """
         if self.names:
-            children = self.xml_doc.xpath(
-                self.xpath + "[1]/*", namespaces=self.namespaces
-            )
+            if self.iterparse:
+                children = self.iterparse[next(iter(self.iterparse))]
+            else:
+                children = self.xml_doc.xpath(
+                    self.xpath + "[1]/*", namespaces=self.namespaces
+                )
 
             if is_list_like(self.names):
                 if len(self.names) < len(children):
@@ -527,12 +608,13 @@ def _validate_names(self) -> None:
                     f"{type(self.names).__name__} is not a valid type for names"
                 )
 
-    def _parse_doc(self, raw_doc) -> bytes:
+    def _parse_doc(
+        self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]
+    ) -> _Element:
         from lxml.etree import (
             XMLParser,
             fromstring,
             parse,
-            tostring,
         )
 
         handle_data = get_data_from_filepath(
@@ -557,9 +639,9 @@ def _parse_doc(self, raw_doc) -> bytes:
             else:
                 doc = parse(xml_data, parser=curr_parser)
 
-        return tostring(doc)
+        return doc
 
-    def _transform_doc(self) -> bytes:
+    def _transform_doc(self) -> _XSLTResultTree:
         """
         Transform original tree using stylesheet.
 
@@ -572,7 +654,7 @@ def _transform_doc(self) -> bytes:
         transformer = XSLT(self.xsl_doc)
         new_doc = transformer(self.xml_doc)
 
-        return bytes(new_doc)
+        return new_doc
 
 
 def get_data_from_filepath(
@@ -671,9 +753,13 @@ def _parse(
     elems_only: bool,
     attrs_only: bool,
     names: Sequence[str] | None,
+    dtype: DtypeArg | None,
+    converters: ConvertersArg | None,
+    parse_dates: ParseDatesArg | None,
     encoding: str | None,
     parser: XMLParsers,
     stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None,
+    iterparse: dict[str, list[str]] | None,
     compression: CompressionOptions,
     storage_options: StorageOptions,
     **kwargs,
@@ -706,8 +792,12 @@ def _parse(
                 elems_only,
                 attrs_only,
                 names,
+                dtype,
+                converters,
+                parse_dates,
                 encoding,
                 stylesheet,
+                iterparse,
                 compression,
                 storage_options,
             )
@@ -722,8 +812,12 @@ def _parse(
             elems_only,
             attrs_only,
             names,
+            dtype,
+            converters,
+            parse_dates,
             encoding,
             stylesheet,
+            iterparse,
             compression,
             storage_options,
         )
@@ -732,12 +826,16 @@ def _parse(
 
     data_dicts = p.parse_data()
 
-    return _data_to_frame(data=data_dicts, **kwargs)
+    return _data_to_frame(
+        data=data_dicts,
+        dtype=dtype,
+        converters=converters,
+        parse_dates=parse_dates,
+        **kwargs,
+    )
 
 
-@deprecate_nonkeyword_arguments(
-    version=None, allowed_args=["path_or_buffer"], stacklevel=2
-)
+@deprecate_nonkeyword_arguments(version=None, allowed_args=["path_or_buffer"])
 @doc(
     storage_options=_shared_docs["storage_options"],
     decompression_options=_shared_docs["decompression_options"] % "path_or_buffer",
@@ -749,10 +847,14 @@ def read_xml(
     elems_only: bool = False,
     attrs_only: bool = False,
     names: Sequence[str] | None = None,
+    dtype: DtypeArg | None = None,
+    converters: ConvertersArg | None = None,
+    parse_dates: ParseDatesArg | None = None,
     # encoding can not be None for lxml and StringIO input
     encoding: str | None = "utf-8",
     parser: XMLParsers = "lxml",
     stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None = None,
+    iterparse: dict[str, list[str]] | None = None,
     compression: CompressionOptions = "infer",
     storage_options: StorageOptions = None,
 ) -> DataFrame:
@@ -797,7 +899,37 @@ def read_xml(
 
     names :  list-like, optional
         Column names for DataFrame of parsed XML data. Use this parameter to
-        rename original element names and distinguish same named elements.
+        rename original element names and distinguish same named elements and
+        attributes.
+
+    dtype : Type name or dict of column -> type, optional
+        Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32,
+        'c': 'Int64'}}
+        Use `str` or `object` together with suitable `na_values` settings
+        to preserve and not interpret dtype.
+        If converters are specified, they will be applied INSTEAD
+        of dtype conversion.
+
+        .. versionadded:: 1.5.0
+
+    converters : dict, optional
+        Dict of functions for converting values in certain columns. Keys can either
+        be integers or column labels.
+
+        .. versionadded:: 1.5.0
+
+    parse_dates : bool or list of int or names or list of lists or dict, default False
+        Identifiers to parse index or columns to datetime. The behavior is as follows:
+
+        * boolean. If True -> try parsing the index.
+        * list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
+          each as a separate date column.
+        * list of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as
+          a single date column.
+        * dict, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
+          result 'foo'
+
+        .. versionadded:: 1.5.0
 
     encoding : str, optional, default 'utf-8'
         Encoding of XML document.
@@ -816,6 +948,20 @@ def read_xml(
         transformation and not the original XML document. Only XSLT 1.0
         scripts and not later versions is currently supported.
 
+    iterparse : dict, optional
+        The nodes or attributes to retrieve in iterparsing of XML document
+        as a dict with key being the name of repeating element and value being
+        list of elements or attribute names that are descendants of the repeated
+        element. Note: If this option is used, it will replace ``xpath`` parsing
+        and unlike xpath, descendants do not need to relate to each other but can
+        exist any where in document under the repeating element. This memory-
+        efficient method should be used for very large XML files (500MB, 1GB, or 5GB+).
+        For example, ::
+
+            iterparse = {{"row_element": ["child_elem", "attr", "grandchild_elem"]}}
+
+        .. versionadded:: 1.5.0
+
     {decompression_options}
 
         .. versionchanged:: 1.4.0 Zstandard support.
@@ -864,6 +1010,10 @@ def read_xml(
     exceptions due to issues with XML document, ``xpath``, or other
     parameters.
 
+    See the :ref:`read_xml documentation in the IO section of the docs
+    <io.read_xml>` for more information in using this method to parse XML
+    files to DataFrames.
+
     Examples
     --------
     >>> xml = '''<?xml version='1.0' encoding='utf-8'?>
@@ -942,9 +1092,13 @@ def read_xml(
         elems_only=elems_only,
         attrs_only=attrs_only,
         names=names,
+        dtype=dtype,
+        converters=converters,
+        parse_dates=parse_dates,
         encoding=encoding,
         parser=parser,
         stylesheet=stylesheet,
+        iterparse=iterparse,
         compression=compression,
         storage_options=storage_options,
     )
diff --git a/pandas/plotting/_core.py b/pandas/plotting/_core.py
index 5ad3e404b94a9..be77de2c5a430 100644
--- a/pandas/plotting/_core.py
+++ b/pandas/plotting/_core.py
@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import importlib
+import itertools
 import types
 from typing import (
     TYPE_CHECKING,
     Sequence,
 )
+import warnings
 
 from pandas._config import get_option
 
@@ -14,6 +16,7 @@
     Appender,
     Substitution,
 )
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     is_integer,
@@ -27,6 +30,8 @@
 from pandas.core.base import PandasObject
 
 if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
     from pandas import DataFrame
 
 
@@ -463,16 +468,16 @@ def hist_frame(
 @Substitution(backend="")
 @Appender(_boxplot_doc)
 def boxplot(
-    data,
-    column=None,
-    by=None,
-    ax=None,
-    fontsize=None,
-    rot=0,
-    grid=True,
-    figsize=None,
-    layout=None,
-    return_type=None,
+    data: DataFrame,
+    column: str | list[str] | None = None,
+    by: str | list[str] | None = None,
+    ax: Axes | None = None,
+    fontsize: float | str | None = None,
+    rot: int = 0,
+    grid: bool = True,
+    figsize: tuple[float, float] | None = None,
+    layout: tuple[int, int] | None = None,
+    return_type: str | None = None,
     **kwargs,
 ):
     plot_backend = _get_plot_backend("matplotlib")
@@ -499,8 +504,8 @@ def boxplot_frame(
     by=None,
     ax=None,
     fontsize=None,
-    rot=0,
-    grid=True,
+    rot: int = 0,
+    grid: bool = True,
     figsize=None,
     layout=None,
     return_type=None,
@@ -525,16 +530,16 @@ def boxplot_frame(
 
 def boxplot_frame_groupby(
     grouped,
-    subplots=True,
+    subplots: bool = True,
     column=None,
     fontsize=None,
-    rot=0,
-    grid=True,
+    rot: int = 0,
+    grid: bool = True,
     ax=None,
     figsize=None,
     layout=None,
-    sharex=False,
-    sharey=True,
+    sharex: bool = False,
+    sharey: bool = True,
     backend=None,
     **kwargs,
 ):
@@ -649,8 +654,18 @@ class PlotAccessor(PandasObject):
         - 'hexbin' : hexbin plot (DataFrame only)
     ax : matplotlib axes object, default None
         An axes of the current figure.
-    subplots : bool, default False
-        Make separate subplots for each column.
+    subplots : bool or sequence of iterables, default False
+        Whether to group columns into subplots:
+
+        - ``False`` : No subplots will be used
+        - ``True`` : Make separate subplots for each column.
+        - sequence of iterables of column labels: Create a subplot for each
+          group of columns. For example `[('a', 'c'), ('b', 'd')]` will
+          create 2 subplots: one with columns 'a' and 'c', and one
+          with columns 'b' and 'd'. Remaining columns that aren't specified
+          will be plotted in additional subplots (one per column).
+          .. versionadded:: 1.5.0
+
     sharex : bool, default True if ax is None else False
         In case ``subplots=True``, share x axis and set some x axis labels
         to invisible; defaults to True if ax is None otherwise False if
@@ -743,6 +758,11 @@ class PlotAccessor(PandasObject):
         If True, create stacked plot.
     sort_columns : bool, default False
         Sort column names to determine plot ordering.
+
+        .. deprecated:: 1.5.0
+            The `sort_columns` arguments is deprecated and will be removed in a
+            future version.
+
     secondary_y : bool or sequence, default False
         Whether to plot on the secondary y-axis if a list/tuple, which
         columns to plot on secondary y-axis.
@@ -783,7 +803,7 @@ class PlotAccessor(PandasObject):
     _kind_aliases = {"density": "kde"}
     _all_kinds = _common_kinds + _series_kinds + _dataframe_kinds
 
-    def __init__(self, data):
+    def __init__(self, data) -> None:
         self._parent = data
 
     @staticmethod
@@ -863,6 +883,14 @@ def _get_call_args(backend_name, data, args, kwargs):
                 "expected Series or DataFrame"
             )
 
+        if "sort_columns" in itertools.chain(args, kwargs.keys()):
+            warnings.warn(
+                "`sort_columns` is deprecated and will be removed in a future "
+                "version.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
         if args and isinstance(data, ABCSeries):
             positional_args = str(args)[1:-1]
             keyword_args = ", ".join(
@@ -987,7 +1015,7 @@ def __call__(self, *args, **kwargs):
 
             >>> s = pd.Series([1, 3, 2])
             >>> s.plot.line()
-            <AxesSubplot:ylabel='Density'>
+            <AxesSubplot: ylabel='Density'>
 
         .. plot::
             :context: close-figs
@@ -1031,7 +1059,7 @@ def __call__(self, *args, **kwargs):
     )
     @Substitution(kind="line")
     @Appender(_bar_or_line_doc)
-    def line(self, x=None, y=None, **kwargs):
+    def line(self, x=None, y=None, **kwargs) -> PlotAccessor:
         """
         Plot Series or DataFrame as lines.
 
@@ -1118,7 +1146,7 @@ def line(self, x=None, y=None, **kwargs):
     )
     @Substitution(kind="bar")
     @Appender(_bar_or_line_doc)
-    def bar(self, x=None, y=None, **kwargs):
+    def bar(self, x=None, y=None, **kwargs) -> PlotAccessor:
         """
         Vertical bar plot.
 
@@ -1204,7 +1232,7 @@ def bar(self, x=None, y=None, **kwargs):
     )
     @Substitution(kind="bar")
     @Appender(_bar_or_line_doc)
-    def barh(self, x=None, y=None, **kwargs):
+    def barh(self, x=None, y=None, **kwargs) -> PlotAccessor:
         """
         Make a horizontal bar plot.
 
@@ -1216,7 +1244,7 @@ def barh(self, x=None, y=None, **kwargs):
         """
         return self(kind="barh", x=x, y=y, **kwargs)
 
-    def box(self, by=None, **kwargs):
+    def box(self, by=None, **kwargs) -> PlotAccessor:
         r"""
         Make a box plot of the DataFrame columns.
 
@@ -1283,7 +1311,7 @@ def box(self, by=None, **kwargs):
         """
         return self(kind="box", by=by, **kwargs)
 
-    def hist(self, by=None, bins=10, **kwargs):
+    def hist(self, by=None, bins: int = 10, **kwargs) -> PlotAccessor:
         """
         Draw one histogram of the DataFrame's columns.
 
@@ -1345,7 +1373,7 @@ def hist(self, by=None, bins=10, **kwargs):
         """
         return self(kind="hist", by=by, bins=bins, **kwargs)
 
-    def kde(self, bw_method=None, ind=None, **kwargs):
+    def kde(self, bw_method=None, ind=None, **kwargs) -> PlotAccessor:
         """
         Generate Kernel Density Estimate plot using Gaussian kernels.
 
@@ -1371,7 +1399,7 @@ def kde(self, bw_method=None, ind=None, **kwargs):
             `ind` number of equally spaced points are used.
         **kwargs
             Additional keyword arguments are documented in
-            :meth:`pandas.%(this-datatype)s.plot`.
+            :meth:`DataFrame.plot`.
 
         Returns
         -------
@@ -1455,7 +1483,7 @@ def kde(self, bw_method=None, ind=None, **kwargs):
 
     density = kde
 
-    def area(self, x=None, y=None, **kwargs):
+    def area(self, x=None, y=None, **kwargs) -> PlotAccessor:
         """
         Draw a stacked area plot.
 
@@ -1528,7 +1556,7 @@ def area(self, x=None, y=None, **kwargs):
         """
         return self(kind="area", x=x, y=y, **kwargs)
 
-    def pie(self, **kwargs):
+    def pie(self, **kwargs) -> PlotAccessor:
         """
         Generate a pie plot.
 
@@ -1583,7 +1611,7 @@ def pie(self, **kwargs):
             raise ValueError("pie requires either y column or 'subplots=True'")
         return self(kind="pie", **kwargs)
 
-    def scatter(self, x, y, s=None, c=None, **kwargs):
+    def scatter(self, x, y, s=None, c=None, **kwargs) -> PlotAccessor:
         """
         Create a scatter plot with varying marker point size and color.
 
@@ -1668,7 +1696,9 @@ def scatter(self, x, y, s=None, c=None, **kwargs):
         """
         return self(kind="scatter", x=x, y=y, s=s, c=c, **kwargs)
 
-    def hexbin(self, x, y, C=None, reduce_C_function=None, gridsize=None, **kwargs):
+    def hexbin(
+        self, x, y, C=None, reduce_C_function=None, gridsize=None, **kwargs
+    ) -> PlotAccessor:
         """
         Generate a hexagonal binning plot.
 
@@ -1769,7 +1799,7 @@ def _load_backend(backend: str) -> types.ModuleType:
     ----------
     backend : str
         The identifier for the backend. Either an entrypoint item registered
-        with pkg_resources, "matplotlib", or a module name.
+        with importlib.metadata, "matplotlib", or a module name.
 
     Returns
     -------
@@ -1793,12 +1823,19 @@ def _load_backend(backend: str) -> types.ModuleType:
     found_backend = False
 
     eps = entry_points()
-    if "pandas_plotting_backends" in eps:
-        for entry_point in eps["pandas_plotting_backends"]:
-            found_backend = entry_point.name == backend
-            if found_backend:
-                module = entry_point.load()
-                break
+    key = "pandas_plotting_backends"
+    # entry_points lost dict API ~ PY 3.10
+    # https://github.com/python/importlib_metadata/issues/298
+    if hasattr(eps, "select"):
+        # error: "Dict[str, Tuple[EntryPoint, ...]]" has no attribute "select"
+        entry = eps.select(group=key)  # type: ignore[attr-defined]
+    else:
+        entry = eps.get(key, ())
+    for entry_point in entry:
+        found_backend = entry_point.name == backend
+        if found_backend:
+            module = entry_point.load()
+            break
 
     if not found_backend:
         # Fall back to unregistered, module name approach.
@@ -1841,11 +1878,11 @@ def _get_plot_backend(backend: str | None = None):
     -----
     Modifies `_backends` with imported backend as a side effect.
     """
-    backend = backend or get_option("plotting.backend")
+    backend_str: str = backend or get_option("plotting.backend")
 
-    if backend in _backends:
-        return _backends[backend]
+    if backend_str in _backends:
+        return _backends[backend_str]
 
-    module = _load_backend(backend)
-    _backends[backend] = module
+    module = _load_backend(backend_str)
+    _backends[backend_str] = module
     return module
diff --git a/pandas/plotting/_matplotlib/boxplot.py b/pandas/plotting/_matplotlib/boxplot.py
index a2089de294e22..6789485f2b9eb 100644
--- a/pandas/plotting/_matplotlib/boxplot.py
+++ b/pandas/plotting/_matplotlib/boxplot.py
@@ -2,6 +2,7 @@
 
 from typing import (
     TYPE_CHECKING,
+    Literal,
     NamedTuple,
 )
 import warnings
@@ -9,6 +10,8 @@
 from matplotlib.artist import setp
 import numpy as np
 
+from pandas.util._exceptions import find_stack_level
+
 from pandas.core.dtypes.common import is_dict_like
 from pandas.core.dtypes.missing import remove_na_arraylike
 
@@ -34,7 +37,10 @@
 
 
 class BoxPlot(LinePlot):
-    _kind = "box"
+    @property
+    def _kind(self) -> Literal["box"]:
+        return "box"
+
     _layout_type = "horizontal"
 
     _valid_return_types = (None, "axes", "dict", "both")
@@ -44,7 +50,7 @@ class BP(NamedTuple):
         ax: Axes
         lines: dict[str, list[Line2D]]
 
-    def __init__(self, data, return_type="axes", **kwargs):
+    def __init__(self, data, return_type: str = "axes", **kwargs) -> None:
         # Do not call LinePlot.__init__ which may fill nan
         if return_type not in self._valid_return_types:
             raise ValueError("return_type must be {None, 'axes', 'dict', 'both'}")
@@ -85,7 +91,8 @@ def _validate_color_args(self):
             if self.colormap is not None:
                 warnings.warn(
                     "'color' and 'colormap' cannot be used "
-                    "simultaneously. Using 'color'"
+                    "simultaneously. Using 'color'",
+                    stacklevel=find_stack_level(),
                 )
             self.color = self.kwds.pop("color")
 
@@ -113,7 +120,7 @@ def _validate_color_args(self):
     def _get_colors(self, num_colors=None, color_kwds="color"):
         pass
 
-    def maybe_color_bp(self, bp):
+    def maybe_color_bp(self, bp) -> None:
         if isinstance(self.color, dict):
             boxes = self.color.get("boxes", self._boxes_c)
             whiskers = self.color.get("whiskers", self._whiskers_c)
@@ -200,7 +207,11 @@ def _make_legend(self):
         pass
 
     def _post_plot_logic(self, ax, data):
-        pass
+        # GH 45465: make sure that the boxplot doesn't ignore xlabel/ylabel
+        if self.xlabel:
+            ax.set_xlabel(pprint_thing(self.xlabel))
+        if self.ylabel:
+            ax.set_ylabel(pprint_thing(self.ylabel))
 
     @property
     def orientation(self):
@@ -237,20 +248,31 @@ def _grouped_plot_by_column(
         columns = data._get_numeric_data().columns.difference(by)
     naxes = len(columns)
     fig, axes = create_subplots(
-        naxes=naxes, sharex=True, sharey=True, figsize=figsize, ax=ax, layout=layout
+        naxes=naxes,
+        sharex=kwargs.pop("sharex", True),
+        sharey=kwargs.pop("sharey", True),
+        figsize=figsize,
+        ax=ax,
+        layout=layout,
     )
 
     _axes = flatten_axes(axes)
 
+    # GH 45465: move the "by" label based on "vert"
+    xlabel, ylabel = kwargs.pop("xlabel", None), kwargs.pop("ylabel", None)
+    if kwargs.get("vert", True):
+        xlabel = xlabel or by
+    else:
+        ylabel = ylabel or by
+
     ax_values = []
 
     for i, col in enumerate(columns):
         ax = _axes[i]
         gp_col = grouped[col]
         keys, values = zip(*gp_col)
-        re_plotf = plotf(keys, values, ax, **kwargs)
+        re_plotf = plotf(keys, values, ax, xlabel=xlabel, ylabel=ylabel, **kwargs)
         ax.set_title(col)
-        ax.set_xlabel(pprint_thing(by))
         ax_values.append(re_plotf)
         ax.grid(grid)
 
@@ -273,8 +295,8 @@ def boxplot(
     by=None,
     ax=None,
     fontsize=None,
-    rot=0,
-    grid=True,
+    rot: int = 0,
+    grid: bool = True,
     figsize=None,
     layout=None,
     return_type=None,
@@ -332,18 +354,28 @@ def maybe_color_bp(bp, **kwds):
         if not kwds.get("capprops"):
             setp(bp["caps"], color=colors[3], alpha=1)
 
-    def plot_group(keys, values, ax: Axes):
+    def plot_group(keys, values, ax: Axes, **kwds):
+        # GH 45465: xlabel/ylabel need to be popped out before plotting happens
+        xlabel, ylabel = kwds.pop("xlabel", None), kwds.pop("ylabel", None)
+        if xlabel:
+            ax.set_xlabel(pprint_thing(xlabel))
+        if ylabel:
+            ax.set_ylabel(pprint_thing(ylabel))
+
         keys = [pprint_thing(x) for x in keys]
         values = [np.asarray(remove_na_arraylike(v), dtype=object) for v in values]
         bp = ax.boxplot(values, **kwds)
         if fontsize is not None:
             ax.tick_params(axis="both", labelsize=fontsize)
-        if kwds.get("vert", 1):
-            ticks = ax.get_xticks()
-            if len(ticks) != len(keys):
-                i, remainder = divmod(len(ticks), len(keys))
-                assert remainder == 0, remainder
-                keys *= i
+
+        # GH 45465: x/y are flipped when "vert" changes
+        is_vertical = kwds.get("vert", True)
+        ticks = ax.get_xticks() if is_vertical else ax.get_yticks()
+        if len(ticks) != len(keys):
+            i, remainder = divmod(len(ticks), len(keys))
+            assert remainder == 0, remainder
+            keys *= i
+        if is_vertical:
             ax.set_xticklabels(keys, rotation=rot)
         else:
             ax.set_yticklabels(keys, rotation=rot)
@@ -379,6 +411,7 @@ def plot_group(keys, values, ax: Axes):
             ax=ax,
             layout=layout,
             return_type=return_type,
+            **kwds,
         )
     else:
         if return_type is None:
@@ -401,7 +434,7 @@ def plot_group(keys, values, ax: Axes):
         else:
             data = data[columns]
 
-        result = plot_group(columns, data.values.T, ax)
+        result = plot_group(columns, data.values.T, ax, **kwds)
         ax.grid(grid)
 
     return result
@@ -413,8 +446,8 @@ def boxplot_frame(
     by=None,
     ax=None,
     fontsize=None,
-    rot=0,
-    grid=True,
+    rot: int = 0,
+    grid: bool = True,
     figsize=None,
     layout=None,
     return_type=None,
@@ -441,16 +474,16 @@ def boxplot_frame(
 
 def boxplot_frame_groupby(
     grouped,
-    subplots=True,
+    subplots: bool = True,
     column=None,
     fontsize=None,
-    rot=0,
-    grid=True,
+    rot: int = 0,
+    grid: bool = True,
     ax=None,
     figsize=None,
     layout=None,
-    sharex=False,
-    sharey=True,
+    sharex: bool = False,
+    sharey: bool = True,
     **kwds,
 ):
     if subplots is True:
diff --git a/pandas/plotting/_matplotlib/compat.py b/pandas/plotting/_matplotlib/compat.py
index 5569b1f2979b0..86b218db4ebe6 100644
--- a/pandas/plotting/_matplotlib/compat.py
+++ b/pandas/plotting/_matplotlib/compat.py
@@ -1,4 +1,6 @@
 # being a bit too dynamic
+from __future__ import annotations
+
 import operator
 
 from pandas.util.version import Version
@@ -10,18 +12,11 @@ def inner():
             import matplotlib as mpl
         except ImportError:
             return False
-        return (
-            op(Version(mpl.__version__), Version(version))
-            and str(mpl.__version__)[0] != "0"
-        )
+        return op(Version(mpl.__version__), Version(version))
 
     return inner
 
 
-mpl_ge_2_2_3 = _mpl_version("2.2.3", operator.ge)
-mpl_ge_3_0_0 = _mpl_version("3.0.0", operator.ge)
-mpl_ge_3_1_0 = _mpl_version("3.1.0", operator.ge)
-mpl_ge_3_2_0 = _mpl_version("3.2.0", operator.ge)
-mpl_ge_3_3_0 = _mpl_version("3.3.0", operator.ge)
 mpl_ge_3_4_0 = _mpl_version("3.4.0", operator.ge)
 mpl_ge_3_5_0 = _mpl_version("3.5.0", operator.ge)
+mpl_ge_3_6_0 = _mpl_version("3.6.0", operator.ge)
diff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py
index 90d3f8d9836bf..51a081645373e 100644
--- a/pandas/plotting/_matplotlib/converter.py
+++ b/pandas/plotting/_matplotlib/converter.py
@@ -9,7 +9,10 @@
 )
 import functools
 from typing import (
+    TYPE_CHECKING,
     Any,
+    Final,
+    Iterator,
     cast,
 )
 
@@ -30,7 +33,6 @@
     to_offset,
 )
 from pandas._libs.tslibs.dtypes import FreqGroup
-from pandas._libs.tslibs.offsets import BaseOffset
 from pandas._typing import F
 
 from pandas.core.dtypes.common import (
@@ -55,15 +57,18 @@
 )
 import pandas.core.tools.datetimes as tools
 
+if TYPE_CHECKING:
+    from pandas._libs.tslibs.offsets import BaseOffset
+
 # constants
-HOURS_PER_DAY = 24.0
-MIN_PER_HOUR = 60.0
-SEC_PER_MIN = 60.0
+HOURS_PER_DAY: Final = 24.0
+MIN_PER_HOUR: Final = 60.0
+SEC_PER_MIN: Final = 60.0
 
-SEC_PER_HOUR = SEC_PER_MIN * MIN_PER_HOUR
-SEC_PER_DAY = SEC_PER_HOUR * HOURS_PER_DAY
+SEC_PER_HOUR: Final = SEC_PER_MIN * MIN_PER_HOUR
+SEC_PER_DAY: Final = SEC_PER_HOUR * HOURS_PER_DAY
 
-MUSEC_PER_DAY = 10 ** 6 * SEC_PER_DAY
+MUSEC_PER_DAY: Final = 10**6 * SEC_PER_DAY
 
 _mpl_units = {}  # Cache for units overwritten by us
 
@@ -94,7 +99,7 @@ def wrapper(*args, **kwargs):
 
 
 @contextlib.contextmanager
-def pandas_converters():
+def pandas_converters() -> Iterator[None]:
     """
     Context manager registering pandas' converters for a plot.
 
@@ -115,7 +120,7 @@ def pandas_converters():
             deregister()
 
 
-def register():
+def register() -> None:
     pairs = get_pairs()
     for type_, cls in pairs:
         # Cache previous converter if present
@@ -126,7 +131,7 @@ def register():
         units.registry[type_] = cls()
 
 
-def deregister():
+def deregister() -> None:
     # Renamed in pandas.plotting.__init__
     for type_, cls in get_pairs():
         # We use type to catch our classes directly, no inheritance
@@ -141,7 +146,7 @@ def deregister():
 
 
 def _to_ordinalf(tm: pydt.time) -> float:
-    tot_sec = tm.hour * 3600 + tm.minute * 60 + tm.second + tm.microsecond / 10 ** 6
+    tot_sec = tm.hour * 3600 + tm.minute * 60 + tm.second + tm.microsecond / 10**6
     return tot_sec
 
 
@@ -184,10 +189,10 @@ def default_units(x, axis) -> str:
 
 # time formatter
 class TimeFormatter(Formatter):
-    def __init__(self, locs):
+    def __init__(self, locs) -> None:
         self.locs = locs
 
-    def __call__(self, x, pos=0) -> str:
+    def __call__(self, x, pos: int = 0) -> str:
         """
         Return the time of day as a formatted string.
 
@@ -207,7 +212,7 @@ def __call__(self, x, pos=0) -> str:
         """
         fmt = "%H:%M:%S.%f"
         s = int(x)
-        msus = round((x - s) * 10 ** 6)
+        msus = round((x - s) * 10**6)
         ms = msus // 1000
         us = msus % 1000
         m, s = divmod(s, 60)
@@ -339,7 +344,7 @@ def axisinfo(unit: tzinfo | None, axis) -> units.AxisInfo:
 
 
 class PandasAutoDateFormatter(dates.AutoDateFormatter):
-    def __init__(self, locator, tz=None, defaultfmt="%Y-%m-%d"):
+    def __init__(self, locator, tz=None, defaultfmt: str = "%Y-%m-%d") -> None:
         dates.AutoDateFormatter.__init__(self, locator, tz, defaultfmt)
 
 
@@ -371,7 +376,7 @@ class MilliSecondLocator(dates.DateLocator):
 
     UNIT = 1.0 / (24 * 3600 * 1000)
 
-    def __init__(self, tz):
+    def __init__(self, tz) -> None:
         dates.DateLocator.__init__(self, tz)
         self._interval = 1.0
 
@@ -531,35 +536,37 @@ def has_level_label(label_flags: np.ndarray, vmin: float) -> bool:
 
 
 def _daily_finder(vmin, vmax, freq: BaseOffset):
-    dtype_code = freq._period_dtype_code
+    # error: "BaseOffset" has no attribute "_period_dtype_code"
+    dtype_code = freq._period_dtype_code  # type: ignore[attr-defined]
+    freq_group = FreqGroup.from_period_dtype_code(dtype_code)
 
     periodsperday = -1
 
     if dtype_code >= FreqGroup.FR_HR.value:
-        if dtype_code == FreqGroup.FR_NS.value:
+        if freq_group == FreqGroup.FR_NS:
             periodsperday = 24 * 60 * 60 * 1000000000
-        elif dtype_code == FreqGroup.FR_US.value:
+        elif freq_group == FreqGroup.FR_US:
             periodsperday = 24 * 60 * 60 * 1000000
-        elif dtype_code == FreqGroup.FR_MS.value:
+        elif freq_group == FreqGroup.FR_MS:
             periodsperday = 24 * 60 * 60 * 1000
-        elif dtype_code == FreqGroup.FR_SEC.value:
+        elif freq_group == FreqGroup.FR_SEC:
             periodsperday = 24 * 60 * 60
-        elif dtype_code == FreqGroup.FR_MIN.value:
+        elif freq_group == FreqGroup.FR_MIN:
             periodsperday = 24 * 60
-        elif dtype_code == FreqGroup.FR_HR.value:
+        elif freq_group == FreqGroup.FR_HR:
             periodsperday = 24
         else:  # pragma: no cover
             raise ValueError(f"unexpected frequency: {dtype_code}")
         periodsperyear = 365 * periodsperday
         periodspermonth = 28 * periodsperday
 
-    elif dtype_code == FreqGroup.FR_BUS.value:
+    elif freq_group == FreqGroup.FR_BUS:
         periodsperyear = 261
         periodspermonth = 19
-    elif dtype_code == FreqGroup.FR_DAY.value:
+    elif freq_group == FreqGroup.FR_DAY:
         periodsperyear = 365
         periodspermonth = 28
-    elif FreqGroup.get_freq_group(dtype_code) == FreqGroup.FR_WK:
+    elif freq_group == FreqGroup.FR_WK:
         periodsperyear = 52
         periodspermonth = 3
     else:  # pragma: no cover
@@ -572,6 +579,8 @@ def _daily_finder(vmin, vmax, freq: BaseOffset):
         Period(ordinal=int(vmin), freq=freq),
         Period(ordinal=int(vmax), freq=freq),
     )
+    assert isinstance(vmin, Period)
+    assert isinstance(vmax, Period)
     span = vmax.ordinal - vmin.ordinal + 1
     dates_ = period_range(start=vmin, end=vmax, freq=freq)
     # Initialize the output
@@ -863,7 +872,8 @@ def _quarterly_finder(vmin, vmax, freq):
         info_fmt[year_start] = "%F"
 
     else:
-        years = dates_[year_start] // 4 + 1
+        # https://github.com/pandas-dev/pandas/pull/47602
+        years = dates_[year_start] // 4 + 1970
         nyears = span / periodsperyear
         (min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
         major_idx = year_start[(years % maj_anndef == 0)]
@@ -895,15 +905,15 @@ def _annual_finder(vmin, vmax, freq):
 
 
 def get_finder(freq: BaseOffset):
-    dtype_code = freq._period_dtype_code
-    fgroup = (dtype_code // 1000) * 1000
-    fgroup = FreqGroup(fgroup)
+    # error: "BaseOffset" has no attribute "_period_dtype_code"
+    dtype_code = freq._period_dtype_code  # type: ignore[attr-defined]
+    fgroup = FreqGroup.from_period_dtype_code(dtype_code)
 
     if fgroup == FreqGroup.FR_ANN:
         return _annual_finder
     elif fgroup == FreqGroup.FR_QTR:
         return _quarterly_finder
-    elif dtype_code == FreqGroup.FR_MTH.value:
+    elif fgroup == FreqGroup.FR_MTH:
         return _monthly_finder
     elif (dtype_code >= FreqGroup.FR_BUS.value) or fgroup == FreqGroup.FR_WK:
         return _daily_finder
@@ -917,7 +927,7 @@ class TimeSeries_DateLocator(Locator):
 
     Parameters
     ----------
-    freq : {var}
+    freq : BaseOffset
         Valid frequency specifier.
     minor_locator : {False, True}, optional
         Whether the locator is for minor ticks (True) or not.
@@ -931,15 +941,15 @@ class TimeSeries_DateLocator(Locator):
 
     def __init__(
         self,
-        freq,
-        minor_locator=False,
-        dynamic_mode=True,
-        base=1,
-        quarter=1,
-        month=1,
-        day=1,
+        freq: BaseOffset,
+        minor_locator: bool = False,
+        dynamic_mode: bool = True,
+        base: int = 1,
+        quarter: int = 1,
+        month: int = 1,
+        day: int = 1,
         plot_obj=None,
-    ):
+    ) -> None:
         freq = to_offset(freq)
         self.freq = freq
         self.base = base
@@ -1008,7 +1018,7 @@ class TimeSeries_DateFormatter(Formatter):
 
     Parameters
     ----------
-    freq : {int, string}
+    freq : BaseOffset
         Valid frequency specifier.
     minor_locator : bool, default False
         Whether the current formatter should apply to minor ticks (True) or
@@ -1019,11 +1029,11 @@ class TimeSeries_DateFormatter(Formatter):
 
     def __init__(
         self,
-        freq,
+        freq: BaseOffset,
         minor_locator: bool = False,
         dynamic_mode: bool = True,
         plot_obj=None,
-    ):
+    ) -> None:
         freq = to_offset(freq)
         self.format = None
         self.freq = freq
@@ -1048,7 +1058,7 @@ def _set_default_format(self, vmin, vmax):
         self.formatdict = {x: f for (x, _, _, f) in format}
         return self.formatdict
 
-    def set_locs(self, locs):
+    def set_locs(self, locs) -> None:
         """Sets the locations of the ticks"""
         # don't actually use the locs. This is just needed to work with
         # matplotlib. Force to use vmin, vmax
@@ -1063,7 +1073,7 @@ def set_locs(self, locs):
             (vmin, vmax) = (vmax, vmin)
         self._set_default_format(vmin, vmax)
 
-    def __call__(self, x, pos=0) -> str:
+    def __call__(self, x, pos: int = 0) -> str:
 
         if self.formatdict is None:
             return ""
@@ -1071,7 +1081,9 @@ def __call__(self, x, pos=0) -> str:
             fmt = self.formatdict.pop(x, "")
             if isinstance(fmt, np.bytes_):
                 fmt = fmt.decode("utf-8")
-            return Period(ordinal=int(x), freq=self.freq).strftime(fmt)
+            period = Period(ordinal=int(x), freq=self.freq)
+            assert isinstance(period, Period)
+            return period.strftime(fmt)
 
 
 class TimeSeries_TimedeltaFormatter(Formatter):
@@ -1084,7 +1096,7 @@ def format_timedelta_ticks(x, pos, n_decimals: int) -> str:
         """
         Convert seconds to 'D days HH:MM:SS.F'
         """
-        s, ns = divmod(x, 10 ** 9)
+        s, ns = divmod(x, 10**9)
         m, s = divmod(s, 60)
         h, m = divmod(m, 60)
         d, h = divmod(h, 24)
@@ -1096,9 +1108,9 @@ def format_timedelta_ticks(x, pos, n_decimals: int) -> str:
             s = f"{int(d):d} days {s}"
         return s
 
-    def __call__(self, x, pos=0) -> str:
+    def __call__(self, x, pos: int = 0) -> str:
         (vmin, vmax) = tuple(self.axis.get_view_interval())
-        n_decimals = int(np.ceil(np.log10(100 * 10 ** 9 / abs(vmax - vmin))))
+        n_decimals = int(np.ceil(np.log10(100 * 10**9 / abs(vmax - vmin))))
         if n_decimals > 9:
             n_decimals = 9
         return self.format_timedelta_ticks(x, pos, n_decimals)
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index ca3eb75ede3f6..af91a8ab83e12 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -1,17 +1,29 @@
 from __future__ import annotations
 
+from abc import (
+    ABC,
+    abstractmethod,
+)
 from typing import (
     TYPE_CHECKING,
     Hashable,
+    Iterable,
+    Literal,
+    Sequence,
 )
 import warnings
 
+import matplotlib as mpl
 from matplotlib.artist import Artist
 import numpy as np
 
-from pandas._typing import IndexLabel
+from pandas._typing import (
+    IndexLabel,
+    PlottingOrientation,
+)
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
@@ -42,9 +54,10 @@
 from pandas.core.frame import DataFrame
 
 from pandas.io.formats.printing import pprint_thing
-from pandas.plotting._matplotlib.compat import mpl_ge_3_0_0
+from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
 from pandas.plotting._matplotlib.converter import register_pandas_matplotlib_converters
 from pandas.plotting._matplotlib.groupby import reconstruct_data_with_by
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
 from pandas.plotting._matplotlib.style import get_standard_colors
 from pandas.plotting._matplotlib.timeseries import (
     decorate_axes,
@@ -77,7 +90,7 @@ def _color_in_style(style: str) -> bool:
     return not set(BASE_COLORS).isdisjoint(style)
 
 
-class MPLPlot:
+class MPLPlot(ABC):
     """
     Base class for assembling a pandas plot using matplotlib
 
@@ -88,13 +101,17 @@ class MPLPlot:
     """
 
     @property
-    def _kind(self):
+    @abstractmethod
+    def _kind(self) -> str:
         """Specify kind str. Must be overridden in child class"""
         raise NotImplementedError
 
     _layout_type = "vertical"
     _default_rot = 0
-    orientation: str | None = None
+
+    @property
+    def orientation(self) -> str | None:
+        return None
 
     axes: np.ndarray  # of Axes objects
 
@@ -103,13 +120,13 @@ def __init__(
         data,
         kind=None,
         by: IndexLabel | None = None,
-        subplots=False,
+        subplots: bool | Sequence[Sequence[str]] = False,
         sharex=None,
-        sharey=False,
-        use_index=True,
+        sharey: bool = False,
+        use_index: bool = True,
         figsize=None,
         grid=None,
-        legend=True,
+        legend: bool | str = True,
         rot=None,
         ax=None,
         fig=None,
@@ -120,16 +137,16 @@ def __init__(
         yticks=None,
         xlabel: Hashable | None = None,
         ylabel: Hashable | None = None,
-        sort_columns=False,
+        sort_columns: bool = False,
         fontsize=None,
-        secondary_y=False,
+        secondary_y: bool | tuple | list | np.ndarray = False,
         colormap=None,
-        table=False,
+        table: bool = False,
         layout=None,
-        include_bool=False,
+        include_bool: bool = False,
         column: IndexLabel | None = None,
         **kwds,
-    ):
+    ) -> None:
 
         import matplotlib.pyplot as plt
 
@@ -162,13 +179,12 @@ def __init__(
         # For `hist` plot, need to get grouped original data before `self.data` is
         # updated later
         if self.by is not None and self._kind == "hist":
-            self._grouped = data.groupby(self.by)
+            self._grouped = data.groupby(unpack_single_str_list(self.by))
 
         self.kind = kind
 
         self.sort_columns = sort_columns
-
-        self.subplots = subplots
+        self.subplots = self._validate_subplots_kwarg(subplots)
 
         if sharex is None:
 
@@ -254,6 +270,112 @@ def __init__(
 
         self._validate_color_args()
 
+    def _validate_subplots_kwarg(
+        self, subplots: bool | Sequence[Sequence[str]]
+    ) -> bool | list[tuple[int, ...]]:
+        """
+        Validate the subplots parameter
+
+        - check type and content
+        - check for duplicate columns
+        - check for invalid column names
+        - convert column names into indices
+        - add missing columns in a group of their own
+        See comments in code below for more details.
+
+        Parameters
+        ----------
+        subplots : subplots parameters as passed to PlotAccessor
+
+        Returns
+        -------
+        validated subplots : a bool or a list of tuples of column indices. Columns
+        in the same tuple will be grouped together in the resulting plot.
+        """
+
+        if isinstance(subplots, bool):
+            return subplots
+        elif not isinstance(subplots, Iterable):
+            raise ValueError("subplots should be a bool or an iterable")
+
+        supported_kinds = (
+            "line",
+            "bar",
+            "barh",
+            "hist",
+            "kde",
+            "density",
+            "area",
+            "pie",
+        )
+        if self._kind not in supported_kinds:
+            raise ValueError(
+                "When subplots is an iterable, kind must be "
+                f"one of {', '.join(supported_kinds)}. Got {self._kind}."
+            )
+
+        if isinstance(self.data, ABCSeries):
+            raise NotImplementedError(
+                "An iterable subplots for a Series is not supported."
+            )
+
+        columns = self.data.columns
+        if isinstance(columns, ABCMultiIndex):
+            raise NotImplementedError(
+                "An iterable subplots for a DataFrame with a MultiIndex column "
+                "is not supported."
+            )
+
+        if columns.nunique() != len(columns):
+            raise NotImplementedError(
+                "An iterable subplots for a DataFrame with non-unique column "
+                "labels is not supported."
+            )
+
+        # subplots is a list of tuples where each tuple is a group of
+        # columns to be grouped together (one ax per group).
+        # we consolidate the subplots list such that:
+        # - the tuples contain indices instead of column names
+        # - the columns that aren't yet in the list are added in a group
+        #   of their own.
+        # For example with columns from a to g, and
+        # subplots = [(a, c), (b, f, e)],
+        # we end up with [(ai, ci), (bi, fi, ei), (di,), (gi,)]
+        # This way, we can handle self.subplots in a homogeneous manner
+        # later.
+        # TODO: also accept indices instead of just names?
+
+        out = []
+        seen_columns: set[Hashable] = set()
+        for group in subplots:
+            if not is_list_like(group):
+                raise ValueError(
+                    "When subplots is an iterable, each entry "
+                    "should be a list/tuple of column names."
+                )
+            idx_locs = columns.get_indexer_for(group)
+            if (idx_locs == -1).any():
+                bad_labels = np.extract(idx_locs == -1, group)
+                raise ValueError(
+                    f"Column label(s) {list(bad_labels)} not found in the DataFrame."
+                )
+            else:
+                unique_columns = set(group)
+                duplicates = seen_columns.intersection(unique_columns)
+                if duplicates:
+                    raise ValueError(
+                        "Each column should be in only one subplot. "
+                        f"Columns {duplicates} were found in multiple subplots."
+                    )
+                seen_columns = seen_columns.union(unique_columns)
+                out.append(tuple(idx_locs))
+
+        unseen_columns = columns.difference(seen_columns)
+        for column in unseen_columns:
+            idx_loc = columns.get_loc(column)
+            out.append((idx_loc,))
+        return out
+
     def _validate_color_args(self):
         if (
             "color" in self.kwds
@@ -276,7 +398,8 @@ def _validate_color_args(self):
             "color" in self.kwds or "colors" in self.kwds
         ) and self.colormap is not None:
             warnings.warn(
-                "'color' and 'colormap' cannot be used simultaneously. Using 'color'"
+                "'color' and 'colormap' cannot be used simultaneously. Using 'color'",
+                stacklevel=find_stack_level(),
             )
 
         if "color" in self.kwds and self.style is not None:
@@ -319,10 +442,10 @@ def nseries(self) -> int:
         else:
             return self.data.shape[1]
 
-    def draw(self):
+    def draw(self) -> None:
         self.plt.draw_if_interactive()
 
-    def generate(self):
+    def generate(self) -> None:
         self._args_adjust()
         self._compute_plot_data()
         self._setup_subplots()
@@ -372,8 +495,11 @@ def _maybe_right_yaxis(self, ax: Axes, axes_num):
 
     def _setup_subplots(self):
         if self.subplots:
+            naxes = (
+                self.nseries if isinstance(self.subplots, bool) else len(self.subplots)
+            )
             fig, axes = create_subplots(
-                naxes=self.nseries,
+                naxes=naxes,
                 sharex=self.sharex,
                 sharey=self.sharey,
                 figsize=self.figsize,
@@ -426,8 +552,11 @@ def result(self):
                 return self.axes
         else:
             sec_true = isinstance(self.secondary_y, bool) and self.secondary_y
+            # error: Argument 1 to "len" has incompatible type "Union[bool,
+            # Tuple[Any, ...], List[Any], ndarray[Any, Any]]"; expected "Sized"
             all_sec = (
-                is_list_like(self.secondary_y) and len(self.secondary_y) == self.nseries
+                is_list_like(self.secondary_y)
+                and len(self.secondary_y) == self.nseries  # type: ignore[arg-type]
             )
             if sec_true or all_sec:
                 # if all data is plotted on secondary, return right axes
@@ -459,7 +588,7 @@ def _compute_plot_data(self):
         if isinstance(data, ABCSeries):
             label = self.label
             if label is None and data.name is None:
-                label = "None"
+                label = ""
             if label is None:
                 # We'll end up with columns of [0] instead of [None]
                 data = data.to_frame()
@@ -558,6 +687,7 @@ def _adorn_subplots(self):
             )
 
         for ax in self.axes:
+            ax = getattr(ax, "right_ax", ax)
             if self.yticks is not None:
                 ax.set_yticks(self.yticks)
 
@@ -734,7 +864,9 @@ def _get_xticks(self, convert_period: bool = False):
 
     @classmethod
     @register_pandas_matplotlib_converters
-    def _plot(cls, ax: Axes, x, y, style=None, is_errorbar: bool = False, **kwds):
+    def _plot(
+        cls, ax: Axes, x, y: np.ndarray, style=None, is_errorbar: bool = False, **kwds
+    ):
         mask = isna(y)
         if mask.any():
             y = np.ma.array(y)
@@ -754,6 +886,10 @@ def _plot(cls, ax: Axes, x, y, style=None, is_errorbar: bool = False, **kwds):
             args = (x, y, style) if style is not None else (x, y)
             return ax.plot(*args, **kwds)
 
+    def _get_custom_index_name(self):
+        """Specify whether xlabel/ylabel should be used to override index name"""
+        return self.xlabel
+
     def _get_index_name(self) -> str | None:
         if isinstance(self.data.index, ABCMultiIndex):
             name = self.data.index.names
@@ -766,9 +902,10 @@ def _get_index_name(self) -> str | None:
             if name is not None:
                 name = pprint_thing(name)
 
-        # GH 9093, override the default xlabel if xlabel is provided.
-        if self.xlabel is not None:
-            name = pprint_thing(self.xlabel)
+        # GH 45145, override the default axis label if one is provided.
+        index_name = self._get_custom_index_name()
+        if index_name is not None:
+            name = pprint_thing(index_name)
 
         return name
 
@@ -780,9 +917,23 @@ def _get_ax_layer(cls, ax, primary=True):
         else:
             return getattr(ax, "right_ax", ax)
 
+    def _col_idx_to_axis_idx(self, col_idx: int) -> int:
+        """Return the index of the axis where the column at col_idx should be plotted"""
+        if isinstance(self.subplots, list):
+            # Subplots is a list: some columns will be grouped together in the same ax
+            return next(
+                group_idx
+                for (group_idx, group) in enumerate(self.subplots)
+                if col_idx in group
+            )
+        else:
+            # subplots is True: one ax per column
+            return col_idx
+
     def _get_ax(self, i: int):
         # get the twinx ax if appropriate
         if self.subplots:
+            i = self._col_idx_to_axis_idx(i)
             ax = self.axes[i]
             ax = self._maybe_right_yaxis(ax, i)
             self.axes[i] = ax
@@ -794,7 +945,7 @@ def _get_ax(self, i: int):
         return ax
 
     @classmethod
-    def get_default_ax(cls, ax):
+    def get_default_ax(cls, ax) -> None:
         import matplotlib.pyplot as plt
 
         if ax is None and len(plt.get_fignums()) > 0:
@@ -973,14 +1124,14 @@ def _get_axes_layout(self) -> tuple[int, int]:
         return (len(y_set), len(x_set))
 
 
-class PlanePlot(MPLPlot):
+class PlanePlot(MPLPlot, ABC):
     """
     Abstract class for plotting on plane, currently scatter and hexbin.
     """
 
     _layout_type = "single"
 
-    def __init__(self, data, x, y, **kwargs):
+    def __init__(self, data, x, y, **kwargs) -> None:
         MPLPlot.__init__(self, data, **kwargs)
         if x is None or y is None:
             raise ValueError(self._kind + " requires an x and y column")
@@ -1027,35 +1178,15 @@ def _plot_colorbar(self, ax: Axes, **kwds):
         # use the last one which contains the latest information
         # about the ax
         img = ax.collections[-1]
-        cbar = self.fig.colorbar(img, ax=ax, **kwds)
-
-        if mpl_ge_3_0_0():
-            # The workaround below is no longer necessary.
-            return cbar
-
-        points = ax.get_position().get_points()
-        cbar_points = cbar.ax.get_position().get_points()
-
-        cbar.ax.set_position(
-            [
-                cbar_points[0, 0],
-                points[0, 1],
-                cbar_points[1, 0] - cbar_points[0, 0],
-                points[1, 1] - points[0, 1],
-            ]
-        )
-        # To see the discrepancy in axis heights uncomment
-        # the following two lines:
-        # print(points[1, 1] - points[0, 1])
-        # print(cbar_points[1, 1] - cbar_points[0, 1])
-
-        return cbar
+        return self.fig.colorbar(img, ax=ax, **kwds)
 
 
 class ScatterPlot(PlanePlot):
-    _kind = "scatter"
+    @property
+    def _kind(self) -> Literal["scatter"]:
+        return "scatter"
 
-    def __init__(self, data, x, y, s=None, c=None, **kwargs):
+    def __init__(self, data, x, y, s=None, c=None, **kwargs) -> None:
         if s is None:
             # hide the matplotlib default for size, in case we want to change
             # the handling of this argument later
@@ -1075,9 +1206,6 @@ def _make_plot(self):
 
         color_by_categorical = c_is_column and is_categorical_dtype(self.data[c])
 
-        # pandas uses colormap, matplotlib uses cmap.
-        cmap = self.colormap or "Greys"
-        cmap = self.plt.cm.get_cmap(cmap)
         color = self.kwds.pop("color", None)
         if c is not None and color is not None:
             raise TypeError("Specify exactly one of `c` and `color`")
@@ -1092,6 +1220,23 @@ def _make_plot(self):
         else:
             c_values = c
 
+        if self.colormap is not None:
+            if mpl_ge_3_6_0():
+                cmap = mpl.colormaps.get_cmap(self.colormap)
+            else:
+                cmap = self.plt.cm.get_cmap(self.colormap)
+        else:
+            # cmap is only used if c_values are integers, otherwise UserWarning
+            if is_integer_dtype(c_values):
+                # pandas uses colormap, matplotlib uses cmap.
+                cmap = "Greys"
+                if mpl_ge_3_6_0():
+                    cmap = mpl.colormaps[cmap]
+                else:
+                    cmap = self.plt.cm.get_cmap(cmap)
+            else:
+                cmap = None
+
         if color_by_categorical:
             from matplotlib import colors
 
@@ -1100,7 +1245,7 @@ def _make_plot(self):
             bounds = np.linspace(0, n_cats, n_cats + 1)
             norm = colors.BoundaryNorm(bounds, cmap.N)
         else:
-            norm = None
+            norm = self.kwds.pop("norm", None)
         # plot colorbar if
         # 1. colormap is assigned, and
         # 2.`c` is a column containing only numeric values
@@ -1141,9 +1286,11 @@ def _make_plot(self):
 
 
 class HexBinPlot(PlanePlot):
-    _kind = "hexbin"
+    @property
+    def _kind(self) -> Literal["hexbin"]:
+        return "hexbin"
 
-    def __init__(self, data, x, y, C=None, **kwargs):
+    def __init__(self, data, x, y, C=None, **kwargs) -> None:
         super().__init__(data, x, y, **kwargs)
         if is_integer(C) and not self.data.columns.holds_integer():
             C = self.data.columns[C]
@@ -1154,7 +1301,10 @@ def _make_plot(self):
         ax = self.axes[0]
         # pandas uses colormap, matplotlib uses cmap.
         cmap = self.colormap or "BuGn"
-        cmap = self.plt.cm.get_cmap(cmap)
+        if mpl_ge_3_6_0():
+            cmap = mpl.colormaps.get_cmap(cmap)
+        else:
+            cmap = self.plt.cm.get_cmap(cmap)
         cb = self.kwds.pop("colorbar", True)
 
         if C is None:
@@ -1171,11 +1321,17 @@ def _make_legend(self):
 
 
 class LinePlot(MPLPlot):
-    _kind = "line"
     _default_rot = 0
-    orientation = "vertical"
 
-    def __init__(self, data, **kwargs):
+    @property
+    def orientation(self) -> PlottingOrientation:
+        return "vertical"
+
+    @property
+    def _kind(self) -> Literal["line", "area", "hist", "kde", "box"]:
+        return "line"
+
+    def __init__(self, data, **kwargs) -> None:
         from pandas.plotting import plot_params
 
         MPLPlot.__init__(self, data, **kwargs)
@@ -1257,8 +1413,7 @@ def _plot(  # type: ignore[override]
         cls._update_stacker(ax, stacking_id, y)
         return lines
 
-    @classmethod
-    def _ts_plot(cls, ax: Axes, x, data, style=None, **kwds):
+    def _ts_plot(self, ax: Axes, x, data, style=None, **kwds):
         # accept x to be consistent with normal plot func,
         # x is not passed to tsplot as it uses data.index as x coordinate
         # column_num must be in kwds for stacking purpose
@@ -1271,9 +1426,9 @@ def _ts_plot(cls, ax: Axes, x, data, style=None, **kwds):
             decorate_axes(ax.left_ax, freq, kwds)
         if hasattr(ax, "right_ax"):
             decorate_axes(ax.right_ax, freq, kwds)
-        ax._plot_data.append((data, cls._kind, kwds))
+        ax._plot_data.append((data, self._kind, kwds))
 
-        lines = cls._plot(ax, data.index, data.values, style=style, **kwds)
+        lines = self._plot(ax, data.index, data.values, style=style, **kwds)
         # set date formatter, locators and rescale limits
         format_dateaxis(ax, ax.freq, data.index)
         return lines
@@ -1365,9 +1520,11 @@ def get_label(i):
 
 
 class AreaPlot(LinePlot):
-    _kind = "area"
+    @property
+    def _kind(self) -> Literal["area"]:
+        return "area"
 
-    def __init__(self, data, **kwargs):
+    def __init__(self, data, **kwargs) -> None:
         kwargs.setdefault("stacked", True)
         data = data.fillna(value=0)
         LinePlot.__init__(self, data, **kwargs)
@@ -1438,11 +1595,17 @@ def _post_plot_logic(self, ax: Axes, data):
 
 
 class BarPlot(MPLPlot):
-    _kind = "bar"
+    @property
+    def _kind(self) -> Literal["bar", "barh"]:
+        return "bar"
+
     _default_rot = 90
-    orientation = "vertical"
 
-    def __init__(self, data, **kwargs):
+    @property
+    def orientation(self) -> PlottingOrientation:
+        return "vertical"
+
+    def __init__(self, data, **kwargs) -> None:
         # we have to treat a series differently than a
         # 1-column DataFrame w.r.t. color handling
         self._is_series = isinstance(data, ABCSeries)
@@ -1572,12 +1735,11 @@ def _post_plot_logic(self, ax: Axes, data):
             str_index = [pprint_thing(key) for key in data.index]
         else:
             str_index = [pprint_thing(key) for key in range(data.shape[0])]
-        name = self._get_index_name()
 
         s_edge = self.ax_pos[0] - 0.25 + self.lim_offset
         e_edge = self.ax_pos[-1] + 0.25 + self.bar_width + self.lim_offset
 
-        self._decorate_ticks(ax, name, str_index, s_edge, e_edge)
+        self._decorate_ticks(ax, self._get_index_name(), str_index, s_edge, e_edge)
 
     def _decorate_ticks(self, ax: Axes, name, ticklabels, start_edge, end_edge):
         ax.set_xlim((start_edge, end_edge))
@@ -1593,9 +1755,15 @@ def _decorate_ticks(self, ax: Axes, name, ticklabels, start_edge, end_edge):
 
 
 class BarhPlot(BarPlot):
-    _kind = "barh"
+    @property
+    def _kind(self) -> Literal["barh"]:
+        return "barh"
+
     _default_rot = 0
-    orientation = "horizontal"
+
+    @property
+    def orientation(self) -> Literal["horizontal"]:
+        return "horizontal"
 
     @property
     def _start_base(self):
@@ -1608,6 +1776,9 @@ def _plot(  # type: ignore[override]
     ):
         return ax.barh(x, y, w, left=start, log=log, **kwds)
 
+    def _get_custom_index_name(self):
+        return self.ylabel
+
     def _decorate_ticks(self, ax: Axes, name, ticklabels, start_edge, end_edge):
         # horizontal bars
         ax.set_ylim((start_edge, end_edge))
@@ -1615,13 +1786,17 @@ def _decorate_ticks(self, ax: Axes, name, ticklabels, start_edge, end_edge):
         ax.set_yticklabels(ticklabels)
         if name is not None and self.use_index:
             ax.set_ylabel(name)
+        ax.set_xlabel(self.xlabel)
 
 
 class PiePlot(MPLPlot):
-    _kind = "pie"
+    @property
+    def _kind(self) -> Literal["pie"]:
+        return "pie"
+
     _layout_type = "horizontal"
 
-    def __init__(self, data, kind=None, **kwargs):
+    def __init__(self, data, kind=None, **kwargs) -> None:
         data = data.fillna(value=0)
         if (data < 0).any().any():
             raise ValueError(f"{self._kind} plot doesn't allow negative values")
diff --git a/pandas/plotting/_matplotlib/groupby.py b/pandas/plotting/_matplotlib/groupby.py
index 1b16eefb360ae..17a214292608b 100644
--- a/pandas/plotting/_matplotlib/groupby.py
+++ b/pandas/plotting/_matplotlib/groupby.py
@@ -16,6 +16,8 @@
     concat,
 )
 
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
+
 
 def create_iter_data_given_by(
     data: DataFrame, kind: str = "hist"
@@ -108,11 +110,14 @@ def reconstruct_data_with_by(
     1  3.0   4.0   NaN   NaN
     2  NaN   NaN   5.0   6.0
     """
-    grouped = data.groupby(by)
+    by_modified = unpack_single_str_list(by)
+    grouped = data.groupby(by_modified)
 
     data_list = []
     for key, group in grouped:
-        columns = MultiIndex.from_product([[key], cols])
+        # error: List item 1 has incompatible type "Union[Hashable,
+        # Sequence[Hashable]]"; expected "Iterable[Hashable]"
+        columns = MultiIndex.from_product([[key], cols])  # type: ignore[list-item]
         sub_group = group[cols]
         sub_group.columns = columns
         data_list.append(sub_group)
diff --git a/pandas/plotting/_matplotlib/hist.py b/pandas/plotting/_matplotlib/hist.py
index 08cffbf475db0..d69f68d9e0b66 100644
--- a/pandas/plotting/_matplotlib/hist.py
+++ b/pandas/plotting/_matplotlib/hist.py
@@ -1,9 +1,14 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    Literal,
+)
 
 import numpy as np
 
+from pandas._typing import PlottingOrientation
+
 from pandas.core.dtypes.common import (
     is_integer,
     is_list_like,
@@ -17,8 +22,6 @@
     remove_na_arraylike,
 )
 
-from pandas.core.frame import DataFrame
-
 from pandas.io.formats.printing import pprint_thing
 from pandas.plotting._matplotlib.core import (
     LinePlot,
@@ -28,6 +31,7 @@
     create_iter_data_given_by,
     reformat_hist_y_given_by,
 )
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
 from pandas.plotting._matplotlib.tools import (
     create_subplots,
     flatten_axes,
@@ -38,23 +42,33 @@
 if TYPE_CHECKING:
     from matplotlib.axes import Axes
 
+    from pandas import DataFrame
+
 
 class HistPlot(LinePlot):
-    _kind = "hist"
+    @property
+    def _kind(self) -> Literal["hist", "kde"]:
+        return "hist"
 
-    def __init__(self, data, bins=10, bottom=0, **kwargs):
+    def __init__(
+        self,
+        data,
+        bins: int | np.ndarray | list[np.ndarray] = 10,
+        bottom: int | np.ndarray = 0,
+        **kwargs,
+    ) -> None:
         self.bins = bins  # use mpl default
         self.bottom = bottom
         # Do not call LinePlot.__init__ which may fill nan
         MPLPlot.__init__(self, data, **kwargs)
 
     def _args_adjust(self):
-
         # calculate bin number separately in different subplots
         # where subplots are created based on by argument
         if is_integer(self.bins):
             if self.by is not None:
-                grouped = self.data.groupby(self.by)[self.columns]
+                by_modified = unpack_single_str_list(self.by)
+                grouped = self.data.groupby(by_modified)[self.columns]
                 self.bins = [self._calculate_bins(group) for key, group in grouped]
             else:
                 self.bins = self._calculate_bins(self.data)
@@ -64,8 +78,8 @@ def _args_adjust(self):
 
     def _calculate_bins(self, data: DataFrame) -> np.ndarray:
         """Calculate bins given data"""
-        values = data._convert(datetime=True)._get_numeric_data()
-        values = np.ravel(values)
+        nd_values = data._convert(datetime=True)._get_numeric_data()
+        values = np.ravel(nd_values)
         values = values[~isna(values)]
 
         hist, bins = np.histogram(
@@ -159,7 +173,7 @@ def _post_plot_logic(self, ax: Axes, data):
             ax.set_ylabel("Frequency")
 
     @property
-    def orientation(self):
+    def orientation(self) -> PlottingOrientation:
         if self.kwds.get("orientation", None) == "horizontal":
             return "horizontal"
         else:
@@ -167,10 +181,15 @@ def orientation(self):
 
 
 class KdePlot(HistPlot):
-    _kind = "kde"
-    orientation = "vertical"
+    @property
+    def _kind(self) -> Literal["kde"]:
+        return "kde"
+
+    @property
+    def orientation(self) -> Literal["vertical"]:
+        return "vertical"
 
-    def __init__(self, data, bw_method=None, ind=None, **kwargs):
+    def __init__(self, data, bw_method=None, ind=None, **kwargs) -> None:
         MPLPlot.__init__(self, data, **kwargs)
         self.bw_method = bw_method
         self.ind = ind
@@ -357,13 +376,13 @@ def hist_series(
     self,
     by=None,
     ax=None,
-    grid=True,
+    grid: bool = True,
     xlabelsize=None,
     xrot=None,
     ylabelsize=None,
     yrot=None,
     figsize=None,
-    bins=10,
+    bins: int = 10,
     legend: bool = False,
     **kwds,
 ):
@@ -429,17 +448,17 @@ def hist_frame(
     data,
     column=None,
     by=None,
-    grid=True,
+    grid: bool = True,
     xlabelsize=None,
     xrot=None,
     ylabelsize=None,
     yrot=None,
     ax=None,
-    sharex=False,
-    sharey=False,
+    sharex: bool = False,
+    sharey: bool = False,
     figsize=None,
     layout=None,
-    bins=10,
+    bins: int = 10,
     legend: bool = False,
     **kwds,
 ):
diff --git a/pandas/plotting/_matplotlib/misc.py b/pandas/plotting/_matplotlib/misc.py
index 6583328f916f1..633cb63664823 100644
--- a/pandas/plotting/_matplotlib/misc.py
+++ b/pandas/plotting/_matplotlib/misc.py
@@ -27,21 +27,22 @@
 
     from pandas import (
         DataFrame,
+        Index,
         Series,
     )
 
 
 def scatter_matrix(
     frame: DataFrame,
-    alpha=0.5,
+    alpha: float = 0.5,
     figsize=None,
     ax=None,
-    grid=False,
-    diagonal="hist",
-    marker=".",
+    grid: bool = False,
+    diagonal: str = "hist",
+    marker: str = ".",
     density_kwds=None,
     hist_kwds=None,
-    range_padding=0.05,
+    range_padding: float = 0.05,
     **kwds,
 ):
     df = frame._get_numeric_data()
@@ -351,7 +352,7 @@ def parallel_coordinates(
     cols=None,
     ax: Axes | None = None,
     color=None,
-    use_columns=False,
+    use_columns: bool = False,
     xticks=None,
     colormap=None,
     axvlines: bool = True,
@@ -378,6 +379,7 @@ def parallel_coordinates(
     ncols = len(df.columns)
 
     # determine values to use for xticks
+    x: list[int] | Index
     if use_columns is True:
         if not np.all(np.isreal(list(df.columns))):
             raise ValueError("Columns must be numeric to be used as xticks")
@@ -473,3 +475,10 @@ def r(h):
         ax.legend()
     ax.grid()
     return ax
+
+
+def unpack_single_str_list(keys):
+    # GH 42795
+    if isinstance(keys, list) and len(keys) == 1:
+        keys = keys[0]
+    return keys
diff --git a/pandas/plotting/_matplotlib/style.py b/pandas/plotting/_matplotlib/style.py
index 597c0dafa8cab..d462fdb515251 100644
--- a/pandas/plotting/_matplotlib/style.py
+++ b/pandas/plotting/_matplotlib/style.py
@@ -11,14 +11,19 @@
 )
 import warnings
 
+import matplotlib as mpl
 import matplotlib.cm as cm
 import matplotlib.colors
 import numpy as np
 
+from pandas.util._exceptions import find_stack_level
+
 from pandas.core.dtypes.common import is_list_like
 
 import pandas.core.common as com
 
+from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+
 if TYPE_CHECKING:
     from matplotlib.colors import Colormap
 
@@ -121,7 +126,8 @@ def _derive_colors(
     elif color is not None:
         if colormap is not None:
             warnings.warn(
-                "'color' and 'colormap' cannot be used simultaneously. Using 'color'"
+                "'color' and 'colormap' cannot be used simultaneously. Using 'color'",
+                stacklevel=find_stack_level(),
             )
         return _get_colors_from_color(color)
     else:
@@ -143,15 +149,18 @@ def _get_colors_from_colormap(
     num_colors: int,
 ) -> list[Color]:
     """Get colors from colormap."""
-    colormap = _get_cmap_instance(colormap)
-    return [colormap(num) for num in np.linspace(0, 1, num=num_colors)]
+    cmap = _get_cmap_instance(colormap)
+    return [cmap(num) for num in np.linspace(0, 1, num=num_colors)]
 
 
 def _get_cmap_instance(colormap: str | Colormap) -> Colormap:
     """Get instance of matplotlib colormap."""
     if isinstance(colormap, str):
         cmap = colormap
-        colormap = cm.get_cmap(colormap)
+        if mpl_ge_3_6_0():
+            colormap = mpl.colormaps[colormap]
+        else:
+            colormap = cm.get_cmap(colormap)
         if colormap is None:
             raise ValueError(f"Colormap {cmap} is not recognized")
     return colormap
diff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py
index 3cd312b06020d..06aac478bfb11 100644
--- a/pandas/plotting/_matplotlib/timeseries.py
+++ b/pandas/plotting/_matplotlib/timeseries.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from datetime import timedelta
 import functools
 from typing import (
     TYPE_CHECKING,
@@ -185,11 +186,10 @@ def _get_ax_freq(ax: Axes):
     return ax_freq
 
 
-def _get_period_alias(freq) -> str | None:
+def _get_period_alias(freq: timedelta | BaseOffset | str) -> str | None:
     freqstr = to_offset(freq).rule_code
 
-    freq = get_period_alias(freqstr)
-    return freq
+    return get_period_alias(freqstr)
 
 
 def _get_freq(ax: Axes, series: Series):
@@ -223,18 +223,21 @@ def use_dynamic_x(ax: Axes, data: DataFrame | Series) -> bool:
     if freq is None:
         return False
 
-    freq = _get_period_alias(freq)
+    freq_str = _get_period_alias(freq)
 
-    if freq is None:
+    if freq_str is None:
         return False
 
     # FIXME: hack this for 0.10.1, creating more technical debt...sigh
     if isinstance(data.index, ABCDatetimeIndex):
-        base = to_offset(freq)._period_dtype_code
+        # error: "BaseOffset" has no attribute "_period_dtype_code"
+        base = to_offset(freq_str)._period_dtype_code  # type: ignore[attr-defined]
         x = data.index
         if base <= FreqGroup.FR_DAY.value:
             return x[:1].is_normalized
-        return Period(x[0], freq).to_timestamp().tz_localize(x.tz) == x[0]
+        period = Period(x[0], freq_str)
+        assert isinstance(period, Period)
+        return period.to_timestamp().tz_localize(x.tz) == x[0]
     return True
 
 
@@ -256,7 +259,7 @@ def maybe_convert_index(ax: Axes, data):
     # tsplot converts automatically, but don't want to convert index
     # over and over for DataFrames
     if isinstance(data.index, (ABCDatetimeIndex, ABCPeriodIndex)):
-        freq = data.index.freq
+        freq: str | BaseOffset | None = data.index.freq
 
         if freq is None:
             # We only get here for DatetimeIndex
@@ -270,12 +273,12 @@ def maybe_convert_index(ax: Axes, data):
         if freq is None:
             raise ValueError("Could not get frequency alias for plotting")
 
-        freq = _get_period_alias(freq)
+        freq_str = _get_period_alias(freq)
 
         if isinstance(data.index, ABCDatetimeIndex):
-            data = data.tz_localize(None).to_period(freq=freq)
+            data = data.tz_localize(None).to_period(freq=freq_str)
         elif isinstance(data.index, ABCPeriodIndex):
-            data.index = data.index.asfreq(freq=freq)
+            data.index = data.index.asfreq(freq=freq_str)
     return data
 
 
@@ -288,7 +291,7 @@ def _format_coord(freq, t, y) -> str:
     return f"t = {time_period}  y = {y:8f}"
 
 
-def format_dateaxis(subplot, freq, index):
+def format_dateaxis(subplot, freq, index) -> None:
     """
     Pretty-formats the date axis (x-axis).
 
diff --git a/pandas/plotting/_matplotlib/tools.py b/pandas/plotting/_matplotlib/tools.py
index 5314a61191d78..1925dd8c4023c 100644
--- a/pandas/plotting/_matplotlib/tools.py
+++ b/pandas/plotting/_matplotlib/tools.py
@@ -50,7 +50,7 @@ def maybe_adjust_figure(fig: Figure, *args, **kwargs):
         fig.subplots_adjust(*args, **kwargs)
 
 
-def format_date_labels(ax: Axes, rot):
+def format_date_labels(ax: Axes, rot) -> None:
     # mini version of autofmt_xdate
     for label in ax.get_xticklabels():
         label.set_ha("right")
@@ -83,7 +83,11 @@ def table(
     return table
 
 
-def _get_layout(nplots: int, layout=None, layout_type: str = "box") -> tuple[int, int]:
+def _get_layout(
+    nplots: int,
+    layout: tuple[int, int] | None = None,
+    layout_type: str = "box",
+) -> tuple[int, int]:
     if layout is not None:
         if not isinstance(layout, (tuple, list)) or len(layout) != 2:
             raise ValueError("Layout must be a tuple of (rows, columns)")
@@ -117,7 +121,7 @@ def _get_layout(nplots: int, layout=None, layout_type: str = "box") -> tuple[int
         return layouts[nplots]
     except KeyError:
         k = 1
-        while k ** 2 < nplots:
+        while k**2 < nplots:
             k += 1
 
         if (k - 1) * k >= nplots:
@@ -229,6 +233,7 @@ def create_subplots(
                 warnings.warn(
                     "When passing multiple axes, layout keyword is ignored.",
                     UserWarning,
+                    stacklevel=find_stack_level(),
                 )
             if sharex or sharey:
                 warnings.warn(
@@ -328,13 +333,13 @@ def _remove_labels_from_axis(axis: Axis):
     axis.get_label().set_visible(False)
 
 
-def _has_externally_shared_axis(ax1: matplotlib.axes, compare_axis: str) -> bool:
+def _has_externally_shared_axis(ax1: Axes, compare_axis: str) -> bool:
     """
     Return whether an axis is externally shared.
 
     Parameters
     ----------
-    ax1 : matplotlib.axes
+    ax1 : matplotlib.axes.Axes
         Axis to query.
     compare_axis : str
         `"x"` or `"y"` according to whether the X-axis or Y-axis is being
@@ -388,12 +393,8 @@ def handle_shared_axes(
     sharey: bool,
 ):
     if nplots > 1:
-        if compat.mpl_ge_3_2_0():
-            row_num = lambda x: x.get_subplotspec().rowspan.start
-            col_num = lambda x: x.get_subplotspec().colspan.start
-        else:
-            row_num = lambda x: x.rowNum
-            col_num = lambda x: x.colNum
+        row_num = lambda x: x.get_subplotspec().rowspan.start
+        col_num = lambda x: x.get_subplotspec().colspan.start
 
         if compat.mpl_ge_3_4_0():
             is_first_col = lambda x: x.get_subplotspec().is_first_col()
diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index ac7e467aa3d9f..b7e6fca88b637 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -1,7 +1,23 @@
+from __future__ import annotations
+
 from contextlib import contextmanager
+from typing import (
+    TYPE_CHECKING,
+    Iterator,
+)
 
 from pandas.plotting._core import _get_plot_backend
 
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+    import numpy as np
+
+    from pandas import (
+        DataFrame,
+        Series,
+    )
+
 
 def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
     """
@@ -27,7 +43,7 @@ def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
     )
 
 
-def register():
+def register() -> None:
     """
     Register pandas formatters and converters with matplotlib.
 
@@ -49,7 +65,7 @@ def register():
     plot_backend.register()
 
 
-def deregister():
+def deregister() -> None:
     """
     Remove pandas formatters and converters.
 
@@ -70,18 +86,18 @@ def deregister():
 
 
 def scatter_matrix(
-    frame,
-    alpha=0.5,
-    figsize=None,
-    ax=None,
-    grid=False,
-    diagonal="hist",
-    marker=".",
+    frame: DataFrame,
+    alpha: float = 0.5,
+    figsize: tuple[float, float] | None = None,
+    ax: Axes | None = None,
+    grid: bool = False,
+    diagonal: str = "hist",
+    marker: str = ".",
     density_kwds=None,
     hist_kwds=None,
-    range_padding=0.05,
+    range_padding: float = 0.05,
     **kwargs,
-):
+) -> np.ndarray:
     """
     Draw a matrix of scatter plots.
 
@@ -123,22 +139,22 @@ def scatter_matrix(
 
         >>> df = pd.DataFrame(np.random.randn(1000, 4), columns=['A','B','C','D'])
         >>> pd.plotting.scatter_matrix(df, alpha=0.2)
-        array([[<AxesSubplot:xlabel='A', ylabel='A'>,
-            <AxesSubplot:xlabel='B', ylabel='A'>,
-            <AxesSubplot:xlabel='C', ylabel='A'>,
-            <AxesSubplot:xlabel='D', ylabel='A'>],
-           [<AxesSubplot:xlabel='A', ylabel='B'>,
-            <AxesSubplot:xlabel='B', ylabel='B'>,
-            <AxesSubplot:xlabel='C', ylabel='B'>,
-            <AxesSubplot:xlabel='D', ylabel='B'>],
-           [<AxesSubplot:xlabel='A', ylabel='C'>,
-            <AxesSubplot:xlabel='B', ylabel='C'>,
-            <AxesSubplot:xlabel='C', ylabel='C'>,
-            <AxesSubplot:xlabel='D', ylabel='C'>],
-           [<AxesSubplot:xlabel='A', ylabel='D'>,
-            <AxesSubplot:xlabel='B', ylabel='D'>,
-            <AxesSubplot:xlabel='C', ylabel='D'>,
-            <AxesSubplot:xlabel='D', ylabel='D'>]], dtype=object)
+        array([[<AxesSubplot: xlabel='A', ylabel='A'>,
+            <AxesSubplot: xlabel='B', ylabel='A'>,
+            <AxesSubplot: xlabel='C', ylabel='A'>,
+            <AxesSubplot: xlabel='D', ylabel='A'>],
+           [<AxesSubplot: xlabel='A', ylabel='B'>,
+            <AxesSubplot: xlabel='B', ylabel='B'>,
+            <AxesSubplot: xlabel='C', ylabel='B'>,
+            <AxesSubplot: xlabel='D', ylabel='B'>],
+           [<AxesSubplot: xlabel='A', ylabel='C'>,
+            <AxesSubplot: xlabel='B', ylabel='C'>,
+            <AxesSubplot: xlabel='C', ylabel='C'>,
+            <AxesSubplot: xlabel='D', ylabel='C'>],
+           [<AxesSubplot: xlabel='A', ylabel='D'>,
+            <AxesSubplot: xlabel='B', ylabel='D'>,
+            <AxesSubplot: xlabel='C', ylabel='D'>,
+            <AxesSubplot: xlabel='D', ylabel='D'>]], dtype=object)
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.scatter_matrix(
@@ -156,7 +172,14 @@ def scatter_matrix(
     )
 
 
-def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
+def radviz(
+    frame: DataFrame,
+    class_column: str,
+    ax: Axes | None = None,
+    color: list[str] | tuple[str, ...] | None = None,
+    colormap=None,
+    **kwds,
+) -> Axes:
     """
     Plot a multidimensional dataset in 2D.
 
@@ -224,7 +247,7 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
         ...     }
         ... )
         >>> pd.plotting.radviz(df, 'Category')
-        <AxesSubplot:xlabel='y(t)', ylabel='y(t + 1)'>
+        <AxesSubplot: xlabel='y(t)', ylabel='y(t + 1)'>
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.radviz(
@@ -238,11 +261,16 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
 
 
 def andrews_curves(
-    frame, class_column, ax=None, samples=200, color=None, colormap=None, **kwargs
-):
+    frame: DataFrame,
+    class_column: str,
+    ax: Axes | None = None,
+    samples: int = 200,
+    color: list[str] | tuple[str, ...] | None = None,
+    colormap=None,
+    **kwargs,
+) -> Axes:
     """
-    Generate a matplotlib plot of Andrews curves, for visualising clusters of
-    multivariate data.
+    Generate a matplotlib plot for visualising clusters of multivariate data.
 
     Andrews curves have the functional form:
 
@@ -279,11 +307,11 @@ def andrews_curves(
         :context: close-figs
 
         >>> df = pd.read_csv(
-        ...     'https://raw.github.com/pandas-dev/'
-        ...     'pandas/master/pandas/tests/io/data/csv/iris.csv'
+        ...     'https://raw.githubusercontent.com/pandas-dev/'
+        ...     'pandas/main/pandas/tests/io/data/csv/iris.csv'
         ... )
         >>> pd.plotting.andrews_curves(df, 'Name')
-        <AxesSubplot:title={'center':'width'}>
+        <AxesSubplot: title={'center': 'width'}>
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.andrews_curves(
@@ -297,7 +325,13 @@ def andrews_curves(
     )
 
 
-def bootstrap_plot(series, fig=None, size=50, samples=500, **kwds):
+def bootstrap_plot(
+    series: Series,
+    fig: Figure | None = None,
+    size: int = 50,
+    samples: int = 500,
+    **kwds,
+) -> Figure:
     """
     Bootstrap plot on mean, median and mid-range statistics.
 
@@ -352,19 +386,19 @@ def bootstrap_plot(series, fig=None, size=50, samples=500, **kwds):
 
 
 def parallel_coordinates(
-    frame,
-    class_column,
-    cols=None,
-    ax=None,
-    color=None,
-    use_columns=False,
-    xticks=None,
+    frame: DataFrame,
+    class_column: str,
+    cols: list[str] | None = None,
+    ax: Axes | None = None,
+    color: list[str] | tuple[str, ...] | None = None,
+    use_columns: bool = False,
+    xticks: list | tuple | None = None,
     colormap=None,
-    axvlines=True,
+    axvlines: bool = True,
     axvlines_kwds=None,
-    sort_labels=False,
+    sort_labels: bool = False,
     **kwargs,
-):
+) -> Axes:
     """
     Parallel coordinates plotting.
 
@@ -405,13 +439,13 @@ def parallel_coordinates(
         :context: close-figs
 
         >>> df = pd.read_csv(
-        ...     'https://raw.github.com/pandas-dev/'
-        ...     'pandas/master/pandas/tests/io/data/csv/iris.csv'
+        ...     'https://raw.githubusercontent.com/pandas-dev/'
+        ...     'pandas/main/pandas/tests/io/data/csv/iris.csv'
         ... )
         >>> pd.plotting.parallel_coordinates(
         ...     df, 'Name', color=('#556270', '#4ECDC4', '#C7F464')
         ... )
-        <AxesSubplot:xlabel='y(t)', ylabel='y(t + 1)'>
+        <AxesSubplot: xlabel='y(t)', ylabel='y(t + 1)'>
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.parallel_coordinates(
@@ -430,7 +464,7 @@ def parallel_coordinates(
     )
 
 
-def lag_plot(series, lag=1, ax=None, **kwds):
+def lag_plot(series: Series, lag: int = 1, ax: Axes | None = None, **kwds) -> Axes:
     """
     Lag plot for time series.
 
@@ -460,7 +494,7 @@ def lag_plot(series, lag=1, ax=None, **kwds):
         >>> x = np.cumsum(np.random.normal(loc=1, scale=5, size=50))
         >>> s = pd.Series(x)
         >>> s.plot()
-        <AxesSubplot:xlabel='Midrange'>
+        <AxesSubplot: xlabel='Midrange'>
 
     A lag plot with ``lag=1`` returns
 
@@ -468,13 +502,13 @@ def lag_plot(series, lag=1, ax=None, **kwds):
         :context: close-figs
 
         >>> pd.plotting.lag_plot(s, lag=1)
-        <AxesSubplot:xlabel='y(t)', ylabel='y(t + 1)'>
+        <AxesSubplot: xlabel='y(t)', ylabel='y(t + 1)'>
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.lag_plot(series=series, lag=lag, ax=ax, **kwds)
 
 
-def autocorrelation_plot(series, ax=None, **kwargs):
+def autocorrelation_plot(series: Series, ax: Axes | None = None, **kwargs) -> Axes:
     """
     Autocorrelation plot for time series.
 
@@ -502,7 +536,7 @@ def autocorrelation_plot(series, ax=None, **kwargs):
         >>> spacing = np.linspace(-9 * np.pi, 9 * np.pi, num=1000)
         >>> s = pd.Series(0.7 * np.random.rand(1000) + 0.3 * np.sin(spacing))
         >>> pd.plotting.autocorrelation_plot(s)
-        <AxesSubplot:title={'center':'width'}, xlabel='Lag', ylabel='Autocorrelation'>
+        <AxesSubplot: title={'center': 'width'}, xlabel='Lag', ylabel='Autocorrelation'>
     """
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.autocorrelation_plot(series=series, ax=ax, **kwargs)
@@ -521,7 +555,7 @@ class _Options(dict):
     _ALIASES = {"x_compat": "xaxis.compat"}
     _DEFAULT_KEYS = ["xaxis.compat"]
 
-    def __init__(self, deprecated=False):
+    def __init__(self, deprecated: bool = False) -> None:
         self._deprecated = deprecated
         super().__setitem__("xaxis.compat", False)
 
@@ -531,21 +565,21 @@ def __getitem__(self, key):
             raise ValueError(f"{key} is not a valid pandas plotting option")
         return super().__getitem__(key)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         key = self._get_canonical_key(key)
-        return super().__setitem__(key, value)
+        super().__setitem__(key, value)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key) -> None:
         key = self._get_canonical_key(key)
         if key in self._DEFAULT_KEYS:
             raise ValueError(f"Cannot remove default parameter {key}")
-        return super().__delitem__(key)
+        super().__delitem__(key)
 
     def __contains__(self, key) -> bool:
         key = self._get_canonical_key(key)
         return super().__contains__(key)
 
-    def reset(self):
+    def reset(self) -> None:
         """
         Reset the option store to its initial state
 
@@ -560,7 +594,7 @@ def _get_canonical_key(self, key):
         return self._ALIASES.get(key, key)
 
     @contextmanager
-    def use(self, key, value):
+    def use(self, key, value) -> Iterator[_Options]:
         """
         Temporarily set a parameter value using the with statement.
         Aliasing allowed.
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index 2e306c76d246c..c2db9698d0537 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -16,7 +16,9 @@ def check(self, namespace, expected, ignored=None):
         # ignored ones
         # compare vs the expected
 
-        result = sorted(f for f in dir(namespace) if not f.startswith("__"))
+        result = sorted(
+            f for f in dir(namespace) if not f.startswith("__") and f != "annotations"
+        )
         if ignored is not None:
             result = sorted(set(result) - set(ignored))
 
@@ -51,6 +53,7 @@ class TestPDApi(Base):
 
     # top-level classes
     classes = [
+        "ArrowDtype",
         "Categorical",
         "CategoricalIndex",
         "DataFrame",
@@ -116,6 +119,7 @@ class TestPDApi(Base):
         "eval",
         "factorize",
         "get_dummies",
+        "from_dummies",
         "infer_freq",
         "isna",
         "isnull",
@@ -274,7 +278,7 @@ def test_np():
 
 
 class TestApi(Base):
-    allowed = ["types", "extensions", "indexers"]
+    allowed = ["types", "extensions", "indexers", "interchange"]
 
     def test_api(self):
         self.check(api, self.allowed)
diff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py
index 98872571ae2bb..faa89e556a01e 100644
--- a/pandas/tests/apply/test_frame_apply.py
+++ b/pandas/tests/apply/test_frame_apply.py
@@ -1287,6 +1287,27 @@ def test_nuiscance_columns():
     tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize("method", ["agg", "apply", "transform"])
+def test_numeric_only_warning_numpy(method):
+    # GH#50538
+    df = DataFrame({"a": [1, 1, 2], "b": list("xyz")})
+    if method == "agg":
+        msg = "The operation <function mean.*failed"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            getattr(df, method)(np.mean)
+        # Ensure users can't pass numeric_only
+        with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+            getattr(df, method)(np.mean, numeric_only=True)
+    elif method == "apply":
+        with pytest.raises(TypeError, match="Could not convert"):
+            getattr(df, method)(np.mean)
+    else:
+        with pytest.raises(ValueError, match="Function did not transform"):
+            msg = "The operation <function mean.*failed"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                getattr(df, method)(np.mean)
+
+
 @pytest.mark.parametrize("how", ["agg", "apply"])
 def test_non_callable_aggregates(how):
 
@@ -1440,7 +1461,7 @@ def test_apply_dtype(col):
     tm.assert_series_equal(result, expected)
 
 
-def test_apply_mutating(using_array_manager):
+def test_apply_mutating(using_array_manager, using_copy_on_write):
     # GH#35462 case where applied func pins a new BlockManager to a row
     df = DataFrame({"a": range(100), "b": range(100, 200)})
     df_orig = df.copy()
@@ -1457,12 +1478,13 @@ def func(row):
     result = df.apply(func, axis=1)
 
     tm.assert_frame_equal(result, expected)
-    if not using_array_manager:
+    if using_copy_on_write or using_array_manager:
+        # INFO(CoW) With copy on write, mutating a viewing row doesn't mutate the parent
         # INFO(ArrayManager) With BlockManager, the row is a view and mutated in place,
         # with ArrayManager the row is not a view, and thus not mutated in place
-        tm.assert_frame_equal(df, result)
-    else:
         tm.assert_frame_equal(df, df_orig)
+    else:
+        tm.assert_frame_equal(df, result)
 
 
 def test_apply_empty_list_reduce():
@@ -1551,3 +1573,90 @@ def foo(x):
     df = DataFrame({"a": [1, 2, 3]})
     with tm.assert_produces_warning(UserWarning, match="Hello, World!"):
         df.agg([foo])
+
+
+def test_apply_type():
+    # GH 46719
+    df = DataFrame(
+        {"col1": [3, "string", float], "col2": [0.25, datetime(2020, 1, 1), np.nan]},
+        index=["a", "b", "c"],
+    )
+
+    # applymap
+    result = df.applymap(type)
+    expected = DataFrame(
+        {"col1": [int, str, type], "col2": [float, datetime, float]},
+        index=["a", "b", "c"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # axis=0
+    result = df.apply(type, axis=0)
+    expected = Series({"col1": Series, "col2": Series})
+    tm.assert_series_equal(result, expected)
+
+    # axis=1
+    result = df.apply(type, axis=1)
+    expected = Series({"a": Series, "b": Series, "c": Series})
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_on_empty_dataframe():
+    # GH 39111
+    df = DataFrame({"a": [1, 2], "b": [3, 0]})
+    result = df.head(0).apply(lambda x: max(x["a"], x["b"]), axis=1)
+    expected = Series([], dtype=np.float64)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "test, constant",
+    [
+        ({"a": [1, 2, 3], "b": [1, 1, 1]}, {"a": [1, 2, 3], "b": [1]}),
+        ({"a": [2, 2, 2], "b": [1, 1, 1]}, {"a": [2], "b": [1]}),
+    ],
+)
+def test_unique_agg_type_is_series(test, constant):
+    # GH#22558
+    df1 = DataFrame(test)
+    expected = Series(data=constant, index=["a", "b"], dtype="object")
+    aggregation = {"a": "unique", "b": "unique"}
+
+    result = df1.agg(aggregation)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_any_non_keyword_deprecation():
+    df = DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]})
+    msg = (
+        "In a future version of pandas all arguments of "
+        "DataFrame.any and Series.any will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.any("index", None)
+    expected = Series({"A": True, "B": True, "C": False})
+    tm.assert_series_equal(result, expected)
+
+    s = Series([False, False, False])
+    msg = (
+        "In a future version of pandas all arguments of "
+        "DataFrame.any and Series.any will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = s.any("index")
+    expected = False
+    tm.assert_equal(result, expected)
+
+
+def test_any_apply_keyword_non_zero_axis_regression():
+    # https://github.com/pandas-dev/pandas/issues/48656
+    df = DataFrame({"A": [1, 2, 0], "B": [0, 2, 0], "C": [0, 0, 0]})
+    expected = Series([True, True, False])
+    tm.assert_series_equal(df.any(axis=1), expected)
+
+    result = df.apply("any", axis=1)
+    tm.assert_series_equal(result, expected)
+
+    result = df.apply("any", 1)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/apply/test_frame_transform.py b/pandas/tests/apply/test_frame_transform.py
index 3384f9d46029a..2d4deff8ebc4a 100644
--- a/pandas/tests/apply/test_frame_transform.py
+++ b/pandas/tests/apply/test_frame_transform.py
@@ -139,6 +139,10 @@ def test_transform_bad_dtype(op, frame_or_series, request):
                 raises=ValueError, reason="GH 40418: rank does not raise a TypeError"
             )
         )
+    elif op == "ngroup":
+        request.node.add_marker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
 
     obj = DataFrame({"A": 3 * [object]})  # DataFrame that will fail on most transforms
     obj = tm.get_obj(obj, frame_or_series)
@@ -157,9 +161,14 @@ def test_transform_bad_dtype(op, frame_or_series, request):
 
 
 @pytest.mark.parametrize("op", frame_kernels_raise)
-def test_transform_partial_failure_typeerror(op):
+def test_transform_partial_failure_typeerror(request, op):
     # GH 35964
 
+    if op == "ngroup":
+        request.node.add_marker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
+
     # Using object makes most transform kernels fail
     df = DataFrame({"A": 3 * [object], "B": [1, 2, 3]})
 
diff --git a/pandas/tests/apply/test_invalid_arg.py b/pandas/tests/apply/test_invalid_arg.py
index 410a8f6bf3965..5a498aa7d6595 100644
--- a/pandas/tests/apply/test_invalid_arg.py
+++ b/pandas/tests/apply/test_invalid_arg.py
@@ -12,6 +12,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SpecificationError
+
 from pandas import (
     Categorical,
     DataFrame,
@@ -20,7 +22,6 @@
     notna,
 )
 import pandas._testing as tm
-from pandas.core.base import SpecificationError
 
 
 @pytest.mark.parametrize("result_type", ["foo", 1])
@@ -66,6 +67,15 @@ def test_map_with_invalid_na_action_raises():
         s.map(lambda x: x, na_action="https://github.com/____")
 
 
+@pytest.mark.parametrize("input_na_action", ["____", True])
+def test_map_arg_is_dict_with_invalid_na_action_raises(input_na_action):
+    # https://github.com/pandas-dev/pandas/issues/46588
+    s = Series([1, 2, 3])
+    msg = f"na_action must either be 'ignore' or None, {input_na_action} was passed"
+    with pytest.raises(ValueError, match=msg):
+        s.map({1: 2}, na_action=input_na_action)
+
+
 def test_map_categorical_na_action():
     values = Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
     s = Series(values, name="XX", index=list("abcdefg"))
diff --git a/pandas/tests/apply/test_series_apply.py b/pandas/tests/apply/test_series_apply.py
index b7084e2bc6dc7..afe1c236858ab 100644
--- a/pandas/tests/apply/test_series_apply.py
+++ b/pandas/tests/apply/test_series_apply.py
@@ -284,8 +284,6 @@ def test_transform_partial_failure(op, request):
                 raises=AssertionError, reason=f"{op} is successful on any dtype"
             )
         )
-    if op in ("rank", "fillna"):
-        pytest.skip(f"{op} doesn't raise TypeError on object")
 
     # Using object makes most transform kernels fail
     ser = Series(3 * [object])
@@ -378,11 +376,11 @@ def test_agg_apply_evaluate_lambdas_the_same(string_series):
 def test_with_nested_series(datetime_series):
     # GH 2316
     # .agg with a reducer and a transform, what to do
-    result = datetime_series.apply(lambda x: Series([x, x ** 2], index=["x", "x^2"]))
-    expected = DataFrame({"x": datetime_series, "x^2": datetime_series ** 2})
+    result = datetime_series.apply(lambda x: Series([x, x**2], index=["x", "x^2"]))
+    expected = DataFrame({"x": datetime_series, "x^2": datetime_series**2})
     tm.assert_frame_equal(result, expected)
 
-    result = datetime_series.agg(lambda x: Series([x, x ** 2], index=["x", "x^2"]))
+    result = datetime_series.agg(lambda x: Series([x, x**2], index=["x", "x^2"]))
     tm.assert_frame_equal(result, expected)
 
 
@@ -497,9 +495,13 @@ def test_map(datetime_series):
     tm.assert_series_equal(a.map(c), exp)
 
 
-def test_map_empty(index):
+def test_map_empty(request, index):
     if isinstance(index, MultiIndex):
-        pytest.skip("Initializing a Series from a MultiIndex is not supported")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Initializing a Series from a MultiIndex is not supported"
+            )
+        )
 
     s = Series(index)
     result = s.map({})
@@ -596,6 +598,34 @@ def test_map_dict_na_key():
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.parametrize("arg_func", [dict, Series])
+def test_map_dict_ignore_na(arg_func):
+    # GH#47527
+    mapping = arg_func({1: 10, np.nan: 42})
+    ser = Series([1, np.nan, 2])
+    result = ser.map(mapping, na_action="https://github.com/ignore")
+    expected = Series([10, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_defaultdict_ignore_na():
+    # GH#47527
+    mapping = defaultdict(int, {1: 10, np.nan: 42})
+    ser = Series([1, np.nan, 2])
+    result = ser.map(mapping)
+    expected = Series([10, 0, 0])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_categorical_na_ignore():
+    # GH#47527
+    values = pd.Categorical([1, np.nan, 2], categories=[10, 1])
+    ser = Series(values)
+    result = ser.map({1: 10, np.nan: 42})
+    expected = Series([10, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
 def test_map_dict_subclass_with_missing():
     """
     Test Series.map with a dictionary subclass that defines __missing__,
@@ -638,7 +668,7 @@ def test_map_abc_mapping_with_missing(non_dict_mapping_subclass):
     # https://github.com/pandas-dev/pandas/issues/29733
     # Check collections.abc.Mapping support as mapper for Series.map
     class NonDictMappingWithMissing(non_dict_mapping_subclass):
-        def __missing__(key):
+        def __missing__(self, key):
             return "missing"
 
     s = Series([1, 2, 3])
@@ -887,3 +917,11 @@ def test_apply_retains_column_name():
         index=Index(range(3), name="x"),
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_apply_type():
+    # GH 46719
+    s = Series([3, "string", float], index=["a", "b", "c"])
+    result = s.apply(type)
+    expected = Series([int, str, type], index=["a", "b", "c"])
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/apply/test_str.py b/pandas/tests/apply/test_str.py
index 82997328529cd..38b2a5459eb1f 100644
--- a/pandas/tests/apply/test_str.py
+++ b/pandas/tests/apply/test_str.py
@@ -45,17 +45,16 @@ def test_apply_with_string_funcs(request, float_frame, func, args, kwds, how):
     tm.assert_series_equal(result, expected)
 
 
-def test_with_string_args(datetime_series):
-
-    for arg in ["sum", "mean", "min", "max", "std"]:
-        result = datetime_series.apply(arg)
-        expected = getattr(datetime_series, arg)()
-        assert result == expected
+@pytest.mark.parametrize("arg", ["sum", "mean", "min", "max", "std"])
+def test_with_string_args(datetime_series, arg):
+    result = datetime_series.apply(arg)
+    expected = getattr(datetime_series, arg)()
+    assert result == expected
 
 
 @pytest.mark.parametrize("op", ["mean", "median", "std", "var"])
 @pytest.mark.parametrize("how", ["agg", "apply"])
-def test_apply_np_reducer(float_frame, op, how):
+def test_apply_np_reducer(op, how):
     # GH 39116
     float_frame = DataFrame({"a": [1, 2], "b": [3, 4]})
     result = getattr(float_frame, how)(op)
@@ -81,7 +80,9 @@ def test_apply_np_transformer(float_frame, op, how):
     if op in ["log", "sqrt"]:
         warn = RuntimeWarning
 
-    with tm.assert_produces_warning(warn):
+    with tm.assert_produces_warning(warn, check_stacklevel=False):
+        # float_frame fixture is defined in conftest.py, so we don't check the
+        # stacklevel as otherwise the test would fail.
         result = getattr(float_frame, how)(op)
         expected = getattr(np, op)(float_frame)
     tm.assert_frame_equal(result, expected)
@@ -244,8 +245,12 @@ def test_agg_cython_table_transform_frame(df, func, expected, axis):
 
 
 @pytest.mark.parametrize("op", series_transform_kernels)
-def test_transform_groupby_kernel_series(string_series, op):
+def test_transform_groupby_kernel_series(request, string_series, op):
     # GH 35964
+    if op == "ngroup":
+        request.node.add_marker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
     # TODO(2.0) Remove after pad/backfill deprecation enforced
     op = maybe_normalize_deprecated_kernels(op)
     args = [0.0] if op == "fillna" else []
@@ -256,20 +261,17 @@ def test_transform_groupby_kernel_series(string_series, op):
 
 
 @pytest.mark.parametrize("op", frame_transform_kernels)
-def test_transform_groupby_kernel_frame(
-    axis, float_frame, op, using_array_manager, request
-):
+def test_transform_groupby_kernel_frame(request, axis, float_frame, op):
     # TODO(2.0) Remove after pad/backfill deprecation enforced
     op = maybe_normalize_deprecated_kernels(op)
-    # GH 35964
-    if using_array_manager and op == "pct_change" and axis in (1, "columns"):
-        # TODO(ArrayManager) shift with axis=1
+
+    if op == "ngroup":
         request.node.add_marker(
-            pytest.mark.xfail(
-                reason="shift axis=1 not yet implemented for ArrayManager"
-            )
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
         )
 
+    # GH 35964
+
     args = [0.0] if op == "fillna" else []
     if axis == 0 or axis == "index":
         ones = np.ones(float_frame.shape[0])
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index 212cfc267cb00..0b1d56a956c07 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -1097,6 +1097,7 @@ def test_dt64arr_addsub_intlike(
                 # IntegerArray
                 "can only perform ops with numeric values",
                 "unsupported operand type.*Categorical",
+                r"unsupported operand type\(s\) for -: 'int' and 'Timestamp'",
             ]
         )
         assert_invalid_addsub_type(obj, 1, msg)
@@ -2017,7 +2018,7 @@ def test_dti_add_tdi(self, tz_naive_fixture):
         expected = date_range("2017-01-01", periods=10, tz=tz)
         expected = expected._with_freq(None)
 
-        # add with TimdeltaIndex
+        # add with TimedeltaIndex
         result = dti + tdi
         tm.assert_index_equal(result, expected)
 
@@ -2039,7 +2040,7 @@ def test_dti_iadd_tdi(self, tz_naive_fixture):
         expected = date_range("2017-01-01", periods=10, tz=tz)
         expected = expected._with_freq(None)
 
-        # iadd with TimdeltaIndex
+        # iadd with TimedeltaIndex
         result = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
         result += tdi
         tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index bc7a929ecaa4a..881a5f1de1c60 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -5,7 +5,6 @@
 
 from collections import abc
 from decimal import Decimal
-from itertools import combinations
 import operator
 from typing import Any
 
@@ -120,12 +119,12 @@ def test_numeric_cmp_string_numexpr_path(self, box_with_array):
         box = box_with_array
         xbox = box if box is not Index else np.ndarray
 
-        obj = Series(np.random.randn(10 ** 5))
+        obj = Series(np.random.randn(10**5))
         obj = tm.box_expected(obj, box, transpose=False)
 
         result = obj == "a"
 
-        expected = Series(np.zeros(10 ** 5, dtype=bool))
+        expected = Series(np.zeros(10**5, dtype=bool))
         expected = tm.box_expected(expected, xbox, transpose=False)
         tm.assert_equal(result, expected)
 
@@ -231,7 +230,7 @@ def test_numeric_arr_mul_tdscalar_numexpr_path(
         # GH#44772 for the float64 case
         box = box_with_array
 
-        arr_i8 = np.arange(2 * 10 ** 4).astype(np.int64, copy=False)
+        arr_i8 = np.arange(2 * 10**4).astype(np.int64, copy=False)
         arr = arr_i8.astype(dtype, copy=False)
         obj = tm.box_expected(arr, box, transpose=False)
 
@@ -676,7 +675,7 @@ def test_mul_index(self, numeric_idx):
         idx = numeric_idx
 
         result = idx * idx
-        tm.assert_index_equal(result, idx ** 2)
+        tm.assert_index_equal(result, idx**2)
 
     def test_mul_datelike_raises(self, numeric_idx):
         idx = numeric_idx
@@ -775,7 +774,7 @@ def test_operators_frame(self):
         df = pd.DataFrame({"A": ts})
 
         tm.assert_series_equal(ts + ts, ts + df["A"], check_names=False)
-        tm.assert_series_equal(ts ** ts, ts ** df["A"], check_names=False)
+        tm.assert_series_equal(ts**ts, ts ** df["A"], check_names=False)
         tm.assert_series_equal(ts < ts, ts < df["A"], check_names=False)
         tm.assert_series_equal(ts / ts, ts / df["A"], check_names=False)
 
@@ -928,7 +927,6 @@ def test_datetime64_with_index(self):
     # TODO: taken from tests.frame.test_operators, needs cleanup
     def test_frame_operators(self, float_frame):
         frame = float_frame
-        frame2 = pd.DataFrame(float_frame, columns=["D", "C", "B", "A"])
 
         garbage = np.random.random(4)
         colSeries = Series(garbage, index=np.array(frame.columns))
@@ -952,23 +950,27 @@ def test_frame_operators(self, float_frame):
                 else:
                     assert np.isnan(origVal)
 
+    def test_frame_operators_col_align(self, float_frame):
+        frame2 = pd.DataFrame(float_frame, columns=["D", "C", "B", "A"])
         added = frame2 + frame2
         expected = frame2 * 2
         tm.assert_frame_equal(added, expected)
 
+    def test_frame_operators_none_to_nan(self):
         df = pd.DataFrame({"a": ["a", None, "b"]})
         tm.assert_frame_equal(df + df, pd.DataFrame({"a": ["aa", np.nan, "bb"]}))
 
+    @pytest.mark.parametrize("dtype", ("float", "int64"))
+    def test_frame_operators_empty_like(self, dtype):
         # Test for issue #10181
-        for dtype in ("float", "int64"):
-            frames = [
-                pd.DataFrame(dtype=dtype),
-                pd.DataFrame(columns=["A"], dtype=dtype),
-                pd.DataFrame(index=[0], dtype=dtype),
-            ]
-            for df in frames:
-                assert (df + df).equals(df)
-                tm.assert_frame_equal(df + df, df)
+        frames = [
+            pd.DataFrame(dtype=dtype),
+            pd.DataFrame(columns=["A"], dtype=dtype),
+            pd.DataFrame(index=[0], dtype=dtype),
+        ]
+        for df in frames:
+            assert (df + df).equals(df)
+            tm.assert_frame_equal(df + df, df)
 
     @pytest.mark.parametrize(
         "func",
@@ -1164,45 +1166,85 @@ def test_operators_reverse_object(self, op):
 class TestNumericArithmeticUnsorted:
     # Tests in this class have been moved from type-specific test modules
     #  but not yet sorted, parametrized, and de-duplicated
-
-    def check_binop(self, ops, scalars, idxs):
-        for op in ops:
-            for a, b in combinations(idxs, 2):
-                a = a._rename("foo")
-                b = b._rename("bar")
-                result = op(a, b)
-                expected = op(Int64Index(a), Int64Index(b))
-                tm.assert_index_equal(result, expected, exact="equiv")
-            for idx in idxs:
-                for scalar in scalars:
-                    result = op(idx, scalar)
-                    expected = op(Int64Index(idx), scalar)
-                    tm.assert_index_equal(result, expected, exact="equiv")
-
-    def test_binops(self):
-        ops = [
+    @pytest.mark.parametrize(
+        "op",
+        [
             operator.add,
             operator.sub,
             operator.mul,
             operator.floordiv,
             operator.truediv,
-        ]
-        scalars = [-1, 1, 2]
-        idxs = [
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx1",
+        [
             RangeIndex(0, 10, 1),
             RangeIndex(0, 20, 2),
             RangeIndex(-10, 10, 2),
             RangeIndex(5, -5, -1),
-        ]
-        self.check_binop(ops, scalars, idxs)
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx2",
+        [
+            RangeIndex(0, 10, 1),
+            RangeIndex(0, 20, 2),
+            RangeIndex(-10, 10, 2),
+            RangeIndex(5, -5, -1),
+        ],
+    )
+    def test_binops_index(self, op, idx1, idx2):
+        idx1 = idx1._rename("foo")
+        idx2 = idx2._rename("bar")
+        result = op(idx1, idx2)
+        expected = op(Int64Index(idx1), Int64Index(idx2))
+        tm.assert_index_equal(result, expected, exact="equiv")
 
-    def test_binops_pow(self):
+    @pytest.mark.parametrize(
+        "op",
+        [
+            operator.add,
+            operator.sub,
+            operator.mul,
+            operator.floordiv,
+            operator.truediv,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            RangeIndex(0, 10, 1),
+            RangeIndex(0, 20, 2),
+            RangeIndex(-10, 10, 2),
+            RangeIndex(5, -5, -1),
+        ],
+    )
+    @pytest.mark.parametrize("scalar", [-1, 1, 2])
+    def test_binops_index_scalar(self, op, idx, scalar):
+        result = op(idx, scalar)
+        expected = op(Int64Index(idx), scalar)
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+    @pytest.mark.parametrize("idx1", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    @pytest.mark.parametrize("idx2", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    def test_binops_index_pow(self, idx1, idx2):
         # numpy does not allow powers of negative integers so test separately
         # https://github.com/numpy/numpy/pull/8127
-        ops = [pow]
-        scalars = [1, 2]
-        idxs = [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)]
-        self.check_binop(ops, scalars, idxs)
+        idx1 = idx1._rename("foo")
+        idx2 = idx2._rename("bar")
+        result = pow(idx1, idx2)
+        expected = pow(Int64Index(idx1), Int64Index(idx2))
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+    @pytest.mark.parametrize("idx", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    @pytest.mark.parametrize("scalar", [1, 2])
+    def test_binops_index_scalar_pow(self, idx, scalar):
+        # numpy does not allow powers of negative integers so test separately
+        # https://github.com/numpy/numpy/pull/8127
+        result = pow(idx, scalar)
+        expected = pow(Int64Index(idx), scalar)
+        tm.assert_index_equal(result, expected, exact="equiv")
 
     # TODO: divmod?
     @pytest.mark.parametrize(
@@ -1269,12 +1311,13 @@ def test_numeric_compat2(self):
 
         # __pow__
         idx = RangeIndex(0, 1000, 2)
-        result = idx ** 2
+        result = idx**2
         expected = Int64Index(idx._values) ** 2
         tm.assert_index_equal(Index(result.values), expected, exact=True)
 
-        # __floordiv__
-        cases_exact = [
+    @pytest.mark.parametrize(
+        "idx, div, expected",
+        [
             (RangeIndex(0, 1000, 2), 2, RangeIndex(0, 500, 1)),
             (RangeIndex(-99, -201, -3), -3, RangeIndex(33, 67, 1)),
             (
@@ -1291,9 +1334,11 @@ def test_numeric_compat2(self):
             (RangeIndex(2, 4, 2), 3, RangeIndex(0, 1, 1)),
             (RangeIndex(-5, -10, -6), 4, RangeIndex(-2, -1, 1)),
             (RangeIndex(-100, -200, 3), 2, RangeIndex(0)),
-        ]
-        for idx, div, expected in cases_exact:
-            tm.assert_index_equal(idx // div, expected, exact=True)
+        ],
+    )
+    def test_numeric_compat2_floordiv(self, idx, div, expected):
+        # __floordiv__
+        tm.assert_index_equal(idx // div, expected, exact=True)
 
     @pytest.mark.parametrize("dtype", [np.int64, np.float64])
     @pytest.mark.parametrize("delta", [1, 0, -1])
@@ -1393,7 +1438,7 @@ def test_sub_multiindex_swapped_levels():
 @pytest.mark.parametrize("string_size", [0, 1, 2, 5])
 def test_empty_str_comparison(power, string_size):
     # GH 37348
-    a = np.array(range(10 ** power))
+    a = np.array(range(10**power))
     right = pd.DataFrame(a, dtype=np.int64)
     left = " " * string_size
 
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
index c96d7c01ec97f..e107ff6b65c0f 100644
--- a/pandas/tests/arithmetic/test_object.py
+++ b/pandas/tests/arithmetic/test_object.py
@@ -80,12 +80,12 @@ def test_pow_ops_object(self):
         # pow is weird with masking & 1, so testing here
         a = Series([1, np.nan, 1, np.nan], dtype=object)
         b = Series([1, np.nan, np.nan, 1], dtype=object)
-        result = a ** b
-        expected = Series(a.values ** b.values, dtype=object)
+        result = a**b
+        expected = Series(a.values**b.values, dtype=object)
         tm.assert_series_equal(result, expected)
 
-        result = b ** a
-        expected = Series(b.values ** a.values, dtype=object)
+        result = b**a
+        expected = Series(b.values**a.values, dtype=object)
 
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
index c31556064eece..b03ac26a4b74d 100644
--- a/pandas/tests/arithmetic/test_period.py
+++ b/pandas/tests/arithmetic/test_period.py
@@ -807,9 +807,13 @@ def test_parr_sub_td64array(self, box_with_array, tdi_freq, pi_freq):
 
         elif pi_freq == "D":
             # Tick, but non-compatible
-            msg = "Input has different freq=None from PeriodArray"
+            msg = (
+                "Cannot add/subtract timedelta-like from PeriodArray that is "
+                "not an integer multiple of the PeriodArray's freq."
+            )
             with pytest.raises(IncompatibleFrequency, match=msg):
                 pi - td64obj
+
             with pytest.raises(IncompatibleFrequency, match=msg):
                 pi[0] - td64obj
 
@@ -914,6 +918,19 @@ def test_pi_sub_intlike(self, five):
         exp = rng + (-five)
         tm.assert_index_equal(result, exp)
 
+    def test_pi_add_sub_int_array_freqn_gt1(self):
+        # GH#47209 test adding array of ints when freq.n > 1 matches
+        #  scalar behavior
+        pi = period_range("2016-01-01", periods=10, freq="2D")
+        arr = np.arange(10)
+        result = pi + arr
+        expected = pd.Index([x + y for x, y in zip(pi, arr)])
+        tm.assert_index_equal(result, expected)
+
+        result = pi - arr
+        expected = pd.Index([x - y for x, y in zip(pi, arr)])
+        tm.assert_index_equal(result, expected)
+
     def test_pi_sub_isub_offset(self):
         # offset
         # DateOffset
@@ -1094,7 +1111,15 @@ def test_parr_add_sub_timedeltalike_freq_mismatch_daily(
         rng = period_range("2014-05-01", "2014-05-15", freq="D")
         rng = tm.box_expected(rng, box_with_array)
 
-        msg = "Input has different freq(=.+)? from Period.*?\\(freq=D\\)"
+        msg = "|".join(
+            [
+                # non-timedelta-like DateOffset
+                "Input has different freq(=.+)? from Period.*?\\(freq=D\\)",
+                # timedelta/td64/Timedelta but not a multiple of 24H
+                "Cannot add/subtract timedelta-like from PeriodArray that is "
+                "not an integer multiple of the PeriodArray's freq.",
+            ]
+        )
         with pytest.raises(IncompatibleFrequency, match=msg):
             rng + other
         with pytest.raises(IncompatibleFrequency, match=msg):
@@ -1121,7 +1146,15 @@ def test_parr_add_timedeltalike_mismatched_freq_hourly(
         other = not_hourly
         rng = period_range("2014-01-01 10:00", "2014-01-05 10:00", freq="H")
         rng = tm.box_expected(rng, box_with_array)
-        msg = "Input has different freq(=.+)? from Period.*?\\(freq=H\\)"
+        msg = "|".join(
+            [
+                # non-timedelta-like DateOffset
+                "Input has different freq(=.+)? from Period.*?\\(freq=H\\)",
+                # timedelta/td64/Timedelta but not a multiple of 24H
+                "Cannot add/subtract timedelta-like from PeriodArray that is "
+                "not an integer multiple of the PeriodArray's freq.",
+            ]
+        )
 
         with pytest.raises(IncompatibleFrequency, match=msg):
             rng + other
@@ -1230,6 +1263,21 @@ def test_parr_add_sub_tdt64_nat_array(self, box_with_array, other):
         with pytest.raises(TypeError, match=msg):
             other - obj
 
+        # some but not *all* NaT
+        other = other.copy()
+        other[0] = np.timedelta64(0, "ns")
+        expected = PeriodIndex([pi[0]] + ["NaT"] * 8, freq="19D")
+        expected = tm.box_expected(expected, box_with_array)
+
+        result = obj + other
+        tm.assert_equal(result, expected)
+        result = other + obj
+        tm.assert_equal(result, expected)
+        result = obj - other
+        tm.assert_equal(result, expected)
+        with pytest.raises(TypeError, match=msg):
+            other - obj
+
     # ---------------------------------------------------------------
     # Unsorted
 
@@ -1480,17 +1528,17 @@ def test_pi_offset_errors(self):
         )
         ser = Series(idx)
 
-        # Series op is applied per Period instance, thus error is raised
-        # from Period
+        msg = (
+            "Cannot add/subtract timedelta-like from PeriodArray that is not "
+            "an integer multiple of the PeriodArray's freq"
+        )
         for obj in [idx, ser]:
-            msg = r"Input has different freq=2H from Period.*?\(freq=D\)"
             with pytest.raises(IncompatibleFrequency, match=msg):
                 obj + pd.offsets.Hour(2)
 
             with pytest.raises(IncompatibleFrequency, match=msg):
                 pd.offsets.Hour(2) + obj
 
-            msg = r"Input has different freq=-2H from Period.*?\(freq=D\)"
             with pytest.raises(IncompatibleFrequency, match=msg):
                 obj - pd.offsets.Hour(2)
 
diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py
index 543531889531a..bb7949c9f08e2 100644
--- a/pandas/tests/arithmetic/test_timedelta64.py
+++ b/pandas/tests/arithmetic/test_timedelta64.py
@@ -204,8 +204,26 @@ def test_comp_nat(self, dtype):
         tm.assert_numpy_array_equal(lhs < NaT, expected)
         tm.assert_numpy_array_equal(NaT > lhs, expected)
 
-    def test_comparisons_nat(self):
-        tdidx1 = TimedeltaIndex(
+    @pytest.mark.parametrize(
+        "idx2",
+        [
+            TimedeltaIndex(
+                ["2 day", "2 day", NaT, NaT, "1 day 00:00:02", "5 days 00:00:03"]
+            ),
+            np.array(
+                [
+                    np.timedelta64(2, "D"),
+                    np.timedelta64(2, "D"),
+                    np.timedelta64("nat"),
+                    np.timedelta64("nat"),
+                    np.timedelta64(1, "D") + np.timedelta64(2, "s"),
+                    np.timedelta64(5, "D") + np.timedelta64(3, "s"),
+                ]
+            ),
+        ],
+    )
+    def test_comparisons_nat(self, idx2):
+        idx1 = TimedeltaIndex(
             [
                 "1 day",
                 NaT,
@@ -215,48 +233,30 @@ def test_comparisons_nat(self):
                 "5 day 00:00:03",
             ]
         )
-        tdidx2 = TimedeltaIndex(
-            ["2 day", "2 day", NaT, NaT, "1 day 00:00:02", "5 days 00:00:03"]
-        )
-        tdarr = np.array(
-            [
-                np.timedelta64(2, "D"),
-                np.timedelta64(2, "D"),
-                np.timedelta64("nat"),
-                np.timedelta64("nat"),
-                np.timedelta64(1, "D") + np.timedelta64(2, "s"),
-                np.timedelta64(5, "D") + np.timedelta64(3, "s"),
-            ]
-        )
-
-        cases = [(tdidx1, tdidx2), (tdidx1, tdarr)]
-
         # Check pd.NaT is handles as the same as np.nan
-        for idx1, idx2 in cases:
-
-            result = idx1 < idx2
-            expected = np.array([True, False, False, False, True, False])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx1 < idx2
+        expected = np.array([True, False, False, False, True, False])
+        tm.assert_numpy_array_equal(result, expected)
 
-            result = idx2 > idx1
-            expected = np.array([True, False, False, False, True, False])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx2 > idx1
+        expected = np.array([True, False, False, False, True, False])
+        tm.assert_numpy_array_equal(result, expected)
 
-            result = idx1 <= idx2
-            expected = np.array([True, False, False, False, True, True])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx1 <= idx2
+        expected = np.array([True, False, False, False, True, True])
+        tm.assert_numpy_array_equal(result, expected)
 
-            result = idx2 >= idx1
-            expected = np.array([True, False, False, False, True, True])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx2 >= idx1
+        expected = np.array([True, False, False, False, True, True])
+        tm.assert_numpy_array_equal(result, expected)
 
-            result = idx1 == idx2
-            expected = np.array([False, False, False, False, False, True])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx1 == idx2
+        expected = np.array([False, False, False, False, False, True])
+        tm.assert_numpy_array_equal(result, expected)
 
-            result = idx1 != idx2
-            expected = np.array([True, True, True, True, True, False])
-            tm.assert_numpy_array_equal(result, expected)
+        result = idx1 != idx2
+        expected = np.array([True, True, True, True, True, False])
+        tm.assert_numpy_array_equal(result, expected)
 
     # TODO: better name
     def test_comparisons_coverage(self):
@@ -538,6 +538,7 @@ def test_timedelta(self, freq):
         expected = index + timedelta(-1)
         tm.assert_index_equal(result, expected)
 
+    def test_timedelta_tick_arithmetic(self):
         # GH#4134, buggy with timedeltas
         rng = pd.date_range("2013", "2014")
         s = Series(rng)
@@ -664,28 +665,21 @@ def test_tdi_ops_attributes(self):
 class TestAddSubNaTMasking:
     # TODO: parametrize over boxes
 
-    def test_tdarr_add_timestamp_nat_masking(self, box_with_array):
+    @pytest.mark.parametrize("str_ts", ["1950-01-01", "1980-01-01"])
+    def test_tdarr_add_timestamp_nat_masking(self, box_with_array, str_ts):
         # GH#17991 checking for overflow-masking with NaT
         tdinat = pd.to_timedelta(["24658 days 11:15:00", "NaT"])
         tdobj = tm.box_expected(tdinat, box_with_array)
 
-        tsneg = Timestamp("1950-01-01")
-        ts_neg_variants = [
-            tsneg,
-            tsneg.to_pydatetime(),
-            tsneg.to_datetime64().astype("datetime64[ns]"),
-            tsneg.to_datetime64().astype("datetime64[D]"),
-        ]
-
-        tspos = Timestamp("1980-01-01")
-        ts_pos_variants = [
-            tspos,
-            tspos.to_pydatetime(),
-            tspos.to_datetime64().astype("datetime64[ns]"),
-            tspos.to_datetime64().astype("datetime64[D]"),
+        ts = Timestamp(str_ts)
+        ts_variants = [
+            ts,
+            ts.to_pydatetime(),
+            ts.to_datetime64().astype("datetime64[ns]"),
+            ts.to_datetime64().astype("datetime64[D]"),
         ]
 
-        for variant in ts_neg_variants + ts_pos_variants:
+        for variant in ts_variants:
             res = tdobj + variant
             if box_with_array is DataFrame:
                 assert res.iloc[1, 1] is NaT
@@ -1474,7 +1468,7 @@ def test_tdi_mul_int_array_zerodim(self, box_with_array):
     def test_tdi_mul_int_array(self, box_with_array):
         rng5 = np.arange(5, dtype="int64")
         idx = TimedeltaIndex(rng5)
-        expected = TimedeltaIndex(rng5 ** 2)
+        expected = TimedeltaIndex(rng5**2)
 
         idx = tm.box_expected(idx, box_with_array)
         expected = tm.box_expected(expected, box_with_array)
@@ -2089,10 +2083,10 @@ def test_td64arr_pow_invalid(self, scalar_td, box_with_array):
         # defined
         pattern = "operate|unsupported|cannot|not supported"
         with pytest.raises(TypeError, match=pattern):
-            scalar_td ** td1
+            scalar_td**td1
 
         with pytest.raises(TypeError, match=pattern):
-            td1 ** scalar_td
+            td1**scalar_td
 
 
 def test_add_timestamp_to_timedelta():
diff --git a/pandas/tests/arrays/boolean/test_arithmetic.py b/pandas/tests/arrays/boolean/test_arithmetic.py
index f8f1af4c3da51..197e83121567e 100644
--- a/pandas/tests/arrays/boolean/test_arithmetic.py
+++ b/pandas/tests/arrays/boolean/test_arithmetic.py
@@ -5,11 +5,11 @@
 
 import pandas as pd
 import pandas._testing as tm
-from pandas.arrays import FloatingArray
 
 
 @pytest.fixture
 def data():
+    """Fixture returning boolean array with valid and missing values."""
     return pd.array(
         [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
         dtype="boolean",
@@ -18,11 +18,13 @@ def data():
 
 @pytest.fixture
 def left_array():
+    """Fixture returning boolean array with valid and missing values."""
     return pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
 
 
 @pytest.fixture
 def right_array():
+    """Fixture returning boolean array with valid and missing values."""
     return pd.array([True, False, None] * 3, dtype="boolean")
 
 
@@ -55,15 +57,13 @@ def test_sub(left_array, right_array):
 
 
 def test_div(left_array, right_array):
-    result = left_array / right_array
-    expected = FloatingArray(
-        np.array(
-            [1.0, np.inf, np.nan, 0.0, np.nan, np.nan, np.nan, np.nan, np.nan],
-            dtype="float64",
-        ),
-        np.array([False, False, True, False, False, True, True, True, True]),
-    )
-    tm.assert_extension_array_equal(result, expected)
+    msg = "operator '.*' not implemented for bool dtypes"
+    with pytest.raises(NotImplementedError, match=msg):
+        # check that we are matching the non-masked Series behavior
+        pd.Series(left_array._data) / pd.Series(right_array._data)
+
+    with pytest.raises(NotImplementedError, match=msg):
+        left_array / right_array
 
 
 @pytest.mark.parametrize(
@@ -71,13 +71,16 @@ def test_div(left_array, right_array):
     [
         "floordiv",
         "mod",
-        pytest.param(
-            "pow", marks=pytest.mark.xfail(reason="TODO follow int8 behaviour? GH34686")
-        ),
+        "pow",
     ],
 )
 def test_op_int8(left_array, right_array, opname):
     op = getattr(operator, opname)
+    if opname != "mod":
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            result = op(left_array, right_array)
+        return
     result = op(left_array, right_array)
     expected = op(left_array.astype("Int8"), right_array.astype("Int8"))
     tm.assert_extension_array_equal(result, expected)
@@ -103,9 +106,11 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     )
     with pytest.raises(TypeError, match=msg):
         ops("foo")
-    msg = (
-        r"unsupported operand type\(s\) for|"
-        "Concatenation operation is not implemented for NumPy arrays"
+    msg = "|".join(
+        [
+            r"unsupported operand type\(s\) for",
+            "Concatenation operation is not implemented for NumPy arrays",
+        ]
     )
     with pytest.raises(TypeError, match=msg):
         ops(pd.Timestamp("20180101"))
@@ -113,9 +118,12 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     # invalid array-likes
     if op not in ("__mul__", "__rmul__"):
         # TODO(extension) numpy's mul with object array sees booleans as numbers
-        msg = (
-            r"unsupported operand type\(s\) for|can only concatenate str|"
-            "not all arguments converted during string formatting"
+        msg = "|".join(
+            [
+                r"unsupported operand type\(s\) for",
+                "can only concatenate str",
+                "not all arguments converted during string formatting",
+            ]
         )
         with pytest.raises(TypeError, match=msg):
             ops(pd.Series("foo", index=s.index))
diff --git a/pandas/tests/arrays/boolean/test_astype.py b/pandas/tests/arrays/boolean/test_astype.py
index 57cec70262526..932e903c0e448 100644
--- a/pandas/tests/arrays/boolean/test_astype.py
+++ b/pandas/tests/arrays/boolean/test_astype.py
@@ -20,7 +20,7 @@ def test_astype():
     tm.assert_numpy_array_equal(result, expected)
 
     result = arr.astype("str")
-    expected = np.array(["True", "False", "<NA>"], dtype="<U5")
+    expected = np.array(["True", "False", "<NA>"], dtype=f"{tm.ENDIAN}U5")
     tm.assert_numpy_array_equal(result, expected)
 
     # no missing values
diff --git a/pandas/tests/arrays/boolean/test_comparison.py b/pandas/tests/arrays/boolean/test_comparison.py
index 2741d13ee599b..2eeb9da574b1e 100644
--- a/pandas/tests/arrays/boolean/test_comparison.py
+++ b/pandas/tests/arrays/boolean/test_comparison.py
@@ -9,6 +9,7 @@
 
 @pytest.fixture
 def data():
+    """Fixture returning boolean array with valid and missing data"""
     return pd.array(
         [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
         dtype="boolean",
@@ -17,6 +18,7 @@ def data():
 
 @pytest.fixture
 def dtype():
+    """Fixture returning BooleanDtype"""
     return pd.BooleanDtype()
 
 
diff --git a/pandas/tests/arrays/boolean/test_construction.py b/pandas/tests/arrays/boolean/test_construction.py
index 15f92f2567c1c..d26eea19c06e9 100644
--- a/pandas/tests/arrays/boolean/test_construction.py
+++ b/pandas/tests/arrays/boolean/test_construction.py
@@ -183,8 +183,11 @@ def test_coerce_to_array():
     values = np.array([True, False, True, False], dtype="bool")
     mask = np.array([False, False, False, True], dtype="bool")
 
+    # passing 2D values is OK as long as no mask
+    coerce_to_array(values.reshape(1, -1))
+
     with pytest.raises(ValueError, match="values.shape and mask.shape must match"):
-        coerce_to_array(values.reshape(1, -1))
+        coerce_to_array(values.reshape(1, -1), mask=mask)
 
     with pytest.raises(ValueError, match="values.shape and mask.shape must match"):
         coerce_to_array(values, mask=mask.reshape(1, -1))
@@ -270,7 +273,7 @@ def test_to_numpy(box):
 
     arr = con([True, False, None], dtype="boolean")
     result = arr.to_numpy(dtype="str")
-    expected = np.array([True, False, pd.NA], dtype="<U5")
+    expected = np.array([True, False, pd.NA], dtype=f"{tm.ENDIAN}U5")
     tm.assert_numpy_array_equal(result, expected)
 
     # no missing values -> can convert to bool, otherwise raises
diff --git a/pandas/tests/arrays/boolean/test_logical.py b/pandas/tests/arrays/boolean/test_logical.py
index b4cca635fa238..66c117ea3fc66 100644
--- a/pandas/tests/arrays/boolean/test_logical.py
+++ b/pandas/tests/arrays/boolean/test_logical.py
@@ -63,7 +63,7 @@ def test_eq_mismatched_type(self, other):
     def test_logical_length_mismatch_raises(self, all_logical_operators):
         op_name = all_logical_operators
         a = pd.array([True, False, None], dtype="boolean")
-        msg = "Lengths must match to compare"
+        msg = "Lengths must match"
 
         with pytest.raises(ValueError, match=msg):
             getattr(a, op_name)([True, False])
diff --git a/pandas/tests/arrays/boolean/test_reduction.py b/pandas/tests/arrays/boolean/test_reduction.py
index a5c18a25f8e16..f3807df929f9a 100644
--- a/pandas/tests/arrays/boolean/test_reduction.py
+++ b/pandas/tests/arrays/boolean/test_reduction.py
@@ -6,6 +6,7 @@
 
 @pytest.fixture
 def data():
+    """Fixture returning boolean array, with valid and missing values."""
     return pd.array(
         [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
         dtype="boolean",
diff --git a/pandas/tests/arrays/categorical/common.py b/pandas/tests/arrays/categorical/common.py
deleted file mode 100644
index 4ef9390656979..0000000000000
--- a/pandas/tests/arrays/categorical/common.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from pandas import Categorical
-
-
-class TestCategorical:
-    def setup_method(self, method):
-        self.factor = Categorical(
-            ["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True
-        )
diff --git a/pandas/tests/arrays/categorical/conftest.py b/pandas/tests/arrays/categorical/conftest.py
index 640f5dfd63887..d5b49e3e5e8c8 100644
--- a/pandas/tests/arrays/categorical/conftest.py
+++ b/pandas/tests/arrays/categorical/conftest.py
@@ -1,7 +1,15 @@
 import pytest
 
+from pandas import Categorical
+
 
 @pytest.fixture(params=[True, False])
 def allow_fill(request):
     """Boolean 'allow_fill' parameter for Categorical.take"""
     return request.param
+
+
+@pytest.fixture
+def factor():
+    """Fixture returning  a Categorical object"""
+    return Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
diff --git a/pandas/tests/arrays/categorical/test_analytics.py b/pandas/tests/arrays/categorical/test_analytics.py
index 59bb34f4f4c3e..1a8dbe25c0b75 100644
--- a/pandas/tests/arrays/categorical/test_analytics.py
+++ b/pandas/tests/arrays/categorical/test_analytics.py
@@ -323,13 +323,22 @@ def test_validate_inplace_raises(self, value):
             f"received type {type(value).__name__}"
         )
         with pytest.raises(ValueError, match=msg):
-            cat.set_ordered(value=True, inplace=value)
+            with tm.assert_produces_warning(
+                FutureWarning, match="Use rename_categories"
+            ):
+                cat.set_ordered(value=True, inplace=value)
 
         with pytest.raises(ValueError, match=msg):
-            cat.as_ordered(inplace=value)
+            with tm.assert_produces_warning(
+                FutureWarning, match="Use rename_categories"
+            ):
+                cat.as_ordered(inplace=value)
 
         with pytest.raises(ValueError, match=msg):
-            cat.as_unordered(inplace=value)
+            with tm.assert_produces_warning(
+                FutureWarning, match="Use rename_categories"
+            ):
+                cat.as_unordered(inplace=value)
 
         with pytest.raises(ValueError, match=msg):
             with tm.assert_produces_warning(FutureWarning):
@@ -363,3 +372,13 @@ def test_validate_inplace_raises(self, value):
 
         with pytest.raises(ValueError, match=msg):
             cat.sort_values(inplace=value)
+
+    def test_quantile_empty(self):
+        # make sure we have correct itemsize on resulting codes
+        cat = Categorical(["A", "B"])
+        idx = Index([0.0, 0.5])
+        result = cat[:0]._quantile(idx, interpolation="linear")
+        assert result._codes.dtype == np.int8
+
+        expected = cat.take([-1, -1], allow_fill=True)
+        tm.assert_extension_array_equal(result, expected)
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index bde75051389ca..f0669f52acee2 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas.compat import PY311
+
 from pandas import (
     Categorical,
     CategoricalIndex,
@@ -12,7 +14,6 @@
 )
 import pandas._testing as tm
 from pandas.core.arrays.categorical import recode_for_categories
-from pandas.tests.arrays.categorical.common import TestCategorical
 
 
 class TestCategoricalAPI:
@@ -35,26 +36,38 @@ def test_ordered_api(self):
         assert cat4.ordered
 
     def test_set_ordered(self):
-
+        msg = (
+            "The `inplace` parameter in pandas.Categorical.set_ordered is "
+            "deprecated and will be removed in a future version. setting "
+            "ordered-ness on categories will always return a new Categorical object"
+        )
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
         cat2 = cat.as_unordered()
         assert not cat2.ordered
         cat2 = cat.as_ordered()
         assert cat2.ordered
-        cat2.as_unordered(inplace=True)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            cat2.as_unordered(inplace=True)
         assert not cat2.ordered
-        cat2.as_ordered(inplace=True)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            cat2.as_ordered(inplace=True)
         assert cat2.ordered
 
         assert cat2.set_ordered(True).ordered
         assert not cat2.set_ordered(False).ordered
-        cat2.set_ordered(True, inplace=True)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            cat2.set_ordered(True, inplace=True)
         assert cat2.ordered
-        cat2.set_ordered(False, inplace=True)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            cat2.set_ordered(False, inplace=True)
         assert not cat2.ordered
 
         # removed in 0.19.0
-        msg = "can't set attribute"
+        msg = (
+            "property 'ordered' of 'Categorical' object has no setter"
+            if PY311
+            else "can't set attribute"
+        )
         with pytest.raises(AttributeError, match=msg):
             cat.ordered = True
         with pytest.raises(AttributeError, match=msg):
@@ -427,13 +440,13 @@ def test_remove_unused_categories(self):
         assert out.tolist() == val.tolist()
 
 
-class TestCategoricalAPIWithFactor(TestCategorical):
-    def test_describe(self):
+class TestCategoricalAPIWithFactor:
+    def test_describe(self, factor):
         # string type
-        desc = self.factor.describe()
-        assert self.factor.ordered
+        desc = factor.describe()
+        assert factor.ordered
         exp_index = CategoricalIndex(
-            ["a", "b", "c"], name="categories", ordered=self.factor.ordered
+            ["a", "b", "c"], name="categories", ordered=factor.ordered
         )
         expected = DataFrame(
             {"counts": [3, 2, 3], "freqs": [3 / 8.0, 2 / 8.0, 3 / 8.0]}, index=exp_index
@@ -441,7 +454,7 @@ def test_describe(self):
         tm.assert_frame_equal(desc, expected)
 
         # check unused categories
-        cat = self.factor.copy()
+        cat = factor.copy()
 
         with tm.assert_produces_warning(FutureWarning):
             # issue #37643 inplace kwarg deprecated
@@ -450,7 +463,7 @@ def test_describe(self):
         desc = cat.describe()
 
         exp_index = CategoricalIndex(
-            list("abcd"), ordered=self.factor.ordered, name="categories"
+            list("abcd"), ordered=factor.ordered, name="categories"
         )
         expected = DataFrame(
             {"counts": [3, 2, 3, 0], "freqs": [3 / 8.0, 2 / 8.0, 3 / 8.0, 0]},
@@ -480,8 +493,8 @@ def test_describe(self):
         )
         tm.assert_frame_equal(desc, expected)
 
-    def test_set_categories_inplace(self):
-        cat = self.factor.copy()
+    def test_set_categories_inplace(self, factor):
+        cat = factor.copy()
 
         with tm.assert_produces_warning(FutureWarning):
             # issue #37643 inplace kwarg deprecated
@@ -508,7 +521,12 @@ def test_codes_immutable(self):
         tm.assert_numpy_array_equal(c.codes, exp)
 
         # Assignments to codes should raise
-        with pytest.raises(AttributeError, match="can't set attribute"):
+        msg = (
+            "property 'codes' of 'Categorical' object has no setter"
+            if PY311
+            else "can't set attribute"
+        )
+        with pytest.raises(AttributeError, match=msg):
             c.codes = np.array([0, 1, 2, 0, 1], dtype="int8")
 
         # changes in the codes array should raise
diff --git a/pandas/tests/arrays/categorical/test_astype.py b/pandas/tests/arrays/categorical/test_astype.py
index 7c4b4d0a223cc..205e3950fa1ce 100644
--- a/pandas/tests/arrays/categorical/test_astype.py
+++ b/pandas/tests/arrays/categorical/test_astype.py
@@ -23,6 +23,16 @@ def test_astype_str_int_categories_to_nullable_int(self):
         expected = array(codes, dtype="Int64")
         tm.assert_extension_array_equal(res, expected)
 
+    def test_astype_str_int_categories_to_nullable_float(self):
+        # GH#39616
+        dtype = CategoricalDtype([str(i / 2) for i in range(5)])
+        codes = np.random.randint(5, size=20)
+        arr = Categorical.from_codes(codes, dtype=dtype)
+
+        res = arr.astype("Float64")
+        expected = array(codes, dtype="Float64") / 2
+        tm.assert_extension_array_equal(res, expected)
+
     @pytest.mark.parametrize("ordered", [True, False])
     def test_astype(self, ordered):
         # string
diff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py
index 716ef6811a01a..24f4dd4a1f64a 100644
--- a/pandas/tests/arrays/categorical/test_constructors.py
+++ b/pandas/tests/arrays/categorical/test_constructors.py
@@ -676,7 +676,6 @@ def test_construction_with_ordered(self, ordered):
         cat = Categorical([0, 1, 2], ordered=ordered)
         assert cat.ordered == bool(ordered)
 
-    @pytest.mark.xfail(reason="Imaginary values not supported in Categorical")
     def test_constructor_imaginary(self):
         values = [1, 2, 3 + 1j]
         c1 = Categorical(values)
@@ -752,7 +751,7 @@ def test_from_sequence_copy(self):
 
     @pytest.mark.xfail(
         not IS64 or is_platform_windows(),
-        reason="Incorrectly raising in ensure_datetime64ns",
+        reason="Incorrectly raising in astype_overflowsafe",
     )
     def test_constructor_datetime64_non_nano(self):
         categories = np.arange(10).view("M8[D]")
@@ -760,3 +759,14 @@ def test_constructor_datetime64_non_nano(self):
 
         cat = Categorical(values, categories=categories)
         assert (cat == values).all()
+
+    def test_constructor_preserves_freq(self):
+        # GH33830 freq retention in categorical
+        dti = date_range("2016-01-01", periods=5)
+
+        expected = dti.freq
+
+        cat = Categorical(dti)
+        result = cat.categories.freq
+
+        assert expected == result
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 617d1861fa65a..94e966642b925 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -1,12 +1,16 @@
+import math
+
 import numpy as np
 import pytest
 
 from pandas import (
+    NA,
     Categorical,
     CategoricalIndex,
     Index,
     Interval,
     IntervalIndex,
+    NaT,
     PeriodIndex,
     Series,
     Timedelta,
@@ -14,31 +18,30 @@
 )
 import pandas._testing as tm
 import pandas.core.common as com
-from pandas.tests.arrays.categorical.common import TestCategorical
 
 
-class TestCategoricalIndexingWithFactor(TestCategorical):
-    def test_getitem(self):
-        assert self.factor[0] == "a"
-        assert self.factor[-1] == "c"
+class TestCategoricalIndexingWithFactor:
+    def test_getitem(self, factor):
+        assert factor[0] == "a"
+        assert factor[-1] == "c"
 
-        subf = self.factor[[0, 1, 2]]
+        subf = factor[[0, 1, 2]]
         tm.assert_numpy_array_equal(subf._codes, np.array([0, 1, 1], dtype=np.int8))
 
-        subf = self.factor[np.asarray(self.factor) == "c"]
+        subf = factor[np.asarray(factor) == "c"]
         tm.assert_numpy_array_equal(subf._codes, np.array([2, 2, 2], dtype=np.int8))
 
-    def test_setitem(self):
+    def test_setitem(self, factor):
 
         # int/positional
-        c = self.factor.copy()
+        c = factor.copy()
         c[0] = "b"
         assert c[0] == "b"
         c[-1] = "a"
         assert c[-1] == "a"
 
         # boolean
-        c = self.factor.copy()
+        c = factor.copy()
         indexer = np.zeros(len(c), dtype="bool")
         indexer[0] = True
         indexer[-1] = True
@@ -191,10 +194,22 @@ def test_periodindex(self):
     def test_categories_assignments(self):
         cat = Categorical(["a", "b", "c", "a"])
         exp = np.array([1, 2, 3, 1], dtype=np.int64)
-        cat.categories = [1, 2, 3]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            cat.categories = [1, 2, 3]
         tm.assert_numpy_array_equal(cat.__array__(), exp)
         tm.assert_index_equal(cat.categories, Index([1, 2, 3]))
 
+    @pytest.mark.parametrize(
+        "null_val",
+        [None, np.nan, NaT, NA, math.nan, "NaT", "nat", "NAT", "nan", "NaN", "NAN"],
+    )
+    def test_periodindex_on_null_types(self, null_val):
+        # GH 46673
+        result = PeriodIndex(["2022-04-06", "2022-04-07", null_val], freq="D")
+        expected = PeriodIndex(["2022-04-06", "2022-04-07", "NaT"], dtype="period[D]")
+        assert result[2] is NaT
+        tm.assert_index_equal(result, expected)
+
     @pytest.mark.parametrize("new_categories", [[1, 2, 3, 4], [1, 2]])
     def test_categories_assignments_wrong_length_raises(self, new_categories):
         cat = Categorical(["a", "b", "c", "a"])
@@ -202,8 +217,9 @@ def test_categories_assignments_wrong_length_raises(self, new_categories):
             "new categories need to have the same number of items "
             "as the old categories!"
         )
-        with pytest.raises(ValueError, match=msg):
-            cat.categories = new_categories
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            with pytest.raises(ValueError, match=msg):
+                cat.categories = new_categories
 
     # Combinations of sorted/unique:
     @pytest.mark.parametrize(
@@ -370,7 +386,7 @@ def array(self, dtype=None):
         yield
 
 
-def test_series_at(non_coercible_categorical):
+def test_series_at():
     arr = Categorical(["a", "b", "c"])
     ser = Series(arr)
     result = ser.at[0]
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 9f19e83e5b3d4..9642691b5c578 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -11,48 +11,47 @@
     date_range,
 )
 import pandas._testing as tm
-from pandas.tests.arrays.categorical.common import TestCategorical
 
 
-class TestCategoricalOpsWithFactor(TestCategorical):
+class TestCategoricalOpsWithFactor:
     def test_categories_none_comparisons(self):
         factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
-        tm.assert_categorical_equal(factor, self.factor)
+        tm.assert_categorical_equal(factor, factor)
 
-    def test_comparisons(self):
-        result = self.factor[self.factor == "a"]
-        expected = self.factor[np.asarray(self.factor) == "a"]
+    def test_comparisons(self, factor):
+        result = factor[factor == "a"]
+        expected = factor[np.asarray(factor) == "a"]
         tm.assert_categorical_equal(result, expected)
 
-        result = self.factor[self.factor != "a"]
-        expected = self.factor[np.asarray(self.factor) != "a"]
+        result = factor[factor != "a"]
+        expected = factor[np.asarray(factor) != "a"]
         tm.assert_categorical_equal(result, expected)
 
-        result = self.factor[self.factor < "c"]
-        expected = self.factor[np.asarray(self.factor) < "c"]
+        result = factor[factor < "c"]
+        expected = factor[np.asarray(factor) < "c"]
         tm.assert_categorical_equal(result, expected)
 
-        result = self.factor[self.factor > "a"]
-        expected = self.factor[np.asarray(self.factor) > "a"]
+        result = factor[factor > "a"]
+        expected = factor[np.asarray(factor) > "a"]
         tm.assert_categorical_equal(result, expected)
 
-        result = self.factor[self.factor >= "b"]
-        expected = self.factor[np.asarray(self.factor) >= "b"]
+        result = factor[factor >= "b"]
+        expected = factor[np.asarray(factor) >= "b"]
         tm.assert_categorical_equal(result, expected)
 
-        result = self.factor[self.factor <= "b"]
-        expected = self.factor[np.asarray(self.factor) <= "b"]
+        result = factor[factor <= "b"]
+        expected = factor[np.asarray(factor) <= "b"]
         tm.assert_categorical_equal(result, expected)
 
-        n = len(self.factor)
+        n = len(factor)
 
-        other = self.factor[np.random.permutation(n)]
-        result = self.factor == other
-        expected = np.asarray(self.factor) == np.asarray(other)
+        other = factor[np.random.permutation(n)]
+        result = factor == other
+        expected = np.asarray(factor) == np.asarray(other)
         tm.assert_numpy_array_equal(result, expected)
 
-        result = self.factor == "d"
-        expected = np.zeros(len(self.factor), dtype=bool)
+        result = factor == "d"
+        expected = np.zeros(len(factor), dtype=bool)
         tm.assert_numpy_array_equal(result, expected)
 
         # comparisons with categoricals
@@ -377,23 +376,31 @@ def test_numeric_like_ops(self):
 
         # mad technically works because it takes always the numeric data
 
+    def test_numeric_like_ops_series(self):
         # numpy ops
         s = Series(Categorical([1, 2, 3, 4]))
         with pytest.raises(TypeError, match="does not support reduction 'sum'"):
             np.sum(s)
 
-        # numeric ops on a Series
-        for op, str_rep in [
+    @pytest.mark.parametrize(
+        "op, str_rep",
+        [
             ("__add__", r"\+"),
             ("__sub__", "-"),
             ("__mul__", r"\*"),
             ("__truediv__", "/"),
-        ]:
-            msg = f"Series cannot perform the operation {str_rep}|unsupported operand"
-            with pytest.raises(TypeError, match=msg):
-                getattr(s, op)(2)
+        ],
+    )
+    def test_numeric_like_ops_series_arith(self, op, str_rep):
+        # numeric ops on a Series
+        s = Series(Categorical([1, 2, 3, 4]))
+        msg = f"Series cannot perform the operation {str_rep}|unsupported operand"
+        with pytest.raises(TypeError, match=msg):
+            getattr(s, op)(2)
 
+    def test_numeric_like_ops_series_invalid(self):
         # invalid ufunc
+        s = Series(Categorical([1, 2, 3, 4]))
         msg = "Object with dtype category cannot perform the numpy op log"
         with pytest.raises(TypeError, match=msg):
             np.log(s)
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index 678109b2c2497..b44af07cee01d 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -9,17 +9,16 @@
     period_range,
     timedelta_range,
 )
-from pandas.tests.arrays.categorical.common import TestCategorical
 
 
-class TestCategoricalReprWithFactor(TestCategorical):
-    def test_print(self):
+class TestCategoricalReprWithFactor:
+    def test_print(self, factor):
         expected = [
             "['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']",
             "Categories (3, object): ['a' < 'b' < 'c']",
         ]
         expected = "\n".join(expected)
-        actual = repr(self.factor)
+        actual = repr(factor)
         assert actual == expected
 
 
@@ -320,7 +319,7 @@ def test_categorical_repr_timedelta(self):
 
         c = Categorical(idx.append(idx), categories=idx)
         exp = """[1 days, 2 days, 3 days, 4 days, 5 days, 1 days, 2 days, 3 days, 4 days, 5 days]
-Categories (5, timedelta64[ns]): [1 days, 2 days, 3 days, 4 days, 5 days]"""
+Categories (5, timedelta64[ns]): [1 days, 2 days, 3 days, 4 days, 5 days]"""  # noqa:E501
 
         assert repr(c) == exp
 
@@ -353,7 +352,7 @@ def test_categorical_repr_timedelta_ordered(self):
 
         c = Categorical(idx.append(idx), categories=idx, ordered=True)
         exp = """[1 days, 2 days, 3 days, 4 days, 5 days, 1 days, 2 days, 3 days, 4 days, 5 days]
-Categories (5, timedelta64[ns]): [1 days < 2 days < 3 days < 4 days < 5 days]"""
+Categories (5, timedelta64[ns]): [1 days < 2 days < 3 days < 4 days < 5 days]"""  # noqa:E501
 
         assert repr(c) == exp
 
@@ -382,7 +381,7 @@ def test_categorical_index_repr(self):
         assert repr(idx) == exp
 
         i = CategoricalIndex(Categorical(np.arange(10)))
-        exp = """CategoricalIndex([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], categories=[0, 1, 2, 3, 4, 5, 6, 7, ...], ordered=False, dtype='category')"""  # noqa:E501
+        exp = """CategoricalIndex([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], categories=[0, 1, 2, 3, ..., 6, 7, 8, 9], ordered=False, dtype='category')"""  # noqa:E501
         assert repr(i) == exp
 
     def test_categorical_index_repr_ordered(self):
@@ -391,7 +390,7 @@ def test_categorical_index_repr_ordered(self):
         assert repr(i) == exp
 
         i = CategoricalIndex(Categorical(np.arange(10), ordered=True))
-        exp = """CategoricalIndex([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], categories=[0, 1, 2, 3, 4, 5, 6, 7, ...], ordered=True, dtype='category')"""  # noqa:E501
+        exp = """CategoricalIndex([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], categories=[0, 1, 2, 3, ..., 6, 7, 8, 9], ordered=True, dtype='category')"""  # noqa:E501
         assert repr(i) == exp
 
     def test_categorical_index_repr_datetime(self):
@@ -498,7 +497,7 @@ def test_categorical_index_repr_period_ordered(self):
     def test_categorical_index_repr_timedelta(self):
         idx = timedelta_range("1 days", periods=5)
         i = CategoricalIndex(Categorical(idx))
-        exp = """CategoricalIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], categories=[1 days 00:00:00, 2 days 00:00:00, 3 days 00:00:00, 4 days 00:00:00, 5 days 00:00:00], ordered=False, dtype='category')"""  # noqa:E501
+        exp = """CategoricalIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], categories=[1 days, 2 days, 3 days, 4 days, 5 days], ordered=False, dtype='category')"""  # noqa:E501
         assert repr(i) == exp
 
         idx = timedelta_range("1 hours", periods=10)
@@ -507,14 +506,14 @@ def test_categorical_index_repr_timedelta(self):
                   '3 days 01:00:00', '4 days 01:00:00', '5 days 01:00:00',
                   '6 days 01:00:00', '7 days 01:00:00', '8 days 01:00:00',
                   '9 days 01:00:00'],
-                 categories=[0 days 01:00:00, 1 days 01:00:00, 2 days 01:00:00, 3 days 01:00:00, 4 days 01:00:00, 5 days 01:00:00, 6 days 01:00:00, 7 days 01:00:00, ...], ordered=False, dtype='category')"""  # noqa:E501
+                 categories=[0 days 01:00:00, 1 days 01:00:00, 2 days 01:00:00, 3 days 01:00:00, ..., 6 days 01:00:00, 7 days 01:00:00, 8 days 01:00:00, 9 days 01:00:00], ordered=False, dtype='category')"""  # noqa:E501
 
         assert repr(i) == exp
 
     def test_categorical_index_repr_timedelta_ordered(self):
         idx = timedelta_range("1 days", periods=5)
         i = CategoricalIndex(Categorical(idx, ordered=True))
-        exp = """CategoricalIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], categories=[1 days 00:00:00, 2 days 00:00:00, 3 days 00:00:00, 4 days 00:00:00, 5 days 00:00:00], ordered=True, dtype='category')"""  # noqa:E501
+        exp = """CategoricalIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], categories=[1 days, 2 days, 3 days, 4 days, 5 days], ordered=True, dtype='category')"""  # noqa:E501
         assert repr(i) == exp
 
         idx = timedelta_range("1 hours", periods=10)
@@ -523,7 +522,7 @@ def test_categorical_index_repr_timedelta_ordered(self):
                   '3 days 01:00:00', '4 days 01:00:00', '5 days 01:00:00',
                   '6 days 01:00:00', '7 days 01:00:00', '8 days 01:00:00',
                   '9 days 01:00:00'],
-                 categories=[0 days 01:00:00, 1 days 01:00:00, 2 days 01:00:00, 3 days 01:00:00, 4 days 01:00:00, 5 days 01:00:00, 6 days 01:00:00, 7 days 01:00:00, ...], ordered=True, dtype='category')"""  # noqa:E501
+                 categories=[0 days 01:00:00, 1 days 01:00:00, 2 days 01:00:00, 3 days 01:00:00, ..., 6 days 01:00:00, 7 days 01:00:00, 8 days 01:00:00, 9 days 01:00:00], ordered=True, dtype='category')"""  # noqa:E501
 
         assert repr(i) == exp
 
diff --git a/pandas/tests/arrays/datetimes/test_constructors.py b/pandas/tests/arrays/datetimes/test_constructors.py
index e6c65499f6fcc..cb2d8f31f0f9c 100644
--- a/pandas/tests/arrays/datetimes/test_constructors.py
+++ b/pandas/tests/arrays/datetimes/test_constructors.py
@@ -29,7 +29,7 @@ def test_only_1dim_accepted(self):
     def test_freq_validation(self):
         # GH#24623 check that invalid instances cannot be created with the
         #  public constructor
-        arr = np.arange(5, dtype=np.int64) * 3600 * 10 ** 9
+        arr = np.arange(5, dtype=np.int64) * 3600 * 10**9
 
         msg = (
             "Inferred frequency H from passed values does not "
@@ -64,7 +64,7 @@ def test_mixing_naive_tzaware_raises(self, meth):
                 meth(obj)
 
     def test_from_pandas_array(self):
-        arr = pd.array(np.arange(5, dtype=np.int64)) * 3600 * 10 ** 9
+        arr = pd.array(np.arange(5, dtype=np.int64)) * 3600 * 10**9
 
         result = DatetimeArray._from_sequence(arr)._with_freq("infer")
 
@@ -77,9 +77,16 @@ def test_mismatched_timezone_raises(self):
             dtype=DatetimeTZDtype(tz="US/Central"),
         )
         dtype = DatetimeTZDtype(tz="US/Eastern")
-        with pytest.raises(TypeError, match="Timezone of the array"):
+        msg = r"dtype=datetime64\[ns.*\] does not match data dtype datetime64\[ns.*\]"
+        with pytest.raises(TypeError, match=msg):
             DatetimeArray(arr, dtype=dtype)
 
+        # also with mismatched tzawareness
+        with pytest.raises(TypeError, match=msg):
+            DatetimeArray(arr, dtype=np.dtype("M8[ns]"))
+        with pytest.raises(TypeError, match=msg):
+            DatetimeArray(arr.tz_localize(None), dtype=arr.dtype)
+
     def test_non_array_raises(self):
         with pytest.raises(ValueError, match="list"):
             DatetimeArray([1, 2, 3])
@@ -87,9 +94,8 @@ def test_non_array_raises(self):
     def test_bool_dtype_raises(self):
         arr = np.array([1, 2, 3], dtype="bool")
 
-        with pytest.raises(
-            ValueError, match="The dtype of 'values' is incorrect.*bool"
-        ):
+        msg = "Unexpected value for 'dtype': 'bool'. Must be"
+        with pytest.raises(ValueError, match=msg):
             DatetimeArray(arr)
 
         msg = r"dtype bool cannot be converted to datetime64\[ns\]"
diff --git a/pandas/tests/arrays/datetimes/test_reductions.py b/pandas/tests/arrays/datetimes/test_reductions.py
index 6e9c8f7b08a72..d0553f9608f25 100644
--- a/pandas/tests/arrays/datetimes/test_reductions.py
+++ b/pandas/tests/arrays/datetimes/test_reductions.py
@@ -12,6 +12,7 @@
 class TestReductions:
     @pytest.fixture
     def arr1d(self, tz_naive_fixture):
+        """Fixture returning DatetimeArray with parametrized timezones"""
         tz = tz_naive_fixture
         dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
         arr = DatetimeArray._from_sequence(
diff --git a/pandas/tests/arrays/floating/conftest.py b/pandas/tests/arrays/floating/conftest.py
index 9eab11516c295..5e971c66029d5 100644
--- a/pandas/tests/arrays/floating/conftest.py
+++ b/pandas/tests/arrays/floating/conftest.py
@@ -10,11 +10,13 @@
 
 @pytest.fixture(params=[Float32Dtype, Float64Dtype])
 def dtype(request):
+    """Parametrized fixture returning a float 'dtype'"""
     return request.param()
 
 
 @pytest.fixture
 def data(dtype):
+    """Fixture returning 'data' array according to parametrized float 'dtype'"""
     return pd.array(
         list(np.arange(0.1, 0.9, 0.1))
         + [pd.NA]
@@ -27,12 +29,19 @@ def data(dtype):
 
 @pytest.fixture
 def data_missing(dtype):
+    """
+    Fixture returning array with missing data according to parametrized float
+    'dtype'.
+    """
     return pd.array([np.nan, 0.1], dtype=dtype)
 
 
 @pytest.fixture(params=["data", "data_missing"])
 def all_data(request, data, data_missing):
-    """Parametrized fixture giving 'data' and 'data_missing'"""
+    """Parametrized fixture returning 'data' or 'data_missing' float arrays.
+
+    Used to test dtype conversion with and without missing values.
+    """
     if request.param == "data":
         return data
     elif request.param == "data_missing":
diff --git a/pandas/tests/arrays/floating/test_arithmetic.py b/pandas/tests/arrays/floating/test_arithmetic.py
index e5f67a2dce3ad..ec7419d6346a8 100644
--- a/pandas/tests/arrays/floating/test_arithmetic.py
+++ b/pandas/tests/arrays/floating/test_arithmetic.py
@@ -51,19 +51,19 @@ def test_divide_by_zero(dtype, zero, negative):
 
 def test_pow_scalar(dtype):
     a = pd.array([-1, 0, 1, None, 2], dtype=dtype)
-    result = a ** 0
+    result = a**0
     expected = pd.array([1, 1, 1, 1, 1], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** 1
+    result = a**1
     expected = pd.array([-1, 0, 1, None, 2], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** pd.NA
+    result = a**pd.NA
     expected = pd.array([None, None, 1, None, None], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** np.nan
+    result = a**np.nan
     # TODO np.nan should be converted to pd.NA / missing before operation?
     expected = FloatingArray(
         np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype=dtype.numpy_dtype),
@@ -74,19 +74,19 @@ def test_pow_scalar(dtype):
     # reversed
     a = a[1:]  # Can't raise integers to negative powers.
 
-    result = 0 ** a
+    result = 0**a
     expected = pd.array([1, 0, None, 0], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = 1 ** a
+    result = 1**a
     expected = pd.array([1, 1, 1, 1], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = pd.NA ** a
+    result = pd.NA**a
     expected = pd.array([1, None, None, None], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
-    result = np.nan ** a
+    result = np.nan**a
     expected = FloatingArray(
         np.array([1, np.nan, np.nan, np.nan], dtype=dtype.numpy_dtype), mask=a._mask
     )
@@ -96,7 +96,7 @@ def test_pow_scalar(dtype):
 def test_pow_array(dtype):
     a = pd.array([0, 0, 0, 1, 1, 1, None, None, None], dtype=dtype)
     b = pd.array([0, 1, None, 0, 1, None, 0, 1, None], dtype=dtype)
-    result = a ** b
+    result = a**b
     expected = pd.array([1, 0, None, 1, 1, 1, 1, None, None], dtype=dtype)
     tm.assert_extension_array_equal(result, expected)
 
@@ -129,9 +129,19 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     ops = getattr(s, op)
 
     # invalid scalars
-    msg = (
-        r"(:?can only perform ops with numeric values)"
-        r"|(:?FloatingArray cannot perform the operation mod)"
+    msg = "|".join(
+        [
+            r"can only perform ops with numeric values",
+            r"FloatingArray cannot perform the operation mod",
+            "unsupported operand type",
+            "not all arguments converted during string formatting",
+            "can't multiply sequence by non-int of type 'float'",
+            "ufunc 'subtract' cannot use operands with types dtype",
+            r"can only concatenate str \(not \"float\"\) to str",
+            "ufunc '.*' not supported for the input types, and the inputs could not",
+            "ufunc '.*' did not contain a loop with signature matching types",
+            "Concatenation operation is not implemented for NumPy arrays",
+        ]
     )
     with pytest.raises(TypeError, match=msg):
         ops("foo")
@@ -148,6 +158,13 @@ def test_error_invalid_values(data, all_arithmetic_operators):
             "cannot perform .* with this index type: DatetimeArray",
             "Addition/subtraction of integers and integer-arrays "
             "with DatetimeArray is no longer supported. *",
+            "unsupported operand type",
+            "not all arguments converted during string formatting",
+            "can't multiply sequence by non-int of type 'float'",
+            "ufunc 'subtract' cannot use operands with types dtype",
+            r"ufunc 'add' cannot use operands with types dtype\('<M8\[ns\]'\)",
+            r"ufunc 'add' cannot use operands with types dtype\('float\d{2}'\)",
+            "cannot subtract DatetimeArray from ndarray",
         ]
     )
     with pytest.raises(TypeError, match=msg):
@@ -201,3 +218,15 @@ def test_unary_float_operators(float_ea_dtype, source, neg_target, abs_target):
     tm.assert_extension_array_equal(pos_result, arr)
     assert not tm.shares_memory(pos_result, arr)
     tm.assert_extension_array_equal(abs_result, abs_target)
+
+
+def test_bitwise(dtype):
+    left = pd.array([1, None, 3, 4], dtype=dtype)
+    right = pd.array([None, 3, 5, 4], dtype=dtype)
+
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left | right
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left & right
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left ^ right
diff --git a/pandas/tests/arrays/floating/test_astype.py b/pandas/tests/arrays/floating/test_astype.py
index f0e91cd540f38..8f61f70fe0735 100644
--- a/pandas/tests/arrays/floating/test_astype.py
+++ b/pandas/tests/arrays/floating/test_astype.py
@@ -9,10 +9,10 @@ def test_astype():
     # with missing values
     arr = pd.array([0.1, 0.2, None], dtype="Float64")
 
-    with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype NumPy"):
+    with pytest.raises(ValueError, match="cannot convert NA to integer"):
         arr.astype("int64")
 
-    with pytest.raises(ValueError, match="cannot convert to 'bool'-dtype NumPy"):
+    with pytest.raises(ValueError, match="cannot convert float NaN to bool"):
         arr.astype("bool")
 
     result = arr.astype("float64")
diff --git a/pandas/tests/arrays/floating/test_construction.py b/pandas/tests/arrays/floating/test_construction.py
index 6fa3744429e5d..2dcd54f443029 100644
--- a/pandas/tests/arrays/floating/test_construction.py
+++ b/pandas/tests/arrays/floating/test_construction.py
@@ -1,13 +1,6 @@
-import locale
-
 import numpy as np
 import pytest
 
-from pandas.compat import (
-    is_platform_windows,
-    np_version_under1p20,
-)
-
 import pandas as pd
 import pandas._testing as tm
 from pandas.core.arrays import FloatingArray
@@ -47,7 +40,7 @@ def test_floating_array_constructor():
         FloatingArray(values)
 
 
-def test_floating_array_disallows_float16(request):
+def test_floating_array_disallows_float16():
     # GH#44715
     arr = np.array([1, 2], dtype=np.float16)
     mask = np.array([False, False])
@@ -56,15 +49,9 @@ def test_floating_array_disallows_float16(request):
     with pytest.raises(TypeError, match=msg):
         FloatingArray(arr, mask)
 
-    if np_version_under1p20 or (
-        locale.getlocale()[0] != "en_US" and not is_platform_windows()
-    ):
-        # the locale condition may need to be refined; this fails on
-        #  the CI in the ZH_CN build
-        # https://github.com/numpy/numpy/issues/20512
-        mark = pytest.mark.xfail(reason="numpy does not raise on np.dtype('Float16')")
-        request.node.add_marker(mark)
 
+def test_floating_array_disallows_Float16_dtype(request):
+    # GH#44715
     with pytest.raises(TypeError, match="data type 'Float16' not understood"):
         pd.array([1.0, 2.0], dtype="Float16")
 
@@ -118,7 +105,6 @@ def test_to_array_mixed_integer_float():
     "values",
     [
         ["foo", "bar"],
-        ["1", "2"],
         "foo",
         1,
         1.0,
@@ -134,15 +120,29 @@ def test_to_array_error(values):
     # error in converting existing arrays to FloatingArray
     msg = "|".join(
         [
-            "cannot be converted to a FloatingDtype",
+            "cannot be converted to FloatingDtype",
             "values must be a 1D list-like",
             "Cannot pass scalar",
+            r"float\(\) argument must be a string or a (real )?number, not 'dict'",
+            "could not convert string to float: 'foo'",
         ]
     )
     with pytest.raises((TypeError, ValueError), match=msg):
         pd.array(values, dtype="Float64")
 
 
+@pytest.mark.parametrize("values", [["1", "2", None], ["1.5", "2", None]])
+def test_construct_from_float_strings(values):
+    # see also test_to_integer_array_str
+    expected = pd.array([float(values[0]), 2, None], dtype="Float64")
+
+    res = pd.array(values, dtype="Float64")
+    tm.assert_extension_array_equal(res, expected)
+
+    res = FloatingArray._from_sequence(values)
+    tm.assert_extension_array_equal(res, expected)
+
+
 def test_to_array_inferred_dtype():
     # if values has dtype -> respect it
     result = pd.array(np.array([1, 2], dtype="float32"))
diff --git a/pandas/tests/arrays/floating/test_to_numpy.py b/pandas/tests/arrays/floating/test_to_numpy.py
index 26e5687b1b4a0..2ed52439adf53 100644
--- a/pandas/tests/arrays/floating/test_to_numpy.py
+++ b/pandas/tests/arrays/floating/test_to_numpy.py
@@ -115,7 +115,7 @@ def test_to_numpy_string(box, dtype):
     arr = con([0.0, 1.0, None], dtype="Float64")
 
     result = arr.to_numpy(dtype="str")
-    expected = np.array([0.0, 1.0, pd.NA], dtype="<U32")
+    expected = np.array([0.0, 1.0, pd.NA], dtype=f"{tm.ENDIAN}U32")
     tm.assert_numpy_array_equal(result, expected)
 
 
diff --git a/pandas/tests/arrays/integer/conftest.py b/pandas/tests/arrays/integer/conftest.py
index 080ca180337f0..f73400dfe689e 100644
--- a/pandas/tests/arrays/integer/conftest.py
+++ b/pandas/tests/arrays/integer/conftest.py
@@ -27,11 +27,18 @@
     ]
 )
 def dtype(request):
+    """Parametrized fixture returning integer 'dtype'"""
     return request.param()
 
 
 @pytest.fixture
 def data(dtype):
+    """
+    Fixture returning 'data' array with valid and missing values according to
+    parametrized integer 'dtype'.
+
+    Used to test dtype conversion with and without missing values.
+    """
     return pd.array(
         list(range(8)) + [np.nan] + list(range(10, 98)) + [np.nan] + [99, 100],
         dtype=dtype,
@@ -40,12 +47,21 @@ def data(dtype):
 
 @pytest.fixture
 def data_missing(dtype):
+    """
+    Fixture returning array with exactly one NaN and one valid integer,
+    according to parametrized integer 'dtype'.
+
+    Used to test dtype conversion with and without missing values.
+    """
     return pd.array([np.nan, 1], dtype=dtype)
 
 
 @pytest.fixture(params=["data", "data_missing"])
 def all_data(request, data, data_missing):
-    """Parametrized fixture giving 'data' and 'data_missing'"""
+    """Parametrized fixture returning 'data' or 'data_missing' integer arrays.
+
+    Used to test dtype conversion with and without missing values.
+    """
     if request.param == "data":
         return data
     elif request.param == "data_missing":
diff --git a/pandas/tests/arrays/integer/test_arithmetic.py b/pandas/tests/arrays/integer/test_arithmetic.py
index 273bd9e4d34d5..5b9780e390775 100644
--- a/pandas/tests/arrays/integer/test_arithmetic.py
+++ b/pandas/tests/arrays/integer/test_arithmetic.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p20
-
 import pandas as pd
 import pandas._testing as tm
 from pandas.core.arrays import FloatingArray
@@ -77,6 +75,21 @@ def test_floordiv(dtype):
     tm.assert_extension_array_equal(result, expected)
 
 
+def test_floordiv_by_int_zero_no_mask(any_int_ea_dtype):
+    # GH 48223: Aligns with non-masked floordiv
+    # but differs from numpy
+    # https://github.com/pandas-dev/pandas/issues/30188#issuecomment-564452740
+    ser = pd.Series([0, 1], dtype=any_int_ea_dtype)
+    result = 1 // ser
+    expected = pd.Series([np.inf, 1.0], dtype="Float64")
+    tm.assert_series_equal(result, expected)
+
+    ser_non_nullable = ser.astype(ser.dtype.numpy_dtype)
+    result = 1 // ser_non_nullable
+    expected = expected.astype(np.float64)
+    tm.assert_series_equal(result, expected)
+
+
 def test_mod(dtype):
     a = pd.array([1, 2, 3, None, 5], dtype=dtype)
     b = pd.array([0, 1, None, 3, 4], dtype=dtype)
@@ -88,19 +101,19 @@ def test_mod(dtype):
 
 def test_pow_scalar():
     a = pd.array([-1, 0, 1, None, 2], dtype="Int64")
-    result = a ** 0
+    result = a**0
     expected = pd.array([1, 1, 1, 1, 1], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** 1
+    result = a**1
     expected = pd.array([-1, 0, 1, None, 2], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** pd.NA
+    result = a**pd.NA
     expected = pd.array([None, None, 1, None, None], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = a ** np.nan
+    result = a**np.nan
     expected = FloatingArray(
         np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64"),
         np.array([False, False, False, True, False]),
@@ -110,19 +123,19 @@ def test_pow_scalar():
     # reversed
     a = a[1:]  # Can't raise integers to negative powers.
 
-    result = 0 ** a
+    result = 0**a
     expected = pd.array([1, 0, None, 0], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = 1 ** a
+    result = 1**a
     expected = pd.array([1, 1, 1, 1], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = pd.NA ** a
+    result = pd.NA**a
     expected = pd.array([1, None, None, None], dtype="Int64")
     tm.assert_extension_array_equal(result, expected)
 
-    result = np.nan ** a
+    result = np.nan**a
     expected = FloatingArray(
         np.array([1, np.nan, np.nan, np.nan], dtype="float64"),
         np.array([False, False, True, False]),
@@ -133,7 +146,7 @@ def test_pow_scalar():
 def test_pow_array():
     a = pd.array([0, 0, 0, 1, 1, 1, None, None, None])
     b = pd.array([0, 1, None, 0, 1, None, 0, 1, None])
-    result = a ** b
+    result = a**b
     expected = pd.array([1, 0, None, 1, 1, 1, 1, None, None])
     tm.assert_extension_array_equal(result, expected)
 
@@ -166,9 +179,17 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     ops = getattr(s, op)
 
     # invalid scalars
-    msg = (
-        r"(:?can only perform ops with numeric values)"
-        r"|(:?IntegerArray cannot perform the operation mod)"
+    msg = "|".join(
+        [
+            r"can only perform ops with numeric values",
+            r"IntegerArray cannot perform the operation mod",
+            r"unsupported operand type",
+            r"can only concatenate str \(not \"int\"\) to str",
+            "not all arguments converted during string",
+            "ufunc '.*' not supported for the input types, and the inputs could not",
+            "ufunc '.*' did not contain a loop with signature matching types",
+            "Addition/subtraction of integers and integer-arrays with Timestamp",
+        ]
     )
     with pytest.raises(TypeError, match=msg):
         ops("foo")
@@ -176,8 +197,18 @@ def test_error_invalid_values(data, all_arithmetic_operators):
         ops(pd.Timestamp("20180101"))
 
     # invalid array-likes
-    with pytest.raises(TypeError, match=msg):
-        ops(pd.Series("foo", index=s.index))
+    str_ser = pd.Series("foo", index=s.index)
+    # with pytest.raises(TypeError, match=msg):
+    if all_arithmetic_operators in [
+        "__mul__",
+        "__rmul__",
+    ]:  # (data[~data.isna()] >= 0).all():
+        res = ops(str_ser)
+        expected = pd.Series(["foo" * x for x in data], index=s.index)
+        tm.assert_series_equal(res, expected)
+    else:
+        with pytest.raises(TypeError, match=msg):
+            ops(str_ser)
 
     msg = "|".join(
         [
@@ -185,6 +216,10 @@ def test_error_invalid_values(data, all_arithmetic_operators):
             "cannot perform .* with this index type: DatetimeArray",
             "Addition/subtraction of integers and integer-arrays "
             "with DatetimeArray is no longer supported. *",
+            "unsupported operand type",
+            r"can only concatenate str \(not \"int\"\) to str",
+            "not all arguments converted during string",
+            "cannot subtract DatetimeArray from ndarray",
         ]
     )
     with pytest.raises(TypeError, match=msg):
@@ -206,16 +241,9 @@ def test_arith_coerce_scalar(data, all_arithmetic_operators):
     result = op(s, other)
     expected = op(s.astype(float), other)
     expected = expected.astype("Float64")
-    # rfloordiv results in nan instead of inf
-    if all_arithmetic_operators == "__rfloordiv__" and np_version_under1p20:
-        # for numpy 1.20 https://github.com/numpy/numpy/pull/16161
-        #  updated floordiv, now matches our behavior defined in core.ops
-        mask = (
-            ((expected == np.inf) | (expected == -np.inf)).fillna(False).to_numpy(bool)
-        )
-        expected.array._data[mask] = np.nan
+
     # rmod results in NaN that wasn't NA in original nullable Series -> unmask it
-    elif all_arithmetic_operators == "__rmod__":
+    if all_arithmetic_operators == "__rmod__":
         mask = (s == 0).fillna(False).to_numpy(bool)
         expected.array._mask[mask] = False
 
@@ -301,3 +329,39 @@ def test_unary_int_operators(any_signed_int_ea_dtype, source, neg_target, abs_ta
     tm.assert_extension_array_equal(pos_result, arr)
     assert not tm.shares_memory(pos_result, arr)
     tm.assert_extension_array_equal(abs_result, abs_target)
+
+
+def test_values_multiplying_large_series_by_NA():
+    # GH#33701
+
+    result = pd.NA * pd.Series(np.zeros(10001))
+    expected = pd.Series([pd.NA] * 10001)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_bitwise(dtype):
+    left = pd.array([1, None, 3, 4], dtype=dtype)
+    right = pd.array([None, 3, 5, 4], dtype=dtype)
+
+    result = left | right
+    expected = pd.array([None, None, 3 | 5, 4 | 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = left & right
+    expected = pd.array([None, None, 3 & 5, 4 & 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = left ^ right
+    expected = pd.array([None, None, 3 ^ 5, 4 ^ 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    # TODO: desired behavior when operating with boolean?  defer?
+
+    floats = right.astype("Float64")
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left | floats
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left & floats
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left ^ floats
diff --git a/pandas/tests/arrays/integer/test_concat.py b/pandas/tests/arrays/integer/test_concat.py
index 2e8ef506140af..feba574da548f 100644
--- a/pandas/tests/arrays/integer/test_concat.py
+++ b/pandas/tests/arrays/integer/test_concat.py
@@ -15,11 +15,13 @@
         (["UInt8", "Int8"], "Int16"),
         (["Int32", "UInt32"], "Int64"),
         (["Int64", "UInt64"], "Float64"),
-        (["Int64", "boolean"], "Int64"),
-        (["UInt8", "boolean"], "UInt8"),
+        (["Int64", "boolean"], "object"),
+        (["UInt8", "boolean"], "object"),
     ],
 )
 def test_concat_series(to_concat_dtypes, result_dtype):
+    # we expect the same dtypes as we would get with non-masked inputs,
+    #  just masked where available.
 
     result = pd.concat([pd.Series([0, 1, pd.NA], dtype=t) for t in to_concat_dtypes])
     expected = pd.concat([pd.Series([0, 1, pd.NA], dtype=object)] * 2).astype(
@@ -47,11 +49,13 @@ def test_concat_series(to_concat_dtypes, result_dtype):
         (["UInt8", "int8"], "Int16"),
         (["Int32", "uint32"], "Int64"),
         (["Int64", "uint64"], "Float64"),
-        (["Int64", "bool"], "Int64"),
-        (["UInt8", "bool"], "UInt8"),
+        (["Int64", "bool"], "object"),
+        (["UInt8", "bool"], "object"),
     ],
 )
 def test_concat_series_with_numpy(to_concat_dtypes, result_dtype):
+    # we expect the same dtypes as we would get with non-masked inputs,
+    #  just masked where available.
 
     s1 = pd.Series([0, 1, pd.NA], dtype=to_concat_dtypes[0])
     s2 = pd.Series(np.array([0, 1], dtype=to_concat_dtypes[1]))
diff --git a/pandas/tests/arrays/integer/test_construction.py b/pandas/tests/arrays/integer/test_construction.py
index e5fd4977ec2b8..43ef46ddfb581 100644
--- a/pandas/tests/arrays/integer/test_construction.py
+++ b/pandas/tests/arrays/integer/test_construction.py
@@ -14,6 +14,10 @@
 
 @pytest.fixture(params=[pd.array, IntegerArray._from_sequence])
 def constructor(request):
+    """Fixture returning parametrized IntegerArray from given sequence.
+
+    Used to test dtype conversions.
+    """
     return request.param
 
 
@@ -135,10 +139,11 @@ def test_to_integer_array_error(values):
     # error in converting existing arrays to IntegerArrays
     msg = "|".join(
         [
-            r"cannot be converted to an IntegerDtype",
+            r"cannot be converted to IntegerDtype",
             r"invalid literal for int\(\) with base 10:",
             r"values must be a 1D list-like",
             r"Cannot pass scalar",
+            r"int\(\) argument must be a string",
         ]
     )
     with pytest.raises((ValueError, TypeError), match=msg):
diff --git a/pandas/tests/arrays/integer/test_dtypes.py b/pandas/tests/arrays/integer/test_dtypes.py
index 3911b7f9bad34..1566476c32989 100644
--- a/pandas/tests/arrays/integer/test_dtypes.py
+++ b/pandas/tests/arrays/integer/test_dtypes.py
@@ -54,7 +54,7 @@ def test_preserve_dtypes(op):
 def test_astype_nansafe():
     # see gh-22343
     arr = pd.array([np.nan, 1, 2], dtype="Int8")
-    msg = "cannot convert to 'uint32'-dtype NumPy array with missing values."
+    msg = "cannot convert NA to integer"
 
     with pytest.raises(ValueError, match=msg):
         arr.astype("uint32")
@@ -136,7 +136,7 @@ def test_astype(all_data):
 
     # coerce to same numpy_dtype - mixed
     s = pd.Series(mixed)
-    msg = r"cannot convert to .*-dtype NumPy array with missing values.*"
+    msg = "cannot convert NA to integer"
     with pytest.raises(ValueError, match=msg):
         s.astype(all_data.dtype.numpy_dtype)
 
@@ -217,7 +217,7 @@ def test_astype_floating():
 
 def test_astype_dt64():
     # GH#32435
-    arr = pd.array([1, 2, 3, pd.NA]) * 10 ** 9
+    arr = pd.array([1, 2, 3, pd.NA]) * 10**9
 
     result = arr.astype("datetime64[ns]")
 
@@ -283,7 +283,7 @@ def test_to_numpy_na_raises(dtype):
 
 def test_astype_str():
     a = pd.array([1, 2, None], dtype="Int64")
-    expected = np.array(["1", "2", "<NA>"], dtype="<U21")
+    expected = np.array(["1", "2", "<NA>"], dtype=f"{tm.ENDIAN}U21")
 
     tm.assert_numpy_array_equal(a.astype(str), expected)
     tm.assert_numpy_array_equal(a.astype("str"), expected)
diff --git a/pandas/tests/arrays/interval/test_interval.py b/pandas/tests/arrays/interval/test_interval.py
index 400846cc4ca1d..2a6bea3255342 100644
--- a/pandas/tests/arrays/interval/test_interval.py
+++ b/pandas/tests/arrays/interval/test_interval.py
@@ -76,13 +76,19 @@ def test_set_closed(self, closed, new_closed):
         ],
     )
     def test_where_raises(self, other):
+        # GH#45768 The IntervalArray methods raises; the Series method coerces
         ser = pd.Series(IntervalArray.from_breaks([1, 2, 3, 4], closed="left"))
+        mask = np.array([True, False, True])
         match = "'value.closed' is 'right', expected 'left'."
         with pytest.raises(ValueError, match=match):
-            ser.where([True, False, True], other=other)
+            ser.array._where(mask, other)
+
+        res = ser.where(mask, other=other)
+        expected = ser.astype(object).where(mask, other)
+        tm.assert_series_equal(res, expected)
 
     def test_shift(self):
-        # https://github.com/pandas-dev/pandas/issues/31495
+        # https://github.com/pandas-dev/pandas/issues/31495, GH#22428, GH#31502
         a = IntervalArray.from_breaks([1, 2, 3])
         result = a.shift()
         # int -> float
@@ -90,6 +96,7 @@ def test_shift(self):
         tm.assert_interval_array_equal(result, expected)
 
     def test_shift_datetime(self):
+        # GH#31502, GH#31504
         a = IntervalArray.from_breaks(date_range("2000", periods=4))
         result = a.shift(2)
         expected = a.take([-1, -1, 0], allow_fill=True)
@@ -113,7 +120,9 @@ def test_set_na(self, left_right_dtypes):
                 result[0] = pd.NaT
         if result.dtype.subtype.kind in ["i", "u"]:
             msg = "Cannot set float NaN to integer-backed IntervalArray"
-            with pytest.raises(ValueError, match=msg):
+            # GH#45484 TypeError, not ValueError, matches what we get with
+            # non-NA un-holdable value.
+            with pytest.raises(TypeError, match=msg):
                 result[0] = np.NaN
             return
 
@@ -239,7 +248,7 @@ def test_min_max(self, left_right_dtypes, index_or_series_or_array):
 def test_arrow_extension_type():
     import pyarrow as pa
 
-    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+    from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 
     p1 = ArrowIntervalType(pa.int64(), "left")
     p2 = ArrowIntervalType(pa.int64(), "left")
@@ -256,7 +265,7 @@ def test_arrow_extension_type():
 def test_arrow_array():
     import pyarrow as pa
 
-    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+    from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 
     intervals = pd.interval_range(1, 5, freq=1).array
 
@@ -286,7 +295,7 @@ def test_arrow_array():
 def test_arrow_array_missing():
     import pyarrow as pa
 
-    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+    from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 
     arr = IntervalArray.from_breaks([0.0, 1.0, 2.0, 3.0])
     arr[1] = None
@@ -321,7 +330,7 @@ def test_arrow_array_missing():
 def test_arrow_table_roundtrip(breaks):
     import pyarrow as pa
 
-    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+    from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 
     arr = IntervalArray.from_breaks(breaks)
     arr[1] = None
@@ -367,3 +376,40 @@ def test_arrow_table_roundtrip_without_metadata(breaks):
     result = table.to_pandas()
     assert isinstance(result["a"].dtype, pd.IntervalDtype)
     tm.assert_frame_equal(result, df)
+
+
+@pyarrow_skip
+def test_from_arrow_from_raw_struct_array():
+    # in case pyarrow lost the Interval extension type (eg on parquet roundtrip
+    # with datetime64[ns] subtype, see GH-45881), still allow conversion
+    # from arrow to IntervalArray
+    import pyarrow as pa
+
+    arr = pa.array([{"left": 0, "right": 1}, {"left": 1, "right": 2}])
+    dtype = pd.IntervalDtype(np.dtype("int64"), closed="neither")
+
+    result = dtype.__from_arrow__(arr)
+    expected = IntervalArray.from_breaks(
+        np.array([0, 1, 2], dtype="int64"), closed="neither"
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    result = dtype.__from_arrow__(pa.chunked_array([arr]))
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("timezone", ["UTC", "US/Pacific", "GMT"])
+def test_interval_index_subtype(timezone, inclusive_endpoints_fixture):
+    # GH 46999
+    dates = date_range("2022", periods=3, tz=timezone)
+    dtype = f"interval[datetime64[ns, {timezone}], {inclusive_endpoints_fixture}]"
+    result = IntervalIndex.from_arrays(
+        ["2022-01-01", "2022-01-02"],
+        ["2022-01-02", "2022-01-03"],
+        closed=inclusive_endpoints_fixture,
+        dtype=dtype,
+    )
+    expected = IntervalIndex.from_arrays(
+        dates[:-1], dates[1:], closed=inclusive_endpoints_fixture
+    )
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/arrays/masked/test_arithmetic.py b/pandas/tests/arrays/masked/test_arithmetic.py
index ab6e5110422ca..f4b571ca627b3 100644
--- a/pandas/tests/arrays/masked/test_arithmetic.py
+++ b/pandas/tests/arrays/masked/test_arithmetic.py
@@ -21,6 +21,11 @@
 
 @pytest.fixture(params=zip(arrays, scalars), ids=[a.dtype.name for a in arrays])
 def data(request):
+    """Fixture returning parametrized (array, scalar) tuple.
+
+    Used to test equivalence of scalars, numpy arrays with array ops, and the
+    equivalence of DataFrame and Series ops.
+    """
     return request.param
 
 
@@ -29,6 +34,15 @@ def check_skip(data, op_name):
         pytest.skip("subtract not implemented for boolean")
 
 
+def is_bool_not_implemented(data, op_name):
+    # match non-masked behavior
+    return data.dtype.kind == "b" and op_name.strip("_").lstrip("r") in [
+        "pow",
+        "truediv",
+        "floordiv",
+    ]
+
+
 # Test equivalence of scalars, numpy arrays with array ops
 # -----------------------------------------------------------------------------
 
@@ -42,12 +56,19 @@ def test_array_scalar_like_equivalence(data, all_arithmetic_operators):
 
     # TODO also add len-1 array (np.array([scalar], dtype=data.dtype.numpy_dtype))
     for scalar in [scalar, data.dtype.type(scalar)]:
-        result = op(data, scalar)
-        expected = op(data, scalar_array)
-        tm.assert_extension_array_equal(result, expected)
-
-
-def test_array_NA(data, all_arithmetic_operators, request):
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar)
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar_array)
+        else:
+            result = op(data, scalar)
+            expected = op(data, scalar_array)
+            tm.assert_extension_array_equal(result, expected)
+
+
+def test_array_NA(data, all_arithmetic_operators):
     data, _ = data
     op = tm.get_op_from_name(all_arithmetic_operators)
     check_skip(data, all_arithmetic_operators)
@@ -55,8 +76,23 @@ def test_array_NA(data, all_arithmetic_operators, request):
     scalar = pd.NA
     scalar_array = pd.array([pd.NA] * len(data), dtype=data.dtype)
 
+    mask = data._mask.copy()
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        # GH#45421 check op doesn't alter data._mask inplace
+        tm.assert_numpy_array_equal(mask, data._mask)
+        return
+
     result = op(data, scalar)
+    # GH#45421 check op doesn't alter data._mask inplace
+    tm.assert_numpy_array_equal(mask, data._mask)
+
     expected = op(data, scalar_array)
+    tm.assert_numpy_array_equal(mask, data._mask)
+
     tm.assert_extension_array_equal(result, expected)
 
 
@@ -68,6 +104,14 @@ def test_numpy_array_equivalence(data, all_arithmetic_operators):
     numpy_array = np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype)
     pd_array = pd.array(numpy_array, dtype=data.dtype)
 
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, numpy_array)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, pd_array)
+        return
+
     result = op(data, numpy_array)
     expected = op(data, pd_array)
     tm.assert_extension_array_equal(result, expected)
@@ -85,6 +129,14 @@ def test_frame(data, all_arithmetic_operators):
     # DataFrame with scalar
     df = pd.DataFrame({"A": data})
 
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(df, scalar)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        return
+
     result = op(df, scalar)
     expected = pd.DataFrame({"A": op(data, scalar)})
     tm.assert_frame_equal(result, expected)
@@ -95,30 +147,25 @@ def test_series(data, all_arithmetic_operators):
     op = tm.get_op_from_name(all_arithmetic_operators)
     check_skip(data, all_arithmetic_operators)
 
-    s = pd.Series(data)
-
-    # Series with scalar
-    result = op(s, scalar)
-    expected = pd.Series(op(data, scalar))
-    tm.assert_series_equal(result, expected)
+    ser = pd.Series(data)
 
-    # Series with np.ndarray
-    other = np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype)
-    result = op(s, other)
-    expected = pd.Series(op(data, other))
-    tm.assert_series_equal(result, expected)
+    others = [
+        scalar,
+        np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype),
+        pd.array([scalar] * len(data), dtype=data.dtype),
+        pd.Series([scalar] * len(data), dtype=data.dtype),
+    ]
 
-    # Series with pd.array
-    other = pd.array([scalar] * len(data), dtype=data.dtype)
-    result = op(s, other)
-    expected = pd.Series(op(data, other))
-    tm.assert_series_equal(result, expected)
+    for other in others:
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(ser, other)
 
-    # Series with Series
-    other = pd.Series([scalar] * len(data), dtype=data.dtype)
-    result = op(s, other)
-    expected = pd.Series(op(data, other.array))
-    tm.assert_series_equal(result, expected)
+        else:
+            result = op(ser, other)
+            expected = pd.Series(op(data, other))
+            tm.assert_series_equal(result, expected)
 
 
 # Test generic characteristics / errors
@@ -147,17 +194,37 @@ def test_error_len_mismatch(data, all_arithmetic_operators):
 
     other = [scalar] * (len(data) - 1)
 
+    err = ValueError
+    msg = "|".join(
+        [
+            r"operands could not be broadcast together with shapes \(3,\) \(4,\)",
+            r"operands could not be broadcast together with shapes \(4,\) \(3,\)",
+        ]
+    )
+    if data.dtype.kind == "b" and all_arithmetic_operators.strip("_") in [
+        "sub",
+        "rsub",
+    ]:
+        err = TypeError
+        msg = (
+            r"numpy boolean subtract, the `\-` operator, is not supported, use "
+            r"the bitwise_xor, the `\^` operator, or the logical_xor function instead"
+        )
+    elif is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        err = NotImplementedError
+
     for other in [other, np.array(other)]:
-        with pytest.raises(ValueError, match="Lengths must match"):
+        with pytest.raises(err, match=msg):
             op(data, other)
 
         s = pd.Series(data)
-        with pytest.raises(ValueError, match="Lengths must match"):
+        with pytest.raises(err, match=msg):
             op(s, other)
 
 
 @pytest.mark.parametrize("op", ["__neg__", "__abs__", "__invert__"])
-def test_unary_op_does_not_propagate_mask(data, op, request):
+def test_unary_op_does_not_propagate_mask(data, op):
     # https://github.com/pandas-dev/pandas/issues/39943
     data, _ = data
     ser = pd.Series(data)
diff --git a/pandas/tests/arrays/masked/test_arrow_compat.py b/pandas/tests/arrays/masked/test_arrow_compat.py
index 051762511a6ca..6b0081321ef22 100644
--- a/pandas/tests/arrays/masked/test_arrow_compat.py
+++ b/pandas/tests/arrays/masked/test_arrow_compat.py
@@ -6,7 +6,7 @@
 
 pa = pytest.importorskip("pyarrow", minversion="1.0.1")
 
-from pandas.core.arrays._arrow_utils import pyarrow_array_to_numpy_and_mask
+from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask
 
 arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
 arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]
@@ -15,6 +15,10 @@
 
 @pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
 def data(request):
+    """
+    Fixture returning parametrized array from given dtype, including integer,
+    float and boolean
+    """
     return request.param
 
 
@@ -101,6 +105,10 @@ def test_arrow_sliced(data):
 
 @pytest.fixture
 def np_dtype_to_arrays(any_real_numpy_dtype):
+    """
+    Fixture returning actual and expected dtype, pandas and numpy arrays and
+    mask from a given numpy dtype
+    """
     np_dtype = np.dtype(any_real_numpy_dtype)
     pa_type = pa.from_numpy_dtype(np_dtype)
 
diff --git a/pandas/tests/arrays/masked/test_function.py b/pandas/tests/arrays/masked/test_function.py
index bf310c7aa455e..9a86ef835e5ef 100644
--- a/pandas/tests/arrays/masked/test_function.py
+++ b/pandas/tests/arrays/masked/test_function.py
@@ -14,11 +14,18 @@
 
 @pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
 def data(request):
+    """
+    Fixture returning parametrized 'data' array with different integer and
+    floating point types
+    """
     return request.param
 
 
 @pytest.fixture()
 def numpy_dtype(data):
+    """
+    Fixture returning numpy dtype from 'data' input array.
+    """
     # For integer dtype, the numpy conversion must be done to float
     if is_integer_dtype(data):
         numpy_dtype = float
diff --git a/pandas/tests/arrays/masked/test_indexing.py b/pandas/tests/arrays/masked/test_indexing.py
new file mode 100644
index 0000000000000..28ee451a7ddd7
--- /dev/null
+++ b/pandas/tests/arrays/masked/test_indexing.py
@@ -0,0 +1,60 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+
+
+class TestSetitemValidation:
+    def _check_setitem_invalid(self, arr, invalid):
+        msg = f"Invalid value '{str(invalid)}' for dtype {arr.dtype}"
+        msg = re.escape(msg)
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[:] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[[0]] = invalid
+
+        # FIXME: don't leave commented-out
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = [invalid]
+
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = np.array([invalid], dtype=object)
+
+        # Series non-coercion, behavior subject to change
+        ser = pd.Series(arr)
+        with pytest.raises(TypeError, match=msg):
+            ser[0] = invalid
+            # TODO: so, so many other variants of this...
+
+    _invalid_scalars = [
+        1 + 2j,
+        "True",
+        "1",
+        "1.0",
+        pd.NaT,
+        np.datetime64("NaT"),
+        np.timedelta64("NaT"),
+    ]
+
+    @pytest.mark.parametrize(
+        "invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
+    )
+    def test_setitem_validation_scalar_bool(self, invalid):
+        arr = pd.array([True, False, None], dtype="boolean")
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
+    def test_setitem_validation_scalar_int(self, invalid, any_int_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=any_int_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True])
+    def test_setitem_validation_scalar_float(self, invalid, float_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=float_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)
diff --git a/pandas/tests/arrays/masked_shared.py b/pandas/tests/arrays/masked_shared.py
index 454be70cf405b..6174ae0a3c19b 100644
--- a/pandas/tests/arrays/masked_shared.py
+++ b/pandas/tests/arrays/masked_shared.py
@@ -55,6 +55,14 @@ def test_scalar(self, other, comparison_op, dtype):
 class NumericOps:
     # Shared by IntegerArray and FloatingArray, not BooleanArray
 
+    def test_searchsorted_nan(self, dtype):
+        # The base class casts to object dtype, for which searchsorted returns
+        #  0 from the left and 10 from the right.
+        arr = pd.array(range(10), dtype=dtype)
+
+        assert arr.searchsorted(np.nan, side="left") == 10
+        assert arr.searchsorted(np.nan, side="right") == 10
+
     def test_no_shared_mask(self, data):
         result = data + 1
         assert not tm.shares_memory(result, data)
@@ -119,7 +127,7 @@ def test_ufunc_with_out(self, dtype):
         assert isinstance(result, np.ndarray)
         assert result.all()
 
-        # result |= mask worked because mask could be cast lossslessly to
+        # result |= mask worked because mask could be cast losslessly to
         #  boolean ndarray. mask2 can't, so this raises
         result = np.zeros(3, dtype=bool)
         msg = "Specify an appropriate 'na_value' for this dtype"
@@ -136,3 +144,12 @@ def test_ufunc_with_out(self, dtype):
         assert res is arr
         tm.assert_extension_array_equal(res, expected)
         tm.assert_extension_array_equal(arr, expected)
+
+    def test_mul_td64_array(self, dtype):
+        # GH#45622
+        arr = pd.array([1, 2, pd.NA], dtype=dtype)
+        other = np.arange(3, dtype=np.int64).view("m8[ns]")
+
+        result = arr * other
+        expected = pd.array([pd.Timedelta(0), pd.Timedelta(2), pd.NaT])
+        tm.assert_extension_array_equal(result, expected)
diff --git a/pandas/tests/arrays/numpy_/__init__.py b/pandas/tests/arrays/numpy_/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/arrays/numpy_/test_indexing.py b/pandas/tests/arrays/numpy_/test_indexing.py
new file mode 100644
index 0000000000000..225d64ad7d258
--- /dev/null
+++ b/pandas/tests/arrays/numpy_/test_indexing.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestSearchsorted:
+    def test_searchsorted_string(self, string_dtype):
+        arr = pd.array(["a", "b", "c"], dtype=string_dtype)
+
+        result = arr.searchsorted("a", side="left")
+        assert is_scalar(result)
+        assert result == 0
+
+        result = arr.searchsorted("a", side="right")
+        assert is_scalar(result)
+        assert result == 1
+
+    def test_searchsorted_numeric_dtypes_scalar(self, any_real_numpy_dtype):
+        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted(30)
+        assert is_scalar(result)
+        assert result == 2
+
+        result = arr.searchsorted([30])
+        expected = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_searchsorted_numeric_dtypes_vector(self, any_real_numpy_dtype):
+        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted([2, 30])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_searchsorted_sorter(self, any_real_numpy_dtype):
+        arr = pd.array([3, 1, 2], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted([0, 3], sorter=np.argsort(arr))
+        expected = np.array([0, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/arrays/test_numpy.py b/pandas/tests/arrays/numpy_/test_numpy.py
similarity index 88%
rename from pandas/tests/arrays/test_numpy.py
rename to pandas/tests/arrays/numpy_/test_numpy.py
index 66f7bf1f4d743..c748d487a2f9c 100644
--- a/pandas/tests/arrays/test_numpy.py
+++ b/pandas/tests/arrays/numpy_/test_numpy.py
@@ -237,6 +237,11 @@ def test_ufunc_unary(ufunc):
     expected = PandasArray(ufunc(arr._ndarray))
     tm.assert_extension_array_equal(result, expected)
 
+    # same thing but with the 'out' keyword
+    out = PandasArray(np.array([-9.0, -9.0, -9.0]))
+    ufunc(arr, out=out)
+    tm.assert_extension_array_equal(out, expected)
+
 
 def test_ufunc():
     arr = PandasArray(np.array([-1.0, 0.0, 1.0]))
@@ -293,3 +298,27 @@ def test_setitem_preserves_views():
     arr[-1] = 2.5
     view1[-1] = 5
     assert arr[-1] == 5
+
+
+@pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+def test_quantile_empty(dtype):
+    # we should get back np.nans, not -1s
+    arr = PandasArray(np.array([], dtype=dtype))
+    idx = pd.Index([0.0, 0.5])
+
+    result = arr._quantile(idx, interpolation="linear")
+    expected = PandasArray(np.array([np.nan, np.nan]))
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_factorize_unsigned():
+    # don't raise when calling factorize on unsigned int PandasArray
+    arr = np.array([1, 2, 3], dtype=np.uint64)
+    obj = PandasArray(arr)
+
+    res_codes, res_unique = obj.factorize()
+    exp_codes, exp_unique = pd.factorize(arr)
+
+    tm.assert_numpy_array_equal(res_codes, exp_codes)
+
+    tm.assert_extension_array_equal(res_unique, PandasArray(exp_unique))
diff --git a/pandas/tests/arrays/period/test_arrow_compat.py b/pandas/tests/arrays/period/test_arrow_compat.py
index 6066d49b68489..03fd146572405 100644
--- a/pandas/tests/arrays/period/test_arrow_compat.py
+++ b/pandas/tests/arrays/period/test_arrow_compat.py
@@ -1,7 +1,5 @@
 import pytest
 
-from pandas.compat import pa_version_under2p0
-
 from pandas.core.dtypes.dtypes import PeriodDtype
 
 import pandas as pd
@@ -15,7 +13,7 @@
 
 
 def test_arrow_extension_type():
-    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
     p1 = ArrowPeriodType("D")
     p2 = ArrowPeriodType("D")
@@ -36,7 +34,7 @@ def test_arrow_extension_type():
     ],
 )
 def test_arrow_array(data, freq):
-    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
     periods = period_array(data, freq=freq)
     result = pa.array(periods)
@@ -59,7 +57,7 @@ def test_arrow_array(data, freq):
 
 
 def test_arrow_array_missing():
-    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
     arr = PeriodArray([1, 2, 3], freq="D")
     arr[1] = pd.NaT
@@ -71,11 +69,8 @@ def test_arrow_array_missing():
     assert result.storage.equals(expected)
 
 
-@pytest.mark.xfail(
-    pa_version_under2p0, reason="pyarrow incorrectly uses pandas internals API"
-)
 def test_arrow_table_roundtrip():
-    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
     arr = PeriodArray([1, 2, 3], freq="D")
     arr[1] = pd.NaT
@@ -93,13 +88,10 @@ def test_arrow_table_roundtrip():
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.xfail(
-    pa_version_under2p0, reason="pyarrow incorrectly uses pandas internals API"
-)
 def test_arrow_load_from_zero_chunks():
     # GH-41040
 
-    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
 
     arr = PeriodArray([], freq="D")
     df = pd.DataFrame({"a": arr})
@@ -114,9 +106,6 @@ def test_arrow_load_from_zero_chunks():
     tm.assert_frame_equal(result, df)
 
 
-@pytest.mark.xfail(
-    pa_version_under2p0, reason="pyarrow incorrectly uses pandas internals API"
-)
 def test_arrow_table_roundtrip_without_metadata():
     arr = PeriodArray([1, 2, 3], freq="H")
     arr[1] = pd.NaT
diff --git a/pandas/tests/arrays/period/test_astype.py b/pandas/tests/arrays/period/test_astype.py
index e16220acd3210..e9245c9ca786b 100644
--- a/pandas/tests/arrays/period/test_astype.py
+++ b/pandas/tests/arrays/period/test_astype.py
@@ -9,40 +9,43 @@
 
 
 @pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
-def test_astype(dtype):
+def test_astype_int(dtype):
     # We choose to ignore the sign and size of integers for
     # Period/Datetime/Timedelta astype
     arr = period_array(["2000", "2001", None], freq="D")
-    with tm.assert_produces_warning(FutureWarning):
-        # astype(int..) deprecated
-        result = arr.astype(dtype)
 
     if np.dtype(dtype).kind == "u":
         expected_dtype = np.dtype("uint64")
+        warn1 = FutureWarning
     else:
         expected_dtype = np.dtype("int64")
+        warn1 = None
 
-    with tm.assert_produces_warning(FutureWarning):
-        # astype(int..) deprecated
+    msg_overflow = "will raise if the conversion overflows"
+    with tm.assert_produces_warning(warn1, match=msg_overflow):
         expected = arr.astype(expected_dtype)
 
+    warn = None if dtype == expected_dtype else FutureWarning
+    msg = " will return exactly the specified dtype"
+    if warn is None and warn1 is not None:
+        warn = warn1
+        msg = msg_overflow
+    with tm.assert_produces_warning(warn, match=msg):
+        result = arr.astype(dtype)
+
     assert result.dtype == expected_dtype
     tm.assert_numpy_array_equal(result, expected)
 
 
 def test_astype_copies():
     arr = period_array(["2000", "2001", None], freq="D")
-    with tm.assert_produces_warning(FutureWarning):
-        # astype(int..) deprecated
-        result = arr.astype(np.int64, copy=False)
+    result = arr.astype(np.int64, copy=False)
 
     # Add the `.base`, since we now use `.asi8` which returns a view.
     # We could maybe override it in PeriodArray to return ._data directly.
     assert result.base is arr._data
 
-    with tm.assert_produces_warning(FutureWarning):
-        # astype(int..) deprecated
-        result = arr.astype(np.int64, copy=True)
+    result = arr.astype(np.int64, copy=True)
     assert result is not arr._data
     tm.assert_numpy_array_equal(result, arr._data.view("i8"))
 
diff --git a/pandas/tests/arrays/sparse/test_accessor.py b/pandas/tests/arrays/sparse/test_accessor.py
index e45dbb393a8de..36af5d32ae461 100644
--- a/pandas/tests/arrays/sparse/test_accessor.py
+++ b/pandas/tests/arrays/sparse/test_accessor.py
@@ -14,13 +14,90 @@
 
 
 class TestSeriesAccessor:
-    # TODO: collect other Series accessor tests
     def test_to_dense(self):
-        s = pd.Series([0, 1, 0, 10], dtype="Sparse[int64]")
-        result = s.sparse.to_dense()
+        ser = pd.Series([0, 1, 0, 10], dtype="Sparse[int64]")
+        result = ser.sparse.to_dense()
         expected = pd.Series([0, 1, 0, 10])
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize("attr", ["npoints", "density", "fill_value", "sp_values"])
+    def test_get_attributes(self, attr):
+        arr = SparseArray([0, 1])
+        ser = pd.Series(arr)
+
+        result = getattr(ser.sparse, attr)
+        expected = getattr(arr, attr)
+        assert result == expected
+
+    @td.skip_if_no_scipy
+    def test_from_coo(self):
+        import scipy.sparse
+
+        row = [0, 3, 1, 0]
+        col = [0, 3, 1, 2]
+        data = [4, 5, 7, 9]
+        # TODO(scipy#13585): Remove dtype when scipy is fixed
+        # https://github.com/scipy/scipy/issues/13585
+        sp_array = scipy.sparse.coo_matrix((data, (row, col)), dtype="int")
+        result = pd.Series.sparse.from_coo(sp_array)
+
+        index = pd.MultiIndex.from_arrays([[0, 0, 1, 3], [0, 2, 1, 3]])
+        expected = pd.Series([4, 9, 7, 5], index=index, dtype="Sparse[int]")
+        tm.assert_series_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize(
+        "sort_labels, expected_rows, expected_cols, expected_values_pos",
+        [
+            (
+                False,
+                [("b", 2), ("a", 2), ("b", 1), ("a", 1)],
+                [("z", 1), ("z", 2), ("x", 2), ("z", 0)],
+                {1: (1, 0), 3: (3, 3)},
+            ),
+            (
+                True,
+                [("a", 1), ("a", 2), ("b", 1), ("b", 2)],
+                [("x", 2), ("z", 0), ("z", 1), ("z", 2)],
+                {1: (1, 2), 3: (0, 1)},
+            ),
+        ],
+    )
+    def test_to_coo(
+        self, sort_labels, expected_rows, expected_cols, expected_values_pos
+    ):
+        import scipy.sparse
+
+        values = SparseArray([0, np.nan, 1, 0, None, 3], fill_value=0)
+        index = pd.MultiIndex.from_tuples(
+            [
+                ("b", 2, "z", 1),
+                ("a", 2, "z", 2),
+                ("a", 2, "z", 1),
+                ("a", 2, "x", 2),
+                ("b", 1, "z", 1),
+                ("a", 1, "z", 0),
+            ]
+        )
+        ss = pd.Series(values, index=index)
+
+        expected_A = np.zeros((4, 4))
+        for value, (row, col) in expected_values_pos.items():
+            expected_A[row, col] = value
+
+        A, rows, cols = ss.sparse.to_coo(
+            row_levels=(0, 1), column_levels=(2, 3), sort_labels=sort_labels
+        )
+        assert isinstance(A, scipy.sparse.coo_matrix)
+        tm.assert_numpy_array_equal(A.toarray(), expected_A)
+        assert rows == expected_rows
+        assert cols == expected_cols
+
+    def test_non_sparse_raises(self):
+        ser = pd.Series([1, 2, 3])
+        with pytest.raises(AttributeError, match=".sparse"):
+            ser.sparse.density
+
 
 class TestFrameAccessor:
     def test_accessor_raises(self):
diff --git a/pandas/tests/arrays/sparse/test_arithmetics.py b/pandas/tests/arrays/sparse/test_arithmetics.py
index 012fe61fdba05..1a32c995f4afa 100644
--- a/pandas/tests/arrays/sparse/test_arithmetics.py
+++ b/pandas/tests/arrays/sparse/test_arithmetics.py
@@ -3,11 +3,8 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p20
-
 import pandas as pd
 import pandas._testing as tm
-from pandas.core import ops
 from pandas.core.arrays.sparse import (
     SparseArray,
     SparseDtype,
@@ -22,16 +19,16 @@ def kind(request):
 
 @pytest.fixture(params=[True, False])
 def mix(request):
-    # whether to operate op(sparse, dense) instead of op(sparse, sparse)
+    """
+    Fixture returning True or False, determining whether to operate
+    op(sparse, dense) instead of op(sparse, sparse)
+    """
     return request.param
 
 
 class TestSparseArrayArithmetics:
-
-    _base = np.array
-    _klass = SparseArray
-
     def _assert(self, a, b):
+        # We have to use tm.assert_sp_array_equal. See GH #45126
         tm.assert_numpy_array_equal(a, b)
 
     def _check_numeric_ops(self, a, b, a_dense, b_dense, mix: bool, op):
@@ -53,7 +50,7 @@ def _check_numeric_ops(self, a, b, a_dense, b_dense, mix: bool, op):
         self._assert(result, expected)
 
     def _check_bool_result(self, res):
-        assert isinstance(res, self._klass)
+        assert isinstance(res, SparseArray)
         assert isinstance(res.dtype, SparseDtype)
         assert res.dtype.subtype == np.bool_
         assert isinstance(res.fill_value, bool)
@@ -121,36 +118,24 @@ def test_float_scalar(
         self, kind, mix, all_arithmetic_functions, fill_value, scalar, request
     ):
         op = all_arithmetic_functions
-
-        if np_version_under1p20:
-            if op in [operator.floordiv, ops.rfloordiv]:
-                if op is operator.floordiv and scalar != 0:
-                    pass
-                elif op is ops.rfloordiv and scalar == 0:
-                    pass
-                else:
-                    mark = pytest.mark.xfail(raises=AssertionError, reason="GH#38172")
-                    request.node.add_marker(mark)
-
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-
-        a = self._klass(values, kind=kind, fill_value=fill_value)
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        a = SparseArray(values, kind=kind, fill_value=fill_value)
         self._check_numeric_ops(a, scalar, values, scalar, mix, op)
 
     def test_float_scalar_comparison(self, kind):
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
 
-        a = self._klass(values, kind=kind)
+        a = SparseArray(values, kind=kind)
         self._check_comparison_ops(a, 1, values, 1)
         self._check_comparison_ops(a, 0, values, 0)
         self._check_comparison_ops(a, 3, values, 3)
 
-        a = self._klass(values, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
         self._check_comparison_ops(a, 1, values, 1)
         self._check_comparison_ops(a, 0, values, 0)
         self._check_comparison_ops(a, 3, values, 3)
 
-        a = self._klass(values, kind=kind, fill_value=2)
+        a = SparseArray(values, kind=kind, fill_value=2)
         self._check_comparison_ops(a, 1, values, 1)
         self._check_comparison_ops(a, 0, values, 0)
         self._check_comparison_ops(a, 3, values, 3)
@@ -159,11 +144,11 @@ def test_float_same_index_without_nans(self, kind, mix, all_arithmetic_functions
         # when sp_index are the same
         op = all_arithmetic_functions
 
-        values = self._base([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
-        rvalues = self._base([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
+        values = np.array([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
+        rvalues = np.array([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
     def test_float_same_index_with_nans(
@@ -171,102 +156,94 @@ def test_float_same_index_with_nans(
     ):
         # when sp_index are the same
         op = all_arithmetic_functions
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
 
-        if (
-            np_version_under1p20
-            and op is ops.rfloordiv
-            and not (mix and kind == "block")
-        ):
-            mark = pytest.mark.xfail(raises=AssertionError, reason="GH#38172")
-            request.node.add_marker(mark)
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
-
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
     def test_float_same_index_comparison(self, kind):
         # when sp_index are the same
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
 
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        values = self._base([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
-        rvalues = self._base([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
+        values = np.array([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
+        rvalues = np.array([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         self._check_comparison_ops(a, b, values, rvalues)
 
     def test_float_array(self, kind, mix, all_arithmetic_functions):
         op = all_arithmetic_functions
 
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
 
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
         self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=1)
-        b = self._klass(rvalues, kind=kind, fill_value=2)
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
     def test_float_array_different_kind(self, mix, all_arithmetic_functions):
         op = all_arithmetic_functions
 
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
 
-        a = self._klass(values, kind="integer")
-        b = self._klass(rvalues, kind="block")
+        a = SparseArray(values, kind="integer")
+        b = SparseArray(rvalues, kind="block")
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
         self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
 
-        a = self._klass(values, kind="integer", fill_value=0)
-        b = self._klass(rvalues, kind="block")
+        a = SparseArray(values, kind="integer", fill_value=0)
+        b = SparseArray(rvalues, kind="block")
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind="integer", fill_value=0)
-        b = self._klass(rvalues, kind="block", fill_value=0)
+        a = SparseArray(values, kind="integer", fill_value=0)
+        b = SparseArray(rvalues, kind="block", fill_value=0)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind="integer", fill_value=1)
-        b = self._klass(rvalues, kind="block", fill_value=2)
+        a = SparseArray(values, kind="integer", fill_value=1)
+        b = SparseArray(rvalues, kind="block", fill_value=2)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
     def test_float_array_comparison(self, kind):
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
 
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         self._check_comparison_ops(a, b, values, rvalues)
         self._check_comparison_ops(a, b * 0, values, rvalues * 0)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, kind=kind, fill_value=1)
-        b = self._klass(rvalues, kind=kind, fill_value=2)
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
         self._check_comparison_ops(a, b, values, rvalues)
 
     def test_int_array(self, kind, mix, all_arithmetic_functions):
@@ -275,33 +252,33 @@ def test_int_array(self, kind, mix, all_arithmetic_functions):
         # have to specify dtype explicitly until fixing GH 667
         dtype = np.int64
 
-        values = self._base([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
-        rvalues = self._base([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
+        values = np.array([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
 
-        a = self._klass(values, dtype=dtype, kind=kind)
+        a = SparseArray(values, dtype=dtype, kind=kind)
         assert a.dtype == SparseDtype(dtype)
-        b = self._klass(rvalues, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
         assert b.dtype == SparseDtype(dtype)
 
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
         self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
 
-        a = self._klass(values, fill_value=0, dtype=dtype, kind=kind)
+        a = SparseArray(values, fill_value=0, dtype=dtype, kind=kind)
         assert a.dtype == SparseDtype(dtype)
-        b = self._klass(rvalues, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
         assert b.dtype == SparseDtype(dtype)
 
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, fill_value=0, dtype=dtype, kind=kind)
+        a = SparseArray(values, fill_value=0, dtype=dtype, kind=kind)
         assert a.dtype == SparseDtype(dtype)
-        b = self._klass(rvalues, fill_value=0, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, fill_value=0, dtype=dtype, kind=kind)
         assert b.dtype == SparseDtype(dtype)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, fill_value=1, dtype=dtype, kind=kind)
+        a = SparseArray(values, fill_value=1, dtype=dtype, kind=kind)
         assert a.dtype == SparseDtype(dtype, fill_value=1)
-        b = self._klass(rvalues, fill_value=2, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, fill_value=2, dtype=dtype, kind=kind)
         assert b.dtype == SparseDtype(dtype, fill_value=2)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
@@ -309,79 +286,73 @@ def test_int_array_comparison(self, kind):
         dtype = "int64"
         # int32 NI ATM
 
-        values = self._base([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
-        rvalues = self._base([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
+        values = np.array([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
 
-        a = self._klass(values, dtype=dtype, kind=kind)
-        b = self._klass(rvalues, dtype=dtype, kind=kind)
+        a = SparseArray(values, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
         self._check_comparison_ops(a, b, values, rvalues)
         self._check_comparison_ops(a, b * 0, values, rvalues * 0)
 
-        a = self._klass(values, dtype=dtype, kind=kind, fill_value=0)
-        b = self._klass(rvalues, dtype=dtype, kind=kind)
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, dtype=dtype, kind=kind, fill_value=0)
-        b = self._klass(rvalues, dtype=dtype, kind=kind, fill_value=0)
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind, fill_value=0)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, dtype=dtype, kind=kind, fill_value=1)
-        b = self._klass(rvalues, dtype=dtype, kind=kind, fill_value=2)
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind, fill_value=2)
         self._check_comparison_ops(a, b, values, rvalues)
 
     @pytest.mark.parametrize("fill_value", [True, False, np.nan])
     def test_bool_same_index(self, kind, fill_value):
         # GH 14000
         # when sp_index are the same
-        values = self._base([True, False, True, True], dtype=np.bool_)
-        rvalues = self._base([True, False, True, True], dtype=np.bool_)
+        values = np.array([True, False, True, True], dtype=np.bool_)
+        rvalues = np.array([True, False, True, True], dtype=np.bool_)
 
-        a = self._klass(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
-        b = self._klass(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        a = SparseArray(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        b = SparseArray(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
         self._check_logical_ops(a, b, values, rvalues)
 
     @pytest.mark.parametrize("fill_value", [True, False, np.nan])
     def test_bool_array_logical(self, kind, fill_value):
         # GH 14000
         # when sp_index are the same
-        values = self._base([True, False, True, False, True, True], dtype=np.bool_)
-        rvalues = self._base([True, False, False, True, False, True], dtype=np.bool_)
+        values = np.array([True, False, True, False, True, True], dtype=np.bool_)
+        rvalues = np.array([True, False, False, True, False, True], dtype=np.bool_)
 
-        a = self._klass(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
-        b = self._klass(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        a = SparseArray(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        b = SparseArray(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
         self._check_logical_ops(a, b, values, rvalues)
 
     def test_mixed_array_float_int(self, kind, mix, all_arithmetic_functions, request):
         op = all_arithmetic_functions
-
-        if np_version_under1p20 and op in [operator.floordiv, ops.rfloordiv] and mix:
-            mark = pytest.mark.xfail(raises=AssertionError, reason="GH#38172")
-            request.node.add_marker(mark)
-
         rdtype = "int64"
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
 
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
-
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         assert b.dtype == SparseDtype(rdtype)
 
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
         self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
         assert b.dtype == SparseDtype(rdtype)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         assert b.dtype == SparseDtype(rdtype)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
-        a = self._klass(values, kind=kind, fill_value=1)
-        b = self._klass(rvalues, kind=kind, fill_value=2)
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
         assert b.dtype == SparseDtype(rdtype, fill_value=2)
         self._check_numeric_ops(a, b, values, rvalues, mix, op)
 
@@ -389,28 +360,28 @@ def test_mixed_array_comparison(self, kind):
         rdtype = "int64"
         # int32 NI ATM
 
-        values = self._base([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
-        rvalues = self._base([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
 
-        a = self._klass(values, kind=kind)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
         assert b.dtype == SparseDtype(rdtype)
 
         self._check_comparison_ops(a, b, values, rvalues)
         self._check_comparison_ops(a, b * 0, values, rvalues * 0)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
         assert b.dtype == SparseDtype(rdtype)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, kind=kind, fill_value=0)
-        b = self._klass(rvalues, kind=kind, fill_value=0)
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
         assert b.dtype == SparseDtype(rdtype)
         self._check_comparison_ops(a, b, values, rvalues)
 
-        a = self._klass(values, kind=kind, fill_value=1)
-        b = self._klass(rvalues, kind=kind, fill_value=2)
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
         assert b.dtype == SparseDtype(rdtype, fill_value=2)
         self._check_comparison_ops(a, b, values, rvalues)
 
@@ -494,36 +465,52 @@ def test_sparray_inplace():
     tm.assert_sp_array_equal(sparray, expected)
 
 
-@pytest.mark.parametrize("fill_value", [True, False])
-def test_invert(fill_value):
-    arr = np.array([True, False, False, True])
-    sparray = SparseArray(arr, fill_value=fill_value)
-    result = ~sparray
-    expected = SparseArray(~arr, fill_value=not fill_value)
-    tm.assert_sp_array_equal(result, expected)
-
-    result = ~pd.Series(sparray)
-    expected = pd.Series(expected)
-    tm.assert_series_equal(result, expected)
-
-    result = ~pd.DataFrame({"A": sparray})
-    expected = pd.DataFrame({"A": expected})
-    tm.assert_frame_equal(result, expected)
-
-
-@pytest.mark.parametrize("fill_value", [0, np.nan])
-@pytest.mark.parametrize("op", [operator.pos, operator.neg])
-def test_unary_op(op, fill_value):
-    arr = np.array([0, 1, np.nan, 2])
-    sparray = SparseArray(arr, fill_value=fill_value)
-    result = op(sparray)
-    expected = SparseArray(op(arr), fill_value=op(fill_value))
-    tm.assert_sp_array_equal(result, expected)
-
-
 @pytest.mark.parametrize("cons", [list, np.array, SparseArray])
 def test_mismatched_length_cmp_op(cons):
     left = SparseArray([True, True])
     right = cons([True, True, True])
     with pytest.raises(ValueError, match="operands have mismatched length"):
         left & right
+
+
+@pytest.mark.parametrize("op", ["add", "sub", "mul", "truediv", "floordiv", "pow"])
+@pytest.mark.parametrize("fill_value", [np.nan, 3])
+def test_binary_operators(op, fill_value):
+    op = getattr(operator, op)
+    data1 = np.random.randn(20)
+    data2 = np.random.randn(20)
+
+    data1[::2] = fill_value
+    data2[::3] = fill_value
+
+    first = SparseArray(data1, fill_value=fill_value)
+    second = SparseArray(data2, fill_value=fill_value)
+
+    with np.errstate(all="ignore"):
+        res = op(first, second)
+        exp = SparseArray(
+            op(first.to_dense(), second.to_dense()), fill_value=first.fill_value
+        )
+        assert isinstance(res, SparseArray)
+        tm.assert_almost_equal(res.to_dense(), exp.to_dense())
+
+        res2 = op(first, second.to_dense())
+        assert isinstance(res2, SparseArray)
+        tm.assert_sp_array_equal(res, res2)
+
+        res3 = op(first.to_dense(), second)
+        assert isinstance(res3, SparseArray)
+        tm.assert_sp_array_equal(res, res3)
+
+        res4 = op(first, 4)
+        assert isinstance(res4, SparseArray)
+
+        # Ignore this if the actual op raises (e.g. pow).
+        try:
+            exp = op(first.to_dense(), 4)
+            exp_fv = op(first.fill_value, 4)
+        except ValueError:
+            pass
+        else:
+            tm.assert_almost_equal(res4.fill_value, exp_fv)
+            tm.assert_almost_equal(res4.to_dense(), exp)
diff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py
index 2c3dcdeeaf8dc..9b78eb345e188 100644
--- a/pandas/tests/arrays/sparse/test_array.py
+++ b/pandas/tests/arrays/sparse/test_array.py
@@ -1,4 +1,3 @@
-import operator
 import re
 import warnings
 
@@ -6,7 +5,6 @@
 import pytest
 
 from pandas._libs.sparse import IntIndex
-import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import isna
@@ -18,308 +16,25 @@
 )
 
 
-class TestSparseArray:
-    def setup_method(self, method):
-        self.arr_data = np.array([np.nan, np.nan, 1, 2, 3, np.nan, 4, 5, np.nan, 6])
-        self.arr = SparseArray(self.arr_data)
-        self.zarr = SparseArray([0, 0, 1, 2, 3, 0, 4, 5, 0, 6], fill_value=0)
-
-    def test_constructor_dtype(self):
-        arr = SparseArray([np.nan, 1, 2, np.nan])
-        assert arr.dtype == SparseDtype(np.float64, np.nan)
-        assert arr.dtype.subtype == np.float64
-        assert np.isnan(arr.fill_value)
+@pytest.fixture
+def arr_data():
+    """Fixture returning numpy array with valid and missing entries"""
+    return np.array([np.nan, np.nan, 1, 2, 3, np.nan, 4, 5, np.nan, 6])
 
-        arr = SparseArray([np.nan, 1, 2, np.nan], fill_value=0)
-        assert arr.dtype == SparseDtype(np.float64, 0)
-        assert arr.fill_value == 0
 
-        arr = SparseArray([0, 1, 2, 4], dtype=np.float64)
-        assert arr.dtype == SparseDtype(np.float64, np.nan)
-        assert np.isnan(arr.fill_value)
+@pytest.fixture
+def arr(arr_data):
+    """Fixture returning SparseArray from 'arr_data'"""
+    return SparseArray(arr_data)
 
-        arr = SparseArray([0, 1, 2, 4], dtype=np.int64)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-        arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=np.int64)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-        arr = SparseArray([0, 1, 2, 4], dtype=None)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-        arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=None)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-    def test_constructor_dtype_str(self):
-        result = SparseArray([1, 2, 3], dtype="int")
-        expected = SparseArray([1, 2, 3], dtype=int)
-        tm.assert_sp_array_equal(result, expected)
-
-    def test_constructor_sparse_dtype(self):
-        result = SparseArray([1, 0, 0, 1], dtype=SparseDtype("int64", -1))
-        expected = SparseArray([1, 0, 0, 1], fill_value=-1, dtype=np.int64)
-        tm.assert_sp_array_equal(result, expected)
-        assert result.sp_values.dtype == np.dtype("int64")
-
-    def test_constructor_sparse_dtype_str(self):
-        result = SparseArray([1, 0, 0, 1], dtype="Sparse[int32]")
-        expected = SparseArray([1, 0, 0, 1], dtype=np.int32)
-        tm.assert_sp_array_equal(result, expected)
-        assert result.sp_values.dtype == np.dtype("int32")
-
-    def test_constructor_object_dtype(self):
-        # GH 11856
-        arr = SparseArray(["A", "A", np.nan, "B"], dtype=object)
-        assert arr.dtype == SparseDtype(object)
-        assert np.isnan(arr.fill_value)
-
-        arr = SparseArray(["A", "A", np.nan, "B"], dtype=object, fill_value="A")
-        assert arr.dtype == SparseDtype(object, "A")
-        assert arr.fill_value == "A"
-
-        # GH 17574
-        data = [False, 0, 100.0, 0.0]
-        arr = SparseArray(data, dtype=object, fill_value=False)
-        assert arr.dtype == SparseDtype(object, False)
-        assert arr.fill_value is False
-        arr_expected = np.array(data, dtype=object)
-        it = (type(x) == type(y) and x == y for x, y in zip(arr, arr_expected))
-        assert np.fromiter(it, dtype=np.bool_).all()
-
-    @pytest.mark.parametrize("dtype", [SparseDtype(int, 0), int])
-    def test_constructor_na_dtype(self, dtype):
-        with pytest.raises(ValueError, match="Cannot convert"):
-            SparseArray([0, 1, np.nan], dtype=dtype)
-
-    def test_constructor_warns_when_losing_timezone(self):
-        # GH#32501 warn when losing timezone information
-        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
-
-        expected = SparseArray(np.asarray(dti, dtype="datetime64[ns]"))
-
-        with tm.assert_produces_warning(UserWarning):
-            result = SparseArray(dti)
-
-        tm.assert_sp_array_equal(result, expected)
-
-        with tm.assert_produces_warning(UserWarning):
-            result = SparseArray(pd.Series(dti))
-
-        tm.assert_sp_array_equal(result, expected)
-
-    def test_constructor_spindex_dtype(self):
-        arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]))
-        # XXX: Behavior change: specifying SparseIndex no longer changes the
-        # fill_value
-        expected = SparseArray([0, 1, 2, 0], kind="integer")
-        tm.assert_sp_array_equal(arr, expected)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        arr = SparseArray(
-            data=[1, 2, 3],
-            sparse_index=IntIndex(4, [1, 2, 3]),
-            dtype=np.int64,
-            fill_value=0,
-        )
-        exp = SparseArray([0, 1, 2, 3], dtype=np.int64, fill_value=0)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        arr = SparseArray(
-            data=[1, 2], sparse_index=IntIndex(4, [1, 2]), fill_value=0, dtype=np.int64
-        )
-        exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=np.int64)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        arr = SparseArray(
-            data=[1, 2, 3],
-            sparse_index=IntIndex(4, [1, 2, 3]),
-            dtype=None,
-            fill_value=0,
-        )
-        exp = SparseArray([0, 1, 2, 3], dtype=None)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-    @pytest.mark.parametrize("sparse_index", [None, IntIndex(1, [0])])
-    def test_constructor_spindex_dtype_scalar(self, sparse_index):
-        # scalar input
-        arr = SparseArray(data=1, sparse_index=sparse_index, dtype=None)
-        exp = SparseArray([1], dtype=None)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        arr = SparseArray(data=1, sparse_index=IntIndex(1, [0]), dtype=None)
-        exp = SparseArray([1], dtype=None)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-    def test_constructor_spindex_dtype_scalar_broadcasts(self):
-        arr = SparseArray(
-            data=[1, 2], sparse_index=IntIndex(4, [1, 2]), fill_value=0, dtype=None
-        )
-        exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=None)
-        tm.assert_sp_array_equal(arr, exp)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-    @pytest.mark.parametrize(
-        "data, fill_value",
-        [
-            (np.array([1, 2]), 0),
-            (np.array([1.0, 2.0]), np.nan),
-            ([True, False], False),
-            ([pd.Timestamp("2017-01-01")], pd.NaT),
-        ],
-    )
-    def test_constructor_inferred_fill_value(self, data, fill_value):
-        result = SparseArray(data).fill_value
-
-        if isna(fill_value):
-            assert isna(result)
-        else:
-            assert result == fill_value
 
-    @pytest.mark.parametrize("format", ["coo", "csc", "csr"])
-    @pytest.mark.parametrize("size", [0, 10])
-    @td.skip_if_no_scipy
-    def test_from_spmatrix(self, size, format):
-        import scipy.sparse
+@pytest.fixture
+def zarr():
+    """Fixture returning SparseArray with integer entries and 'fill_value=0'"""
+    return SparseArray([0, 0, 1, 2, 3, 0, 4, 5, 0, 6], fill_value=0)
 
-        mat = scipy.sparse.random(size, 1, density=0.5, format=format)
-        result = SparseArray.from_spmatrix(mat)
-
-        result = np.asarray(result)
-        expected = mat.toarray().ravel()
-        tm.assert_numpy_array_equal(result, expected)
-
-    @pytest.mark.parametrize("format", ["coo", "csc", "csr"])
-    @td.skip_if_no_scipy
-    def test_from_spmatrix_including_explicit_zero(self, format):
-        import scipy.sparse
-
-        mat = scipy.sparse.random(10, 1, density=0.5, format=format)
-        mat.data[0] = 0
-        result = SparseArray.from_spmatrix(mat)
-
-        result = np.asarray(result)
-        expected = mat.toarray().ravel()
-        tm.assert_numpy_array_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    def test_from_spmatrix_raises(self):
-        import scipy.sparse
-
-        mat = scipy.sparse.eye(5, 4, format="csc")
-
-        with pytest.raises(ValueError, match="not '4'"):
-            SparseArray.from_spmatrix(mat)
-
-    @pytest.mark.parametrize(
-        "scalar,dtype",
-        [
-            (False, SparseDtype(bool, False)),
-            (0.0, SparseDtype("float64", 0)),
-            (1, SparseDtype("int64", 1)),
-            ("z", SparseDtype("object", "z")),
-        ],
-    )
-    def test_scalar_with_index_infer_dtype(self, scalar, dtype):
-        # GH 19163
-        with tm.assert_produces_warning(
-            FutureWarning, match="The index argument has been deprecated"
-        ):
-            arr = SparseArray(scalar, index=[1, 2, 3], fill_value=scalar)
-        exp = SparseArray([scalar, scalar, scalar], fill_value=scalar)
-
-        tm.assert_sp_array_equal(arr, exp)
-
-        assert arr.dtype == dtype
-        assert exp.dtype == dtype
-
-    # GH 23122
-    def test_getitem_bool_sparse_array(self):
-        spar_bool = SparseArray([False, True] * 5, dtype=np.bool8, fill_value=True)
-        exp = SparseArray([np.nan, 2, np.nan, 5, 6])
-        tm.assert_sp_array_equal(self.arr[spar_bool], exp)
-
-        spar_bool = ~spar_bool
-        res = self.arr[spar_bool]
-        exp = SparseArray([np.nan, 1, 3, 4, np.nan])
-        tm.assert_sp_array_equal(res, exp)
-
-        spar_bool = SparseArray(
-            [False, True, np.nan] * 3, dtype=np.bool8, fill_value=np.nan
-        )
-        res = self.arr[spar_bool]
-        exp = SparseArray([np.nan, 3, 5])
-        tm.assert_sp_array_equal(res, exp)
-
-    def test_get_item(self):
-
-        assert np.isnan(self.arr[1])
-        assert self.arr[2] == 1
-        assert self.arr[7] == 5
-
-        assert self.zarr[0] == 0
-        assert self.zarr[2] == 1
-        assert self.zarr[7] == 5
-
-        errmsg = "must be an integer between -10 and 10"
-
-        with pytest.raises(IndexError, match=errmsg):
-            self.arr[11]
-
-        with pytest.raises(IndexError, match=errmsg):
-            self.arr[-11]
-
-        assert self.arr[-1] == self.arr[len(self.arr) - 1]
-
-    def test_take_scalar_raises(self):
-        msg = "'indices' must be an array, not a scalar '2'."
-        with pytest.raises(ValueError, match=msg):
-            self.arr.take(2)
-
-    def test_take(self):
-        exp = SparseArray(np.take(self.arr_data, [2, 3]))
-        tm.assert_sp_array_equal(self.arr.take([2, 3]), exp)
-
-        exp = SparseArray(np.take(self.arr_data, [0, 1, 2]))
-        tm.assert_sp_array_equal(self.arr.take([0, 1, 2]), exp)
-
-    def test_take_all_empty(self):
-        a = pd.array([0, 0], dtype=SparseDtype("int64"))
-        result = a.take([0, 1], allow_fill=True, fill_value=np.nan)
-        tm.assert_sp_array_equal(a, result)
-
-    def test_take_fill_value(self):
-        data = np.array([1, np.nan, 0, 3, 0])
-        sparse = SparseArray(data, fill_value=0)
-
-        exp = SparseArray(np.take(data, [0]), fill_value=0)
-        tm.assert_sp_array_equal(sparse.take([0]), exp)
-
-        exp = SparseArray(np.take(data, [1, 3, 4]), fill_value=0)
-        tm.assert_sp_array_equal(sparse.take([1, 3, 4]), exp)
-
-    def test_take_negative(self):
-        exp = SparseArray(np.take(self.arr_data, [-1]))
-        tm.assert_sp_array_equal(self.arr.take([-1]), exp)
-
-        exp = SparseArray(np.take(self.arr_data, [-4, -3, -2]))
-        tm.assert_sp_array_equal(self.arr.take([-4, -3, -2]), exp)
 
+class TestSparseArray:
     @pytest.mark.parametrize("fill_value", [0, None, np.nan])
     def test_shift_fill_value(self, fill_value):
         # GH #24128
@@ -330,274 +45,6 @@ def test_shift_fill_value(self, fill_value):
         exp = SparseArray(np.array([fill_value, 1, 0, 0, 3]), fill_value=8.0)
         tm.assert_sp_array_equal(res, exp)
 
-    def test_bad_take(self):
-        with pytest.raises(IndexError, match="bounds"):
-            self.arr.take([11])
-
-    def test_take_filling(self):
-        # similar tests as GH 12631
-        sparse = SparseArray([np.nan, np.nan, 1, np.nan, 4])
-        result = sparse.take(np.array([1, 0, -1]))
-        expected = SparseArray([np.nan, np.nan, 4])
-        tm.assert_sp_array_equal(result, expected)
-
-        # XXX: test change: fill_value=True -> allow_fill=True
-        result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
-        expected = SparseArray([np.nan, np.nan, np.nan])
-        tm.assert_sp_array_equal(result, expected)
-
-        # allow_fill=False
-        result = sparse.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = SparseArray([np.nan, np.nan, 4])
-        tm.assert_sp_array_equal(result, expected)
-
-        msg = "Invalid value in 'indices'"
-        with pytest.raises(ValueError, match=msg):
-            sparse.take(np.array([1, 0, -2]), allow_fill=True)
-
-        with pytest.raises(ValueError, match=msg):
-            sparse.take(np.array([1, 0, -5]), allow_fill=True)
-
-        msg = "out of bounds value in 'indices'"
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]), allow_fill=True)
-
-    def test_take_filling_fill_value(self):
-        # same tests as GH 12631
-        sparse = SparseArray([np.nan, 0, 1, 0, 4], fill_value=0)
-        result = sparse.take(np.array([1, 0, -1]))
-        expected = SparseArray([0, np.nan, 4], fill_value=0)
-        tm.assert_sp_array_equal(result, expected)
-
-        # fill_value
-        result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
-        # XXX: behavior change.
-        # the old way of filling self.fill_value doesn't follow EA rules.
-        # It's supposed to be self.dtype.na_value (nan in this case)
-        expected = SparseArray([0, np.nan, np.nan], fill_value=0)
-        tm.assert_sp_array_equal(result, expected)
-
-        # allow_fill=False
-        result = sparse.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = SparseArray([0, np.nan, 4], fill_value=0)
-        tm.assert_sp_array_equal(result, expected)
-
-        msg = "Invalid value in 'indices'."
-        with pytest.raises(ValueError, match=msg):
-            sparse.take(np.array([1, 0, -2]), allow_fill=True)
-        with pytest.raises(ValueError, match=msg):
-            sparse.take(np.array([1, 0, -5]), allow_fill=True)
-
-        msg = "out of bounds value in 'indices'"
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]), fill_value=True)
-
-    @pytest.mark.parametrize("kind", ["block", "integer"])
-    def test_take_filling_all_nan(self, kind):
-        sparse = SparseArray([np.nan, np.nan, np.nan, np.nan, np.nan], kind=kind)
-        result = sparse.take(np.array([1, 0, -1]))
-        expected = SparseArray([np.nan, np.nan, np.nan], kind=kind)
-        tm.assert_sp_array_equal(result, expected)
-
-        result = sparse.take(np.array([1, 0, -1]), fill_value=True)
-        expected = SparseArray([np.nan, np.nan, np.nan], kind=kind)
-        tm.assert_sp_array_equal(result, expected)
-
-        msg = "out of bounds value in 'indices'"
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError, match=msg):
-            sparse.take(np.array([1, 5]), fill_value=True)
-
-    def test_set_item(self):
-        def setitem():
-            self.arr[5] = 3
-
-        def setslice():
-            self.arr[1:5] = 2
-
-        with pytest.raises(TypeError, match="assignment via setitem"):
-            setitem()
-
-        with pytest.raises(TypeError, match="assignment via setitem"):
-            setslice()
-
-    def test_constructor_from_too_large_array(self):
-        with pytest.raises(TypeError, match="expected dimension <= 1 data"):
-            SparseArray(np.arange(10).reshape((2, 5)))
-
-    def test_constructor_from_sparse(self):
-        res = SparseArray(self.zarr)
-        assert res.fill_value == 0
-        tm.assert_almost_equal(res.sp_values, self.zarr.sp_values)
-
-    def test_constructor_copy(self):
-        cp = SparseArray(self.arr, copy=True)
-        cp.sp_values[:3] = 0
-        assert not (self.arr.sp_values[:3] == 0).any()
-
-        not_copy = SparseArray(self.arr)
-        not_copy.sp_values[:3] = 0
-        assert (self.arr.sp_values[:3] == 0).all()
-
-    def test_constructor_bool(self):
-        # GH 10648
-        data = np.array([False, False, True, True, False, False])
-        arr = SparseArray(data, fill_value=False, dtype=bool)
-
-        assert arr.dtype == SparseDtype(bool)
-        tm.assert_numpy_array_equal(arr.sp_values, np.array([True, True]))
-        # Behavior change: np.asarray densifies.
-        # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
-        tm.assert_numpy_array_equal(arr.sp_index.indices, np.array([2, 3], np.int32))
-
-        dense = arr.to_dense()
-        assert dense.dtype == bool
-        tm.assert_numpy_array_equal(dense, data)
-
-    def test_constructor_bool_fill_value(self):
-        arr = SparseArray([True, False, True], dtype=None)
-        assert arr.dtype == SparseDtype(np.bool_)
-        assert not arr.fill_value
-
-        arr = SparseArray([True, False, True], dtype=np.bool_)
-        assert arr.dtype == SparseDtype(np.bool_)
-        assert not arr.fill_value
-
-        arr = SparseArray([True, False, True], dtype=np.bool_, fill_value=True)
-        assert arr.dtype == SparseDtype(np.bool_, True)
-        assert arr.fill_value
-
-    def test_constructor_float32(self):
-        # GH 10648
-        data = np.array([1.0, np.nan, 3], dtype=np.float32)
-        arr = SparseArray(data, dtype=np.float32)
-
-        assert arr.dtype == SparseDtype(np.float32)
-        tm.assert_numpy_array_equal(arr.sp_values, np.array([1, 3], dtype=np.float32))
-        # Behavior change: np.asarray densifies.
-        # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
-        tm.assert_numpy_array_equal(
-            arr.sp_index.indices, np.array([0, 2], dtype=np.int32)
-        )
-
-        dense = arr.to_dense()
-        assert dense.dtype == np.float32
-        tm.assert_numpy_array_equal(dense, data)
-
-    def test_astype(self):
-        # float -> float
-        arr = SparseArray([None, None, 0, 2])
-        result = arr.astype("Sparse[float32]")
-        expected = SparseArray([None, None, 0, 2], dtype=np.dtype("float32"))
-        tm.assert_sp_array_equal(result, expected)
-
-        dtype = SparseDtype("float64", fill_value=0)
-        result = arr.astype(dtype)
-        expected = SparseArray._simple_new(
-            np.array([0.0, 2.0], dtype=dtype.subtype), IntIndex(4, [2, 3]), dtype
-        )
-        tm.assert_sp_array_equal(result, expected)
-
-        dtype = SparseDtype("int64", 0)
-        result = arr.astype(dtype)
-        expected = SparseArray._simple_new(
-            np.array([0, 2], dtype=np.int64), IntIndex(4, [2, 3]), dtype
-        )
-        tm.assert_sp_array_equal(result, expected)
-
-        arr = SparseArray([0, np.nan, 0, 1], fill_value=0)
-        with pytest.raises(ValueError, match="NA"):
-            arr.astype("Sparse[i8]")
-
-    def test_astype_bool(self):
-        a = SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
-        result = a.astype(bool)
-        expected = SparseArray(
-            [True, False, False, True], dtype=SparseDtype(bool, False)
-        )
-        tm.assert_sp_array_equal(result, expected)
-
-        # update fill value
-        result = a.astype(SparseDtype(bool, False))
-        expected = SparseArray(
-            [True, False, False, True], dtype=SparseDtype(bool, False)
-        )
-        tm.assert_sp_array_equal(result, expected)
-
-    def test_astype_all(self, any_real_numpy_dtype):
-        vals = np.array([1, 2, 3])
-        arr = SparseArray(vals, fill_value=1)
-        typ = np.dtype(any_real_numpy_dtype)
-        res = arr.astype(typ)
-        assert res.dtype == SparseDtype(typ, 1)
-        assert res.sp_values.dtype == typ
-
-        tm.assert_numpy_array_equal(np.asarray(res.to_dense()), vals.astype(typ))
-
-    @pytest.mark.parametrize(
-        "arr, dtype, expected",
-        [
-            (
-                SparseArray([0, 1]),
-                "float",
-                SparseArray([0.0, 1.0], dtype=SparseDtype(float, 0.0)),
-            ),
-            (SparseArray([0, 1]), bool, SparseArray([False, True])),
-            (
-                SparseArray([0, 1], fill_value=1),
-                bool,
-                SparseArray([False, True], dtype=SparseDtype(bool, True)),
-            ),
-            pytest.param(
-                SparseArray([0, 1]),
-                "datetime64[ns]",
-                SparseArray(
-                    np.array([0, 1], dtype="datetime64[ns]"),
-                    dtype=SparseDtype("datetime64[ns]", pd.Timestamp("1970")),
-                ),
-                marks=[pytest.mark.xfail(reason="NumPy-7619")],
-            ),
-            (
-                SparseArray([0, 1, 10]),
-                str,
-                SparseArray(["0", "1", "10"], dtype=SparseDtype(str, "0")),
-            ),
-            (SparseArray(["10", "20"]), float, SparseArray([10.0, 20.0])),
-            (
-                SparseArray([0, 1, 0]),
-                object,
-                SparseArray([0, 1, 0], dtype=SparseDtype(object, 0)),
-            ),
-        ],
-    )
-    def test_astype_more(self, arr, dtype, expected):
-        result = arr.astype(dtype)
-        tm.assert_sp_array_equal(result, expected)
-
-    def test_astype_nan_raises(self):
-        arr = SparseArray([1.0, np.nan])
-        with pytest.raises(ValueError, match="Cannot convert non-finite"):
-            arr.astype(int)
-
-    def test_astype_copy_false(self):
-        # GH#34456 bug caused by using .view instead of .astype in astype_nansafe
-        arr = SparseArray([1, 2, 3])
-
-        result = arr.astype(float, copy=False)
-        expected = SparseArray([1.0, 2.0, 3.0], fill_value=0.0)
-        tm.assert_sp_array_equal(result, expected)
-
     def test_set_fill_value(self):
         arr = SparseArray([1.0, np.nan, 2.0], fill_value=np.nan)
         arr.fill_value = 2
@@ -607,7 +54,7 @@ def test_set_fill_value(self):
         arr.fill_value = 2
         assert arr.fill_value == 2
 
-        # XXX: this seems fine? You can construct an integer
+        # TODO: this seems fine? You can construct an integer
         # sparsearray with NaN fill value, why not update one?
         # coerces to int
         # msg = "unable to set fill_value 3\\.1 to int64 dtype"
@@ -624,8 +71,9 @@ def test_set_fill_value(self):
         arr.fill_value = True
         assert arr.fill_value
 
+        # FIXME: don't leave commented-out
         # coerces to bool
-        # XXX: we can construct an sparse array of bool
+        # TODO: we can construct an sparse array of bool
         #      type and use as fill_value any value
         # msg = "fill_value must be True, False or nan"
         # with pytest.raises(ValueError, match=msg):
@@ -644,13 +92,13 @@ def test_set_fill_invalid_non_scalar(self, val):
         with pytest.raises(ValueError, match=msg):
             arr.fill_value = val
 
-    def test_copy(self):
-        arr2 = self.arr.copy()
-        assert arr2.sp_values is not self.arr.sp_values
-        assert arr2.sp_index is self.arr.sp_index
+    def test_copy(self, arr):
+        arr2 = arr.copy()
+        assert arr2.sp_values is not arr.sp_values
+        assert arr2.sp_index is arr.sp_index
 
-    def test_values_asarray(self):
-        tm.assert_almost_equal(self.arr.to_dense(), self.arr_data)
+    def test_values_asarray(self, arr_data, arr):
+        tm.assert_almost_equal(arr.to_dense(), arr_data)
 
     @pytest.mark.parametrize(
         "data,shape,dtype",
@@ -682,174 +130,11 @@ def test_dense_repr(self, vals, fill_value):
         res = arr.to_dense()
         tm.assert_numpy_array_equal(res, vals)
 
-        res2 = arr._internal_get_values()
-
-        tm.assert_numpy_array_equal(res2, vals)
-
-    def test_getitem(self):
-        def _checkit(i):
-            tm.assert_almost_equal(self.arr[i], self.arr.to_dense()[i])
-
-        for i in range(len(self.arr)):
-            _checkit(i)
-            _checkit(-i)
-
-    def test_getitem_arraylike_mask(self):
-        arr = SparseArray([0, 1, 2])
-        result = arr[[True, False, True]]
-        expected = SparseArray([0, 2])
-        tm.assert_sp_array_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "slc",
-        [
-            np.s_[:],
-            np.s_[1:10],
-            np.s_[1:100],
-            np.s_[10:1],
-            np.s_[:-3],
-            np.s_[-5:-4],
-            np.s_[:-12],
-            np.s_[-12:],
-            np.s_[2:],
-            np.s_[2::3],
-            np.s_[::2],
-            np.s_[::-1],
-            np.s_[::-2],
-            np.s_[1:6:2],
-            np.s_[:-6:-2],
-        ],
-    )
-    @pytest.mark.parametrize(
-        "as_dense", [[np.nan] * 10, [1] * 10, [np.nan] * 5 + [1] * 5, []]
-    )
-    def test_getslice(self, slc, as_dense):
-        as_dense = np.array(as_dense)
-        arr = SparseArray(as_dense)
-
-        result = arr[slc]
-        expected = SparseArray(as_dense[slc])
-
-        tm.assert_sp_array_equal(result, expected)
-
-    def test_getslice_tuple(self):
-        dense = np.array([np.nan, 0, 3, 4, 0, 5, np.nan, np.nan, 0])
-
-        sparse = SparseArray(dense)
-        res = sparse[(slice(4, None),)]
-        exp = SparseArray(dense[4:])
-        tm.assert_sp_array_equal(res, exp)
-
-        sparse = SparseArray(dense, fill_value=0)
-        res = sparse[(slice(4, None),)]
-        exp = SparseArray(dense[4:], fill_value=0)
-        tm.assert_sp_array_equal(res, exp)
-
-        msg = "too many indices for array"
-        with pytest.raises(IndexError, match=msg):
-            sparse[4:, :]
-
-        with pytest.raises(IndexError, match=msg):
-            # check numpy compat
-            dense[4:, :]
-
-    def test_boolean_slice_empty(self):
-        arr = SparseArray([0, 1, 2])
-        res = arr[[False, False, False]]
-        assert res.dtype == arr.dtype
-
-    def test_neg_operator(self):
-        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
-        res = -arr
-        exp = SparseArray([1, 2, np.nan, -3], fill_value=np.nan, dtype=np.int8)
-        tm.assert_sp_array_equal(exp, res)
-
-        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
-        res = -arr
-        exp = SparseArray([1, 2, -1, -3], fill_value=1, dtype=np.int8)
-        tm.assert_sp_array_equal(exp, res)
-
-    def test_abs_operator(self):
-        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
-        res = abs(arr)
-        exp = SparseArray([1, 2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
-        tm.assert_sp_array_equal(exp, res)
-
-        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
-        res = abs(arr)
-        exp = SparseArray([1, 2, 1, 3], fill_value=1, dtype=np.int8)
-        tm.assert_sp_array_equal(exp, res)
-
-    def test_invert_operator(self):
-        arr = SparseArray([False, True, False, True], fill_value=False, dtype=np.bool8)
-        res = ~arr
-        exp = SparseArray(
-            np.invert([False, True, False, True]), fill_value=True, dtype=np.bool8
-        )
-        res = ~arr
-        tm.assert_sp_array_equal(exp, res)
-
-        arr = SparseArray([0, 1, 0, 2, 3, 0], fill_value=0, dtype=np.int32)
-        res = ~arr
-        exp = SparseArray([-1, -2, -1, -3, -4, -1], fill_value=-1, dtype=np.int32)
-
-    @pytest.mark.parametrize("op", ["add", "sub", "mul", "truediv", "floordiv", "pow"])
-    def test_binary_operators(self, op):
-        op = getattr(operator, op)
-        data1 = np.random.randn(20)
-        data2 = np.random.randn(20)
-
-        data1[::2] = np.nan
-        data2[::3] = np.nan
-
-        arr1 = SparseArray(data1)
-        arr2 = SparseArray(data2)
-
-        data1[::2] = 3
-        data2[::3] = 3
-        farr1 = SparseArray(data1, fill_value=3)
-        farr2 = SparseArray(data2, fill_value=3)
-
-        def _check_op(op, first, second):
-            res = op(first, second)
-            exp = SparseArray(
-                op(first.to_dense(), second.to_dense()), fill_value=first.fill_value
-            )
-            assert isinstance(res, SparseArray)
-            tm.assert_almost_equal(res.to_dense(), exp.to_dense())
-
-            res2 = op(first, second.to_dense())
-            assert isinstance(res2, SparseArray)
-            tm.assert_sp_array_equal(res, res2)
-
-            res3 = op(first.to_dense(), second)
-            assert isinstance(res3, SparseArray)
-            tm.assert_sp_array_equal(res, res3)
-
-            res4 = op(first, 4)
-            assert isinstance(res4, SparseArray)
-
-            # Ignore this if the actual op raises (e.g. pow).
-            try:
-                exp = op(first.to_dense(), 4)
-                exp_fv = op(first.fill_value, 4)
-            except ValueError:
-                pass
-            else:
-                tm.assert_almost_equal(res4.fill_value, exp_fv)
-                tm.assert_almost_equal(res4.to_dense(), exp)
-
-        with np.errstate(all="ignore"):
-            for first_arr, second_arr in [(arr1, arr2), (farr1, farr2)]:
-                _check_op(op, first_arr, second_arr)
-
-    def test_pickle(self):
-        def _check_roundtrip(obj):
-            unpickled = tm.round_trip_pickle(obj)
-            tm.assert_sp_array_equal(unpickled, obj)
-
-        _check_roundtrip(self.arr)
-        _check_roundtrip(self.zarr)
+    @pytest.mark.parametrize("fix", ["arr", "zarr"])
+    def test_pickle(self, fix, request):
+        obj = request.getfixturevalue(fix)
+        unpickled = tm.round_trip_pickle(obj)
+        tm.assert_sp_array_equal(unpickled, obj)
 
     def test_generator_warnings(self):
         sp_arr = SparseArray([1, 2, 3])
@@ -860,6 +145,20 @@ def test_generator_warnings(self):
                 pass
             assert len(w) == 0
 
+    def test_where_retain_fill_value(self):
+        # GH#45691 don't lose fill_value on _where
+        arr = SparseArray([np.nan, 1.0], fill_value=0)
+
+        mask = np.array([True, False])
+
+        res = arr._where(~mask, 1)
+        exp = SparseArray([1, 1.0], fill_value=0)
+        tm.assert_sp_array_equal(res, exp)
+
+        ser = pd.Series(arr)
+        res = ser.where(~mask, 1)
+        tm.assert_series_equal(res, pd.Series(exp))
+
     def test_fillna(self):
         s = SparseArray([1, np.nan, np.nan, 3, np.nan])
         res = s.fillna(-1)
@@ -946,163 +245,6 @@ def test_nonzero(self):
 
 
 class TestSparseArrayAnalytics:
-    @pytest.mark.parametrize(
-        "data,pos,neg",
-        [
-            ([True, True, True], True, False),
-            ([1, 2, 1], 1, 0),
-            ([1.0, 2.0, 1.0], 1.0, 0.0),
-        ],
-    )
-    def test_all(self, data, pos, neg):
-        # GH 17570
-        out = SparseArray(data).all()
-        assert out
-
-        out = SparseArray(data, fill_value=pos).all()
-        assert out
-
-        data[1] = neg
-        out = SparseArray(data).all()
-        assert not out
-
-        out = SparseArray(data, fill_value=pos).all()
-        assert not out
-
-    @pytest.mark.parametrize(
-        "data,pos,neg",
-        [
-            ([True, True, True], True, False),
-            ([1, 2, 1], 1, 0),
-            ([1.0, 2.0, 1.0], 1.0, 0.0),
-        ],
-    )
-    def test_numpy_all(self, data, pos, neg):
-        # GH 17570
-        out = np.all(SparseArray(data))
-        assert out
-
-        out = np.all(SparseArray(data, fill_value=pos))
-        assert out
-
-        data[1] = neg
-        out = np.all(SparseArray(data))
-        assert not out
-
-        out = np.all(SparseArray(data, fill_value=pos))
-        assert not out
-
-        # raises with a different message on py2.
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.all(SparseArray(data), out=np.array([]))
-
-    @pytest.mark.parametrize(
-        "data,pos,neg",
-        [
-            ([False, True, False], True, False),
-            ([0, 2, 0], 2, 0),
-            ([0.0, 2.0, 0.0], 2.0, 0.0),
-        ],
-    )
-    def test_any(self, data, pos, neg):
-        # GH 17570
-        out = SparseArray(data).any()
-        assert out
-
-        out = SparseArray(data, fill_value=pos).any()
-        assert out
-
-        data[1] = neg
-        out = SparseArray(data).any()
-        assert not out
-
-        out = SparseArray(data, fill_value=pos).any()
-        assert not out
-
-    @pytest.mark.parametrize(
-        "data,pos,neg",
-        [
-            ([False, True, False], True, False),
-            ([0, 2, 0], 2, 0),
-            ([0.0, 2.0, 0.0], 2.0, 0.0),
-        ],
-    )
-    def test_numpy_any(self, data, pos, neg):
-        # GH 17570
-        out = np.any(SparseArray(data))
-        assert out
-
-        out = np.any(SparseArray(data, fill_value=pos))
-        assert out
-
-        data[1] = neg
-        out = np.any(SparseArray(data))
-        assert not out
-
-        out = np.any(SparseArray(data, fill_value=pos))
-        assert not out
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.any(SparseArray(data), out=out)
-
-    def test_sum(self):
-        data = np.arange(10).astype(float)
-        out = SparseArray(data).sum()
-        assert out == 45.0
-
-        data[5] = np.nan
-        out = SparseArray(data, fill_value=2).sum()
-        assert out == 40.0
-
-        out = SparseArray(data, fill_value=np.nan).sum()
-        assert out == 40.0
-
-    @pytest.mark.parametrize(
-        "arr",
-        [np.array([0, 1, np.nan, 1]), np.array([0, 1, 1])],
-    )
-    @pytest.mark.parametrize("fill_value", [0, 1, np.nan])
-    @pytest.mark.parametrize("min_count, expected", [(3, 2), (4, np.nan)])
-    def test_sum_min_count(self, arr, fill_value, min_count, expected):
-        # https://github.com/pandas-dev/pandas/issues/25777
-        sparray = SparseArray(arr, fill_value=fill_value)
-        result = sparray.sum(min_count=min_count)
-        if np.isnan(expected):
-            assert np.isnan(result)
-        else:
-            assert result == expected
-
-    def test_bool_sum_min_count(self):
-        spar_bool = pd.arrays.SparseArray(
-            [False, True] * 5, dtype=np.bool8, fill_value=True
-        )
-        res = spar_bool.sum(min_count=1)
-        assert res == 5
-        res = spar_bool.sum(min_count=11)
-        assert isna(res)
-
-    def test_numpy_sum(self):
-        data = np.arange(10).astype(float)
-        out = np.sum(SparseArray(data))
-        assert out == 45.0
-
-        data[5] = np.nan
-        out = np.sum(SparseArray(data, fill_value=2))
-        assert out == 40.0
-
-        out = np.sum(SparseArray(data, fill_value=np.nan))
-        assert out == 40.0
-
-        msg = "the 'dtype' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.sum(SparseArray(data), dtype=np.int64)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.sum(SparseArray(data), out=out)
-
     @pytest.mark.parametrize(
         "data,expected",
         [
@@ -1143,32 +285,6 @@ def test_cumsum(self, data, expected, numpy):
             with pytest.raises(ValueError, match=msg):
                 SparseArray(data).cumsum(axis=axis)
 
-    def test_mean(self):
-        data = np.arange(10).astype(float)
-        out = SparseArray(data).mean()
-        assert out == 4.5
-
-        data[5] = np.nan
-        out = SparseArray(data).mean()
-        assert out == 40.0 / 9
-
-    def test_numpy_mean(self):
-        data = np.arange(10).astype(float)
-        out = np.mean(SparseArray(data))
-        assert out == 4.5
-
-        data[5] = np.nan
-        out = np.mean(SparseArray(data))
-        assert out == 40.0 / 9
-
-        msg = "the 'dtype' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.mean(SparseArray(data), dtype=np.int64)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.mean(SparseArray(data), out=out)
-
     def test_ufunc(self):
         # GH 13853 make sure ufunc is applied to fill_value
         sparse = SparseArray([1, np.nan, 2, np.nan, -2])
@@ -1247,86 +363,6 @@ def test_npoints(self):
         assert arr.npoints == 1
 
 
-class TestAccessor:
-    @pytest.mark.parametrize("attr", ["npoints", "density", "fill_value", "sp_values"])
-    def test_get_attributes(self, attr):
-        arr = SparseArray([0, 1])
-        ser = pd.Series(arr)
-
-        result = getattr(ser.sparse, attr)
-        expected = getattr(arr, attr)
-        assert result == expected
-
-    @td.skip_if_no_scipy
-    def test_from_coo(self):
-        import scipy.sparse
-
-        row = [0, 3, 1, 0]
-        col = [0, 3, 1, 2]
-        data = [4, 5, 7, 9]
-        # TODO(scipy#13585): Remove dtype when scipy is fixed
-        # https://github.com/scipy/scipy/issues/13585
-        sp_array = scipy.sparse.coo_matrix((data, (row, col)), dtype="int")
-        result = pd.Series.sparse.from_coo(sp_array)
-
-        index = pd.MultiIndex.from_arrays([[0, 0, 1, 3], [0, 2, 1, 3]])
-        expected = pd.Series([4, 9, 7, 5], index=index, dtype="Sparse[int]")
-        tm.assert_series_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize(
-        "sort_labels, expected_rows, expected_cols, expected_values_pos",
-        [
-            (
-                False,
-                [("b", 2), ("a", 2), ("b", 1), ("a", 1)],
-                [("z", 1), ("z", 2), ("x", 2), ("z", 0)],
-                {1: (1, 0), 3: (3, 3)},
-            ),
-            (
-                True,
-                [("a", 1), ("a", 2), ("b", 1), ("b", 2)],
-                [("x", 2), ("z", 0), ("z", 1), ("z", 2)],
-                {1: (1, 2), 3: (0, 1)},
-            ),
-        ],
-    )
-    def test_to_coo(
-        self, sort_labels, expected_rows, expected_cols, expected_values_pos
-    ):
-        import scipy.sparse
-
-        values = SparseArray([0, np.nan, 1, 0, None, 3], fill_value=0)
-        index = pd.MultiIndex.from_tuples(
-            [
-                ("b", 2, "z", 1),
-                ("a", 2, "z", 2),
-                ("a", 2, "z", 1),
-                ("a", 2, "x", 2),
-                ("b", 1, "z", 1),
-                ("a", 1, "z", 0),
-            ]
-        )
-        ss = pd.Series(values, index=index)
-
-        expected_A = np.zeros((4, 4))
-        for value, (row, col) in expected_values_pos.items():
-            expected_A[row, col] = value
-
-        A, rows, cols = ss.sparse.to_coo(
-            row_levels=(0, 1), column_levels=(2, 3), sort_labels=sort_labels
-        )
-        assert isinstance(A, scipy.sparse.coo_matrix)
-        tm.assert_numpy_array_equal(A.toarray(), expected_A)
-        assert rows == expected_rows
-        assert cols == expected_cols
-
-    def test_non_sparse_raises(self):
-        ser = pd.Series([1, 2, 3])
-        with pytest.raises(AttributeError, match=".sparse"):
-            ser.sparse.density
-
-
 def test_setting_fill_value_fillna_still_works():
     # This is why letting users update fill_value / dtype is bad
     # astype has the same problem.
@@ -1355,23 +391,36 @@ def test_setting_fill_value_updates():
 
 
 @pytest.mark.parametrize(
-    "arr, loc",
+    "arr,fill_value,loc",
     [
-        ([None, 1, 2], 0),
-        ([0, None, 2], 1),
-        ([0, 1, None], 2),
-        ([0, 1, 1, None, None], 3),
-        ([1, 1, 1, 2], -1),
-        ([], -1),
+        ([None, 1, 2], None, 0),
+        ([0, None, 2], None, 1),
+        ([0, 1, None], None, 2),
+        ([0, 1, 1, None, None], None, 3),
+        ([1, 1, 1, 2], None, -1),
+        ([], None, -1),
+        ([None, 1, 0, 0, None, 2], None, 0),
+        ([None, 1, 0, 0, None, 2], 1, 1),
+        ([None, 1, 0, 0, None, 2], 2, 5),
+        ([None, 1, 0, 0, None, 2], 3, -1),
+        ([None, 0, 0, 1, 2, 1], 0, 1),
+        ([None, 0, 0, 1, 2, 1], 1, 3),
     ],
 )
-def test_first_fill_value_loc(arr, loc):
-    result = SparseArray(arr)._first_fill_value_loc()
+def test_first_fill_value_loc(arr, fill_value, loc):
+    result = SparseArray(arr, fill_value=fill_value)._first_fill_value_loc()
     assert result == loc
 
 
 @pytest.mark.parametrize(
-    "arr", [[1, 2, np.nan, np.nan], [1, np.nan, 2, np.nan], [1, 2, np.nan]]
+    "arr",
+    [
+        [1, 2, np.nan, np.nan],
+        [1, np.nan, 2, np.nan],
+        [1, 2, np.nan],
+        [np.nan, 1, 0, 0, np.nan, 2],
+        [np.nan, 0, 0, 1, 2, 1],
+    ],
 )
 @pytest.mark.parametrize("fill_value", [np.nan, 0, 1])
 def test_unique_na_fill(arr, fill_value):
@@ -1434,78 +483,3 @@ def test_drop_duplicates_fill_value():
     result = df.drop_duplicates()
     expected = pd.DataFrame({i: SparseArray([0.0], fill_value=0) for i in range(5)})
     tm.assert_frame_equal(result, expected)
-
-
-class TestMinMax:
-    @pytest.mark.parametrize(
-        "raw_data,max_expected,min_expected",
-        [
-            (np.arange(5.0), [4], [0]),
-            (-np.arange(5.0), [0], [-4]),
-            (np.array([0, 1, 2, np.nan, 4]), [4], [0]),
-            (np.array([np.nan] * 5), [np.nan], [np.nan]),
-            (np.array([]), [np.nan], [np.nan]),
-        ],
-    )
-    def test_nan_fill_value(self, raw_data, max_expected, min_expected):
-        arr = SparseArray(raw_data)
-        max_result = arr.max()
-        min_result = arr.min()
-        assert max_result in max_expected
-        assert min_result in min_expected
-
-        max_result = arr.max(skipna=False)
-        min_result = arr.min(skipna=False)
-        if np.isnan(raw_data).any():
-            assert np.isnan(max_result)
-            assert np.isnan(min_result)
-        else:
-            assert max_result in max_expected
-            assert min_result in min_expected
-
-    @pytest.mark.parametrize(
-        "fill_value,max_expected,min_expected",
-        [
-            (100, 100, 0),
-            (-100, 1, -100),
-        ],
-    )
-    def test_fill_value(self, fill_value, max_expected, min_expected):
-        arr = SparseArray(
-            np.array([fill_value, 0, 1]), dtype=SparseDtype("int", fill_value)
-        )
-        max_result = arr.max()
-        assert max_result == max_expected
-
-        min_result = arr.min()
-        assert min_result == min_expected
-
-    def test_only_fill_value(self):
-        fv = 100
-        arr = SparseArray(np.array([fv, fv, fv]), dtype=SparseDtype("int", fv))
-        assert len(arr._valid_sp_values) == 0
-
-        assert arr.max() == fv
-        assert arr.min() == fv
-        assert arr.max(skipna=False) == fv
-        assert arr.min(skipna=False) == fv
-
-    @pytest.mark.parametrize("func", ["min", "max"])
-    @pytest.mark.parametrize("data", [np.array([]), np.array([np.nan, np.nan])])
-    @pytest.mark.parametrize(
-        "dtype,expected",
-        [
-            (SparseDtype(np.float64, np.nan), np.nan),
-            (SparseDtype(np.float64, 5.0), np.nan),
-            (SparseDtype("datetime64[ns]", pd.NaT), pd.NaT),
-            (SparseDtype("datetime64[ns]", pd.to_datetime("2018-05-05")), pd.NaT),
-        ],
-    )
-    def test_na_value_if_no_valid_values(self, func, data, dtype, expected):
-        arr = SparseArray(data, dtype=dtype)
-        result = getattr(arr, func)()
-        if expected is pd.NaT:
-            # TODO: pin down whether we wrap datetime64("NaT")
-            assert result is pd.NaT or np.isnat(result)
-        else:
-            assert np.isnan(result)
diff --git a/pandas/tests/arrays/sparse/test_astype.py b/pandas/tests/arrays/sparse/test_astype.py
new file mode 100644
index 0000000000000..6761040d444a5
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_astype.py
@@ -0,0 +1,128 @@
+import numpy as np
+import pytest
+
+from pandas._libs.sparse import IntIndex
+
+from pandas import Timestamp
+import pandas._testing as tm
+from pandas.core.arrays.sparse import (
+    SparseArray,
+    SparseDtype,
+)
+
+
+class TestAstype:
+    def test_astype(self):
+        # float -> float
+        arr = SparseArray([None, None, 0, 2])
+        result = arr.astype("Sparse[float32]")
+        expected = SparseArray([None, None, 0, 2], dtype=np.dtype("float32"))
+        tm.assert_sp_array_equal(result, expected)
+
+        dtype = SparseDtype("float64", fill_value=0)
+        result = arr.astype(dtype)
+        expected = SparseArray._simple_new(
+            np.array([0.0, 2.0], dtype=dtype.subtype), IntIndex(4, [2, 3]), dtype
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+        dtype = SparseDtype("int64", 0)
+        result = arr.astype(dtype)
+        expected = SparseArray._simple_new(
+            np.array([0, 2], dtype=np.int64), IntIndex(4, [2, 3]), dtype
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+        arr = SparseArray([0, np.nan, 0, 1], fill_value=0)
+        with pytest.raises(ValueError, match="NA"):
+            arr.astype("Sparse[i8]")
+
+    def test_astype_bool(self):
+        a = SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
+        with tm.assert_produces_warning(FutureWarning, match="astype from Sparse"):
+            result = a.astype(bool)
+        expected = SparseArray(
+            [True, False, False, True], dtype=SparseDtype(bool, False)
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+        # update fill value
+        result = a.astype(SparseDtype(bool, False))
+        expected = SparseArray(
+            [True, False, False, True], dtype=SparseDtype(bool, False)
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_astype_all(self, any_real_numpy_dtype):
+        vals = np.array([1, 2, 3])
+        arr = SparseArray(vals, fill_value=1)
+        typ = np.dtype(any_real_numpy_dtype)
+        with tm.assert_produces_warning(FutureWarning, match="astype from Sparse"):
+            res = arr.astype(typ)
+        assert res.dtype == SparseDtype(typ, 1)
+        assert res.sp_values.dtype == typ
+
+        tm.assert_numpy_array_equal(np.asarray(res.to_dense()), vals.astype(typ))
+
+    @pytest.mark.parametrize(
+        "arr, dtype, expected",
+        [
+            (
+                SparseArray([0, 1]),
+                "float",
+                SparseArray([0.0, 1.0], dtype=SparseDtype(float, 0.0)),
+            ),
+            (SparseArray([0, 1]), bool, SparseArray([False, True])),
+            (
+                SparseArray([0, 1], fill_value=1),
+                bool,
+                SparseArray([False, True], dtype=SparseDtype(bool, True)),
+            ),
+            pytest.param(
+                SparseArray([0, 1]),
+                "datetime64[ns]",
+                SparseArray(
+                    np.array([0, 1], dtype="datetime64[ns]"),
+                    dtype=SparseDtype("datetime64[ns]", Timestamp("1970")),
+                ),
+            ),
+            (
+                SparseArray([0, 1, 10]),
+                str,
+                SparseArray(["0", "1", "10"], dtype=SparseDtype(str, "0")),
+            ),
+            (SparseArray(["10", "20"]), float, SparseArray([10.0, 20.0])),
+            (
+                SparseArray([0, 1, 0]),
+                object,
+                SparseArray([0, 1, 0], dtype=SparseDtype(object, 0)),
+            ),
+        ],
+    )
+    def test_astype_more(self, arr, dtype, expected):
+
+        if isinstance(dtype, SparseDtype):
+            warn = None
+        else:
+            warn = FutureWarning
+
+        with tm.assert_produces_warning(warn, match="astype from SparseDtype"):
+            result = arr.astype(dtype)
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_astype_nan_raises(self):
+        arr = SparseArray([1.0, np.nan])
+        with pytest.raises(ValueError, match="Cannot convert non-finite"):
+            msg = "astype from SparseDtype"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                arr.astype(int)
+
+    def test_astype_copy_false(self):
+        # GH#34456 bug caused by using .view instead of .astype in astype_nansafe
+        arr = SparseArray([1, 2, 3])
+
+        dtype = SparseDtype(float, 0)
+
+        result = arr.astype(dtype, copy=False)
+        expected = SparseArray([1.0, 2.0, 3.0], fill_value=0.0)
+        tm.assert_sp_array_equal(result, expected)
diff --git a/pandas/tests/arrays/sparse/test_constructors.py b/pandas/tests/arrays/sparse/test_constructors.py
new file mode 100644
index 0000000000000..e1d401f198533
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_constructors.py
@@ -0,0 +1,308 @@
+import numpy as np
+import pytest
+
+from pandas._libs.sparse import IntIndex
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import isna
+import pandas._testing as tm
+from pandas.core.arrays.sparse import (
+    SparseArray,
+    SparseDtype,
+)
+
+
+class TestConstructors:
+    def test_constructor_dtype(self):
+        arr = SparseArray([np.nan, 1, 2, np.nan])
+        assert arr.dtype == SparseDtype(np.float64, np.nan)
+        assert arr.dtype.subtype == np.float64
+        assert np.isnan(arr.fill_value)
+
+        arr = SparseArray([np.nan, 1, 2, np.nan], fill_value=0)
+        assert arr.dtype == SparseDtype(np.float64, 0)
+        assert arr.fill_value == 0
+
+        arr = SparseArray([0, 1, 2, 4], dtype=np.float64)
+        assert arr.dtype == SparseDtype(np.float64, np.nan)
+        assert np.isnan(arr.fill_value)
+
+        arr = SparseArray([0, 1, 2, 4], dtype=np.int64)
+        assert arr.dtype == SparseDtype(np.int64, 0)
+        assert arr.fill_value == 0
+
+        arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=np.int64)
+        assert arr.dtype == SparseDtype(np.int64, 0)
+        assert arr.fill_value == 0
+
+        arr = SparseArray([0, 1, 2, 4], dtype=None)
+        assert arr.dtype == SparseDtype(np.int64, 0)
+        assert arr.fill_value == 0
+
+        arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=None)
+        assert arr.dtype == SparseDtype(np.int64, 0)
+        assert arr.fill_value == 0
+
+    def test_constructor_dtype_str(self):
+        result = SparseArray([1, 2, 3], dtype="int")
+        expected = SparseArray([1, 2, 3], dtype=int)
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_constructor_sparse_dtype(self):
+        result = SparseArray([1, 0, 0, 1], dtype=SparseDtype("int64", -1))
+        expected = SparseArray([1, 0, 0, 1], fill_value=-1, dtype=np.int64)
+        tm.assert_sp_array_equal(result, expected)
+        assert result.sp_values.dtype == np.dtype("int64")
+
+    def test_constructor_sparse_dtype_str(self):
+        result = SparseArray([1, 0, 0, 1], dtype="Sparse[int32]")
+        expected = SparseArray([1, 0, 0, 1], dtype=np.int32)
+        tm.assert_sp_array_equal(result, expected)
+        assert result.sp_values.dtype == np.dtype("int32")
+
+    def test_constructor_object_dtype(self):
+        # GH#11856
+        arr = SparseArray(["A", "A", np.nan, "B"], dtype=object)
+        assert arr.dtype == SparseDtype(object)
+        assert np.isnan(arr.fill_value)
+
+        arr = SparseArray(["A", "A", np.nan, "B"], dtype=object, fill_value="A")
+        assert arr.dtype == SparseDtype(object, "A")
+        assert arr.fill_value == "A"
+
+    def test_constructor_object_dtype_bool_fill(self):
+        # GH#17574
+        data = [False, 0, 100.0, 0.0]
+        arr = SparseArray(data, dtype=object, fill_value=False)
+        assert arr.dtype == SparseDtype(object, False)
+        assert arr.fill_value is False
+        arr_expected = np.array(data, dtype=object)
+        it = (type(x) == type(y) and x == y for x, y in zip(arr, arr_expected))
+        assert np.fromiter(it, dtype=np.bool_).all()
+
+    @pytest.mark.parametrize("dtype", [SparseDtype(int, 0), int])
+    def test_constructor_na_dtype(self, dtype):
+        with pytest.raises(ValueError, match="Cannot convert"):
+            SparseArray([0, 1, np.nan], dtype=dtype)
+
+    def test_constructor_warns_when_losing_timezone(self):
+        # GH#32501 warn when losing timezone information
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+
+        expected = SparseArray(np.asarray(dti, dtype="datetime64[ns]"))
+
+        with tm.assert_produces_warning(UserWarning):
+            result = SparseArray(dti)
+
+        tm.assert_sp_array_equal(result, expected)
+
+        with tm.assert_produces_warning(UserWarning):
+            result = SparseArray(pd.Series(dti))
+
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_constructor_spindex_dtype(self):
+        arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]))
+        # TODO: actionable?
+        # XXX: Behavior change: specifying SparseIndex no longer changes the
+        # fill_value
+        expected = SparseArray([0, 1, 2, 0], kind="integer")
+        tm.assert_sp_array_equal(arr, expected)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+        arr = SparseArray(
+            data=[1, 2, 3],
+            sparse_index=IntIndex(4, [1, 2, 3]),
+            dtype=np.int64,
+            fill_value=0,
+        )
+        exp = SparseArray([0, 1, 2, 3], dtype=np.int64, fill_value=0)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+        arr = SparseArray(
+            data=[1, 2], sparse_index=IntIndex(4, [1, 2]), fill_value=0, dtype=np.int64
+        )
+        exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=np.int64)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+        arr = SparseArray(
+            data=[1, 2, 3],
+            sparse_index=IntIndex(4, [1, 2, 3]),
+            dtype=None,
+            fill_value=0,
+        )
+        exp = SparseArray([0, 1, 2, 3], dtype=None)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+    @pytest.mark.parametrize("sparse_index", [None, IntIndex(1, [0])])
+    def test_constructor_spindex_dtype_scalar(self, sparse_index):
+        # scalar input
+        arr = SparseArray(data=1, sparse_index=sparse_index, dtype=None)
+        exp = SparseArray([1], dtype=None)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+        arr = SparseArray(data=1, sparse_index=IntIndex(1, [0]), dtype=None)
+        exp = SparseArray([1], dtype=None)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+    def test_constructor_spindex_dtype_scalar_broadcasts(self):
+        arr = SparseArray(
+            data=[1, 2], sparse_index=IntIndex(4, [1, 2]), fill_value=0, dtype=None
+        )
+        exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=None)
+        tm.assert_sp_array_equal(arr, exp)
+        assert arr.dtype == SparseDtype(np.int64)
+        assert arr.fill_value == 0
+
+    @pytest.mark.parametrize(
+        "data, fill_value",
+        [
+            (np.array([1, 2]), 0),
+            (np.array([1.0, 2.0]), np.nan),
+            ([True, False], False),
+            ([pd.Timestamp("2017-01-01")], pd.NaT),
+        ],
+    )
+    def test_constructor_inferred_fill_value(self, data, fill_value):
+        result = SparseArray(data).fill_value
+
+        if isna(fill_value):
+            assert isna(result)
+        else:
+            assert result == fill_value
+
+    @pytest.mark.parametrize("format", ["coo", "csc", "csr"])
+    @pytest.mark.parametrize("size", [0, 10])
+    @td.skip_if_no_scipy
+    def test_from_spmatrix(self, size, format):
+        import scipy.sparse
+
+        mat = scipy.sparse.random(size, 1, density=0.5, format=format)
+        result = SparseArray.from_spmatrix(mat)
+
+        result = np.asarray(result)
+        expected = mat.toarray().ravel()
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("format", ["coo", "csc", "csr"])
+    @td.skip_if_no_scipy
+    def test_from_spmatrix_including_explicit_zero(self, format):
+        import scipy.sparse
+
+        mat = scipy.sparse.random(10, 1, density=0.5, format=format)
+        mat.data[0] = 0
+        result = SparseArray.from_spmatrix(mat)
+
+        result = np.asarray(result)
+        expected = mat.toarray().ravel()
+        tm.assert_numpy_array_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    def test_from_spmatrix_raises(self):
+        import scipy.sparse
+
+        mat = scipy.sparse.eye(5, 4, format="csc")
+
+        with pytest.raises(ValueError, match="not '4'"):
+            SparseArray.from_spmatrix(mat)
+
+    @pytest.mark.parametrize(
+        "scalar,dtype",
+        [
+            (False, SparseDtype(bool, False)),
+            (0.0, SparseDtype("float64", 0)),
+            (1, SparseDtype("int64", 1)),
+            ("z", SparseDtype("object", "z")),
+        ],
+    )
+    def test_scalar_with_index_infer_dtype(self, scalar, dtype):
+        # GH#19163
+        with tm.assert_produces_warning(
+            FutureWarning, match="The index argument has been deprecated"
+        ):
+            arr = SparseArray(scalar, index=[1, 2, 3], fill_value=scalar)
+        exp = SparseArray([scalar, scalar, scalar], fill_value=scalar)
+
+        tm.assert_sp_array_equal(arr, exp)
+
+        assert arr.dtype == dtype
+        assert exp.dtype == dtype
+
+    def test_constructor_from_too_large_array(self):
+        with pytest.raises(TypeError, match="expected dimension <= 1 data"):
+            SparseArray(np.arange(10).reshape((2, 5)))
+
+    def test_constructor_from_sparse(self):
+        zarr = SparseArray([0, 0, 1, 2, 3, 0, 4, 5, 0, 6], fill_value=0)
+        res = SparseArray(zarr)
+        assert res.fill_value == 0
+        tm.assert_almost_equal(res.sp_values, zarr.sp_values)
+
+    def test_constructor_copy(self):
+        arr_data = np.array([np.nan, np.nan, 1, 2, 3, np.nan, 4, 5, np.nan, 6])
+        arr = SparseArray(arr_data)
+
+        cp = SparseArray(arr, copy=True)
+        cp.sp_values[:3] = 0
+        assert not (arr.sp_values[:3] == 0).any()
+
+        not_copy = SparseArray(arr)
+        not_copy.sp_values[:3] = 0
+        assert (arr.sp_values[:3] == 0).all()
+
+    def test_constructor_bool(self):
+        # GH#10648
+        data = np.array([False, False, True, True, False, False])
+        arr = SparseArray(data, fill_value=False, dtype=bool)
+
+        assert arr.dtype == SparseDtype(bool)
+        tm.assert_numpy_array_equal(arr.sp_values, np.array([True, True]))
+        # Behavior change: np.asarray densifies.
+        # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
+        tm.assert_numpy_array_equal(arr.sp_index.indices, np.array([2, 3], np.int32))
+
+        dense = arr.to_dense()
+        assert dense.dtype == bool
+        tm.assert_numpy_array_equal(dense, data)
+
+    def test_constructor_bool_fill_value(self):
+        arr = SparseArray([True, False, True], dtype=None)
+        assert arr.dtype == SparseDtype(np.bool_)
+        assert not arr.fill_value
+
+        arr = SparseArray([True, False, True], dtype=np.bool_)
+        assert arr.dtype == SparseDtype(np.bool_)
+        assert not arr.fill_value
+
+        arr = SparseArray([True, False, True], dtype=np.bool_, fill_value=True)
+        assert arr.dtype == SparseDtype(np.bool_, True)
+        assert arr.fill_value
+
+    def test_constructor_float32(self):
+        # GH#10648
+        data = np.array([1.0, np.nan, 3], dtype=np.float32)
+        arr = SparseArray(data, dtype=np.float32)
+
+        assert arr.dtype == SparseDtype(np.float32)
+        tm.assert_numpy_array_equal(arr.sp_values, np.array([1, 3], dtype=np.float32))
+        # Behavior change: np.asarray densifies.
+        # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
+        tm.assert_numpy_array_equal(
+            arr.sp_index.indices, np.array([0, 2], dtype=np.int32)
+        )
+
+        dense = arr.to_dense()
+        assert dense.dtype == np.float32
+        tm.assert_numpy_array_equal(dense, data)
diff --git a/pandas/tests/arrays/sparse/test_indexing.py b/pandas/tests/arrays/sparse/test_indexing.py
new file mode 100644
index 0000000000000..311a8a04e5b91
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_indexing.py
@@ -0,0 +1,290 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays.sparse import (
+    SparseArray,
+    SparseDtype,
+)
+
+arr_data = np.array([np.nan, np.nan, 1, 2, 3, np.nan, 4, 5, np.nan, 6])
+arr = SparseArray(arr_data)
+
+
+class TestGetitem:
+    def test_getitem(self):
+        dense = arr.to_dense()
+        for i in range(len(arr)):
+            tm.assert_almost_equal(arr[i], dense[i])
+            tm.assert_almost_equal(arr[-i], dense[-i])
+
+    def test_getitem_arraylike_mask(self):
+        arr = SparseArray([0, 1, 2])
+        result = arr[[True, False, True]]
+        expected = SparseArray([0, 2])
+        tm.assert_sp_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "slc",
+        [
+            np.s_[:],
+            np.s_[1:10],
+            np.s_[1:100],
+            np.s_[10:1],
+            np.s_[:-3],
+            np.s_[-5:-4],
+            np.s_[:-12],
+            np.s_[-12:],
+            np.s_[2:],
+            np.s_[2::3],
+            np.s_[::2],
+            np.s_[::-1],
+            np.s_[::-2],
+            np.s_[1:6:2],
+            np.s_[:-6:-2],
+        ],
+    )
+    @pytest.mark.parametrize(
+        "as_dense", [[np.nan] * 10, [1] * 10, [np.nan] * 5 + [1] * 5, []]
+    )
+    def test_getslice(self, slc, as_dense):
+        as_dense = np.array(as_dense)
+        arr = SparseArray(as_dense)
+
+        result = arr[slc]
+        expected = SparseArray(as_dense[slc])
+
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_getslice_tuple(self):
+        dense = np.array([np.nan, 0, 3, 4, 0, 5, np.nan, np.nan, 0])
+
+        sparse = SparseArray(dense)
+        res = sparse[(slice(4, None),)]
+        exp = SparseArray(dense[4:])
+        tm.assert_sp_array_equal(res, exp)
+
+        sparse = SparseArray(dense, fill_value=0)
+        res = sparse[(slice(4, None),)]
+        exp = SparseArray(dense[4:], fill_value=0)
+        tm.assert_sp_array_equal(res, exp)
+
+        msg = "too many indices for array"
+        with pytest.raises(IndexError, match=msg):
+            sparse[4:, :]
+
+        with pytest.raises(IndexError, match=msg):
+            # check numpy compat
+            dense[4:, :]
+
+    def test_boolean_slice_empty(self):
+        arr = SparseArray([0, 1, 2])
+        res = arr[[False, False, False]]
+        assert res.dtype == arr.dtype
+
+    def test_getitem_bool_sparse_array(self):
+        # GH 23122
+        spar_bool = SparseArray([False, True] * 5, dtype=np.bool_, fill_value=True)
+        exp = SparseArray([np.nan, 2, np.nan, 5, 6])
+        tm.assert_sp_array_equal(arr[spar_bool], exp)
+
+        spar_bool = ~spar_bool
+        res = arr[spar_bool]
+        exp = SparseArray([np.nan, 1, 3, 4, np.nan])
+        tm.assert_sp_array_equal(res, exp)
+
+        spar_bool = SparseArray(
+            [False, True, np.nan] * 3, dtype=np.bool_, fill_value=np.nan
+        )
+        res = arr[spar_bool]
+        exp = SparseArray([np.nan, 3, 5])
+        tm.assert_sp_array_equal(res, exp)
+
+    def test_getitem_bool_sparse_array_as_comparison(self):
+        # GH 45110
+        arr = SparseArray([1, 2, 3, 4, np.nan, np.nan], fill_value=np.nan)
+        res = arr[arr > 2]
+        exp = SparseArray([3.0, 4.0], fill_value=np.nan)
+        tm.assert_sp_array_equal(res, exp)
+
+    def test_get_item(self):
+        zarr = SparseArray([0, 0, 1, 2, 3, 0, 4, 5, 0, 6], fill_value=0)
+
+        assert np.isnan(arr[1])
+        assert arr[2] == 1
+        assert arr[7] == 5
+
+        assert zarr[0] == 0
+        assert zarr[2] == 1
+        assert zarr[7] == 5
+
+        errmsg = "must be an integer between -10 and 10"
+
+        with pytest.raises(IndexError, match=errmsg):
+            arr[11]
+
+        with pytest.raises(IndexError, match=errmsg):
+            arr[-11]
+
+        assert arr[-1] == arr[len(arr) - 1]
+
+
+class TestSetitem:
+    def test_set_item(self):
+        arr = SparseArray(arr_data).copy()
+
+        def setitem():
+            arr[5] = 3
+
+        def setslice():
+            arr[1:5] = 2
+
+        with pytest.raises(TypeError, match="assignment via setitem"):
+            setitem()
+
+        with pytest.raises(TypeError, match="assignment via setitem"):
+            setslice()
+
+
+class TestTake:
+    def test_take_scalar_raises(self):
+        msg = "'indices' must be an array, not a scalar '2'."
+        with pytest.raises(ValueError, match=msg):
+            arr.take(2)
+
+    def test_take(self):
+        exp = SparseArray(np.take(arr_data, [2, 3]))
+        tm.assert_sp_array_equal(arr.take([2, 3]), exp)
+
+        exp = SparseArray(np.take(arr_data, [0, 1, 2]))
+        tm.assert_sp_array_equal(arr.take([0, 1, 2]), exp)
+
+    def test_take_all_empty(self):
+        a = pd.array([0, 0], dtype=SparseDtype("int64"))
+        result = a.take([0, 1], allow_fill=True, fill_value=np.nan)
+        tm.assert_sp_array_equal(a, result)
+
+    def test_take_fill_value(self):
+        data = np.array([1, np.nan, 0, 3, 0])
+        sparse = SparseArray(data, fill_value=0)
+
+        exp = SparseArray(np.take(data, [0]), fill_value=0)
+        tm.assert_sp_array_equal(sparse.take([0]), exp)
+
+        exp = SparseArray(np.take(data, [1, 3, 4]), fill_value=0)
+        tm.assert_sp_array_equal(sparse.take([1, 3, 4]), exp)
+
+    def test_take_negative(self):
+        exp = SparseArray(np.take(arr_data, [-1]))
+        tm.assert_sp_array_equal(arr.take([-1]), exp)
+
+        exp = SparseArray(np.take(arr_data, [-4, -3, -2]))
+        tm.assert_sp_array_equal(arr.take([-4, -3, -2]), exp)
+
+    def test_bad_take(self):
+        with pytest.raises(IndexError, match="bounds"):
+            arr.take([11])
+
+    def test_take_filling(self):
+        # similar tests as GH 12631
+        sparse = SparseArray([np.nan, np.nan, 1, np.nan, 4])
+        result = sparse.take(np.array([1, 0, -1]))
+        expected = SparseArray([np.nan, np.nan, 4])
+        tm.assert_sp_array_equal(result, expected)
+
+        # TODO: actionable?
+        # XXX: test change: fill_value=True -> allow_fill=True
+        result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
+        expected = SparseArray([np.nan, np.nan, np.nan])
+        tm.assert_sp_array_equal(result, expected)
+
+        # allow_fill=False
+        result = sparse.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = SparseArray([np.nan, np.nan, 4])
+        tm.assert_sp_array_equal(result, expected)
+
+        msg = "Invalid value in 'indices'"
+        with pytest.raises(ValueError, match=msg):
+            sparse.take(np.array([1, 0, -2]), allow_fill=True)
+
+        with pytest.raises(ValueError, match=msg):
+            sparse.take(np.array([1, 0, -5]), allow_fill=True)
+
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, -6]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]), allow_fill=True)
+
+    def test_take_filling_fill_value(self):
+        # same tests as GH#12631
+        sparse = SparseArray([np.nan, 0, 1, 0, 4], fill_value=0)
+        result = sparse.take(np.array([1, 0, -1]))
+        expected = SparseArray([0, np.nan, 4], fill_value=0)
+        tm.assert_sp_array_equal(result, expected)
+
+        # fill_value
+        result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
+        # TODO: actionable?
+        # XXX: behavior change.
+        # the old way of filling self.fill_value doesn't follow EA rules.
+        # It's supposed to be self.dtype.na_value (nan in this case)
+        expected = SparseArray([0, np.nan, np.nan], fill_value=0)
+        tm.assert_sp_array_equal(result, expected)
+
+        # allow_fill=False
+        result = sparse.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = SparseArray([0, np.nan, 4], fill_value=0)
+        tm.assert_sp_array_equal(result, expected)
+
+        msg = "Invalid value in 'indices'."
+        with pytest.raises(ValueError, match=msg):
+            sparse.take(np.array([1, 0, -2]), allow_fill=True)
+        with pytest.raises(ValueError, match=msg):
+            sparse.take(np.array([1, 0, -5]), allow_fill=True)
+
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, -6]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]), fill_value=True)
+
+    @pytest.mark.parametrize("kind", ["block", "integer"])
+    def test_take_filling_all_nan(self, kind):
+        sparse = SparseArray([np.nan, np.nan, np.nan, np.nan, np.nan], kind=kind)
+        result = sparse.take(np.array([1, 0, -1]))
+        expected = SparseArray([np.nan, np.nan, np.nan], kind=kind)
+        tm.assert_sp_array_equal(result, expected)
+
+        result = sparse.take(np.array([1, 0, -1]), fill_value=True)
+        expected = SparseArray([np.nan, np.nan, np.nan], kind=kind)
+        tm.assert_sp_array_equal(result, expected)
+
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, -6]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]))
+        with pytest.raises(IndexError, match=msg):
+            sparse.take(np.array([1, 5]), fill_value=True)
+
+
+class TestWhere:
+    def test_where_retain_fill_value(self):
+        # GH#45691 don't lose fill_value on _where
+        arr = SparseArray([np.nan, 1.0], fill_value=0)
+
+        mask = np.array([True, False])
+
+        res = arr._where(~mask, 1)
+        exp = SparseArray([1, 1.0], fill_value=0)
+        tm.assert_sp_array_equal(res, exp)
+
+        ser = pd.Series(arr)
+        res = ser.where(~mask, 1)
+        tm.assert_series_equal(res, pd.Series(exp))
diff --git a/pandas/tests/arrays/sparse/test_libsparse.py b/pandas/tests/arrays/sparse/test_libsparse.py
index 527ae3ce37d1e..35d58c29b1e03 100644
--- a/pandas/tests/arrays/sparse/test_libsparse.py
+++ b/pandas/tests/arrays/sparse/test_libsparse.py
@@ -16,183 +16,134 @@
 
 TEST_LENGTH = 20
 
-plain_case = {
-    "xloc": [0, 7, 15],
-    "xlen": [3, 5, 5],
-    "yloc": [2, 9, 14],
-    "ylen": [2, 3, 5],
-    "intersect_loc": [2, 9, 15],
-    "intersect_len": [1, 3, 4],
-}
-delete_blocks = {
-    "xloc": [0, 5],
-    "xlen": [4, 4],
-    "yloc": [1],
-    "ylen": [4],
-    "intersect_loc": [1],
-    "intersect_len": [3],
-}
-split_blocks = {
-    "xloc": [0],
-    "xlen": [10],
-    "yloc": [0, 5],
-    "ylen": [3, 7],
-    "intersect_loc": [0, 5],
-    "intersect_len": [3, 5],
-}
-skip_block = {
-    "xloc": [10],
-    "xlen": [5],
-    "yloc": [0, 12],
-    "ylen": [5, 3],
-    "intersect_loc": [12],
-    "intersect_len": [3],
-}
-
-no_intersect = {
-    "xloc": [0, 10],
-    "xlen": [4, 6],
-    "yloc": [5, 17],
-    "ylen": [4, 2],
-    "intersect_loc": [],
-    "intersect_len": [],
-}
-
-
-def check_cases(_check_case):
-    def _check_case_dict(case):
-        _check_case(
-            case["xloc"],
-            case["xlen"],
-            case["yloc"],
-            case["ylen"],
-            case["intersect_loc"],
-            case["intersect_len"],
-        )
-
-    _check_case_dict(plain_case)
-    _check_case_dict(delete_blocks)
-    _check_case_dict(split_blocks)
-    _check_case_dict(skip_block)
-    _check_case_dict(no_intersect)
-
-    # one or both is empty
-    _check_case([0], [5], [], [], [], [])
-    _check_case([], [], [], [], [], [])
+plain_case = [
+    [0, 7, 15],
+    [3, 5, 5],
+    [2, 9, 14],
+    [2, 3, 5],
+    [2, 9, 15],
+    [1, 3, 4],
+]
+delete_blocks = [
+    [0, 5],
+    [4, 4],
+    [1],
+    [4],
+    [1],
+    [3],
+]
+split_blocks = [
+    [0],
+    [10],
+    [0, 5],
+    [3, 7],
+    [0, 5],
+    [3, 5],
+]
+skip_block = [
+    [10],
+    [5],
+    [0, 12],
+    [5, 3],
+    [12],
+    [3],
+]
+
+no_intersect = [
+    [0, 10],
+    [4, 6],
+    [5, 17],
+    [4, 2],
+    [],
+    [],
+]
+
+one_empty = [
+    [0],
+    [5],
+    [],
+    [],
+    [],
+    [],
+]
+
+both_empty = [  # type: ignore[var-annotated]
+    [],
+    [],
+    [],
+    [],
+    [],
+    [],
+]
+
+CASES = [plain_case, delete_blocks, split_blocks, skip_block, no_intersect, one_empty]
+IDS = [
+    "plain_case",
+    "delete_blocks",
+    "split_blocks",
+    "skip_block",
+    "no_intersect",
+    "one_empty",
+]
 
 
 class TestSparseIndexUnion:
-    def test_index_make_union(self):
-        def _check_case(xloc, xlen, yloc, ylen, eloc, elen):
-            xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
-            yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
-            bresult = xindex.make_union(yindex)
-            assert isinstance(bresult, BlockIndex)
-            tm.assert_numpy_array_equal(bresult.blocs, np.array(eloc, dtype=np.int32))
-            tm.assert_numpy_array_equal(
-                bresult.blengths, np.array(elen, dtype=np.int32)
-            )
-
-            ixindex = xindex.to_int_index()
-            iyindex = yindex.to_int_index()
-            iresult = ixindex.make_union(iyindex)
-            assert isinstance(iresult, IntIndex)
-            tm.assert_numpy_array_equal(iresult.indices, bresult.to_int_index().indices)
-
-        """
-        x: ----
-        y:     ----
-        r: --------
-        """
-        xloc = [0]
-        xlen = [5]
-        yloc = [5]
-        ylen = [4]
-        eloc = [0]
-        elen = [9]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: -----     -----
-        y:   -----          --
-        """
-        xloc = [0, 10]
-        xlen = [5, 5]
-        yloc = [2, 17]
-        ylen = [5, 2]
-        eloc = [0, 10, 17]
-        elen = [7, 5, 2]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ------
-        y:    -------
-        r: ----------
-        """
-        xloc = [1]
-        xlen = [5]
-        yloc = [3]
-        ylen = [5]
-        eloc = [1]
-        elen = [7]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ------  -----
-        y:    -------
-        r: -------------
-        """
-        xloc = [2, 10]
-        xlen = [4, 4]
-        yloc = [4]
-        ylen = [8]
-        eloc = [2]
-        elen = [12]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ---  -----
-        y: -------
-        r: -------------
-        """
-        xloc = [0, 5]
-        xlen = [3, 5]
-        yloc = [0]
-        ylen = [7]
-        eloc = [0]
-        elen = [10]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ------  -----
-        y:    -------  ---
-        r: -------------
-        """
-        xloc = [2, 10]
-        xlen = [4, 4]
-        yloc = [4, 13]
-        ylen = [8, 4]
-        eloc = [2]
-        elen = [15]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ----------------------
-        y:   ----  ----   ---
-        r: ----------------------
-        """
-        xloc = [2]
-        xlen = [15]
-        yloc = [4, 9, 14]
-        ylen = [3, 2, 2]
-        eloc = [2]
-        elen = [15]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
-        """
-        x: ----       ---
-        y:       ---       ---
-        """
-        xloc = [0, 10]
-        xlen = [3, 3]
-        yloc = [5, 15]
-        ylen = [2, 2]
-        eloc = [0, 5, 10, 15]
-        elen = [3, 2, 3, 2]
-        _check_case(xloc, xlen, yloc, ylen, eloc, elen)
+    @pytest.mark.parametrize(
+        "xloc, xlen, yloc, ylen, eloc, elen",
+        [
+            [[0], [5], [5], [4], [0], [9]],
+            [[0, 10], [5, 5], [2, 17], [5, 2], [0, 10, 17], [7, 5, 2]],
+            [[1], [5], [3], [5], [1], [7]],
+            [[2, 10], [4, 4], [4], [8], [2], [12]],
+            [[0, 5], [3, 5], [0], [7], [0], [10]],
+            [[2, 10], [4, 4], [4, 13], [8, 4], [2], [15]],
+            [[2], [15], [4, 9, 14], [3, 2, 2], [2], [15]],
+            [[0, 10], [3, 3], [5, 15], [2, 2], [0, 5, 10, 15], [3, 2, 3, 2]],
+        ],
+    )
+    def test_index_make_union(self, xloc, xlen, yloc, ylen, eloc, elen):
+        # Case 1
+        # x: ----
+        # y:     ----
+        # r: --------
+        # Case 2
+        # x: -----     -----
+        # y:   -----          --
+        # Case 3
+        # x: ------
+        # y:    -------
+        # r: ----------
+        # Case 4
+        # x: ------  -----
+        # y:    -------
+        # r: -------------
+        # Case 5
+        # x: ---  -----
+        # y: -------
+        # r: -------------
+        # Case 6
+        # x: ------  -----
+        # y:    -------  ---
+        # r: -------------
+        # Case 7
+        # x: ----------------------
+        # y:   ----  ----   ---
+        # r: ----------------------
+        # Case 8
+        # x: ----       ---
+        # y:       ---       ---
+        xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
+        yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
+        bresult = xindex.make_union(yindex)
+        assert isinstance(bresult, BlockIndex)
+        tm.assert_numpy_array_equal(bresult.blocs, np.array(eloc, dtype=np.int32))
+        tm.assert_numpy_array_equal(bresult.blengths, np.array(elen, dtype=np.int32))
+
+        ixindex = xindex.to_int_index()
+        iyindex = yindex.to_int_index()
+        iresult = ixindex.make_union(iyindex)
+        assert isinstance(iresult, IntIndex)
+        tm.assert_numpy_array_equal(iresult.indices, bresult.to_int_index().indices)
 
     def test_int_index_make_union(self):
         a = IntIndex(5, np.array([0, 3, 4], dtype=np.int32))
@@ -229,31 +180,23 @@ def test_int_index_make_union(self):
 
 class TestSparseIndexIntersect:
     @td.skip_if_windows
-    def test_intersect(self):
-        def _check_correct(a, b, expected):
-            result = a.intersect(b)
-            assert result.equals(expected)
+    @pytest.mark.parametrize("xloc, xlen, yloc, ylen, eloc, elen", CASES, ids=IDS)
+    def test_intersect(self, xloc, xlen, yloc, ylen, eloc, elen):
+        xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
+        yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
+        expected = BlockIndex(TEST_LENGTH, eloc, elen)
+        longer_index = BlockIndex(TEST_LENGTH + 1, yloc, ylen)
+
+        result = xindex.intersect(yindex)
+        assert result.equals(expected)
+        result = xindex.to_int_index().intersect(yindex.to_int_index())
+        assert result.equals(expected.to_int_index())
 
-        def _check_length_exc(a, longer):
-            msg = "Indices must reference same underlying length"
-            with pytest.raises(Exception, match=msg):
-                a.intersect(longer)
-
-        def _check_case(xloc, xlen, yloc, ylen, eloc, elen):
-            xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
-            yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
-            expected = BlockIndex(TEST_LENGTH, eloc, elen)
-            longer_index = BlockIndex(TEST_LENGTH + 1, yloc, ylen)
-
-            _check_correct(xindex, yindex, expected)
-            _check_correct(
-                xindex.to_int_index(), yindex.to_int_index(), expected.to_int_index()
-            )
-
-            _check_length_exc(xindex, longer_index)
-            _check_length_exc(xindex.to_int_index(), longer_index.to_int_index())
-
-        check_cases(_check_case)
+        msg = "Indices must reference same underlying length"
+        with pytest.raises(Exception, match=msg):
+            xindex.intersect(longer_index)
+        with pytest.raises(Exception, match=msg):
+            xindex.to_int_index().intersect(longer_index.to_int_index())
 
     def test_intersect_empty(self):
         xindex = IntIndex(4, np.array([], dtype=np.int32))
@@ -266,18 +209,19 @@ def test_intersect_empty(self):
         assert xindex.intersect(yindex).equals(xindex)
         assert yindex.intersect(xindex).equals(xindex)
 
-    def test_intersect_identical(self):
-        cases = [
-            IntIndex(5, np.array([1, 2], dtype=np.int32)),
-            IntIndex(5, np.array([0, 2, 4], dtype=np.int32)),
-            IntIndex(0, np.array([], dtype=np.int32)),
-            IntIndex(5, np.array([], dtype=np.int32)),
-        ]
-
-        for case in cases:
-            assert case.intersect(case).equals(case)
-            case = case.to_block_index()
-            assert case.intersect(case).equals(case)
+    @pytest.mark.parametrize(
+        "case",
+        [
+            IntIndex(5, np.array([1, 2], dtype=np.int32)),  # type: ignore[arg-type]
+            IntIndex(5, np.array([0, 2, 4], dtype=np.int32)),  # type: ignore[arg-type]
+            IntIndex(0, np.array([], dtype=np.int32)),  # type: ignore[arg-type]
+            IntIndex(5, np.array([], dtype=np.int32)),  # type: ignore[arg-type]
+        ],
+    )
+    def test_intersect_identical(self, case):
+        assert case.intersect(case).equals(case)
+        case = case.to_block_index()
+        assert case.intersect(case).equals(case)
 
 
 class TestSparseIndexCommon:
@@ -324,74 +268,71 @@ def test_block_internal(self):
         tm.assert_numpy_array_equal(idx.blocs, np.array([0, 2], dtype=np.int32))
         tm.assert_numpy_array_equal(idx.blengths, np.array([1, 2], dtype=np.int32))
 
-    def test_lookup(self):
-        for kind in ["integer", "block"]:
-            idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
-            assert idx.lookup(-1) == -1
-            assert idx.lookup(0) == -1
-            assert idx.lookup(1) == -1
-            assert idx.lookup(2) == 0
-            assert idx.lookup(3) == 1
-            assert idx.lookup(4) == -1
-
-            idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
-
-            for i in range(-1, 5):
-                assert idx.lookup(i) == -1
-
-            idx = make_sparse_index(
-                4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind
-            )
-            assert idx.lookup(-1) == -1
-            assert idx.lookup(0) == 0
-            assert idx.lookup(1) == 1
-            assert idx.lookup(2) == 2
-            assert idx.lookup(3) == 3
-            assert idx.lookup(4) == -1
-
-            idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
-            assert idx.lookup(-1) == -1
-            assert idx.lookup(0) == 0
-            assert idx.lookup(1) == -1
-            assert idx.lookup(2) == 1
-            assert idx.lookup(3) == 2
-            assert idx.lookup(4) == -1
-
-    def test_lookup_array(self):
-        for kind in ["integer", "block"]:
-            idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
-
-            res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
-            exp = np.array([-1, -1, 0], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
-
-            res = idx.lookup_array(np.array([4, 2, 1, 3], dtype=np.int32))
-            exp = np.array([-1, 0, -1, 1], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
-
-            idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
-            res = idx.lookup_array(np.array([-1, 0, 2, 4], dtype=np.int32))
-            exp = np.array([-1, -1, -1, -1], dtype=np.int32)
-
-            idx = make_sparse_index(
-                4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind
-            )
-            res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
-            exp = np.array([-1, 0, 2], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
-
-            res = idx.lookup_array(np.array([4, 2, 1, 3], dtype=np.int32))
-            exp = np.array([-1, 2, 1, 3], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
-
-            idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
-            res = idx.lookup_array(np.array([2, 1, 3, 0], dtype=np.int32))
-            exp = np.array([1, -1, 2, 0], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
-
-            res = idx.lookup_array(np.array([1, 4, 2, 5], dtype=np.int32))
-            exp = np.array([-1, -1, 1, -1], dtype=np.int32)
-            tm.assert_numpy_array_equal(res, exp)
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_lookup(self, kind):
+        idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
+        assert idx.lookup(-1) == -1
+        assert idx.lookup(0) == -1
+        assert idx.lookup(1) == -1
+        assert idx.lookup(2) == 0
+        assert idx.lookup(3) == 1
+        assert idx.lookup(4) == -1
+
+        idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
+
+        for i in range(-1, 5):
+            assert idx.lookup(i) == -1
+
+        idx = make_sparse_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind)
+        assert idx.lookup(-1) == -1
+        assert idx.lookup(0) == 0
+        assert idx.lookup(1) == 1
+        assert idx.lookup(2) == 2
+        assert idx.lookup(3) == 3
+        assert idx.lookup(4) == -1
+
+        idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
+        assert idx.lookup(-1) == -1
+        assert idx.lookup(0) == 0
+        assert idx.lookup(1) == -1
+        assert idx.lookup(2) == 1
+        assert idx.lookup(3) == 2
+        assert idx.lookup(4) == -1
+
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_lookup_array(self, kind):
+        idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
+
+        res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
+        exp = np.array([-1, -1, 0], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        res = idx.lookup_array(np.array([4, 2, 1, 3], dtype=np.int32))
+        exp = np.array([-1, 0, -1, 1], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
+        res = idx.lookup_array(np.array([-1, 0, 2, 4], dtype=np.int32))
+        exp = np.array([-1, -1, -1, -1], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        idx = make_sparse_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind)
+        res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
+        exp = np.array([-1, 0, 2], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        res = idx.lookup_array(np.array([4, 2, 1, 3], dtype=np.int32))
+        exp = np.array([-1, 2, 1, 3], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
+        res = idx.lookup_array(np.array([2, 1, 3, 0], dtype=np.int32))
+        exp = np.array([1, -1, 2, 0], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
+
+        res = idx.lookup_array(np.array([1, 4, 2, 5], dtype=np.int32))
+        exp = np.array([-1, -1, 1, -1], dtype=np.int32)
+        tm.assert_numpy_array_equal(res, exp)
 
     @pytest.mark.parametrize(
         "idx, expected",
@@ -442,13 +383,13 @@ def test_block_internal(self):
         tm.assert_numpy_array_equal(idx.blocs, np.array([0, 2], dtype=np.int32))
         tm.assert_numpy_array_equal(idx.blengths, np.array([1, 2], dtype=np.int32))
 
-    def test_make_block_boundary(self):
-        for i in [5, 10, 100, 101]:
-            idx = make_sparse_index(i, np.arange(0, i, 2, dtype=np.int32), kind="block")
+    @pytest.mark.parametrize("i", [5, 10, 100, 101])
+    def test_make_block_boundary(self, i):
+        idx = make_sparse_index(i, np.arange(0, i, 2, dtype=np.int32), kind="block")
 
-            exp = np.arange(0, i, 2, dtype=np.int32)
-            tm.assert_numpy_array_equal(idx.blocs, exp)
-            tm.assert_numpy_array_equal(idx.blengths, np.ones(len(exp), dtype=np.int32))
+        exp = np.arange(0, i, 2, dtype=np.int32)
+        tm.assert_numpy_array_equal(idx.blocs, exp)
+        tm.assert_numpy_array_equal(idx.blengths, np.ones(len(exp), dtype=np.int32))
 
     def test_equals(self):
         index = BlockIndex(10, [0, 4], [2, 5])
@@ -551,19 +492,17 @@ def test_equals(self):
         assert index.equals(index)
         assert not index.equals(IntIndex(10, [0, 1, 2, 3]))
 
-    def test_to_block_index(self):
-        def _check_case(xloc, xlen, yloc, ylen, eloc, elen):
-            xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
-            yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
+    @pytest.mark.parametrize("xloc, xlen, yloc, ylen, eloc, elen", CASES, ids=IDS)
+    def test_to_block_index(self, xloc, xlen, yloc, ylen, eloc, elen):
+        xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
+        yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
 
-            # see if survive the round trip
-            xbindex = xindex.to_int_index().to_block_index()
-            ybindex = yindex.to_int_index().to_block_index()
-            assert isinstance(xbindex, BlockIndex)
-            assert xbindex.equals(xindex)
-            assert ybindex.equals(yindex)
-
-        check_cases(_check_case)
+        # see if survive the round trip
+        xbindex = xindex.to_int_index().to_block_index()
+        ybindex = yindex.to_int_index().to_block_index()
+        assert isinstance(xbindex, BlockIndex)
+        assert xbindex.equals(xindex)
+        assert ybindex.equals(yindex)
 
     def test_to_int_index(self):
         index = IntIndex(10, [2, 3, 4, 5, 6])
@@ -571,48 +510,44 @@ def test_to_int_index(self):
 
 
 class TestSparseOperators:
-    def _op_tests(self, sparse_op, python_op):
-        def _check_case(xloc, xlen, yloc, ylen, eloc, elen):
-            xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
-            yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
-
-            xdindex = xindex.to_int_index()
-            ydindex = yindex.to_int_index()
+    @pytest.mark.parametrize("opname", ["add", "sub", "mul", "truediv", "floordiv"])
+    @pytest.mark.parametrize("xloc, xlen, yloc, ylen, eloc, elen", CASES, ids=IDS)
+    def test_op(self, opname, xloc, xlen, yloc, ylen, eloc, elen):
+        sparse_op = getattr(splib, f"sparse_{opname}_float64")
+        python_op = getattr(operator, opname)
 
-            x = np.arange(xindex.npoints) * 10.0 + 1
-            y = np.arange(yindex.npoints) * 100.0 + 1
+        xindex = BlockIndex(TEST_LENGTH, xloc, xlen)
+        yindex = BlockIndex(TEST_LENGTH, yloc, ylen)
 
-            xfill = 0
-            yfill = 2
+        xdindex = xindex.to_int_index()
+        ydindex = yindex.to_int_index()
 
-            result_block_vals, rb_index, bfill = sparse_op(
-                x, xindex, xfill, y, yindex, yfill
-            )
-            result_int_vals, ri_index, ifill = sparse_op(
-                x, xdindex, xfill, y, ydindex, yfill
-            )
+        x = np.arange(xindex.npoints) * 10.0 + 1
+        y = np.arange(yindex.npoints) * 100.0 + 1
 
-            assert rb_index.to_int_index().equals(ri_index)
-            tm.assert_numpy_array_equal(result_block_vals, result_int_vals)
-            assert bfill == ifill
+        xfill = 0
+        yfill = 2
 
-            # check versus Series...
-            xseries = Series(x, xdindex.indices)
-            xseries = xseries.reindex(np.arange(TEST_LENGTH)).fillna(xfill)
+        result_block_vals, rb_index, bfill = sparse_op(
+            x, xindex, xfill, y, yindex, yfill
+        )
+        result_int_vals, ri_index, ifill = sparse_op(
+            x, xdindex, xfill, y, ydindex, yfill
+        )
 
-            yseries = Series(y, ydindex.indices)
-            yseries = yseries.reindex(np.arange(TEST_LENGTH)).fillna(yfill)
+        assert rb_index.to_int_index().equals(ri_index)
+        tm.assert_numpy_array_equal(result_block_vals, result_int_vals)
+        assert bfill == ifill
 
-            series_result = python_op(xseries, yseries)
-            series_result = series_result.reindex(ri_index.indices)
+        # check versus Series...
+        xseries = Series(x, xdindex.indices)
+        xseries = xseries.reindex(np.arange(TEST_LENGTH)).fillna(xfill)
 
-            tm.assert_numpy_array_equal(result_block_vals, series_result.values)
-            tm.assert_numpy_array_equal(result_int_vals, series_result.values)
+        yseries = Series(y, ydindex.indices)
+        yseries = yseries.reindex(np.arange(TEST_LENGTH)).fillna(yfill)
 
-        check_cases(_check_case)
+        series_result = python_op(xseries, yseries)
+        series_result = series_result.reindex(ri_index.indices)
 
-    @pytest.mark.parametrize("opname", ["add", "sub", "mul", "truediv", "floordiv"])
-    def test_op(self, opname):
-        sparse_op = getattr(splib, f"sparse_{opname}_float64")
-        python_op = getattr(operator, opname)
-        self._op_tests(sparse_op, python_op)
+        tm.assert_numpy_array_equal(result_block_vals, series_result.values)
+        tm.assert_numpy_array_equal(result_int_vals, series_result.values)
diff --git a/pandas/tests/arrays/sparse/test_reductions.py b/pandas/tests/arrays/sparse/test_reductions.py
new file mode 100644
index 0000000000000..5d6d65dde69ad
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_reductions.py
@@ -0,0 +1,308 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NaT,
+    Timestamp,
+    isna,
+)
+from pandas.core.arrays.sparse import (
+    SparseArray,
+    SparseDtype,
+)
+
+
+class TestReductions:
+    @pytest.mark.parametrize(
+        "data,pos,neg",
+        [
+            ([True, True, True], True, False),
+            ([1, 2, 1], 1, 0),
+            ([1.0, 2.0, 1.0], 1.0, 0.0),
+        ],
+    )
+    def test_all(self, data, pos, neg):
+        # GH#17570
+        out = SparseArray(data).all()
+        assert out
+
+        out = SparseArray(data, fill_value=pos).all()
+        assert out
+
+        data[1] = neg
+        out = SparseArray(data).all()
+        assert not out
+
+        out = SparseArray(data, fill_value=pos).all()
+        assert not out
+
+    @pytest.mark.parametrize(
+        "data,pos,neg",
+        [
+            ([True, True, True], True, False),
+            ([1, 2, 1], 1, 0),
+            ([1.0, 2.0, 1.0], 1.0, 0.0),
+        ],
+    )
+    def test_numpy_all(self, data, pos, neg):
+        # GH#17570
+        out = np.all(SparseArray(data))
+        assert out
+
+        out = np.all(SparseArray(data, fill_value=pos))
+        assert out
+
+        data[1] = neg
+        out = np.all(SparseArray(data))
+        assert not out
+
+        out = np.all(SparseArray(data, fill_value=pos))
+        assert not out
+
+        # raises with a different message on py2.
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.all(SparseArray(data), out=np.array([]))
+
+    @pytest.mark.parametrize(
+        "data,pos,neg",
+        [
+            ([False, True, False], True, False),
+            ([0, 2, 0], 2, 0),
+            ([0.0, 2.0, 0.0], 2.0, 0.0),
+        ],
+    )
+    def test_any(self, data, pos, neg):
+        # GH#17570
+        out = SparseArray(data).any()
+        assert out
+
+        out = SparseArray(data, fill_value=pos).any()
+        assert out
+
+        data[1] = neg
+        out = SparseArray(data).any()
+        assert not out
+
+        out = SparseArray(data, fill_value=pos).any()
+        assert not out
+
+    @pytest.mark.parametrize(
+        "data,pos,neg",
+        [
+            ([False, True, False], True, False),
+            ([0, 2, 0], 2, 0),
+            ([0.0, 2.0, 0.0], 2.0, 0.0),
+        ],
+    )
+    def test_numpy_any(self, data, pos, neg):
+        # GH#17570
+        out = np.any(SparseArray(data))
+        assert out
+
+        out = np.any(SparseArray(data, fill_value=pos))
+        assert out
+
+        data[1] = neg
+        out = np.any(SparseArray(data))
+        assert not out
+
+        out = np.any(SparseArray(data, fill_value=pos))
+        assert not out
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.any(SparseArray(data), out=out)
+
+    def test_sum(self):
+        data = np.arange(10).astype(float)
+        out = SparseArray(data).sum()
+        assert out == 45.0
+
+        data[5] = np.nan
+        out = SparseArray(data, fill_value=2).sum()
+        assert out == 40.0
+
+        out = SparseArray(data, fill_value=np.nan).sum()
+        assert out == 40.0
+
+    @pytest.mark.parametrize(
+        "arr",
+        [np.array([0, 1, np.nan, 1]), np.array([0, 1, 1])],
+    )
+    @pytest.mark.parametrize("fill_value", [0, 1, np.nan])
+    @pytest.mark.parametrize("min_count, expected", [(3, 2), (4, np.nan)])
+    def test_sum_min_count(self, arr, fill_value, min_count, expected):
+        # GH#25777
+        sparray = SparseArray(arr, fill_value=fill_value)
+        result = sparray.sum(min_count=min_count)
+        if np.isnan(expected):
+            assert np.isnan(result)
+        else:
+            assert result == expected
+
+    def test_bool_sum_min_count(self):
+        spar_bool = SparseArray([False, True] * 5, dtype=np.bool_, fill_value=True)
+        res = spar_bool.sum(min_count=1)
+        assert res == 5
+        res = spar_bool.sum(min_count=11)
+        assert isna(res)
+
+    def test_numpy_sum(self):
+        data = np.arange(10).astype(float)
+        out = np.sum(SparseArray(data))
+        assert out == 45.0
+
+        data[5] = np.nan
+        out = np.sum(SparseArray(data, fill_value=2))
+        assert out == 40.0
+
+        out = np.sum(SparseArray(data, fill_value=np.nan))
+        assert out == 40.0
+
+        msg = "the 'dtype' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.sum(SparseArray(data), dtype=np.int64)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.sum(SparseArray(data), out=out)
+
+    def test_mean(self):
+        data = np.arange(10).astype(float)
+        out = SparseArray(data).mean()
+        assert out == 4.5
+
+        data[5] = np.nan
+        out = SparseArray(data).mean()
+        assert out == 40.0 / 9
+
+    def test_numpy_mean(self):
+        data = np.arange(10).astype(float)
+        out = np.mean(SparseArray(data))
+        assert out == 4.5
+
+        data[5] = np.nan
+        out = np.mean(SparseArray(data))
+        assert out == 40.0 / 9
+
+        msg = "the 'dtype' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.mean(SparseArray(data), dtype=np.int64)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.mean(SparseArray(data), out=out)
+
+
+class TestMinMax:
+    @pytest.mark.parametrize(
+        "raw_data,max_expected,min_expected",
+        [
+            (np.arange(5.0), [4], [0]),
+            (-np.arange(5.0), [0], [-4]),
+            (np.array([0, 1, 2, np.nan, 4]), [4], [0]),
+            (np.array([np.nan] * 5), [np.nan], [np.nan]),
+            (np.array([]), [np.nan], [np.nan]),
+        ],
+    )
+    def test_nan_fill_value(self, raw_data, max_expected, min_expected):
+        arr = SparseArray(raw_data)
+        max_result = arr.max()
+        min_result = arr.min()
+        assert max_result in max_expected
+        assert min_result in min_expected
+
+        max_result = arr.max(skipna=False)
+        min_result = arr.min(skipna=False)
+        if np.isnan(raw_data).any():
+            assert np.isnan(max_result)
+            assert np.isnan(min_result)
+        else:
+            assert max_result in max_expected
+            assert min_result in min_expected
+
+    @pytest.mark.parametrize(
+        "fill_value,max_expected,min_expected",
+        [
+            (100, 100, 0),
+            (-100, 1, -100),
+        ],
+    )
+    def test_fill_value(self, fill_value, max_expected, min_expected):
+        arr = SparseArray(
+            np.array([fill_value, 0, 1]), dtype=SparseDtype("int", fill_value)
+        )
+        max_result = arr.max()
+        assert max_result == max_expected
+
+        min_result = arr.min()
+        assert min_result == min_expected
+
+    def test_only_fill_value(self):
+        fv = 100
+        arr = SparseArray(np.array([fv, fv, fv]), dtype=SparseDtype("int", fv))
+        assert len(arr._valid_sp_values) == 0
+
+        assert arr.max() == fv
+        assert arr.min() == fv
+        assert arr.max(skipna=False) == fv
+        assert arr.min(skipna=False) == fv
+
+    @pytest.mark.parametrize("func", ["min", "max"])
+    @pytest.mark.parametrize("data", [np.array([]), np.array([np.nan, np.nan])])
+    @pytest.mark.parametrize(
+        "dtype,expected",
+        [
+            (SparseDtype(np.float64, np.nan), np.nan),
+            (SparseDtype(np.float64, 5.0), np.nan),
+            (SparseDtype("datetime64[ns]", NaT), NaT),
+            (SparseDtype("datetime64[ns]", Timestamp("2018-05-05")), NaT),
+        ],
+    )
+    def test_na_value_if_no_valid_values(self, func, data, dtype, expected):
+        arr = SparseArray(data, dtype=dtype)
+        result = getattr(arr, func)()
+        if expected is NaT:
+            # TODO: pin down whether we wrap datetime64("NaT")
+            assert result is NaT or np.isnat(result)
+        else:
+            assert np.isnan(result)
+
+
+class TestArgmaxArgmin:
+    @pytest.mark.parametrize(
+        "arr,argmax_expected,argmin_expected",
+        [
+            (SparseArray([1, 2, 0, 1, 2]), 1, 2),
+            (SparseArray([-1, -2, 0, -1, -2]), 2, 1),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, -1]), 1, 5),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2]), 5, 2),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2], fill_value=-1), 5, 2),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2], fill_value=0), 5, 2),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2], fill_value=1), 5, 2),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2], fill_value=2), 5, 2),
+            (SparseArray([np.nan, 1, 0, 0, np.nan, 2], fill_value=3), 5, 2),
+            (SparseArray([0] * 10 + [-1], fill_value=0), 0, 10),
+            (SparseArray([0] * 10 + [-1], fill_value=-1), 0, 10),
+            (SparseArray([0] * 10 + [-1], fill_value=1), 0, 10),
+            (SparseArray([-1] + [0] * 10, fill_value=0), 1, 0),
+            (SparseArray([1] + [0] * 10, fill_value=0), 0, 1),
+            (SparseArray([-1] + [0] * 10, fill_value=-1), 1, 0),
+            (SparseArray([1] + [0] * 10, fill_value=1), 0, 1),
+        ],
+    )
+    def test_argmax_argmin(self, arr, argmax_expected, argmin_expected):
+        argmax_result = arr.argmax()
+        argmin_result = arr.argmin()
+        assert argmax_result == argmax_expected
+        assert argmin_result == argmin_expected
+
+    @pytest.mark.parametrize(
+        "arr,method",
+        [(SparseArray([]), "argmax"), (SparseArray([]), "argmin")],
+    )
+    def test_empty_array(self, arr, method):
+        msg = f"attempt to get {method} of an empty sequence"
+        with pytest.raises(ValueError, match=msg):
+            arr.argmax() if method == "argmax" else arr.argmin()
diff --git a/pandas/tests/arrays/sparse/test_unary.py b/pandas/tests/arrays/sparse/test_unary.py
new file mode 100644
index 0000000000000..605023a407a06
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_unary.py
@@ -0,0 +1,72 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import SparseArray
+
+
+@pytest.mark.parametrize("fill_value", [0, np.nan])
+@pytest.mark.parametrize("op", [operator.pos, operator.neg])
+def test_unary_op(op, fill_value):
+    arr = np.array([0, 1, np.nan, 2])
+    sparray = SparseArray(arr, fill_value=fill_value)
+    result = op(sparray)
+    expected = SparseArray(op(arr), fill_value=op(fill_value))
+    tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("fill_value", [True, False])
+def test_invert(fill_value):
+    arr = np.array([True, False, False, True])
+    sparray = SparseArray(arr, fill_value=fill_value)
+    result = ~sparray
+    expected = SparseArray(~arr, fill_value=not fill_value)
+    tm.assert_sp_array_equal(result, expected)
+
+    result = ~pd.Series(sparray)
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)
+
+    result = ~pd.DataFrame({"A": sparray})
+    expected = pd.DataFrame({"A": expected})
+    tm.assert_frame_equal(result, expected)
+
+
+class TestUnaryMethods:
+    def test_neg_operator(self):
+        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        res = -arr
+        exp = SparseArray([1, 2, np.nan, -3], fill_value=np.nan, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
+        res = -arr
+        exp = SparseArray([1, 2, -1, -3], fill_value=1, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+    def test_abs_operator(self):
+        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        res = abs(arr)
+        exp = SparseArray([1, 2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
+        res = abs(arr)
+        exp = SparseArray([1, 2, 1, 3], fill_value=1, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+    def test_invert_operator(self):
+        arr = SparseArray([False, True, False, True], fill_value=False, dtype=np.bool_)
+        exp = SparseArray(
+            np.invert([False, True, False, True]), fill_value=True, dtype=np.bool_
+        )
+        res = ~arr
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([0, 1, 0, 2, 3, 0], fill_value=0, dtype=np.int32)
+        res = ~arr
+        exp = SparseArray([-1, -2, -1, -3, -4, -1], fill_value=-1, dtype=np.int32)
+        tm.assert_sp_array_equal(exp, res)
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index 22fe7bb0de949..6a17a56a47cbc 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -5,6 +5,11 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    pa_version_under2p0,
+    pa_version_under6p0,
+)
+from pandas.errors import PerformanceWarning
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import is_dtype_equal
@@ -16,11 +21,13 @@
 
 @pytest.fixture
 def dtype(string_storage):
+    """Fixture giving StringDtype from parametrized 'string_storage'"""
     return pd.StringDtype(storage=string_storage)
 
 
 @pytest.fixture
 def cls(dtype):
+    """Fixture giving array type from parametrized 'dtype'"""
     return dtype.construct_array_type()
 
 
@@ -97,7 +104,7 @@ def test_add(dtype, request):
             "unsupported operand type(s) for +: 'ArrowStringArray' and "
             "'ArrowStringArray'"
         )
-        mark = pytest.mark.xfail(raises=TypeError, reason=reason)
+        mark = pytest.mark.xfail(raises=NotImplementedError, reason=reason)
         request.node.add_marker(mark)
 
     a = pd.Series(["a", "b", "c", None, None], dtype=dtype)
@@ -138,7 +145,7 @@ def test_add_2d(dtype, request):
 def test_add_sequence(dtype, request):
     if dtype.storage == "pyarrow":
         reason = "unsupported operand type(s) for +: 'ArrowStringArray' and 'list'"
-        mark = pytest.mark.xfail(raises=TypeError, reason=reason)
+        mark = pytest.mark.xfail(raises=NotImplementedError, reason=reason)
         request.node.add_marker(mark)
 
     a = pd.array(["a", "b", None, None], dtype=dtype)
@@ -156,7 +163,7 @@ def test_add_sequence(dtype, request):
 def test_mul(dtype, request):
     if dtype.storage == "pyarrow":
         reason = "unsupported operand type(s) for *: 'ArrowStringArray' and 'int'"
-        mark = pytest.mark.xfail(raises=TypeError, reason=reason)
+        mark = pytest.mark.xfail(raises=NotImplementedError, reason=reason)
         request.node.add_marker(mark)
 
     a = pd.array(["a", "b", None], dtype=dtype)
@@ -258,7 +265,7 @@ def test_constructor_raises(cls):
     if cls is pd.arrays.StringArray:
         msg = "StringArray requires a sequence of strings or pandas.NA"
     else:
-        msg = "Unsupported type '<class 'numpy.ndarray'>' for ArrowStringArray"
+        msg = "Unsupported type '<class 'numpy.ndarray'>' for ArrowExtensionArray"
 
     with pytest.raises(ValueError, match=msg):
         cls(np.array(["a", "b"], dtype="S1"))
@@ -266,15 +273,34 @@ def test_constructor_raises(cls):
     with pytest.raises(ValueError, match=msg):
         cls(np.array([]))
 
-    with pytest.raises(ValueError, match=msg):
+    if cls is pd.arrays.StringArray:
+        # GH#45057 np.nan and None do NOT raise, as they are considered valid NAs
+        #  for string dtype
         cls(np.array(["a", np.nan], dtype=object))
-
-    with pytest.raises(ValueError, match=msg):
         cls(np.array(["a", None], dtype=object))
+    else:
+        with pytest.raises(ValueError, match=msg):
+            cls(np.array(["a", np.nan], dtype=object))
+        with pytest.raises(ValueError, match=msg):
+            cls(np.array(["a", None], dtype=object))
 
     with pytest.raises(ValueError, match=msg):
         cls(np.array(["a", pd.NaT], dtype=object))
 
+    with pytest.raises(ValueError, match=msg):
+        cls(np.array(["a", np.datetime64("NaT", "ns")], dtype=object))
+
+    with pytest.raises(ValueError, match=msg):
+        cls(np.array(["a", np.timedelta64("NaT", "ns")], dtype=object))
+
+
+@pytest.mark.parametrize("na", [np.nan, np.float64("nan"), float("nan"), None, pd.NA])
+def test_constructor_nan_like(na):
+    expected = pd.arrays.StringArray(np.array(["a", pd.NA]))
+    tm.assert_extension_array_equal(
+        pd.arrays.StringArray(np.array(["a", na], dtype="object")), expected
+    )
+
 
 @pytest.mark.parametrize("copy", [True, False])
 def test_from_sequence_no_mutate(copy, cls, request):
@@ -352,7 +378,7 @@ def test_reduce_missing(skipna, dtype):
 @pytest.mark.parametrize("method", ["min", "max"])
 @pytest.mark.parametrize("skipna", [True, False])
 def test_min_max(method, skipna, dtype, request):
-    if dtype.storage == "pyarrow":
+    if dtype.storage == "pyarrow" and pa_version_under6p0:
         reason = "'ArrowStringArray' object has no attribute 'max'"
         mark = pytest.mark.xfail(raises=TypeError, reason=reason)
         request.node.add_marker(mark)
@@ -369,7 +395,7 @@ def test_min_max(method, skipna, dtype, request):
 @pytest.mark.parametrize("method", ["min", "max"])
 @pytest.mark.parametrize("box", [pd.Series, pd.array])
 def test_min_max_numpy(method, box, dtype, request):
-    if dtype.storage == "pyarrow":
+    if dtype.storage == "pyarrow" and (pa_version_under6p0 or box is pd.array):
         if box is pd.array:
             reason = "'<=' not supported between instances of 'str' and 'NoneType'"
         else:
@@ -504,7 +530,7 @@ def test_memory_usage(dtype):
     # GH 33963
 
     if dtype.storage == "pyarrow":
-        pytest.skip("not applicable")
+        pytest.skip(f"not applicable for {dtype.storage}")
 
     series = pd.Series(["a", "b", "c"], dtype=dtype)
 
@@ -535,21 +561,53 @@ def test_to_numpy_na_value(dtype, nulls_fixture):
     tm.assert_numpy_array_equal(result, expected)
 
 
-def test_isin(dtype, request, fixed_now_ts):
+def test_isin(dtype, fixed_now_ts):
     s = pd.Series(["a", "b", None], dtype=dtype)
 
-    result = s.isin(["a", "c"])
+    with tm.maybe_produces_warning(
+        PerformanceWarning, dtype == "pyarrow" and pa_version_under2p0
+    ):
+        result = s.isin(["a", "c"])
     expected = pd.Series([True, False, False])
     tm.assert_series_equal(result, expected)
 
-    result = s.isin(["a", pd.NA])
+    with tm.maybe_produces_warning(
+        PerformanceWarning, dtype == "pyarrow" and pa_version_under2p0
+    ):
+        result = s.isin(["a", pd.NA])
     expected = pd.Series([True, False, True])
     tm.assert_series_equal(result, expected)
 
-    result = s.isin([])
+    with tm.maybe_produces_warning(
+        PerformanceWarning, dtype == "pyarrow" and pa_version_under2p0
+    ):
+        result = s.isin([])
     expected = pd.Series([False, False, False])
     tm.assert_series_equal(result, expected)
 
-    result = s.isin(["a", fixed_now_ts])
+    with tm.maybe_produces_warning(
+        PerformanceWarning, dtype == "pyarrow" and pa_version_under2p0
+    ):
+        result = s.isin(["a", fixed_now_ts])
     expected = pd.Series([True, False, False])
     tm.assert_series_equal(result, expected)
+
+
+def test_setitem_scalar_with_mask_validation(dtype):
+    # https://github.com/pandas-dev/pandas/issues/47628
+    # setting None with a boolean mask (through _putmaks) should still result
+    # in pd.NA values in the underlying array
+    ser = pd.Series(["a", "b", "c"], dtype=dtype)
+    mask = np.array([False, True, False])
+
+    ser[mask] = None
+    assert ser.array[1] is pd.NA
+
+    # for other non-string we should also raise an error
+    ser = pd.Series(["a", "b", "c"], dtype=dtype)
+    if type(ser.array) is pd.arrays.StringArray:
+        msg = "Cannot set non-string value"
+    else:
+        msg = "Scalar must be NA or str"
+    with pytest.raises(ValueError, match=msg):
+        ser[mask] = 1
diff --git a/pandas/tests/arrays/string_/test_string_arrow.py b/pandas/tests/arrays/string_/test_string_arrow.py
index 265afa89d6530..f43cf298857a0 100644
--- a/pandas/tests/arrays/string_/test_string_arrow.py
+++ b/pandas/tests/arrays/string_/test_string_arrow.py
@@ -59,7 +59,7 @@ def test_constructor_not_string_type_raises(array, chunked):
             pytest.skip("chunked not applicable to numpy array")
         arr = pa.chunked_array(arr)
     if array is np:
-        msg = "Unsupported type '<class 'numpy.ndarray'>' for ArrowStringArray"
+        msg = "Unsupported type '<class 'numpy.ndarray'>' for ArrowExtensionArray"
     else:
         msg = re.escape(
             "ArrowStringArray requires a PyArrow (chunked) array of string type"
@@ -122,7 +122,7 @@ def test_from_sequence_wrong_dtype_raises():
     reason="pyarrow is installed",
 )
 def test_pyarrow_not_installed_raises():
-    msg = re.escape("pyarrow>=1.0.0 is required for PyArrow backed StringArray")
+    msg = re.escape("pyarrow>=1.0.0 is required for PyArrow backed")
 
     with pytest.raises(ImportError, match=msg):
         StringDtype(storage="pyarrow")
@@ -132,3 +132,68 @@ def test_pyarrow_not_installed_raises():
 
     with pytest.raises(ImportError, match=msg):
         ArrowStringArray._from_sequence(["a", None, "b"])
+
+
+@skip_if_no_pyarrow
+@pytest.mark.parametrize("multiple_chunks", [False, True])
+@pytest.mark.parametrize(
+    "key, value, expected",
+    [
+        (-1, "XX", ["a", "b", "c", "d", "XX"]),
+        (1, "XX", ["a", "XX", "c", "d", "e"]),
+        (1, None, ["a", None, "c", "d", "e"]),
+        (1, pd.NA, ["a", None, "c", "d", "e"]),
+        ([1, 3], "XX", ["a", "XX", "c", "XX", "e"]),
+        ([1, 3], ["XX", "YY"], ["a", "XX", "c", "YY", "e"]),
+        ([1, 3], ["XX", None], ["a", "XX", "c", None, "e"]),
+        ([1, 3], ["XX", pd.NA], ["a", "XX", "c", None, "e"]),
+        ([0, -1], ["XX", "YY"], ["XX", "b", "c", "d", "YY"]),
+        ([-1, 0], ["XX", "YY"], ["YY", "b", "c", "d", "XX"]),
+        (slice(3, None), "XX", ["a", "b", "c", "XX", "XX"]),
+        (slice(2, 4), ["XX", "YY"], ["a", "b", "XX", "YY", "e"]),
+        (slice(3, 1, -1), ["XX", "YY"], ["a", "b", "YY", "XX", "e"]),
+        (slice(None), "XX", ["XX", "XX", "XX", "XX", "XX"]),
+        ([False, True, False, True, False], ["XX", "YY"], ["a", "XX", "c", "YY", "e"]),
+    ],
+)
+def test_setitem(multiple_chunks, key, value, expected):
+    import pyarrow as pa
+
+    result = pa.array(list("abcde"))
+    expected = pa.array(expected)
+
+    if multiple_chunks:
+        result = pa.chunked_array([result[:3], result[3:]])
+        expected = pa.chunked_array([expected[:3], expected[3:]])
+
+    result = ArrowStringArray(result)
+    expected = ArrowStringArray(expected)
+
+    result[key] = value
+    tm.assert_equal(result, expected)
+    assert result._data.num_chunks == expected._data.num_chunks
+
+
+@skip_if_no_pyarrow
+def test_setitem_invalid_indexer_raises():
+    import pyarrow as pa
+
+    arr = ArrowStringArray(pa.array(list("abcde")))
+
+    with pytest.raises(IndexError, match=None):
+        arr[5] = "foo"
+
+    with pytest.raises(IndexError, match=None):
+        arr[-6] = "foo"
+
+    with pytest.raises(IndexError, match=None):
+        arr[[0, 5]] = "foo"
+
+    with pytest.raises(IndexError, match=None):
+        arr[[0, -6]] = "foo"
+
+    with pytest.raises(IndexError, match=None):
+        arr[[True, True, False]] = "foo"
+
+    with pytest.raises(ValueError, match=None):
+        arr[[0, 1]] = ["foo", "bar", "baz"]
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index 329d28c263ff2..9f8c277f07891 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -10,7 +10,6 @@
 import pandas as pd
 import pandas._testing as tm
 from pandas.api.extensions import register_extension_dtype
-from pandas.api.types import is_scalar
 from pandas.arrays import (
     BooleanArray,
     DatetimeArray,
@@ -377,6 +376,7 @@ def test_array_unboxes(index_or_series):
 
 @pytest.fixture
 def registry_without_decimal():
+    """Fixture yielding 'registry' with no DecimalDtype entries"""
     idx = registry.dtypes.index(DecimalDtype)
     registry.dtypes.pop(idx)
     yield
@@ -391,61 +391,3 @@ def test_array_not_registered(registry_without_decimal):
     result = pd.array(data, dtype=DecimalDtype)
     expected = DecimalArray._from_sequence(data)
     tm.assert_equal(result, expected)
-
-
-class TestArrayAnalytics:
-    def test_searchsorted(self, string_dtype):
-        arr = pd.array(["a", "b", "c"], dtype=string_dtype)
-
-        result = arr.searchsorted("a", side="left")
-        assert is_scalar(result)
-        assert result == 0
-
-        result = arr.searchsorted("a", side="right")
-        assert is_scalar(result)
-        assert result == 1
-
-    def test_searchsorted_numeric_dtypes_scalar(self, any_real_numpy_dtype):
-        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted(30)
-        assert is_scalar(result)
-        assert result == 2
-
-        result = arr.searchsorted([30])
-        expected = np.array([2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)
-
-    def test_searchsorted_numeric_dtypes_vector(self, any_real_numpy_dtype):
-        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted([2, 30])
-        expected = np.array([1, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "arr, val",
-        [
-            [
-                pd.date_range("20120101", periods=10, freq="2D"),
-                pd.Timestamp("20120102"),
-            ],
-            [
-                pd.date_range("20120101", periods=10, freq="2D", tz="Asia/Hong_Kong"),
-                pd.Timestamp("20120102", tz="Asia/Hong_Kong"),
-            ],
-            [
-                pd.timedelta_range(start="1 day", end="10 days", periods=10),
-                pd.Timedelta("2 days"),
-            ],
-        ],
-    )
-    def test_search_sorted_datetime64_scalar(self, arr, val):
-        arr = pd.array(arr)
-        result = arr.searchsorted(val)
-        assert is_scalar(result)
-        assert result == 1
-
-    def test_searchsorted_sorter(self, any_real_numpy_dtype):
-        arr = pd.array([3, 1, 2], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted([0, 3], sorter=np.argsort(arr))
-        expected = np.array([0, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 7484fdccf4937..ea895e5656ccb 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -33,6 +33,7 @@
 # TODO: more freq variants
 @pytest.fixture(params=["D", "B", "W", "M", "Q", "Y"])
 def freqstr(request):
+    """Fixture returning parametrized frequency in string format."""
     return request.param
 
 
@@ -81,7 +82,8 @@ class SharedTests:
 
     @pytest.fixture
     def arr1d(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        """Fixture returning DatetimeArray with daily frequency."""
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
         return arr
 
@@ -148,7 +150,7 @@ def test_compare_categorical_dtype(self, arr1d, as_index, reverse, ordered):
             tm.assert_numpy_array_equal(result, ones)
 
     def test_take(self):
-        data = np.arange(100, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(100, dtype="i8") * 24 * 3600 * 10**9
         np.random.shuffle(data)
 
         freq = None if self.array_cls is not PeriodArray else "D"
@@ -170,7 +172,7 @@ def test_take(self):
 
     @pytest.mark.parametrize("fill_value", [2, 2.0, Timestamp(2021, 1, 1, 12).time])
     def test_take_fill_raises(self, fill_value):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
 
         arr = self.array_cls(data, freq="D")
 
@@ -179,7 +181,7 @@ def test_take_fill_raises(self, fill_value):
             arr.take([0, 1], allow_fill=True, fill_value=fill_value)
 
     def test_take_fill(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
 
         arr = self.array_cls(data, freq="D")
 
@@ -215,7 +217,7 @@ def test_concat_same_type(self, arr1d):
         tm.assert_index_equal(self.index_cls(result), expected)
 
     def test_unbox_scalar(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
         result = arr._unbox_scalar(arr[0])
         expected = arr._data.dtype.type
@@ -229,7 +231,7 @@ def test_unbox_scalar(self):
             arr._unbox_scalar("foo")
 
     def test_check_compatible_with(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         arr._check_compatible_with(arr[0])
@@ -237,13 +239,13 @@ def test_check_compatible_with(self):
         arr._check_compatible_with(NaT)
 
     def test_scalar_from_string(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
         result = arr._scalar_from_string(str(arr[0]))
         assert result == arr[0]
 
     def test_reduce_invalid(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         msg = "does not support reduction 'not a method'"
@@ -252,7 +254,7 @@ def test_reduce_invalid(self):
 
     @pytest.mark.parametrize("method", ["pad", "backfill"])
     def test_fillna_method_doesnt_change_orig(self, method):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
         arr[4] = NaT
 
@@ -265,7 +267,7 @@ def test_fillna_method_doesnt_change_orig(self, method):
         assert arr[4] is NaT
 
     def test_searchsorted(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         # scalar
@@ -415,11 +417,11 @@ def test_repr_2d(self, arr1d):
         assert result == expected
 
     def test_setitem(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         arr[0] = arr[1]
-        expected = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        expected = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         expected[0] = expected[1]
 
         tm.assert_numpy_array_equal(arr.asi8, expected)
@@ -504,7 +506,7 @@ def test_setitem_categorical(self, arr1d, as_index):
         tm.assert_equal(arr1d, expected)
 
     def test_setitem_raises(self):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
         val = arr[0]
 
@@ -540,7 +542,7 @@ def test_setitem_numeric_raises(self, arr1d, box):
 
     def test_inplace_arithmetic(self):
         # GH#24115 check that iadd and isub are actually in-place
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         expected = arr + pd.Timedelta(days=1)
@@ -553,7 +555,7 @@ def test_inplace_arithmetic(self):
 
     def test_shift_fill_int_deprecated(self):
         # GH#31971
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = self.array_cls(data, freq="D")
 
         msg = "Passing <class 'int'> to shift"
@@ -562,7 +564,7 @@ def test_shift_fill_int_deprecated(self):
 
         expected = arr.copy()
         if self.array_cls is PeriodArray:
-            fill_val = PeriodArray._scalar_type._from_ordinal(1, freq=arr.freq)
+            fill_val = arr._scalar_type._from_ordinal(1, freq=arr.freq)
         else:
             fill_val = arr._scalar_type(1)
         expected[0] = fill_val
@@ -635,6 +637,10 @@ class TestDatetimeArray(SharedTests):
 
     @pytest.fixture
     def arr1d(self, tz_naive_fixture, freqstr):
+        """
+        Fixture returning DatetimeArray with parametrized frequency and
+        timezones
+        """
         tz = tz_naive_fixture
         dti = pd.date_range("2016-01-01 01:01:00", periods=5, freq=freqstr, tz=tz)
         dta = dti._data
@@ -1068,6 +1074,9 @@ class TestPeriodArray(SharedTests):
 
     @pytest.fixture
     def arr1d(self, period_index):
+        """
+        Fixture returning DatetimeArray from parametrized PeriodIndex objects
+        """
         return period_index._data
 
     def test_from_pi(self, arr1d):
@@ -1389,6 +1398,10 @@ def test_from_pandas_array(dtype):
     ]
 )
 def array_likes(request):
+    """
+    Fixture giving a numpy array and a parametrized 'data' object, which can
+    be a memoryview, array, dask or xarray object created from the numpy array.
+    """
     # GH#24539 recognize e.g xarray, dask, ...
     arr = np.array([1, 2, 3], dtype=np.int64)
 
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index d905c55c4553a..af1a292a2975a 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -1,9 +1,14 @@
 """
 Tests for DatetimeArray
 """
+import operator
+
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs import tz_compare
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
@@ -11,6 +16,198 @@
 from pandas.core.arrays import DatetimeArray
 
 
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def unit(self, request):
+        """Fixture returning parametrized time units"""
+        return request.param
+
+    @pytest.fixture
+    def reso(self, unit):
+        """Fixture returning datetime resolution for a given time unit"""
+        return {
+            "s": NpyDatetimeUnit.NPY_FR_s.value,
+            "ms": NpyDatetimeUnit.NPY_FR_ms.value,
+            "us": NpyDatetimeUnit.NPY_FR_us.value,
+        }[unit]
+
+    @pytest.fixture
+    def dtype(self, unit, tz_naive_fixture):
+        tz = tz_naive_fixture
+        if tz is None:
+            return np.dtype(f"datetime64[{unit}]")
+        else:
+            return DatetimeTZDtype(unit=unit, tz=tz)
+
+    @pytest.fixture
+    def dta_dti(self, unit, dtype):
+        tz = getattr(dtype, "tz", None)
+
+        dti = pd.date_range("2016-01-01", periods=55, freq="D", tz=tz)
+        if tz is None:
+            arr = np.asarray(dti).astype(f"M8[{unit}]")
+        else:
+            arr = np.asarray(dti.tz_convert("UTC").tz_localize(None)).astype(
+                f"M8[{unit}]"
+            )
+
+        dta = DatetimeArray._simple_new(arr, dtype=dtype)
+        return dta, dti
+
+    @pytest.fixture
+    def dta(self, dta_dti):
+        dta, dti = dta_dti
+        return dta
+
+    def test_non_nano(self, unit, reso, dtype):
+        arr = np.arange(5, dtype=np.int64).view(f"M8[{unit}]")
+        dta = DatetimeArray._simple_new(arr, dtype=dtype)
+
+        assert dta.dtype == dtype
+        assert dta[0]._reso == reso
+        assert tz_compare(dta.tz, dta[0].tz)
+        assert (dta[0] == dta[:1]).all()
+
+    @pytest.mark.filterwarnings(
+        "ignore:weekofyear and week have been deprecated:FutureWarning"
+    )
+    @pytest.mark.parametrize(
+        "field", DatetimeArray._field_ops + DatetimeArray._bool_ops
+    )
+    def test_fields(self, unit, reso, field, dtype, dta_dti):
+        dta, dti = dta_dti
+
+        # FIXME: assert (dti == dta).all()
+
+        res = getattr(dta, field)
+        expected = getattr(dti._data, field)
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_normalize(self, unit):
+        dti = pd.date_range("2016-01-01 06:00:00", periods=55, freq="D")
+        arr = np.asarray(dti).astype(f"M8[{unit}]")
+
+        dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+
+        assert not dta.is_normalized
+
+        # TODO: simplify once we can just .astype to other unit
+        exp = np.asarray(dti.normalize()).astype(f"M8[{unit}]")
+        expected = DatetimeArray._simple_new(exp, dtype=exp.dtype)
+
+        res = dta.normalize()
+        tm.assert_extension_array_equal(res, expected)
+
+    def test_simple_new_requires_match(self, unit):
+        arr = np.arange(5, dtype=np.int64).view(f"M8[{unit}]")
+        dtype = DatetimeTZDtype(unit, "UTC")
+
+        dta = DatetimeArray._simple_new(arr, dtype=dtype)
+        assert dta.dtype == dtype
+
+        wrong = DatetimeTZDtype("ns", "UTC")
+        with pytest.raises(AssertionError, match=""):
+            DatetimeArray._simple_new(arr, dtype=wrong)
+
+    def test_std_non_nano(self, unit):
+        dti = pd.date_range("2016-01-01", periods=55, freq="D")
+        arr = np.asarray(dti).astype(f"M8[{unit}]")
+
+        dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+
+        # we should match the nano-reso std, but floored to our reso.
+        res = dta.std()
+        assert res._reso == dta._reso
+        assert res == dti.std().floor(unit)
+
+    @pytest.mark.filterwarnings("ignore:Converting to PeriodArray.*:UserWarning")
+    def test_to_period(self, dta_dti):
+        dta, dti = dta_dti
+        result = dta.to_period("D")
+        expected = dti._data.to_period("D")
+
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_iter(self, dta):
+        res = next(iter(dta))
+        expected = dta[0]
+
+        assert type(res) is pd.Timestamp
+        assert res.value == expected.value
+        assert res._reso == expected._reso
+        assert res == expected
+
+    def test_astype_object(self, dta):
+        result = dta.astype(object)
+        assert all(x._reso == dta._reso for x in result)
+        assert all(x == y for x, y in zip(result, dta))
+
+    def test_to_pydatetime(self, dta_dti):
+        dta, dti = dta_dti
+
+        result = dta.to_pydatetime()
+        expected = dti.to_pydatetime()
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("meth", ["time", "timetz", "date"])
+    def test_time_date(self, dta_dti, meth):
+        dta, dti = dta_dti
+
+        result = getattr(dta, meth)
+        expected = getattr(dti, meth)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_format_native_types(self, unit, reso, dtype, dta_dti):
+        # In this case we should get the same formatted values with our nano
+        #  version dti._data as we do with the non-nano dta
+        dta, dti = dta_dti
+
+        res = dta._format_native_types()
+        exp = dti._data._format_native_types()
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_repr(self, dta_dti, unit):
+        dta, dti = dta_dti
+
+        assert repr(dta) == repr(dti._data).replace("[ns", f"[{unit}")
+
+    # TODO: tests with td64
+    def test_compare_mismatched_resolutions(self, comparison_op):
+        # comparison that numpy gets wrong bc of silent overflows
+        op = comparison_op
+
+        iinfo = np.iinfo(np.int64)
+        vals = np.array([iinfo.min, iinfo.min + 1, iinfo.max], dtype=np.int64)
+
+        # Construct so that arr2[1] < arr[1] < arr[2] < arr2[2]
+        arr = np.array(vals).view("M8[ns]")
+        arr2 = arr.view("M8[s]")
+
+        left = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+        right = DatetimeArray._simple_new(arr2, dtype=arr2.dtype)
+
+        if comparison_op is operator.eq:
+            expected = np.array([False, False, False])
+        elif comparison_op is operator.ne:
+            expected = np.array([True, True, True])
+        elif comparison_op in [operator.lt, operator.le]:
+            expected = np.array([False, False, True])
+        else:
+            expected = np.array([False, True, False])
+
+        result = op(left, right)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = op(left[1], right)
+        tm.assert_numpy_array_equal(result, expected)
+
+        if op not in [operator.eq, operator.ne]:
+            # check that numpy still gets this wrong; if it is fixed we may be
+            #  able to remove compare_mismatched_resolutions
+            np_res = op(left._ndarray, right._ndarray)
+            tm.assert_numpy_array_equal(np_res[1:], ~expected[1:])
+
+
 class TestDatetimeArrayComparisons:
     # TODO: merge this into tests/arithmetic/test_datetime64 once it is
     #  sufficiently robust
@@ -48,6 +245,36 @@ def test_cmp_dt64_arraylike_tznaive(self, comparison_op):
 
 
 class TestDatetimeArray:
+    def test_astype_non_nano_tznaive(self):
+        dti = pd.date_range("2016-01-01", periods=3)
+
+        res = dti.astype("M8[s]")
+        assert res.dtype == "M8[s]"
+
+        dta = dti._data
+        res = dta.astype("M8[s]")
+        assert res.dtype == "M8[s]"
+        assert isinstance(res, pd.core.arrays.DatetimeArray)  # used to be ndarray
+
+    def test_astype_non_nano_tzaware(self):
+        dti = pd.date_range("2016-01-01", periods=3, tz="UTC")
+
+        res = dti.astype("M8[s, US/Pacific]")
+        assert res.dtype == "M8[s, US/Pacific]"
+
+        dta = dti._data
+        res = dta.astype("M8[s, US/Pacific]")
+        assert res.dtype == "M8[s, US/Pacific]"
+
+        # from non-nano to non-nano, preserving reso
+        res2 = res.astype("M8[s, UTC]")
+        assert res2.dtype == "M8[s, UTC]"
+        assert not tm.shares_memory(res2, res)
+
+        res3 = res.astype("M8[s, UTC]", copy=False)
+        assert res2.dtype == "M8[s, UTC]"
+        assert tm.shares_memory(res3, res)
+
     def test_astype_to_same(self):
         arr = DatetimeArray._from_sequence(
             ["2000"], dtype=DatetimeTZDtype(tz="US/Central")
@@ -77,18 +304,19 @@ def test_astype_copies(self, dtype, other):
     @pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
     def test_astype_int(self, dtype):
         arr = DatetimeArray._from_sequence([pd.Timestamp("2000"), pd.Timestamp("2001")])
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(int..) deprecated
-            result = arr.astype(dtype)
 
         if np.dtype(dtype).kind == "u":
             expected_dtype = np.dtype("uint64")
         else:
             expected_dtype = np.dtype("int64")
+        expected = arr.astype(expected_dtype)
 
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(int..) deprecated
-            expected = arr.astype(expected_dtype)
+        warn = None
+        if dtype != expected_dtype:
+            warn = FutureWarning
+        msg = " will return exactly the specified dtype"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = arr.astype(dtype)
 
         assert result.dtype == expected_dtype
         tm.assert_numpy_array_equal(result, expected)
@@ -285,7 +513,7 @@ def test_array_interface(self):
 
     @pytest.mark.parametrize("index", [True, False])
     def test_searchsorted_different_tz(self, index):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = DatetimeArray(data, freq="D").tz_localize("Asia/Tokyo")
         if index:
             arr = pd.Index(arr)
@@ -300,7 +528,7 @@ def test_searchsorted_different_tz(self, index):
 
     @pytest.mark.parametrize("index", [True, False])
     def test_searchsorted_tzawareness_compat(self, index):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = DatetimeArray(data, freq="D")
         if index:
             arr = pd.Index(arr)
@@ -327,14 +555,14 @@ def test_searchsorted_tzawareness_compat(self, index):
             np.timedelta64("NaT"),
             pd.Timedelta(days=2),
             "invalid",
-            np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
-            np.arange(10).view("timedelta64[ns]") * 24 * 3600 * 10 ** 9,
+            np.arange(10, dtype="i8") * 24 * 3600 * 10**9,
+            np.arange(10).view("timedelta64[ns]") * 24 * 3600 * 10**9,
             pd.Timestamp("2021-01-01").to_period("D"),
         ],
     )
     @pytest.mark.parametrize("index", [True, False])
     def test_searchsorted_invalid_types(self, other, index):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = DatetimeArray(data, freq="D")
         if index:
             arr = pd.Index(arr)
diff --git a/pandas/tests/arrays/test_period.py b/pandas/tests/arrays/test_period.py
index 2592a0263c585..a4b442ff526e9 100644
--- a/pandas/tests/arrays/test_period.py
+++ b/pandas/tests/arrays/test_period.py
@@ -115,6 +115,20 @@ def test_sub_period():
         arr - other
 
 
+def test_sub_period_overflow():
+    # GH#47538
+    dti = pd.date_range("1677-09-22", periods=2, freq="D")
+    pi = dti.to_period("ns")
+
+    per = pd.Period._from_ordinal(10**14, pi.freq)
+
+    with pytest.raises(OverflowError, match="Overflow in int64 addition"):
+        pi - per
+
+    with pytest.raises(OverflowError, match="Overflow in int64 addition"):
+        per - pi
+
+
 # ----------------------------------------------------------------------------
 # Methods
 
@@ -124,10 +138,16 @@ def test_sub_period():
     [pd.Period("2000", freq="H"), period_array(["2000", "2001", "2000"], freq="H")],
 )
 def test_where_different_freq_raises(other):
+    # GH#45768 The PeriodArray method raises, the Series method coerces
     ser = pd.Series(period_array(["2000", "2001", "2002"], freq="D"))
     cond = np.array([True, False, True])
+
     with pytest.raises(IncompatibleFrequency, match="freq"):
-        ser.where(cond, other)
+        ser.array._where(cond, other)
+
+    res = ser.where(cond, other)
+    expected = ser.astype(object).where(cond, other)
+    tm.assert_series_equal(res, expected)
 
 
 # ----------------------------------------------------------------------------
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index 6b6f677cbf7e8..b3b79bd988ad8 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -1,28 +1,190 @@
+from datetime import timedelta
+
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
 import pandas as pd
 from pandas import Timedelta
 import pandas._testing as tm
-from pandas.core.arrays import TimedeltaArray
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def unit(self, request):
+        return request.param
+
+    @pytest.fixture
+    def reso(self, unit):
+        if unit == "s":
+            return NpyDatetimeUnit.NPY_FR_s.value
+        elif unit == "ms":
+            return NpyDatetimeUnit.NPY_FR_ms.value
+        elif unit == "us":
+            return NpyDatetimeUnit.NPY_FR_us.value
+        else:
+            raise NotImplementedError(unit)
+
+    @pytest.fixture
+    def tda(self, unit):
+        arr = np.arange(5, dtype=np.int64).view(f"m8[{unit}]")
+        return TimedeltaArray._simple_new(arr, dtype=arr.dtype)
+
+    def test_non_nano(self, unit, reso):
+        arr = np.arange(5, dtype=np.int64).view(f"m8[{unit}]")
+        tda = TimedeltaArray._simple_new(arr, dtype=arr.dtype)
+
+        assert tda.dtype == arr.dtype
+        assert tda[0]._reso == reso
+
+    @pytest.mark.parametrize("field", TimedeltaArray._field_ops)
+    def test_fields(self, tda, field):
+        as_nano = tda._ndarray.astype("m8[ns]")
+        tda_nano = TimedeltaArray._simple_new(as_nano, dtype=as_nano.dtype)
+
+        result = getattr(tda, field)
+        expected = getattr(tda_nano, field)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_pytimedelta(self, tda):
+        as_nano = tda._ndarray.astype("m8[ns]")
+        tda_nano = TimedeltaArray._simple_new(as_nano, dtype=as_nano.dtype)
+
+        result = tda.to_pytimedelta()
+        expected = tda_nano.to_pytimedelta()
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_total_seconds(self, unit, tda):
+        as_nano = tda._ndarray.astype("m8[ns]")
+        tda_nano = TimedeltaArray._simple_new(as_nano, dtype=as_nano.dtype)
+
+        result = tda.total_seconds()
+        expected = tda_nano.total_seconds()
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "nat", [np.datetime64("NaT", "ns"), np.datetime64("NaT", "us")]
+    )
+    def test_add_nat_datetimelike_scalar(self, nat, tda):
+        result = tda + nat
+        assert isinstance(result, DatetimeArray)
+        assert result._reso == tda._reso
+        assert result.isna().all()
+
+        result = nat + tda
+        assert isinstance(result, DatetimeArray)
+        assert result._reso == tda._reso
+        assert result.isna().all()
+
+    def test_add_pdnat(self, tda):
+        result = tda + pd.NaT
+        assert isinstance(result, TimedeltaArray)
+        assert result._reso == tda._reso
+        assert result.isna().all()
+
+        result = pd.NaT + tda
+        assert isinstance(result, TimedeltaArray)
+        assert result._reso == tda._reso
+        assert result.isna().all()
+
+    # TODO: 2022-07-11 this is the only test that gets to DTA.tz_convert
+    #  or tz_localize with non-nano; implement tests specific to that.
+    def test_add_datetimelike_scalar(self, tda, tz_naive_fixture):
+        ts = pd.Timestamp("2016-01-01", tz=tz_naive_fixture)
+
+        msg = "with mis-matched resolutions"
+        with pytest.raises(NotImplementedError, match=msg):
+            # mismatched reso -> check that we don't give an incorrect result
+            tda + ts
+        with pytest.raises(NotImplementedError, match=msg):
+            # mismatched reso -> check that we don't give an incorrect result
+            ts + tda
+
+        ts = ts._as_unit(tda._unit)
+
+        exp_values = tda._ndarray + ts.asm8
+        expected = (
+            DatetimeArray._simple_new(exp_values, dtype=exp_values.dtype)
+            .tz_localize("UTC")
+            .tz_convert(ts.tz)
+        )
+
+        result = tda + ts
+        tm.assert_extension_array_equal(result, expected)
+
+        result = ts + tda
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_mul_scalar(self, tda):
+        other = 2
+        result = tda * other
+        expected = TimedeltaArray._simple_new(tda._ndarray * other, dtype=tda.dtype)
+        tm.assert_extension_array_equal(result, expected)
+        assert result._reso == tda._reso
+
+    def test_mul_listlike(self, tda):
+        other = np.arange(len(tda))
+        result = tda * other
+        expected = TimedeltaArray._simple_new(tda._ndarray * other, dtype=tda.dtype)
+        tm.assert_extension_array_equal(result, expected)
+        assert result._reso == tda._reso
+
+    def test_mul_listlike_object(self, tda):
+        other = np.arange(len(tda))
+        result = tda * other.astype(object)
+        expected = TimedeltaArray._simple_new(tda._ndarray * other, dtype=tda.dtype)
+        tm.assert_extension_array_equal(result, expected)
+        assert result._reso == tda._reso
+
+    def test_div_numeric_scalar(self, tda):
+        other = 2
+        result = tda / other
+        expected = TimedeltaArray._simple_new(tda._ndarray / other, dtype=tda.dtype)
+        tm.assert_extension_array_equal(result, expected)
+        assert result._reso == tda._reso
+
+    def test_div_td_scalar(self, tda):
+        other = timedelta(seconds=1)
+        result = tda / other
+        expected = tda._ndarray / np.timedelta64(1, "s")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_div_numeric_array(self, tda):
+        other = np.arange(len(tda))
+        result = tda / other
+        expected = TimedeltaArray._simple_new(tda._ndarray / other, dtype=tda.dtype)
+        tm.assert_extension_array_equal(result, expected)
+        assert result._reso == tda._reso
+
+    def test_div_td_array(self, tda):
+        other = tda._ndarray + tda._ndarray[-1]
+        result = tda / other
+        expected = tda._ndarray / other
+        tm.assert_numpy_array_equal(result, expected)
 
 
 class TestTimedeltaArray:
     @pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
     def test_astype_int(self, dtype):
         arr = TimedeltaArray._from_sequence([Timedelta("1H"), Timedelta("2H")])
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(int..) deprecated
-            result = arr.astype(dtype)
 
         if np.dtype(dtype).kind == "u":
             expected_dtype = np.dtype("uint64")
         else:
             expected_dtype = np.dtype("int64")
+        expected = arr.astype(expected_dtype)
 
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(int..) deprecated
-            expected = arr.astype(expected_dtype)
+        warn = None
+        if dtype != expected_dtype:
+            warn = FutureWarning
+        msg = " will return exactly the specified dtype"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = arr.astype(dtype)
 
         assert result.dtype == expected_dtype
         tm.assert_numpy_array_equal(result, expected)
@@ -57,14 +219,14 @@ def test_setitem_objects(self, obj):
             np.datetime64("NaT"),
             pd.Timestamp("2021-01-01"),
             "invalid",
-            np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
-            (np.arange(10) * 24 * 3600 * 10 ** 9).view("datetime64[ns]"),
+            np.arange(10, dtype="i8") * 24 * 3600 * 10**9,
+            (np.arange(10) * 24 * 3600 * 10**9).view("datetime64[ns]"),
             pd.Timestamp("2021-01-01").to_period("D"),
         ],
     )
     @pytest.mark.parametrize("index", [True, False])
     def test_searchsorted_invalid_types(self, other, index):
-        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
         arr = TimedeltaArray(data, freq="D")
         if index:
             arr = pd.Index(arr)
@@ -81,10 +243,10 @@ def test_searchsorted_invalid_types(self, other, index):
 
 class TestUnaryOps:
     def test_abs(self):
-        vals = np.array([-3600 * 10 ** 9, "NaT", 7200 * 10 ** 9], dtype="m8[ns]")
+        vals = np.array([-3600 * 10**9, "NaT", 7200 * 10**9], dtype="m8[ns]")
         arr = TimedeltaArray(vals)
 
-        evals = np.array([3600 * 10 ** 9, "NaT", 7200 * 10 ** 9], dtype="m8[ns]")
+        evals = np.array([3600 * 10**9, "NaT", 7200 * 10**9], dtype="m8[ns]")
         expected = TimedeltaArray(evals)
 
         result = abs(arr)
@@ -94,7 +256,7 @@ def test_abs(self):
         tm.assert_timedelta_array_equal(result2, expected)
 
     def test_pos(self):
-        vals = np.array([-3600 * 10 ** 9, "NaT", 7200 * 10 ** 9], dtype="m8[ns]")
+        vals = np.array([-3600 * 10**9, "NaT", 7200 * 10**9], dtype="m8[ns]")
         arr = TimedeltaArray(vals)
 
         result = +arr
@@ -106,10 +268,10 @@ def test_pos(self):
         assert not tm.shares_memory(result2, arr)
 
     def test_neg(self):
-        vals = np.array([-3600 * 10 ** 9, "NaT", 7200 * 10 ** 9], dtype="m8[ns]")
+        vals = np.array([-3600 * 10**9, "NaT", 7200 * 10**9], dtype="m8[ns]")
         arr = TimedeltaArray(vals)
 
-        evals = np.array([3600 * 10 ** 9, "NaT", -7200 * 10 ** 9], dtype="m8[ns]")
+        evals = np.array([3600 * 10**9, "NaT", -7200 * 10**9], dtype="m8[ns]")
         expected = TimedeltaArray(evals)
 
         result = -arr
diff --git a/pandas/tests/arrays/timedeltas/test_constructors.py b/pandas/tests/arrays/timedeltas/test_constructors.py
index d297e745f107b..d24fabfeecb26 100644
--- a/pandas/tests/arrays/timedeltas/test_constructors.py
+++ b/pandas/tests/arrays/timedeltas/test_constructors.py
@@ -19,7 +19,7 @@ def test_only_1dim_accepted(self):
 
     def test_freq_validation(self):
         # ensure that the public constructor cannot create an invalid instance
-        arr = np.array([0, 0, 1], dtype=np.int64) * 3600 * 10 ** 9
+        arr = np.array([0, 0, 1], dtype=np.int64) * 3600 * 10**9
 
         msg = (
             "Inferred frequency None from passed values does not "
diff --git a/pandas/tests/arrays/timedeltas/test_reductions.py b/pandas/tests/arrays/timedeltas/test_reductions.py
index 586a9187fc169..72d45f5b9a78c 100644
--- a/pandas/tests/arrays/timedeltas/test_reductions.py
+++ b/pandas/tests/arrays/timedeltas/test_reductions.py
@@ -147,7 +147,7 @@ def test_std(self, add):
 
         if getattr(arr, "tz", None) is None:
             result = nanops.nanstd(np.asarray(arr), skipna=True)
-            assert isinstance(result, Timedelta)
+            assert isinstance(result, np.timedelta64)
             assert result == expected
 
         result = arr.std(skipna=False)
@@ -158,7 +158,8 @@ def test_std(self, add):
 
         if getattr(arr, "tz", None) is None:
             result = nanops.nanstd(np.asarray(arr), skipna=False)
-            assert result is pd.NaT
+            assert isinstance(result, np.timedelta64)
+            assert np.isnat(result)
 
     def test_median(self):
         tdi = pd.TimedeltaIndex(["0H", "3H", "NaT", "5H06m", "0H", "2H"])
diff --git a/pandas/tests/base/test_constructors.py b/pandas/tests/base/test_constructors.py
index 16ce709a5b021..858eaacd67ec2 100644
--- a/pandas/tests/base/test_constructors.py
+++ b/pandas/tests/base/test_constructors.py
@@ -51,12 +51,9 @@ def bar(self, *args, **kwargs):
             pass
 
     class Delegate(PandasDelegate, PandasObject):
-        def __init__(self, obj):
+        def __init__(self, obj) -> None:
             self.obj = obj
 
-    def setup_method(self, method):
-        pass
-
     def test_invalid_delegation(self):
         # these show that in order for the delegation to work
         # the _delegate_* methods need to be overridden to not raise
@@ -160,7 +157,7 @@ def test_constructor_datetime_outofbound(self, a, klass):
 
         # Explicit dtype specified
         # Forced conversion fails for all -> all cases raise error
-        msg = "Out of bounds"
+        msg = "Out of bounds|Out of bounds .* present at position 0"
         with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
             klass(a, dtype="datetime64[ns]")
 
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
index 84e4992cce0e3..599aaae4d3527 100644
--- a/pandas/tests/base/test_conversion.py
+++ b/pandas/tests/base/test_conversion.py
@@ -199,7 +199,7 @@ def test_iter_box(self):
             "datetime64[ns]",
         ),
         (
-            pd.TimedeltaIndex([10 ** 10]),
+            pd.TimedeltaIndex([10**10]),
             TimedeltaArray,
             "m8[ns]",
         ),
@@ -415,6 +415,49 @@ def test_to_numpy_na_value_numpy_dtype(
     tm.assert_numpy_array_equal(result, expected)
 
 
+@pytest.mark.parametrize(
+    "data, multiindex, dtype, na_value, expected",
+    [
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            None,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            np.nan,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1.0, 2.0, np.nan, 4.0],
+            [("a", 0), ("a", 1), ("a", 2), ("b", 0)],
+            int,
+            0,
+            [1, 2, 0, 4],
+        ),
+        (
+            [Timestamp("2000"), Timestamp("2000"), pd.NaT],
+            [(0, Timestamp("2021")), (0, Timestamp("2022")), (1, Timestamp("2000"))],
+            None,
+            Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+def test_to_numpy_multiindex_series_na_value(
+    data, multiindex, dtype, na_value, expected
+):
+    index = pd.MultiIndex.from_tuples(multiindex)
+    series = Series(data, index=index)
+    result = series.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
 def test_to_numpy_kwargs_raises():
     # numpy
     s = Series([1, 2, 3])
diff --git a/pandas/tests/base/test_misc.py b/pandas/tests/base/test_misc.py
index f3be4749fb3aa..a55c013a7340d 100644
--- a/pandas/tests/base/test_misc.py
+++ b/pandas/tests/base/test_misc.py
@@ -84,6 +84,17 @@ def test_ndarray_compat_properties(index_or_series_obj):
     assert Series([1]).item() == 1
 
 
+def test_array_wrap_compat():
+    # Note: at time of dask 2022.01.0, this is still used by eg dask
+    # (https://github.com/dask/dask/issues/8580).
+    # This test is a small dummy ensuring coverage
+    orig = Series([1, 2, 3], dtype="int64", index=["a", "b", "c"])
+    with tm.assert_produces_warning(DeprecationWarning):
+        result = orig.__array_wrap__(np.array([2, 4, 6], dtype="int64"))
+    expected = orig * 2
+    tm.assert_series_equal(result, expected)
+
+
 @pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
 def test_memory_usage(index_or_series_obj):
     obj = index_or_series_obj
@@ -130,21 +141,30 @@ def test_memory_usage_components_series(series_with_simple_index):
 
 @pytest.mark.parametrize("dtype", tm.NARROW_NP_DTYPES)
 def test_memory_usage_components_narrow_series(dtype):
-    series = tm.makeFloatSeries(name="a").astype(dtype)
+    series = tm.make_rand_series(name="a", dtype=dtype)
     total_usage = series.memory_usage(index=True)
     non_index_usage = series.memory_usage(index=False)
     index_usage = series.index.memory_usage()
     assert total_usage == non_index_usage + index_usage
 
 
-def test_searchsorted(index_or_series_obj):
+def test_searchsorted(request, index_or_series_obj):
     # numpy.searchsorted calls obj.searchsorted under the hood.
     # See gh-12238
     obj = index_or_series_obj
 
     if isinstance(obj, pd.MultiIndex):
         # See gh-14833
-        pytest.skip("np.searchsorted doesn't work on pd.MultiIndex")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="np.searchsorted doesn't work on pd.MultiIndex: GH 14833"
+            )
+        )
+    elif obj.dtype.kind == "c" and isinstance(obj, Index):
+        # TODO: Should Series cases also raise? Looks like they use numpy
+        #  comparison semantics https://github.com/numpy/numpy/issues/15981
+        mark = pytest.mark.xfail(reason="complex objects are not comparable")
+        request.node.add_marker(mark)
 
     max_obj = max(obj, default=0)
     index = np.searchsorted(obj, max_obj)
diff --git a/pandas/tests/base/test_unique.py b/pandas/tests/base/test_unique.py
index ac21c2f979dd4..eac1e35699585 100644
--- a/pandas/tests/base/test_unique.py
+++ b/pandas/tests/base/test_unique.py
@@ -1,6 +1,9 @@
 import numpy as np
 import pytest
 
+from pandas.compat import pa_version_under2p0
+from pandas.errors import PerformanceWarning
+
 from pandas.core.dtypes.common import is_datetime64tz_dtype
 
 import pandas as pd
@@ -12,7 +15,11 @@
 def test_unique(index_or_series_obj):
     obj = index_or_series_obj
     obj = np.repeat(obj, range(1, len(obj) + 1))
-    result = obj.unique()
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+    ):
+        result = obj.unique()
 
     # dict.fromkeys preserves the order
     unique_values = list(dict.fromkeys(obj.values))
@@ -50,7 +57,11 @@ def test_unique_null(null_obj, index_or_series_obj):
     klass = type(obj)
     repeated_values = np.repeat(values, range(1, len(values) + 1))
     obj = klass(repeated_values, dtype=obj.dtype)
-    result = obj.unique()
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+    ):
+        result = obj.unique()
 
     unique_values_raw = dict.fromkeys(obj.values)
     # because np.nan == np.nan is False, but None == None is True
@@ -75,7 +86,11 @@ def test_unique_null(null_obj, index_or_series_obj):
 def test_nunique(index_or_series_obj):
     obj = index_or_series_obj
     obj = np.repeat(obj, range(1, len(obj) + 1))
-    expected = len(obj.unique())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+    ):
+        expected = len(obj.unique())
     assert obj.nunique(dropna=False) == expected
 
 
@@ -99,12 +114,27 @@ def test_nunique_null(null_obj, index_or_series_obj):
         assert obj.nunique() == len(obj.categories)
         assert obj.nunique(dropna=False) == len(obj.categories) + 1
     else:
-        num_unique_values = len(obj.unique())
-        assert obj.nunique() == max(0, num_unique_values - 1)
-        assert obj.nunique(dropna=False) == max(0, num_unique_values)
-
-
-@pytest.mark.single
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+        ):
+            num_unique_values = len(obj.unique())
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+        ):
+            assert obj.nunique() == max(0, num_unique_values - 1)
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under2p0 and str(index_or_series_obj.dtype) == "string[pyarrow]",
+        ):
+            assert obj.nunique(dropna=False) == max(0, num_unique_values)
+
+
+@pytest.mark.single_cpu
+@pytest.mark.xfail(
+    reason="Flaky in the CI. Remove once CI has a single build: GH 44584", strict=False
+)
 def test_unique_bad_unicode(index_or_series):
     # regression test for #34550
     uval = "\ud83d"  # smiley emoji
diff --git a/pandas/tests/base/test_value_counts.py b/pandas/tests/base/test_value_counts.py
index 13bf096cfe167..af6546691eed2 100644
--- a/pandas/tests/base/test_value_counts.py
+++ b/pandas/tests/base/test_value_counts.py
@@ -4,6 +4,9 @@
 import numpy as np
 import pytest
 
+from pandas.compat import pa_version_under7p0
+from pandas.errors import PerformanceWarning
+
 import pandas as pd
 from pandas import (
     DatetimeIndex,
@@ -36,8 +39,16 @@ def test_value_counts(index_or_series_obj):
     # TODO(GH#32514): Order of entries with the same count is inconsistent
     #  on CI (gh-32449)
     if obj.duplicated().any():
-        result = result.sort_index()
-        expected = expected.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            result = result.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            expected = expected.sort_index()
     tm.assert_series_equal(result, expected)
 
 
@@ -70,8 +81,16 @@ def test_value_counts_null(null_obj, index_or_series_obj):
     if obj.duplicated().any():
         # TODO(GH#32514):
         #  Order of entries with the same count is inconsistent on CI (gh-32449)
-        expected = expected.sort_index()
-        result = result.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            expected = expected.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            result = result.sort_index()
 
     if not isinstance(result.dtype, np.dtype):
         # i.e IntegerDtype
@@ -84,8 +103,16 @@ def test_value_counts_null(null_obj, index_or_series_obj):
     if obj.duplicated().any():
         # TODO(GH#32514):
         #  Order of entries with the same count is inconsistent on CI (gh-32449)
-        expected = expected.sort_index()
-        result = result.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            expected = expected.sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            result = result.sort_index()
     tm.assert_series_equal(result, expected)
 
 
@@ -284,7 +311,7 @@ def test_value_counts_with_nan(dropna, index_or_series):
     obj = klass(values)
     res = obj.value_counts(dropna=dropna)
     if dropna is True:
-        expected = Series([1], index=[True])
+        expected = Series([1], index=Index([True], dtype=obj.dtype))
     else:
         expected = Series([1, 1, 1], index=[True, pd.NA, np.nan])
     tm.assert_series_equal(res, expected)
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index 948eeeecb2ce4..b3b80e8e5db65 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -3,12 +3,17 @@
 from functools import reduce
 from itertools import product
 import operator
+import random
 import warnings
 
 import numpy as np
 import pytest
 
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    NumExprClobberingError,
+    PerformanceWarning,
+    UndefinedVariableError,
+)
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import (
@@ -26,10 +31,7 @@
 )
 import pandas._testing as tm
 from pandas.core.computation import pytables
-from pandas.core.computation.engines import (
-    ENGINES,
-    NumExprClobberingError,
-)
+from pandas.core.computation.engines import ENGINES
 import pandas.core.computation.expr as expr
 from pandas.core.computation.expr import (
     BaseExprVisitor,
@@ -47,6 +49,7 @@
     _binary_ops_dict,
     _unary_math_ops,
 )
+from pandas.core.computation.scope import DEFAULT_GLOBALS
 
 
 @pytest.fixture(
@@ -74,22 +77,14 @@ def parser(request):
     return request.param
 
 
-def _get_unary_fns_for_ne():
-    return list(_unary_math_ops) if NUMEXPR_INSTALLED else []
-
-
-@pytest.fixture(params=_get_unary_fns_for_ne())
+@pytest.fixture(params=list(_unary_math_ops) if NUMEXPR_INSTALLED else [])
 def unary_fns_for_ne(request):
     return request.param
 
 
-def engine_has_neg_frac(engine):
-    return ENGINES[engine].has_neg_frac
-
-
 def _eval_single_bin(lhs, cmp1, rhs, engine):
     c = _binary_ops_dict[cmp1]
-    if engine_has_neg_frac(engine):
+    if ENGINES[engine].has_neg_frac:
         try:
             return c(lhs, rhs)
         except ValueError as e:
@@ -101,29 +96,6 @@ def _eval_single_bin(lhs, cmp1, rhs, engine):
     return c(lhs, rhs)
 
 
-def _series_and_2d_ndarray(lhs, rhs):
-    return (
-        isinstance(lhs, Series) and isinstance(rhs, np.ndarray) and rhs.ndim > 1
-    ) or (isinstance(rhs, Series) and isinstance(lhs, np.ndarray) and lhs.ndim > 1)
-
-
-def _series_and_frame(lhs, rhs):
-    return (isinstance(lhs, Series) and isinstance(rhs, DataFrame)) or (
-        isinstance(rhs, Series) and isinstance(lhs, DataFrame)
-    )
-
-
-def _bool_and_frame(lhs, rhs):
-    return isinstance(lhs, bool) and isinstance(rhs, pd.core.generic.NDFrame)
-
-
-def _is_py3_complex_incompat(result, expected):
-    return isinstance(expected, (complex, np.complexfloating)) and np.isnan(result)
-
-
-_good_arith_ops = sorted(set(ARITH_OPS_SYMS).difference(SPECIAL_CASE_ARITH_OPS_SYMS))
-
-
 # TODO: using range(5) here is a kludge
 @pytest.fixture(
     params=list(range(5)),
@@ -149,22 +121,6 @@ def lhs(request):
 
 
 class TestEval:
-    @pytest.fixture(autouse=True)
-    def set_engine_parser_attrs(self, engine, parser):
-        # Older tests look for these as attributes, so we set them here.
-        self.engine = engine
-        self.parser = parser
-
-    @classmethod
-    def setup_class(cls):
-        import numexpr as ne
-
-        cls.ne = ne
-
-    @property
-    def current_engines(self):
-        return (engine for engine in ENGINES if engine != self.engine)
-
     @pytest.mark.parametrize(
         "cmp1",
         ["!=", "==", "<=", ">=", "<", ">"],
@@ -172,178 +128,195 @@ def current_engines(self):
     )
     @pytest.mark.parametrize("cmp2", [">", "<"], ids=["gt", "lt"])
     @pytest.mark.parametrize("binop", expr.BOOL_OPS_SYMS)
-    def test_complex_cmp_ops(self, cmp1, cmp2, binop, lhs, rhs):
-        if self.parser == "python" and binop in ["and", "or"]:
+    def test_complex_cmp_ops(self, cmp1, cmp2, binop, lhs, rhs, engine, parser):
+        if parser == "python" and binop in ["and", "or"]:
             msg = "'BoolOp' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
                 ex = f"(lhs {cmp1} rhs) {binop} (lhs {cmp2} rhs)"
-                result = pd.eval(ex, engine=self.engine, parser=self.parser)
+                pd.eval(ex, engine=engine, parser=parser)
             return
 
-        lhs_new = _eval_single_bin(lhs, cmp1, rhs, self.engine)
-        rhs_new = _eval_single_bin(lhs, cmp2, rhs, self.engine)
-        expected = _eval_single_bin(lhs_new, binop, rhs_new, self.engine)
+        lhs_new = _eval_single_bin(lhs, cmp1, rhs, engine)
+        rhs_new = _eval_single_bin(lhs, cmp2, rhs, engine)
+        expected = _eval_single_bin(lhs_new, binop, rhs_new, engine)
 
         ex = f"(lhs {cmp1} rhs) {binop} (lhs {cmp2} rhs)"
-        result = pd.eval(ex, engine=self.engine, parser=self.parser)
-        self.check_equal(result, expected)
+        result = pd.eval(ex, engine=engine, parser=parser)
+        tm.assert_equal(result, expected)
 
     @pytest.mark.parametrize("cmp_op", expr.CMP_OPS_SYMS)
-    def test_simple_cmp_ops(self, cmp_op, lhs, rhs):
+    def test_simple_cmp_ops(self, cmp_op, lhs, rhs, engine, parser):
         lhs = lhs < 0
         rhs = rhs < 0
 
-        if self.parser == "python" and cmp_op in ["in", "not in"]:
+        if parser == "python" and cmp_op in ["in", "not in"]:
             msg = "'(In|NotIn)' nodes are not implemented"
 
             with pytest.raises(NotImplementedError, match=msg):
-                self.check_simple_cmp_op(lhs, cmp_op, rhs)
+                ex = f"lhs {cmp_op} rhs"
+                pd.eval(ex, engine=engine, parser=parser)
             return
 
-        self.check_simple_cmp_op(lhs, cmp_op, rhs)
+        ex = f"lhs {cmp_op} rhs"
+        msg = "|".join(
+            [
+                r"only list-like( or dict-like)? objects are allowed to be "
+                r"passed to (DataFrame\.)?isin\(\), you passed a "
+                r"(\[|')bool(\]|')",
+                "argument of type 'bool' is not iterable",
+            ]
+        )
+        if cmp_op in ("in", "not in") and not is_list_like(rhs):
+            with pytest.raises(TypeError, match=msg):
+                pd.eval(
+                    ex,
+                    engine=engine,
+                    parser=parser,
+                    local_dict={"lhs": lhs, "rhs": rhs},
+                )
+        else:
+            expected = _eval_single_bin(lhs, cmp_op, rhs, engine)
+            result = pd.eval(ex, engine=engine, parser=parser)
+            tm.assert_equal(result, expected)
 
     @pytest.mark.parametrize("op", expr.CMP_OPS_SYMS)
-    def test_compound_invert_op(self, op, lhs, rhs, request):
-        if self.parser == "python" and op in ["in", "not in"]:
+    def test_compound_invert_op(self, op, lhs, rhs, request, engine, parser):
+        if parser == "python" and op in ["in", "not in"]:
 
             msg = "'(In|NotIn)' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
-                self.check_compound_invert_op(lhs, op, rhs)
+                ex = f"~(lhs {op} rhs)"
+                pd.eval(ex, engine=engine, parser=parser)
             return
 
         if (
             is_float(lhs)
             and not is_float(rhs)
             and op in ["in", "not in"]
-            and self.engine == "python"
-            and self.parser == "pandas"
+            and engine == "python"
+            and parser == "pandas"
         ):
             mark = pytest.mark.xfail(
                 reason="Looks like expected is negative, unclear whether "
                 "expected is incorrect or result is incorrect"
             )
             request.node.add_marker(mark)
+        skip_these = ["in", "not in"]
+        ex = f"~(lhs {op} rhs)"
 
-        self.check_compound_invert_op(lhs, op, rhs)
+        msg = "|".join(
+            [
+                r"only list-like( or dict-like)? objects are allowed to be "
+                r"passed to (DataFrame\.)?isin\(\), you passed a "
+                r"(\[|')float(\]|')",
+                "argument of type 'float' is not iterable",
+            ]
+        )
+        if is_scalar(rhs) and op in skip_these:
+            with pytest.raises(TypeError, match=msg):
+                pd.eval(
+                    ex,
+                    engine=engine,
+                    parser=parser,
+                    local_dict={"lhs": lhs, "rhs": rhs},
+                )
+        else:
+            # compound
+            if is_scalar(lhs) and is_scalar(rhs):
+                lhs, rhs = map(lambda x: np.array([x]), (lhs, rhs))
+            expected = _eval_single_bin(lhs, op, rhs, engine)
+            if is_scalar(expected):
+                expected = not expected
+            else:
+                expected = ~expected
+            result = pd.eval(ex, engine=engine, parser=parser)
+            tm.assert_almost_equal(expected, result)
 
     @pytest.mark.parametrize("cmp1", ["<", ">"])
     @pytest.mark.parametrize("cmp2", ["<", ">"])
-    def test_chained_cmp_op(self, cmp1, cmp2, lhs, midhs, rhs):
-        self.check_chained_cmp_op(lhs, cmp1, midhs, cmp2, rhs)
-
-    def check_equal(self, result, expected):
-        if isinstance(result, DataFrame):
-            tm.assert_frame_equal(result, expected)
-        elif isinstance(result, Series):
-            tm.assert_series_equal(result, expected)
-        elif isinstance(result, np.ndarray):
-            tm.assert_numpy_array_equal(result, expected)
-        else:
-            assert result == expected
-
-    def check_chained_cmp_op(self, lhs, cmp1, mid, cmp2, rhs):
-
-        if self.parser == "python":
+    def test_chained_cmp_op(self, cmp1, cmp2, lhs, midhs, rhs, engine, parser):
+        mid = midhs
+        if parser == "python":
             ex1 = f"lhs {cmp1} mid {cmp2} rhs"
             msg = "'BoolOp' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval(ex1, engine=self.engine, parser=self.parser)
+                pd.eval(ex1, engine=engine, parser=parser)
             return
 
-        lhs_new = _eval_single_bin(lhs, cmp1, mid, self.engine)
-        rhs_new = _eval_single_bin(mid, cmp2, rhs, self.engine)
+        lhs_new = _eval_single_bin(lhs, cmp1, mid, engine)
+        rhs_new = _eval_single_bin(mid, cmp2, rhs, engine)
 
         if lhs_new is not None and rhs_new is not None:
             ex1 = f"lhs {cmp1} mid {cmp2} rhs"
             ex2 = f"lhs {cmp1} mid and mid {cmp2} rhs"
             ex3 = f"(lhs {cmp1} mid) & (mid {cmp2} rhs)"
-            expected = _eval_single_bin(lhs_new, "&", rhs_new, self.engine)
+            expected = _eval_single_bin(lhs_new, "&", rhs_new, engine)
 
             for ex in (ex1, ex2, ex3):
-                result = pd.eval(ex, engine=self.engine, parser=self.parser)
+                result = pd.eval(ex, engine=engine, parser=parser)
 
                 tm.assert_almost_equal(result, expected)
 
-    def check_simple_cmp_op(self, lhs, cmp1, rhs):
-        ex = f"lhs {cmp1} rhs"
-        msg = "|".join(
-            [
-                r"only list-like( or dict-like)? objects are allowed to be "
-                r"passed to (DataFrame\.)?isin\(\), you passed a "
-                r"(\[|')bool(\]|')",
-                "argument of type 'bool' is not iterable",
-            ]
-        )
-        if cmp1 in ("in", "not in") and not is_list_like(rhs):
-            with pytest.raises(TypeError, match=msg):
-                pd.eval(
-                    ex,
-                    engine=self.engine,
-                    parser=self.parser,
-                    local_dict={"lhs": lhs, "rhs": rhs},
-                )
-        else:
-            expected = _eval_single_bin(lhs, cmp1, rhs, self.engine)
-            result = pd.eval(ex, engine=self.engine, parser=self.parser)
-            self.check_equal(result, expected)
-
-    @pytest.mark.parametrize("arith1", _good_arith_ops)
-    def test_binary_arith_ops(self, arith1, lhs, rhs):
+    @pytest.mark.parametrize(
+        "arith1", sorted(set(ARITH_OPS_SYMS).difference(SPECIAL_CASE_ARITH_OPS_SYMS))
+    )
+    def test_binary_arith_ops(self, arith1, lhs, rhs, engine, parser):
         ex = f"lhs {arith1} rhs"
-        result = pd.eval(ex, engine=self.engine, parser=self.parser)
-        expected = _eval_single_bin(lhs, arith1, rhs, self.engine)
+        result = pd.eval(ex, engine=engine, parser=parser)
+        expected = _eval_single_bin(lhs, arith1, rhs, engine)
 
         tm.assert_almost_equal(result, expected)
         ex = f"lhs {arith1} rhs {arith1} rhs"
-        result = pd.eval(ex, engine=self.engine, parser=self.parser)
-        nlhs = _eval_single_bin(lhs, arith1, rhs, self.engine)
-        self.check_alignment(result, nlhs, rhs, arith1)
-
-    def check_alignment(self, result, nlhs, ghs, op):
+        result = pd.eval(ex, engine=engine, parser=parser)
+        nlhs = _eval_single_bin(lhs, arith1, rhs, engine)
         try:
-            nlhs, ghs = nlhs.align(ghs)
+            nlhs, ghs = nlhs.align(rhs)
         except (ValueError, TypeError, AttributeError):
             # ValueError: series frame or frame series align
             # TypeError, AttributeError: series or frame with scalar align
-            pass
+            return
         else:
-            if self.engine == "numexpr":
+            if engine == "numexpr":
+                import numexpr as ne
+
                 # direct numpy comparison
-                expected = self.ne.evaluate(f"nlhs {op} ghs")
+                expected = ne.evaluate(f"nlhs {arith1} ghs")
                 # Update assert statement due to unreliable numerical
                 # precision component (GH37328)
                 # TODO: update testing code so that assert_almost_equal statement
                 #  can be replaced again by the assert_numpy_array_equal statement
                 tm.assert_almost_equal(result.values, expected)
             else:
-                expected = eval(f"nlhs {op} ghs")
+                expected = eval(f"nlhs {arith1} ghs")
                 tm.assert_almost_equal(result, expected)
 
     # modulus, pow, and floor division require special casing
 
-    def test_modulus(self, lhs, rhs):
+    def test_modulus(self, lhs, rhs, engine, parser):
         ex = r"lhs % rhs"
-        result = pd.eval(ex, engine=self.engine, parser=self.parser)
+        result = pd.eval(ex, engine=engine, parser=parser)
         expected = lhs % rhs
         tm.assert_almost_equal(result, expected)
 
-        if self.engine == "numexpr":
-            expected = self.ne.evaluate(r"expected % rhs")
+        if engine == "numexpr":
+            import numexpr as ne
+
+            expected = ne.evaluate(r"expected % rhs")
             if isinstance(result, (DataFrame, Series)):
                 tm.assert_almost_equal(result.values, expected)
             else:
                 tm.assert_almost_equal(result, expected.item())
         else:
-            expected = _eval_single_bin(expected, "%", rhs, self.engine)
+            expected = _eval_single_bin(expected, "%", rhs, engine)
             tm.assert_almost_equal(result, expected)
 
-    def test_floor_division(self, lhs, rhs):
+    def test_floor_division(self, lhs, rhs, engine, parser):
         ex = "lhs // rhs"
 
-        if self.engine == "python":
-            res = pd.eval(ex, engine=self.engine, parser=self.parser)
+        if engine == "python":
+            res = pd.eval(ex, engine=engine, parser=parser)
             expected = lhs // rhs
-            self.check_equal(res, expected)
+            tm.assert_equal(res, expected)
         else:
             msg = (
                 r"unsupported operand type\(s\) for //: 'VariableNode' and "
@@ -353,21 +326,22 @@ def test_floor_division(self, lhs, rhs):
                 pd.eval(
                     ex,
                     local_dict={"lhs": lhs, "rhs": rhs},
-                    engine=self.engine,
-                    parser=self.parser,
+                    engine=engine,
+                    parser=parser,
                 )
 
     @td.skip_if_windows
-    def test_pow(self, lhs, rhs):
+    def test_pow(self, lhs, rhs, engine, parser):
         # odd failure on win32 platform, so skip
         ex = "lhs ** rhs"
-        expected = _eval_single_bin(lhs, "**", rhs, self.engine)
-        result = pd.eval(ex, engine=self.engine, parser=self.parser)
+        expected = _eval_single_bin(lhs, "**", rhs, engine)
+        result = pd.eval(ex, engine=engine, parser=parser)
 
         if (
             is_scalar(lhs)
             and is_scalar(rhs)
-            and _is_py3_complex_incompat(result, expected)
+            and isinstance(expected, (complex, np.complexfloating))
+            and np.isnan(result)
         ):
             msg = "(DataFrame.columns|numpy array) are different"
             with pytest.raises(AssertionError, match=msg):
@@ -376,138 +350,96 @@ def test_pow(self, lhs, rhs):
             tm.assert_almost_equal(result, expected)
 
             ex = "(lhs ** rhs) ** rhs"
-            result = pd.eval(ex, engine=self.engine, parser=self.parser)
+            result = pd.eval(ex, engine=engine, parser=parser)
 
-            middle = _eval_single_bin(lhs, "**", rhs, self.engine)
-            expected = _eval_single_bin(middle, "**", rhs, self.engine)
+            middle = _eval_single_bin(lhs, "**", rhs, engine)
+            expected = _eval_single_bin(middle, "**", rhs, engine)
             tm.assert_almost_equal(result, expected)
 
-    def check_single_invert_op(self, lhs):
+    def check_single_invert_op(self, lhs, engine, parser):
         # simple
         try:
             elb = lhs.astype(bool)
         except AttributeError:
             elb = np.array([bool(lhs)])
         expected = ~elb
-        result = pd.eval("~elb", engine=self.engine, parser=self.parser)
+        result = pd.eval("~elb", engine=engine, parser=parser)
         tm.assert_almost_equal(expected, result)
 
-        for engine in self.current_engines:
-            tm.assert_almost_equal(
-                result, pd.eval("~elb", engine=engine, parser=self.parser)
-            )
-
-    def check_compound_invert_op(self, lhs, cmp1, rhs):
-        skip_these = ["in", "not in"]
-        ex = f"~(lhs {cmp1} rhs)"
-
-        msg = "|".join(
-            [
-                r"only list-like( or dict-like)? objects are allowed to be "
-                r"passed to (DataFrame\.)?isin\(\), you passed a "
-                r"(\[|')float(\]|')",
-                "argument of type 'float' is not iterable",
-            ]
-        )
-        if is_scalar(rhs) and cmp1 in skip_these:
-            with pytest.raises(TypeError, match=msg):
-                pd.eval(
-                    ex,
-                    engine=self.engine,
-                    parser=self.parser,
-                    local_dict={"lhs": lhs, "rhs": rhs},
-                )
-        else:
-            # compound
-            if is_scalar(lhs) and is_scalar(rhs):
-                lhs, rhs = map(lambda x: np.array([x]), (lhs, rhs))
-            expected = _eval_single_bin(lhs, cmp1, rhs, self.engine)
-            if is_scalar(expected):
-                expected = not expected
-            else:
-                expected = ~expected
-            result = pd.eval(ex, engine=self.engine, parser=self.parser)
-            tm.assert_almost_equal(expected, result)
-
-            # make sure the other engines work the same as this one
-            for engine in self.current_engines:
-                ev = pd.eval(ex, engine=self.engine, parser=self.parser)
-                tm.assert_almost_equal(ev, result)
-
-    def test_frame_invert(self):
+    def test_frame_invert(self, engine, parser):
         expr = "~lhs"
 
         # ~ ##
         # frame
         # float always raises
         lhs = DataFrame(np.random.randn(5, 2))
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'invert_dd'"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             msg = "ufunc 'invert' not supported for the input types"
             with pytest.raises(TypeError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
 
         # int raises on numexpr
         lhs = DataFrame(np.random.randint(5, size=(5, 2)))
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'invert"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             expect = ~lhs
-            result = pd.eval(expr, engine=self.engine, parser=self.parser)
+            result = pd.eval(expr, engine=engine, parser=parser)
             tm.assert_frame_equal(expect, result)
 
         # bool always works
         lhs = DataFrame(np.random.rand(5, 2) > 0.5)
         expect = ~lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_frame_equal(expect, result)
 
         # object raises
         lhs = DataFrame({"b": ["a", 1, 2.0], "c": np.random.rand(3) > 0.5})
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             with pytest.raises(ValueError, match="unknown type object"):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             msg = "bad operand type for unary ~: 'str'"
             with pytest.raises(TypeError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
 
-    def test_series_invert(self):
+    def test_series_invert(self, engine, parser):
         # ~ ####
         expr = "~lhs"
 
         # series
         # float raises
         lhs = Series(np.random.randn(5))
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'invert_dd'"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                result = pd.eval(expr, engine=engine, parser=parser)
         else:
             msg = "ufunc 'invert' not supported for the input types"
             with pytest.raises(TypeError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
 
         # int raises on numexpr
         lhs = Series(np.random.randint(5, size=5))
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'invert"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             expect = ~lhs
-            result = pd.eval(expr, engine=self.engine, parser=self.parser)
+            result = pd.eval(expr, engine=engine, parser=parser)
             tm.assert_series_equal(expect, result)
 
         # bool
         lhs = Series(np.random.rand(5) > 0.5)
         expect = ~lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_series_equal(expect, result)
 
         # float
@@ -516,64 +448,64 @@ def test_series_invert(self):
 
         # object
         lhs = Series(["a", 1, 2.0])
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             with pytest.raises(ValueError, match="unknown type object"):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             msg = "bad operand type for unary ~: 'str'"
             with pytest.raises(TypeError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
 
-    def test_frame_negate(self):
+    def test_frame_negate(self, engine, parser):
         expr = "-lhs"
 
         # float
         lhs = DataFrame(np.random.randn(5, 2))
         expect = -lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_frame_equal(expect, result)
 
         # int
         lhs = DataFrame(np.random.randint(5, size=(5, 2)))
         expect = -lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_frame_equal(expect, result)
 
         # bool doesn't work with numexpr but works elsewhere
         lhs = DataFrame(np.random.rand(5, 2) > 0.5)
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'neg_bb'"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             expect = -lhs
-            result = pd.eval(expr, engine=self.engine, parser=self.parser)
+            result = pd.eval(expr, engine=engine, parser=parser)
             tm.assert_frame_equal(expect, result)
 
-    def test_series_negate(self):
+    def test_series_negate(self, engine, parser):
         expr = "-lhs"
 
         # float
         lhs = Series(np.random.randn(5))
         expect = -lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_series_equal(expect, result)
 
         # int
         lhs = Series(np.random.randint(5, size=5))
         expect = -lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_series_equal(expect, result)
 
         # bool doesn't work with numexpr but works elsewhere
         lhs = Series(np.random.rand(5) > 0.5)
-        if self.engine == "numexpr":
+        if engine == "numexpr":
             msg = "couldn't find matching opcode for 'neg_bb'"
             with pytest.raises(NotImplementedError, match=msg):
-                result = pd.eval(expr, engine=self.engine, parser=self.parser)
+                pd.eval(expr, engine=engine, parser=parser)
         else:
             expect = -lhs
-            result = pd.eval(expr, engine=self.engine, parser=self.parser)
+            result = pd.eval(expr, engine=engine, parser=parser)
             tm.assert_series_equal(expect, result)
 
     @pytest.mark.parametrize(
@@ -587,11 +519,11 @@ def test_series_negate(self):
             DataFrame(np.random.rand(5, 2) > 0.5),
         ],
     )
-    def test_frame_pos(self, lhs):
+    def test_frame_pos(self, lhs, engine, parser):
         expr = "+lhs"
         expect = lhs
 
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_frame_equal(expect, result)
 
     @pytest.mark.parametrize(
@@ -605,126 +537,133 @@ def test_frame_pos(self, lhs):
             Series(np.random.rand(5) > 0.5),
         ],
     )
-    def test_series_pos(self, lhs):
+    def test_series_pos(self, lhs, engine, parser):
         expr = "+lhs"
         expect = lhs
 
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
+        result = pd.eval(expr, engine=engine, parser=parser)
         tm.assert_series_equal(expect, result)
 
-    def test_scalar_unary(self):
+    def test_scalar_unary(self, engine, parser):
         msg = "bad operand type for unary ~: 'float'"
         with pytest.raises(TypeError, match=msg):
-            pd.eval("~1.0", engine=self.engine, parser=self.parser)
-
-        assert pd.eval("-1.0", parser=self.parser, engine=self.engine) == -1.0
-        assert pd.eval("+1.0", parser=self.parser, engine=self.engine) == +1.0
-        assert pd.eval("~1", parser=self.parser, engine=self.engine) == ~1
-        assert pd.eval("-1", parser=self.parser, engine=self.engine) == -1
-        assert pd.eval("+1", parser=self.parser, engine=self.engine) == +1
-        assert pd.eval("~True", parser=self.parser, engine=self.engine) == ~True
-        assert pd.eval("~False", parser=self.parser, engine=self.engine) == ~False
-        assert pd.eval("-True", parser=self.parser, engine=self.engine) == -True
-        assert pd.eval("-False", parser=self.parser, engine=self.engine) == -False
-        assert pd.eval("+True", parser=self.parser, engine=self.engine) == +True
-        assert pd.eval("+False", parser=self.parser, engine=self.engine) == +False
+            pd.eval("~1.0", engine=engine, parser=parser)
+
+        assert pd.eval("-1.0", parser=parser, engine=engine) == -1.0
+        assert pd.eval("+1.0", parser=parser, engine=engine) == +1.0
+        assert pd.eval("~1", parser=parser, engine=engine) == ~1
+        assert pd.eval("-1", parser=parser, engine=engine) == -1
+        assert pd.eval("+1", parser=parser, engine=engine) == +1
+        assert pd.eval("~True", parser=parser, engine=engine) == ~True
+        assert pd.eval("~False", parser=parser, engine=engine) == ~False
+        assert pd.eval("-True", parser=parser, engine=engine) == -True
+        assert pd.eval("-False", parser=parser, engine=engine) == -False
+        assert pd.eval("+True", parser=parser, engine=engine) == +True
+        assert pd.eval("+False", parser=parser, engine=engine) == +False
 
     def test_unary_in_array(self):
         # GH 11235
-        tm.assert_numpy_array_equal(
+        # TODO: 2022-01-29: result return list with numexpr 2.7.3 in CI
+        # but cannot reproduce locally
+        result = np.array(
             pd.eval(
                 "[-True, True, ~True, +True,"
                 "-False, False, ~False, +False,"
                 "-37, 37, ~37, +37]"
             ),
-            np.array(
-                [
-                    -True,
-                    True,
-                    ~True,
-                    +True,
-                    -False,
-                    False,
-                    ~False,
-                    +False,
-                    -37,
-                    37,
-                    ~37,
-                    +37,
-                ],
-                dtype=np.object_,
-            ),
+            dtype=np.object_,
         )
+        expected = np.array(
+            [
+                -True,
+                True,
+                ~True,
+                +True,
+                -False,
+                False,
+                ~False,
+                +False,
+                -37,
+                37,
+                ~37,
+                +37,
+            ],
+            dtype=np.object_,
+        )
+        tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-    def test_float_comparison_bin_op(self, dtype):
+    @pytest.mark.parametrize("expr", ["x < -0.1", "-5 > x"])
+    def test_float_comparison_bin_op(self, dtype, expr):
         # GH 16363
         df = DataFrame({"x": np.array([0], dtype=dtype)})
-        res = df.eval("x < -0.1")
-        assert res.values == np.array([False])
-
-        res = df.eval("-5 > x")
+        res = df.eval(expr)
         assert res.values == np.array([False])
 
-    def test_disallow_scalar_bool_ops(self):
-        exprs = "1 or 2", "1 and 2"
-        exprs += "a and b", "a or b"
-        exprs += ("1 or 2 and (3 + 2) > 3",)
-        exprs += ("2 * x > 2 or 1 and 2",)
-        exprs += ("2 * df > 3 and 1 or a",)
-
+    @pytest.mark.parametrize(
+        "ex",
+        (
+            "1 or 2",
+            "1 and 2",
+            "a and b",
+            "a or b",
+            "1 or 2 and (3 + 2) > 3",
+            "2 * x > 2 or 1 and 2",
+            "2 * df > 3 and 1 or a",
+        ),
+    )
+    def test_disallow_scalar_bool_ops(self, ex, engine, parser):
         x, a, b = np.random.randn(3), 1, 2  # noqa:F841
         df = DataFrame(np.random.randn(3, 2))  # noqa:F841
 
-        for ex in exprs:
-            msg = "cannot evaluate scalar only bool ops|'BoolOp' nodes are not"
-            with pytest.raises(NotImplementedError, match=msg):
-                pd.eval(ex, engine=self.engine, parser=self.parser)
+        msg = "cannot evaluate scalar only bool ops|'BoolOp' nodes are not"
+        with pytest.raises(NotImplementedError, match=msg):
+            pd.eval(ex, engine=engine, parser=parser)
 
-    def test_identical(self):
+    def test_identical(self, engine, parser):
         # see gh-10546
         x = 1
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         assert result == 1
         assert is_scalar(result)
 
         x = 1.5
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         assert result == 1.5
         assert is_scalar(result)
 
         x = False
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         assert not result
         assert is_bool(result)
         assert is_scalar(result)
 
         x = np.array([1])
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         tm.assert_numpy_array_equal(result, np.array([1]))
         assert result.shape == (1,)
 
         x = np.array([1.5])
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         tm.assert_numpy_array_equal(result, np.array([1.5]))
         assert result.shape == (1,)
 
         x = np.array([False])  # noqa:F841
-        result = pd.eval("x", engine=self.engine, parser=self.parser)
+        result = pd.eval("x", engine=engine, parser=parser)
         tm.assert_numpy_array_equal(result, np.array([False]))
         assert result.shape == (1,)
 
-    def test_line_continuation(self):
+    def test_line_continuation(self, engine, parser):
         # GH 11149
         exp = """1 + 2 * \
         5 - 1 + 2 """
-        result = pd.eval(exp, engine=self.engine, parser=self.parser)
+        result = pd.eval(exp, engine=engine, parser=parser)
         assert result == 12
 
-    def test_float_truncation(self):
+    def test_float_truncation(self, engine, parser):
         # GH 14241
         exp = "1000000000.006"
-        result = pd.eval(exp, engine=self.engine, parser=self.parser)
+        result = pd.eval(exp, engine=engine, parser=parser)
         expected = np.float64(exp)
         assert result == expected
 
@@ -755,6 +694,18 @@ def test_disallow_python_keywords(self):
         with pytest.raises(SyntaxError, match=msg):
             df.query("lambda == 0")
 
+    def test_true_false_logic(self):
+        # GH 25823
+        assert pd.eval("not True") == -2
+        assert pd.eval("not False") == -1
+        assert pd.eval("True and not True") == 0
+
+    def test_and_logic_string_match(self):
+        # GH 25823
+        event = Series({"a": "hello"})
+        assert pd.eval(f"{event.str.match('hello').a}")
+        assert pd.eval(f"{event.str.match('hello').a and event.str.match('hello').a}")
+
 
 f = lambda *args, **kwargs: np.random.randn()
 
@@ -768,15 +719,11 @@ class TestTypeCasting:
     # maybe someday... numexpr has too many upcasting rules now
     # chain(*(np.sctypes[x] for x in ['uint', 'int', 'float']))
     @pytest.mark.parametrize("dt", [np.float32, np.float64])
-    def test_binop_typecasting(self, engine, parser, op, dt):
+    @pytest.mark.parametrize("left_right", [("df", "3"), ("3", "df")])
+    def test_binop_typecasting(self, engine, parser, op, dt, left_right):
         df = tm.makeCustomDataframe(5, 3, data_gen_f=f, dtype=dt)
-        s = f"df {op} 3"
-        res = pd.eval(s, engine=engine, parser=parser)
-        assert df.values.dtype == dt
-        assert res.values.dtype == dt
-        tm.assert_frame_equal(res, eval(s))
-
-        s = f"3 {op} df"
+        left, right = left_right
+        s = f"{left} {op} {right}"
         res = pd.eval(s, engine=engine, parser=parser)
         assert df.values.dtype == dt
         assert res.values.dtype == dt
@@ -787,19 +734,17 @@ def test_binop_typecasting(self, engine, parser, op, dt):
 # Basic and complex alignment
 
 
-def _is_datetime(x):
-    return issubclass(x.dtype.type, np.datetime64)
-
-
 def should_warn(*args):
-    not_mono = not any(map(operator.attrgetter("is_monotonic"), args))
-    only_one_dt = reduce(operator.xor, map(_is_datetime, args))
+    not_mono = not any(map(operator.attrgetter("is_monotonic_increasing"), args))
+    only_one_dt = reduce(
+        operator.xor, map(lambda x: issubclass(x.dtype.type, np.datetime64), args)
+    )
     return not_mono and only_one_dt
 
 
 class TestAlignment:
 
-    index_types = ["i", "u", "dt"]
+    index_types = ["i", "s", "dt"]
     lhs_index_types = index_types + ["s"]  # 'p'
 
     def test_align_nested_unary_op(self, engine, parser):
@@ -898,12 +843,25 @@ def test_basic_frame_series_alignment(
     @pytest.mark.parametrize("index_name", ["index", "columns"])
     @pytest.mark.parametrize(
         "r_idx_type, c_idx_type",
-        list(product(["i", "u", "s"], ["i", "u", "s"])) + [("dt", "dt")],
+        list(product(["i", "s"], ["i", "s"])) + [("dt", "dt")],
     )
     @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     def test_basic_series_frame_alignment(
-        self, engine, parser, index_name, r_idx_type, c_idx_type
+        self, request, engine, parser, index_name, r_idx_type, c_idx_type
     ):
+        if (
+            engine == "numexpr"
+            and parser == "pandas"
+            and index_name == "index"
+            and r_idx_type == "i"
+            and c_idx_type == "s"
+        ):
+            reason = (
+                f"Flaky column ordering when engine={engine}, "
+                f"parser={parser}, index_name={index_name}, "
+                f"r_idx_type={r_idx_type}, c_idx_type={c_idx_type}"
+            )
+            request.node.add_marker(pytest.mark.xfail(reason=reason, strict=False))
         df = tm.makeCustomDataframe(
             10, 7, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type
         )
@@ -958,8 +916,6 @@ def test_series_frame_commutativity(
     @pytest.mark.parametrize("r2", index_types)
     @pytest.mark.parametrize("c2", index_types)
     def test_complex_series_frame_alignment(self, engine, parser, r1, c1, r2, c2):
-        import random
-
         n = 3
         m1 = 5
         m2 = 2 * m1
@@ -1053,21 +1009,13 @@ def test_performance_warning_for_poor_alignment(self, engine, parser):
 
 
 class TestOperations:
-    @pytest.fixture(autouse=True)
-    def set_engine_parser_attrs(self, engine, parser):
-        # Older tests look for these as attributes, so we set them here.
-        self.engine = engine
-        self.parser = parser
-
     def eval(self, *args, **kwargs):
-        kwargs["engine"] = self.engine
-        kwargs["parser"] = self.parser
         kwargs["level"] = kwargs.pop("level", 0) + 1
         return pd.eval(*args, **kwargs)
 
-    def test_simple_arith_ops(self):
+    def test_simple_arith_ops(self, engine, parser):
         exclude_arith = []
-        if self.parser == "python":
+        if parser == "python":
             exclude_arith = ["in", "not in"]
 
         arith_ops = [
@@ -1086,22 +1034,18 @@ def test_simple_arith_ops(self):
             if op in ("in", "not in"):
                 msg = "argument of type 'int' is not iterable"
                 with pytest.raises(TypeError, match=msg):
-                    pd.eval(ex, engine=self.engine, parser=self.parser)
+                    pd.eval(ex, engine=engine, parser=parser)
             else:
-                expec = _eval_single_bin(1, op, 1, self.engine)
-                x = self.eval(ex, engine=self.engine, parser=self.parser)
+                expec = _eval_single_bin(1, op, 1, engine)
+                x = self.eval(ex, engine=engine, parser=parser)
                 assert x == expec
 
-                expec = _eval_single_bin(x, op, 1, self.engine)
-                y = self.eval(
-                    ex2, local_dict={"x": x}, engine=self.engine, parser=self.parser
-                )
+                expec = _eval_single_bin(x, op, 1, engine)
+                y = self.eval(ex2, local_dict={"x": x}, engine=engine, parser=parser)
                 assert y == expec
 
-                expec = _eval_single_bin(1, op, x + 1, self.engine)
-                y = self.eval(
-                    ex3, local_dict={"x": x}, engine=self.engine, parser=self.parser
-                )
+                expec = _eval_single_bin(1, op, x + 1, engine)
+                y = self.eval(ex3, local_dict={"x": x}, engine=engine, parser=parser)
                 assert y == expec
 
     @pytest.mark.parametrize("rhs", [True, False])
@@ -1110,7 +1054,7 @@ def test_simple_arith_ops(self):
     def test_simple_bool_ops(self, rhs, lhs, op):
         ex = f"{lhs} {op} {rhs}"
 
-        if self.parser == "python" and op in ["and", "or"]:
+        if parser == "python" and op in ["and", "or"]:
             msg = "'BoolOp' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
                 self.eval(ex)
@@ -1126,7 +1070,7 @@ def test_simple_bool_ops(self, rhs, lhs, op):
     def test_bool_ops_with_constants(self, rhs, lhs, op):
         ex = f"{lhs} {op} {rhs}"
 
-        if self.parser == "python" and op in ["and", "or"]:
+        if parser == "python" and op in ["and", "or"]:
             msg = "'BoolOp' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
                 self.eval(ex)
@@ -1218,72 +1162,74 @@ def test_assignment_fails(self):
         with pytest.raises(ValueError, match=msg):
             self.eval(expr1, local_dict={"df": df, "df2": df2})
 
-    def test_assignment_column(self):
+    def test_assignment_column_multiple_raise(self):
         df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
-        orig_df = df.copy()
-
         # multiple assignees
         with pytest.raises(SyntaxError, match="invalid syntax"):
             df.eval("d c = a + b")
 
+    def test_assignment_column_invalid_assign(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         # invalid assignees
         msg = "left hand side of an assignment must be a single name"
         with pytest.raises(SyntaxError, match=msg):
             df.eval("d,c = a + b")
 
+    def test_assignment_column_invalid_assign_function_call(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         msg = "cannot assign to function call"
         with pytest.raises(SyntaxError, match=msg):
             df.eval('Timestamp("20131001") = a + b')
 
+    def test_assignment_single_assign_existing(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         # single assignment - existing variable
-        expected = orig_df.copy()
+        expected = df.copy()
         expected["a"] = expected["a"] + expected["b"]
-        df = orig_df.copy()
         df.eval("a = a + b", inplace=True)
         tm.assert_frame_equal(df, expected)
 
+    def test_assignment_single_assign_new(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         # single assignment - new variable
-        expected = orig_df.copy()
+        expected = df.copy()
         expected["c"] = expected["a"] + expected["b"]
-        df = orig_df.copy()
         df.eval("c = a + b", inplace=True)
         tm.assert_frame_equal(df, expected)
 
-        # with a local name overlap
-        def f():
-            df = orig_df.copy()
-            a = 1  # noqa:F841
-            df.eval("a = 1 + b", inplace=True)
-            return df
+    def test_assignment_single_assign_local_overlap(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
+        df = df.copy()
+        a = 1  # noqa:F841
+        df.eval("a = 1 + b", inplace=True)
 
-        df = f()
-        expected = orig_df.copy()
+        expected = df.copy()
         expected["a"] = 1 + expected["b"]
         tm.assert_frame_equal(df, expected)
 
-        df = orig_df.copy()
-
-        def f():
-            a = 1  # noqa:F841
-            old_a = df.a.copy()
-            df.eval("a = a + b", inplace=True)
-            result = old_a + df.b
-            tm.assert_series_equal(result, df.a, check_names=False)
-            assert result.name is None
+    def test_assignment_single_assign_name(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
 
-        f()
+        a = 1  # noqa:F841
+        old_a = df.a.copy()
+        df.eval("a = a + b", inplace=True)
+        result = old_a + df.b
+        tm.assert_series_equal(result, df.a, check_names=False)
+        assert result.name is None
 
+    def test_assignment_multiple_raises(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         # multiple assignment
-        df = orig_df.copy()
         df.eval("c = a + b", inplace=True)
         msg = "can only assign a single expression"
         with pytest.raises(SyntaxError, match=msg):
             df.eval("c = a = b")
 
+    def test_assignment_explicit(self):
+        df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
         # explicit targets
-        df = orig_df.copy()
         self.eval("c = df.a + df.b", local_dict={"df": df}, target=df, inplace=True)
-        expected = orig_df.copy()
+        expected = df.copy()
         expected["c"] = expected["a"] + expected["b"]
         tm.assert_frame_equal(df, expected)
 
@@ -1292,9 +1238,12 @@ def test_column_in(self):
         df = DataFrame({"a": [11], "b": [-32]})
         result = df.eval("a in [11, -32]")
         expected = Series([True])
-        tm.assert_series_equal(result, expected)
+        # TODO: 2022-01-29: Name check failed with numexpr 2.7.3 in CI
+        # but cannot reproduce locally
+        tm.assert_series_equal(result, expected, check_names=False)
 
-    def assignment_not_inplace(self):
+    @pytest.mark.xfail(reason="Unknown: Omitted test_ in name prior.")
+    def test_assignment_not_inplace(self):
         # see gh-9297
         df = DataFrame(np.random.randn(5, 2), columns=list("ab"))
 
@@ -1501,78 +1450,70 @@ def test_nested_period_index_subscript_expression(self):
         e = df[df[df < 2] < 2] + df * 2
         tm.assert_frame_equal(r, e)
 
-    def test_date_boolean(self):
+    def test_date_boolean(self, engine, parser):
         df = DataFrame(np.random.randn(5, 3))
         df["dates1"] = date_range("1/1/2012", periods=5)
         res = self.eval(
             "df.dates1 < 20130101",
             local_dict={"df": df},
-            engine=self.engine,
-            parser=self.parser,
+            engine=engine,
+            parser=parser,
         )
         expec = df.dates1 < "20130101"
         tm.assert_series_equal(res, expec, check_names=False)
 
-    def test_simple_in_ops(self):
-        if self.parser != "python":
-            res = pd.eval("1 in [1, 2]", engine=self.engine, parser=self.parser)
+    def test_simple_in_ops(self, engine, parser):
+        if parser != "python":
+            res = pd.eval("1 in [1, 2]", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("2 in (1, 2)", engine=self.engine, parser=self.parser)
+            res = pd.eval("2 in (1, 2)", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("3 in (1, 2)", engine=self.engine, parser=self.parser)
+            res = pd.eval("3 in (1, 2)", engine=engine, parser=parser)
             assert not res
 
-            res = pd.eval("3 not in (1, 2)", engine=self.engine, parser=self.parser)
+            res = pd.eval("3 not in (1, 2)", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("[3] not in (1, 2)", engine=self.engine, parser=self.parser)
+            res = pd.eval("[3] not in (1, 2)", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("[3] in ([3], 2)", engine=self.engine, parser=self.parser)
+            res = pd.eval("[3] in ([3], 2)", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("[[3]] in [[[3]], 2]", engine=self.engine, parser=self.parser)
+            res = pd.eval("[[3]] in [[[3]], 2]", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval("(3,) in [(3,), 2]", engine=self.engine, parser=self.parser)
+            res = pd.eval("(3,) in [(3,), 2]", engine=engine, parser=parser)
             assert res
 
-            res = pd.eval(
-                "(3,) not in [(3,), 2]", engine=self.engine, parser=self.parser
-            )
+            res = pd.eval("(3,) not in [(3,), 2]", engine=engine, parser=parser)
             assert not res
 
-            res = pd.eval(
-                "[(3,)] in [[(3,)], 2]", engine=self.engine, parser=self.parser
-            )
+            res = pd.eval("[(3,)] in [[(3,)], 2]", engine=engine, parser=parser)
             assert res
         else:
             msg = "'In' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval("1 in [1, 2]", engine=self.engine, parser=self.parser)
+                pd.eval("1 in [1, 2]", engine=engine, parser=parser)
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval("2 in (1, 2)", engine=self.engine, parser=self.parser)
+                pd.eval("2 in (1, 2)", engine=engine, parser=parser)
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval("3 in (1, 2)", engine=self.engine, parser=self.parser)
+                pd.eval("3 in (1, 2)", engine=engine, parser=parser)
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval(
-                    "[(3,)] in (1, 2, [(3,)])", engine=self.engine, parser=self.parser
-                )
+                pd.eval("[(3,)] in (1, 2, [(3,)])", engine=engine, parser=parser)
             msg = "'NotIn' nodes are not implemented"
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval("3 not in (1, 2)", engine=self.engine, parser=self.parser)
+                pd.eval("3 not in (1, 2)", engine=engine, parser=parser)
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval(
-                    "[3] not in (1, 2, [[3]])", engine=self.engine, parser=self.parser
-                )
+                pd.eval("[3] not in (1, 2, [[3]])", engine=engine, parser=parser)
 
-    def test_check_many_exprs(self):
+    def test_check_many_exprs(self, engine, parser):
         a = 1  # noqa:F841
         expr = " * ".join("a" * 33)
         expected = 1
-        res = pd.eval(expr, engine=self.engine, parser=self.parser)
+        res = pd.eval(expr, engine=engine, parser=parser)
         assert res == expected
 
     @pytest.mark.parametrize(
@@ -1583,9 +1524,9 @@ def test_check_many_exprs(self):
             "not df > 2",
         ],
     )
-    def test_fails_and_or_not(self, expr):
+    def test_fails_and_or_not(self, expr, engine, parser):
         df = DataFrame(np.random.randn(5, 3))
-        if self.parser == "python":
+        if parser == "python":
             msg = "'BoolOp' nodes are not implemented"
             if "not" in expr:
                 msg = "'Not' nodes are not implemented"
@@ -1594,41 +1535,33 @@ def test_fails_and_or_not(self, expr):
                 pd.eval(
                     expr,
                     local_dict={"df": df},
-                    parser=self.parser,
-                    engine=self.engine,
+                    parser=parser,
+                    engine=engine,
                 )
         else:
             # smoke-test, should not raise
             pd.eval(
                 expr,
                 local_dict={"df": df},
-                parser=self.parser,
-                engine=self.engine,
+                parser=parser,
+                engine=engine,
             )
 
     @pytest.mark.parametrize("char", ["|", "&"])
-    def test_fails_ampersand_pipe(self, char):
+    def test_fails_ampersand_pipe(self, char, engine, parser):
         df = DataFrame(np.random.randn(5, 3))  # noqa:F841
         ex = f"(df + 2)[df > 1] > 0 {char} (df > 0)"
-        if self.parser == "python":
+        if parser == "python":
             msg = "cannot evaluate scalar only bool ops"
             with pytest.raises(NotImplementedError, match=msg):
-                pd.eval(ex, parser=self.parser, engine=self.engine)
+                pd.eval(ex, parser=parser, engine=engine)
         else:
             # smoke-test, should not raise
-            pd.eval(ex, parser=self.parser, engine=self.engine)
+            pd.eval(ex, parser=parser, engine=engine)
 
 
 class TestMath:
-    @pytest.fixture(autouse=True)
-    def set_engine_parser_attrs(self, engine, parser):
-        # Older tests look for these as attributes, so we set them here.
-        self.engine = engine
-        self.parser = parser
-
     def eval(self, *args, **kwargs):
-        kwargs["engine"] = self.engine
-        kwargs["parser"] = self.parser
         kwargs["level"] = kwargs.pop("level", 0) + 1
         return pd.eval(*args, **kwargs)
 
@@ -1656,63 +1589,63 @@ def test_binary_functions(self, fn):
             expect = getattr(np, fn)(a, b)
         tm.assert_almost_equal(got, expect, check_names=False)
 
-    def test_df_use_case(self):
+    def test_df_use_case(self, engine, parser):
         df = DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})
         df.eval(
             "e = arctan2(sin(a), b)",
-            engine=self.engine,
-            parser=self.parser,
+            engine=engine,
+            parser=parser,
             inplace=True,
         )
         got = df.e
         expect = np.arctan2(np.sin(df.a), df.b)
         tm.assert_series_equal(got, expect, check_names=False)
 
-    def test_df_arithmetic_subexpression(self):
+    def test_df_arithmetic_subexpression(self, engine, parser):
         df = DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})
-        df.eval("e = sin(a + b)", engine=self.engine, parser=self.parser, inplace=True)
+        df.eval("e = sin(a + b)", engine=engine, parser=parser, inplace=True)
         got = df.e
         expect = np.sin(df.a + df.b)
         tm.assert_series_equal(got, expect, check_names=False)
 
-    def check_result_type(self, dtype, expect_dtype):
+    @pytest.mark.parametrize(
+        "dtype, expect_dtype",
+        [
+            (np.int32, np.float64),
+            (np.int64, np.float64),
+            (np.float32, np.float32),
+            (np.float64, np.float64),
+            pytest.param(np.complex128, np.complex128, marks=td.skip_if_windows),
+        ],
+    )
+    def test_result_types(self, dtype, expect_dtype, engine, parser):
+        # xref https://github.com/pandas-dev/pandas/issues/12293
+        #  this fails on Windows, apparently a floating point precision issue
+
+        # Did not test complex64 because DataFrame is converting it to
+        # complex128. Due to https://github.com/pandas-dev/pandas/issues/10952
         df = DataFrame({"a": np.random.randn(10).astype(dtype)})
         assert df.a.dtype == dtype
-        df.eval("b = sin(a)", engine=self.engine, parser=self.parser, inplace=True)
+        df.eval("b = sin(a)", engine=engine, parser=parser, inplace=True)
         got = df.b
         expect = np.sin(df.a)
         assert expect.dtype == got.dtype
         assert expect_dtype == got.dtype
         tm.assert_series_equal(got, expect, check_names=False)
 
-    def test_result_types(self):
-        self.check_result_type(np.int32, np.float64)
-        self.check_result_type(np.int64, np.float64)
-        self.check_result_type(np.float32, np.float32)
-        self.check_result_type(np.float64, np.float64)
-
-    @td.skip_if_windows
-    def test_result_complex128(self):
-        # xref https://github.com/pandas-dev/pandas/issues/12293
-        #  this fails on Windows, apparently a floating point precision issue
-
-        # Did not test complex64 because DataFrame is converting it to
-        # complex128. Due to https://github.com/pandas-dev/pandas/issues/10952
-        self.check_result_type(np.complex128, np.complex128)
-
-    def test_undefined_func(self):
+    def test_undefined_func(self, engine, parser):
         df = DataFrame({"a": np.random.randn(10)})
         msg = '"mysin" is not a supported function'
 
         with pytest.raises(ValueError, match=msg):
-            df.eval("mysin(a)", engine=self.engine, parser=self.parser)
+            df.eval("mysin(a)", engine=engine, parser=parser)
 
-    def test_keyword_arg(self):
+    def test_keyword_arg(self, engine, parser):
         df = DataFrame({"a": np.random.randn(10)})
         msg = 'Function "sin" does not support keyword arguments'
 
         with pytest.raises(TypeError, match=msg):
-            df.eval("sin(x=a)", engine=self.engine, parser=self.parser)
+            df.eval("sin(x=a)", engine=engine, parser=parser)
 
 
 _var_s = np.random.randn(10)
@@ -1740,6 +1673,20 @@ def test_no_new_globals(self, engine, parser):
         gbls2 = globals().copy()
         assert gbls == gbls2
 
+    def test_empty_locals(self, engine, parser):
+        # GH 47084
+        x = 1  # noqa: F841
+        msg = "name 'x' is not defined"
+        with pytest.raises(UndefinedVariableError, match=msg):
+            pd.eval("x + 1", engine=engine, parser=parser, local_dict={})
+
+    def test_empty_globals(self, engine, parser):
+        # GH 47084
+        msg = "name '_var_s' is not defined"
+        e = "_var_s * 2"
+        with pytest.raises(UndefinedVariableError, match=msg):
+            pd.eval(e, engine=engine, parser=parser, global_dict={})
+
 
 @td.skip_if_no_ne
 def test_invalid_engine():
@@ -1853,7 +1800,7 @@ def test_empty_string_raises(engine, parser):
 
 
 def test_more_than_one_expression_raises(engine, parser):
-    with pytest.raises(SyntaxError, match=("only a single expression is allowed")):
+    with pytest.raises(SyntaxError, match="only a single expression is allowed"):
         pd.eval("1 + 1; 2 + 2", engine=engine, parser=parser)
 
 
@@ -1944,6 +1891,47 @@ def test_negate_lt_eq_le(engine, parser):
         tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize(
+    "column",
+    DEFAULT_GLOBALS.keys(),
+)
+def test_eval_no_support_column_name(request, column):
+    # GH 44603
+    if column in ["True", "False", "inf", "Inf"]:
+        request.node.add_marker(
+            pytest.mark.xfail(
+                raises=KeyError,
+                reason=f"GH 47859 DataFrame eval not supported with {column}",
+            )
+        )
+
+    df = DataFrame(np.random.randint(0, 100, size=(10, 2)), columns=[column, "col1"])
+    expected = df[df[column] > 6]
+    result = df.query(f"{column}>6")
+
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_array_manager_not_yet_implemented
+def test_set_inplace(using_copy_on_write):
+    # https://github.com/pandas-dev/pandas/issues/47449
+    # Ensure we don't only update the DataFrame inplace, but also the actual
+    # column values, such that references to this column also get updated
+    df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
+    result_view = df[:]
+    ser = df["A"]
+    df.eval("A = B + C", inplace=True)
+    expected = DataFrame({"A": [11, 13, 15], "B": [4, 5, 6], "C": [7, 8, 9]})
+    tm.assert_frame_equal(df, expected)
+    if not using_copy_on_write:
+        tm.assert_series_equal(ser, expected["A"])
+        tm.assert_series_equal(result_view["A"], expected["A"])
+    else:
+        expected = Series([1, 2, 3], name="A")
+        tm.assert_series_equal(ser, expected)
+        tm.assert_series_equal(result_view["A"], expected)
+
+
 class TestValidate:
     @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
     def test_validate_bool_args(self, value):
diff --git a/pandas/tests/config/test_config.py b/pandas/tests/config/test_config.py
index 761c8535e6b4a..cc394bbb23d00 100644
--- a/pandas/tests/config/test_config.py
+++ b/pandas/tests/config/test_config.py
@@ -18,7 +18,7 @@ def setup_class(cls):
         cls.do = deepcopy(getattr(cls.cf, "_deprecated_options"))
         cls.ro = deepcopy(getattr(cls.cf, "_registered_options"))
 
-    def setup_method(self, method):
+    def setup_method(self):
         setattr(self.cf, "_global_config", {})
         setattr(self.cf, "options", self.cf.DictWrapper(self.cf._global_config))
         setattr(self.cf, "_deprecated_options", {})
@@ -30,7 +30,7 @@ def setup_method(self, method):
         # "chained_assignment" option, so re-register it.
         self.cf.register_option("chained_assignment", "raise")
 
-    def teardown_method(self, method):
+    def teardown_method(self):
         setattr(self.cf, "_global_config", self.gc)
         setattr(self.cf, "_deprecated_options", self.do)
         setattr(self.cf, "_registered_options", self.ro)
diff --git a/pandas/tests/config/test_localization.py b/pandas/tests/config/test_localization.py
index 21b1b7ed6ee65..f972a9ee3b497 100644
--- a/pandas/tests/config/test_localization.py
+++ b/pandas/tests/config/test_localization.py
@@ -10,31 +10,67 @@
     set_locale,
 )
 
-from pandas.compat import is_platform_windows
-
 import pandas as pd
 
 _all_locales = get_locales() or []
-_current_locale = locale.getlocale()
+_current_locale = locale.setlocale(locale.LC_ALL)  # getlocale() is wrong, see GH#46595
 
-# Don't run any of these tests if we are on Windows or have no locales.
-pytestmark = pytest.mark.skipif(
-    is_platform_windows() or not _all_locales, reason="Need non-Windows and locales"
-)
+# Don't run any of these tests if we have no locales.
+pytestmark = pytest.mark.skipif(not _all_locales, reason="Need locales")
 
 _skip_if_only_one_locale = pytest.mark.skipif(
     len(_all_locales) <= 1, reason="Need multiple locales for meaningful test"
 )
 
 
-def test_can_set_locale_valid_set():
+def _get_current_locale(lc_var: int = locale.LC_ALL) -> str:
+    # getlocale is not always compliant with setlocale, use setlocale. GH#46595
+    return locale.setlocale(lc_var)
+
+
+@pytest.mark.parametrize("lc_var", (locale.LC_ALL, locale.LC_CTYPE, locale.LC_TIME))
+def test_can_set_current_locale(lc_var):
+    # Can set the current locale
+    before_locale = _get_current_locale(lc_var)
+    assert can_set_locale(before_locale, lc_var=lc_var)
+    after_locale = _get_current_locale(lc_var)
+    assert before_locale == after_locale
+
+
+@pytest.mark.parametrize("lc_var", (locale.LC_ALL, locale.LC_CTYPE, locale.LC_TIME))
+def test_can_set_locale_valid_set(lc_var):
     # Can set the default locale.
-    assert can_set_locale("")
+    before_locale = _get_current_locale(lc_var)
+    assert can_set_locale("", lc_var=lc_var)
+    after_locale = _get_current_locale(lc_var)
+    assert before_locale == after_locale
 
 
-def test_can_set_locale_invalid_set():
+@pytest.mark.parametrize("lc_var", (locale.LC_ALL, locale.LC_CTYPE, locale.LC_TIME))
+def test_can_set_locale_invalid_set(lc_var):
     # Cannot set an invalid locale.
-    assert not can_set_locale("non-existent_locale")
+    before_locale = _get_current_locale(lc_var)
+    assert not can_set_locale("non-existent_locale", lc_var=lc_var)
+    after_locale = _get_current_locale(lc_var)
+    assert before_locale == after_locale
+
+
+@pytest.mark.parametrize(
+    "lang,enc",
+    [
+        ("it_CH", "UTF-8"),
+        ("en_US", "ascii"),
+        ("zh_CN", "GB2312"),
+        ("it_IT", "ISO-8859-1"),
+    ],
+)
+@pytest.mark.parametrize("lc_var", (locale.LC_ALL, locale.LC_CTYPE, locale.LC_TIME))
+def test_can_set_locale_no_leak(lang, enc, lc_var):
+    # Test that can_set_locale does not leak even when returning False. See GH#46595
+    before_locale = _get_current_locale(lc_var)
+    can_set_locale((lang, enc), locale.LC_ALL)
+    after_locale = _get_current_locale(lc_var)
+    assert before_locale == after_locale
 
 
 def test_can_set_locale_invalid_get(monkeypatch):
@@ -72,10 +108,7 @@ def test_get_locales_prefix():
     ],
 )
 def test_set_locale(lang, enc):
-    if all(x is None for x in _current_locale):
-        # Not sure why, but on some Travis runs with pytest,
-        #  getlocale() returned (None, None).
-        pytest.skip("Current locale is not set.")
+    before_locale = _get_current_locale()
 
     enc = codecs.lookup(enc).name
     new_locale = lang, enc
@@ -95,8 +128,8 @@ def test_set_locale(lang, enc):
             assert normalized_locale == new_locale
 
     # Once we exit the "with" statement, locale should be back to what it was.
-    current_locale = locale.getlocale()
-    assert current_locale == _current_locale
+    after_locale = _get_current_locale()
+    assert before_locale == after_locale
 
 
 def test_encoding_detected():
diff --git a/pandas/tests/copy_view/__init__.py b/pandas/tests/copy_view/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
new file mode 100644
index 0000000000000..444c6ff204b88
--- /dev/null
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -0,0 +1,802 @@
+import numpy as np
+import pytest
+
+from pandas.errors import SettingWithCopyWarning
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+# -----------------------------------------------------------------------------
+# Indexing operations taking subset + modifying the subset/parent
+
+
+def test_subset_column_selection(using_copy_on_write):
+    # Case: taking a subset of the columns of a DataFrame
+    # + afterwards modifying the subset
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    subset = df[["a", "c"]]
+
+    if using_copy_on_write:
+        # the subset shares memory ...
+        assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # ... but uses CoW when being modified
+        subset.iloc[0, 0] = 0
+    else:
+        assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # INFO this no longer raise warning since pandas 1.4
+        # with pd.option_context("chained_assignment", "warn"):
+        #     with tm.assert_produces_warning(SettingWithCopyWarning):
+        subset.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    expected = DataFrame({"a": [0, 2, 3], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_column_selection_modify_parent(using_copy_on_write):
+    # Case: taking a subset of the columns of a DataFrame
+    # + afterwards modifying the parent
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+
+    subset = df[["a", "c"]]
+    if using_copy_on_write:
+        # the subset shares memory ...
+        assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # ... but parent uses CoW parent when it is modified
+    df.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        # different column/block still shares memory
+        assert np.shares_memory(get_array(subset, "c"), get_array(df, "c"))
+
+    expected = DataFrame({"a": [1, 2, 3], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(subset, expected)
+
+
+def test_subset_row_slice(using_copy_on_write):
+    # Case: taking a subset of the rows of a DataFrame using a slice
+    # + afterwards modifying the subset
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    subset = df[1:3]
+    subset._mgr._verify_integrity()
+
+    assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    if using_copy_on_write:
+        subset.iloc[0, 0] = 0
+        assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    else:
+        # INFO this no longer raise warning since pandas 1.4
+        # with pd.option_context("chained_assignment", "warn"):
+        #     with tm.assert_produces_warning(SettingWithCopyWarning):
+        subset.iloc[0, 0] = 0
+
+    subset._mgr._verify_integrity()
+
+    expected = DataFrame({"a": [0, 3], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.iloc[1, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_column_slice(using_copy_on_write, using_array_manager, dtype):
+    # Case: taking a subset of the columns of a DataFrame using a slice
+    # + afterwards modifying the subset
+    single_block = (dtype == "int64") and not using_array_manager
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.iloc[:, 1:]
+    subset._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
+
+        subset.iloc[0, 0] = 0
+        assert not np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
+
+    else:
+        # we only get a warning in case of a single block
+        warn = SettingWithCopyWarning if single_block else None
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                subset.iloc[0, 0] = 0
+
+    expected = DataFrame({"b": [0, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)})
+    tm.assert_frame_equal(subset, expected)
+    # original parent dataframe is not modified (also not for BlockManager case,
+    # except for single block)
+    if not using_copy_on_write and (using_array_manager or single_block):
+        df_orig.iloc[0, 1] = 0
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+@pytest.mark.parametrize(
+    "row_indexer",
+    [slice(1, 2), np.array([False, True, True]), np.array([1, 2])],
+    ids=["slice", "mask", "array"],
+)
+@pytest.mark.parametrize(
+    "column_indexer",
+    [slice("b", "c"), np.array([False, True, True]), ["b", "c"]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_loc_rows_columns(
+    dtype, row_indexer, column_indexer, using_array_manager, using_copy_on_write
+):
+    # Case: taking a subset of the rows+columns of a DataFrame using .loc
+    # + afterwards modifying the subset
+    # Generic test for several combinations of row/column indexers, not all
+    # of those could actually return a view / need CoW (so this test is not
+    # checking memory sharing, only ensuring subsequent mutation doesn't
+    # affect the parent dataframe)
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.loc[row_indexer, column_indexer]
+
+    # modifying the subset never modifies the parent
+    subset.iloc[0, 0] = 0
+
+    expected = DataFrame(
+        {"b": [0, 6], "c": np.array([8, 9], dtype=dtype)}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    # a few corner cases _do_ actually modify the parent (with both row and column
+    # slice, and in case of ArrayManager or BlockManager with single block)
+    if (
+        isinstance(row_indexer, slice)
+        and isinstance(column_indexer, slice)
+        and (using_array_manager or (dtype == "int64" and not using_copy_on_write))
+    ):
+        df_orig.iloc[1, 1] = 0
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+@pytest.mark.parametrize(
+    "row_indexer",
+    [slice(1, 3), np.array([False, True, True]), np.array([1, 2])],
+    ids=["slice", "mask", "array"],
+)
+@pytest.mark.parametrize(
+    "column_indexer",
+    [slice(1, 3), np.array([False, True, True]), [1, 2]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_iloc_rows_columns(
+    dtype, row_indexer, column_indexer, using_array_manager, using_copy_on_write
+):
+    # Case: taking a subset of the rows+columns of a DataFrame using .iloc
+    # + afterwards modifying the subset
+    # Generic test for several combinations of row/column indexers, not all
+    # of those could actually return a view / need CoW (so this test is not
+    # checking memory sharing, only ensuring subsequent mutation doesn't
+    # affect the parent dataframe)
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.iloc[row_indexer, column_indexer]
+
+    # modifying the subset never modifies the parent
+    subset.iloc[0, 0] = 0
+
+    expected = DataFrame(
+        {"b": [0, 6], "c": np.array([8, 9], dtype=dtype)}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    # a few corner cases _do_ actually modify the parent (with both row and column
+    # slice, and in case of ArrayManager or BlockManager with single block)
+    if (
+        isinstance(row_indexer, slice)
+        and isinstance(column_indexer, slice)
+        and (using_array_manager or (dtype == "int64" and not using_copy_on_write))
+    ):
+        df_orig.iloc[1, 1] = 0
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice(0, 2), np.array([True, True, False]), np.array([0, 1])],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_set_with_row_indexer(indexer_si, indexer, using_copy_on_write):
+    # Case: setting values with a row indexer on a viewing subset
+    # subset[indexer] = value and subset.iloc[indexer] = value
+    df = DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7], "c": [0.1, 0.2, 0.3, 0.4]})
+    df_orig = df.copy()
+    subset = df[1:4]
+
+    if (
+        indexer_si is tm.setitem
+        and isinstance(indexer, np.ndarray)
+        and indexer.dtype == "int"
+    ):
+        pytest.skip("setitem with labels selects on columns")
+
+    if using_copy_on_write:
+        indexer_si(subset)[indexer] = 0
+    else:
+        # INFO iloc no longer raises warning since pandas 1.4
+        warn = SettingWithCopyWarning if indexer_si is tm.setitem else None
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                indexer_si(subset)[indexer] = 0
+
+    expected = DataFrame(
+        {"a": [0, 0, 4], "b": [0, 0, 7], "c": [0.0, 0.0, 0.4]}, index=range(1, 4)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig[1:3] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_with_mask(using_copy_on_write):
+    # Case: setting values with a mask on a viewing subset: subset[mask] = value
+    df = DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7], "c": [0.1, 0.2, 0.3, 0.4]})
+    df_orig = df.copy()
+    subset = df[1:4]
+
+    mask = subset > 3
+
+    if using_copy_on_write:
+        subset[mask] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset[mask] = 0
+
+    expected = DataFrame(
+        {"a": [2, 3, 0], "b": [0, 0, 0], "c": [0.20, 0.3, 0.4]}, index=range(1, 4)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[3, "a"] = 0
+        df_orig.loc[1:3, "b"] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_column(using_copy_on_write):
+    # Case: setting a single column on a viewing subset -> subset[col] = value
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset["a"] = np.array([10, 11], dtype="int64")
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset["a"] = np.array([10, 11], dtype="int64")
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame(
+        {"a": [10, 11], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_set_column_with_loc(using_copy_on_write, using_array_manager, dtype):
+    # Case: setting a single column with loc on a viewing subset
+    # -> subset.loc[:, col] = value
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            # The (i)loc[:, col] inplace deprecation gets triggered here, ignore those
+            # warnings and only assert the SettingWithCopyWarning
+            raise_on_extra_warnings = False if using_array_manager else True
+            with tm.assert_produces_warning(
+                SettingWithCopyWarning,
+                raise_on_extra_warnings=raise_on_extra_warnings,
+            ):
+                subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame(
+        {"a": [10, 11], "b": [5, 6], "c": np.array([8, 9], dtype=dtype)},
+        index=range(1, 3),
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write or using_array_manager:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[1:3, "a"] = np.array([10, 11], dtype="int64")
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_column_with_loc2(using_copy_on_write, using_array_manager):
+    # Case: setting a single column with loc on a viewing subset
+    # -> subset.loc[:, col] = value
+    # separate test for case of DataFrame of a single column -> takes a separate
+    # code path
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, "a"] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            # The (i)loc[:, col] inplace deprecation gets triggered here, ignore those
+            # warnings and only assert the SettingWithCopyWarning
+            raise_on_extra_warnings = False if using_array_manager else True
+            with tm.assert_produces_warning(
+                SettingWithCopyWarning,
+                raise_on_extra_warnings=raise_on_extra_warnings,
+            ):
+                subset.loc[:, "a"] = 0
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame({"a": [0, 0]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write or using_array_manager:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[1:3, "a"] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_set_columns(using_copy_on_write, dtype):
+    # Case: setting multiple columns on a viewing subset
+    # -> subset[[col1, col2]] = value
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset[["a", "c"]] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset[["a", "c"]] = 0
+
+    subset._mgr._verify_integrity()
+    if using_copy_on_write:
+        # first and third column should certainly have no references anymore
+        assert all(subset._mgr._has_no_reference(i) for i in [0, 2])
+    expected = DataFrame({"a": [0, 0], "b": [5, 6], "c": [0, 0]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice("a", "b"), np.array([True, True, False]), ["a", "b"]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_set_with_column_indexer(
+    indexer, using_copy_on_write, using_array_manager
+):
+    # Case: setting multiple columns with a column indexer on a viewing subset
+    # -> subset.loc[:, [col1, col2]] = value
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "c": [4, 5, 6]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, indexer] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            # The (i)loc[:, col] inplace deprecation gets triggered here, ignore those
+            # warnings and only assert the SettingWithCopyWarning
+            with tm.assert_produces_warning(
+                SettingWithCopyWarning, raise_on_extra_warnings=False
+            ):
+                subset.loc[:, indexer] = 0
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame({"a": [0, 0], "b": [0.0, 0.0], "c": [5, 6]}, index=range(1, 3))
+    # TODO full row slice .loc[:, idx] update inplace instead of overwrite?
+    expected["b"] = expected["b"].astype("int64")
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write or using_array_manager:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # In the mixed case with BlockManager, only one of the two columns is
+        # mutated in the parent frame ..
+        df_orig.loc[1:2, ["a"]] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df[["a", "b"]][0:2],
+        lambda df: df[0:2][["a", "b"]],
+        lambda df: df[["a", "b"]].iloc[0:2],
+        lambda df: df[["a", "b"]].loc[0:1],
+        lambda df: df[0:2].iloc[:, 0:2],
+        lambda df: df[0:2].loc[:, "a":"b"],  # type: ignore[misc]
+    ],
+    ids=[
+        "row-getitem-slice",
+        "column-getitem",
+        "row-iloc-slice",
+        "row-loc-slice",
+        "column-iloc-slice",
+        "column-loc-slice",
+    ],
+)
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_chained_getitem(
+    request, method, dtype, using_copy_on_write, using_array_manager
+):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    # when not using CoW, it depends on whether we have a single block or not
+    # and whether we are slicing the columns -> in that case we have a view
+    subset_is_view = request.node.callspec.id in (
+        "single-block-column-iloc-slice",
+        "single-block-column-loc-slice",
+    ) or (
+        request.node.callspec.id
+        in ("mixed-block-column-iloc-slice", "mixed-block-column-loc-slice")
+        and using_array_manager
+    )
+
+    # modify subset -> don't modify parent
+    subset = method(df)
+    subset.iloc[0, 0] = 0
+    if using_copy_on_write or (not subset_is_view):
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = method(df)
+    df.iloc[0, 0] = 0
+    expected = DataFrame({"a": [1, 2], "b": [4, 5]})
+    if using_copy_on_write or not subset_is_view:
+        tm.assert_frame_equal(subset, expected)
+    else:
+        assert subset.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_chained_getitem_column(dtype, using_copy_on_write):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    # modify subset -> don't modify parent
+    subset = df[:]["a"][0:2]
+    df._clear_item_cache()
+    subset.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = df[:]["a"][0:2]
+    df._clear_item_cache()
+    df.iloc[0, 0] = 0
+    expected = Series([1, 2], name="a")
+    if using_copy_on_write:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda s: s["a":"c"]["a":"b"],  # type: ignore[misc]
+        lambda s: s.iloc[0:3].iloc[0:2],
+        lambda s: s.loc["a":"c"].loc["a":"b"],  # type: ignore[misc]
+        lambda s: s.loc["a":"c"]  # type: ignore[misc]
+        .iloc[0:3]
+        .iloc[0:2]
+        .loc["a":"b"]  # type: ignore[misc]
+        .iloc[0:1],
+    ],
+    ids=["getitem", "iloc", "loc", "long-chain"],
+)
+def test_subset_chained_getitem_series(method, using_copy_on_write):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    # modify subset -> don't modify parent
+    subset = method(s)
+    subset.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        assert s.iloc[0] == 0
+
+    # modify parent -> don't modify subset
+    subset = s.iloc[0:3].iloc[0:2]
+    s.iloc[0] = 0
+    expected = Series([1, 2], index=["a", "b"])
+    if using_copy_on_write:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+def test_subset_chained_single_block_row(using_copy_on_write, using_array_manager):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+
+    # modify subset -> don't modify parent
+    subset = df[:].iloc[0].iloc[0:2]
+    subset.iloc[0] = 0
+    if using_copy_on_write or using_array_manager:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = df[:].iloc[0].iloc[0:2]
+    df.iloc[0, 0] = 0
+    expected = Series([1, 4], index=["a", "b"], name=0)
+    if using_copy_on_write or using_array_manager:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+# TODO add more tests modifying the parent
+
+
+# -----------------------------------------------------------------------------
+# Series -- Indexing operations taking subset + modifying the subset/parent
+
+
+def test_series_getitem_slice(using_copy_on_write):
+    # Case: taking a slice of a Series + afterwards modifying the subset
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    subset = s[:]
+    assert np.shares_memory(subset.values, s.values)
+
+    subset.iloc[0] = 0
+
+    if using_copy_on_write:
+        assert not np.shares_memory(subset.values, s.values)
+
+    expected = Series([0, 2, 3], index=["a", "b", "c"])
+    tm.assert_series_equal(subset, expected)
+
+    if using_copy_on_write:
+        # original parent series is not modified (CoW)
+        tm.assert_series_equal(s, s_orig)
+    else:
+        # original parent series is actually updated
+        assert s.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice(0, 2), np.array([True, True, False]), np.array([0, 1])],
+    ids=["slice", "mask", "array"],
+)
+def test_series_subset_set_with_indexer(indexer_si, indexer, using_copy_on_write):
+    # Case: setting values in a viewing Series with an indexer
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+    subset = s[:]
+
+    indexer_si(subset)[indexer] = 0
+    expected = Series([0, 0, 3], index=["a", "b", "c"])
+    tm.assert_series_equal(subset, expected)
+
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        tm.assert_series_equal(s, expected)
+
+
+# -----------------------------------------------------------------------------
+# del operator
+
+
+def test_del_frame(using_copy_on_write):
+    # Case: deleting a column with `del` on a viewing child dataframe should
+    # not modify parent + update the references
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df[:]
+
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    del df2["b"]
+
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    tm.assert_frame_equal(df, df_orig)
+    tm.assert_frame_equal(df2, df_orig[["a", "c"]])
+    df2._mgr._verify_integrity()
+
+    # TODO in theory modifying column "b" of the parent wouldn't need a CoW
+    # but the weakref is still alive and so we still perform CoW
+
+    df2.loc[0, "a"] = 100
+    if using_copy_on_write:
+        # modifying child after deleting a column still doesn't update parent
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.loc[0, "a"] == 100
+
+
+def test_del_series():
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+    s2 = s[:]
+
+    assert np.shares_memory(s.values, s2.values)
+
+    del s2["a"]
+
+    assert not np.shares_memory(s.values, s2.values)
+    tm.assert_series_equal(s, s_orig)
+    tm.assert_series_equal(s2, s_orig[["b", "c"]])
+
+    # modifying s2 doesn't need copy on write (due to `del`, s2 is backed by new array)
+    values = s2.values
+    s2.loc["b"] = 100
+    assert values[0] == 100
+
+
+# -----------------------------------------------------------------------------
+# Accessing column as Series
+
+
+def test_column_as_series(using_copy_on_write, using_array_manager):
+    # Case: selecting a single column now also uses Copy-on-Write
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    s = df["a"]
+
+    assert np.shares_memory(s.values, get_array(df, "a"))
+
+    if using_copy_on_write or using_array_manager:
+        s[0] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                s[0] = 0
+
+    expected = Series([0, 2, 3], name="a")
+    tm.assert_series_equal(s, expected)
+    if using_copy_on_write:
+        # assert not np.shares_memory(s.values, get_array(df, "a"))
+        tm.assert_frame_equal(df, df_orig)
+        # ensure cached series on getitem is not the changed series
+        tm.assert_series_equal(df["a"], df_orig["a"])
+    else:
+        df_orig.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_column_as_series_set_with_upcast(using_copy_on_write, using_array_manager):
+    # Case: selecting a single column now also uses Copy-on-Write -> when
+    # setting a value causes an upcast, we don't need to update the parent
+    # DataFrame through the cache mechanism
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    s = df["a"]
+    if using_copy_on_write or using_array_manager:
+        s[0] = "foo"
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                s[0] = "foo"
+
+    expected = Series(["foo", 2, 3], dtype=object, name="a")
+    tm.assert_series_equal(s, expected)
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+        # ensure cached series on getitem is not the changed series
+        tm.assert_series_equal(df["a"], df_orig["a"])
+    else:
+        df_orig["a"] = expected
+        tm.assert_frame_equal(df, df_orig)
+
+
+# TODO add tests for other indexing methods on the Series
+
+
+def test_dataframe_add_column_from_series():
+    # Case: adding a new column to a DataFrame from an existing column/series
+    # -> always already takes a copy on assignment
+    # (no change in behaviour here)
+    # TODO can we achieve the same behaviour with Copy-on-Write?
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+
+    s = Series([10, 11, 12])
+    df["new"] = s
+    assert not np.shares_memory(get_array(df, "new"), s.values)
+
+    # editing series -> doesn't modify column in frame
+    s[0] = 0
+    expected = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "new": [10, 11, 12]})
+    tm.assert_frame_equal(df, expected)
+
+    # editing column in frame -> doesn't modify series
+    df.loc[2, "new"] = 100
+    expected_s = Series([0, 11, 12])
+    tm.assert_series_equal(s, expected_s)
+
+
+# TODO add tests for constructors
diff --git a/pandas/tests/copy_view/test_internals.py b/pandas/tests/copy_view/test_internals.py
new file mode 100644
index 0000000000000..1938a1c58fe3d
--- /dev/null
+++ b/pandas/tests/copy_view/test_internals.py
@@ -0,0 +1,95 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame
+from pandas.tests.copy_view.util import get_array
+
+
+@td.skip_array_manager_invalid_test
+def test_consolidate(using_copy_on_write):
+
+    # create unconsolidated DataFrame
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    df["c"] = [4, 5, 6]
+
+    # take a viewing subset
+    subset = df[:]
+
+    # each block of subset references a block of df
+    assert subset._mgr.refs is not None and all(
+        ref is not None for ref in subset._mgr.refs
+    )
+
+    # consolidate the two int64 blocks
+    subset._consolidate_inplace()
+
+    # the float64 block still references the parent one because it still a view
+    assert subset._mgr.refs[0] is not None
+    # equivalent of assert np.shares_memory(df["b"].values, subset["b"].values)
+    # but avoids caching df["b"]
+    assert np.shares_memory(get_array(df, "b"), get_array(subset, "b"))
+
+    # the new consolidated int64 block does not reference another
+    assert subset._mgr.refs[1] is None
+
+    # the parent dataframe now also only is linked for the float column
+    assert df._mgr._has_no_reference(0)
+    assert not df._mgr._has_no_reference(1)
+    assert df._mgr._has_no_reference(2)
+
+    # and modifying subset still doesn't modify parent
+    if using_copy_on_write:
+        subset.iloc[0, 1] = 0.0
+        assert df._mgr._has_no_reference(1)
+        assert df.loc[0, "b"] == 0.1
+
+
+@td.skip_array_manager_invalid_test
+def test_clear_parent(using_copy_on_write):
+    # ensure to clear parent reference if we are no longer viewing data from parent
+    if not using_copy_on_write:
+        pytest.skip("test only relevant when using copy-on-write")
+
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    subset = df[:]
+    assert subset._mgr.parent is not None
+
+    # replacing existing columns loses the references to the parent df
+    subset["a"] = 0
+    assert subset._mgr.parent is not None
+    # when losing the last reference, also the parent should be reset
+    subset["b"] = 0
+    assert subset._mgr.parent is None
+
+
+@pytest.mark.single_cpu
+@td.skip_array_manager_invalid_test
+def test_switch_options():
+    # ensure we can switch the value of the option within one session
+    # (assuming data is constructed after switching)
+
+    # using the option_context to ensure we set back to global option value
+    # after running the test
+    with pd.option_context("mode.copy_on_write", False):
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df updated with CoW disabled
+        assert df.iloc[0, 0] == 0
+
+        pd.options.mode.copy_on_write = True
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df not updated with CoW enabled
+        assert df.iloc[0, 0] == 1
+
+        pd.options.mode.copy_on_write = False
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df updated with CoW disabled
+        assert df.iloc[0, 0] == 0
diff --git a/pandas/tests/copy_view/test_methods.py b/pandas/tests/copy_view/test_methods.py
new file mode 100644
index 0000000000000..0b366f378fa13
--- /dev/null
+++ b/pandas/tests/copy_view/test_methods.py
@@ -0,0 +1,231 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_copy(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_copy = df.copy()
+
+    # the deep copy doesn't share memory
+    assert not np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert df_copy._mgr.refs is None
+
+    # mutating copy doesn't mutate original
+    df_copy.iloc[0, 0] = 0
+    assert df.iloc[0, 0] == 1
+
+
+def test_copy_shallow(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_copy = df.copy(deep=False)
+
+    # the shallow copy still shares memory
+    assert np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert df_copy._mgr.refs is not None
+
+    if using_copy_on_write:
+        # mutating shallow copy doesn't mutate original
+        df_copy.iloc[0, 0] = 0
+        assert df.iloc[0, 0] == 1
+        # mutating triggered a copy-on-write -> no longer shares memory
+        assert not np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+        # but still shares memory for the other columns/blocks
+        assert np.shares_memory(get_array(df_copy, "c"), get_array(df, "c"))
+    else:
+        # mutating shallow copy does mutate original
+        df_copy.iloc[0, 0] = 0
+        assert df.iloc[0, 0] == 0
+        # and still shares memory
+        assert np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+
+
+# -----------------------------------------------------------------------------
+# DataFrame methods returning new DataFrame using shallow copy
+
+
+def test_reset_index(using_copy_on_write):
+    # Case: resetting the index (i.e. adding a new column) + mutating the
+    # resulting dataframe
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]}, index=[10, 11, 12]
+    )
+    df_orig = df.copy()
+    df2 = df.reset_index()
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        # still shares memory (df2 is a shallow copy)
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 2] = 0
+    assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_rename_columns(using_copy_on_write):
+    # Case: renaming columns returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.rename(columns=str.upper)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "C"), get_array(df, "c"))
+    expected = DataFrame({"A": [0, 2, 3], "B": [4, 5, 6], "C": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(df2, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_rename_columns_modify_parent(using_copy_on_write):
+    # Case: renaming columns returns a new dataframe
+    # + afterwards modifying the original (parent) dataframe
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df2 = df.rename(columns=str.upper)
+    df2_orig = df2.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    df.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "C"), get_array(df, "c"))
+    expected = DataFrame({"a": [0, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(df, expected)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+def test_reindex_columns(using_copy_on_write):
+    # Case: reindexing the column returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.reindex(columns=["a", "c"])
+
+    if using_copy_on_write:
+        # still shares memory (df2 is a shallow copy)
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    # mutating df2 triggers a copy-on-write for that column
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_select_dtypes(using_copy_on_write):
+    # Case: selecting columns using `select_dtypes()` returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.select_dtypes("int64")
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_to_frame(using_copy_on_write):
+    # Case: converting a Series to a DataFrame with to_frame
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+
+    df = ser[:].to_frame()
+
+    # currently this always returns a "view"
+    assert np.shares_memory(ser.values, get_array(df, 0))
+
+    df.iloc[0, 0] = 0
+
+    if using_copy_on_write:
+        # mutating df triggers a copy-on-write for that column
+        assert not np.shares_memory(ser.values, get_array(df, 0))
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        # but currently select_dtypes() actually returns a view -> mutates parent
+        expected = ser_orig.copy()
+        expected.iloc[0] = 0
+        tm.assert_series_equal(ser, expected)
+
+    # modify original series -> don't modify dataframe
+    df = ser[:].to_frame()
+    ser.iloc[0] = 0
+
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, ser_orig.to_frame())
+    else:
+        expected = ser_orig.copy().to_frame()
+        expected.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize(
+    "method, idx",
+    [
+        (lambda df: df.copy(deep=False).copy(deep=False), 0),
+        (lambda df: df.reset_index().reset_index(), 2),
+        (lambda df: df.rename(columns=str.upper).rename(columns=str.lower), 0),
+        (lambda df: df.copy(deep=False).select_dtypes(include="number"), 0),
+    ],
+    ids=["shallow-copy", "reset_index", "rename", "select_dtypes"],
+)
+def test_chained_methods(request, method, idx, using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    # when not using CoW, only the copy() variant actually gives a view
+    df2_is_view = not using_copy_on_write and request.node.callspec.id == "shallow-copy"
+
+    # modify df2 -> don't modify df
+    df2 = method(df)
+    df2.iloc[0, idx] = 0
+    if not df2_is_view:
+        tm.assert_frame_equal(df, df_orig)
+
+    # modify df -> don't modify df2
+    df2 = method(df)
+    df.iloc[0, 0] = 0
+    if not df2_is_view:
+        tm.assert_frame_equal(df2.iloc[:, idx:], df_orig)
+
+
+def test_putmask(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1, "c": 2})
+    view = df[:]
+    df_orig = df.copy()
+    df[df == df] = 5
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        # Without CoW the original will be modified
+        assert np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        assert view.iloc[0, 0] == 5
diff --git a/pandas/tests/copy_view/test_setitem.py b/pandas/tests/copy_view/test_setitem.py
new file mode 100644
index 0000000000000..9e0d350dde0de
--- /dev/null
+++ b/pandas/tests/copy_view/test_setitem.py
@@ -0,0 +1,91 @@
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    Index,
+    RangeIndex,
+    Series,
+)
+import pandas._testing as tm
+
+# -----------------------------------------------------------------------------
+# Copy/view behaviour for the values that are set in a DataFrame
+
+
+def test_set_column_with_array():
+    # Case: setting an array as a new column (df[col] = arr) copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    arr = np.array([1, 2, 3], dtype="int64")
+
+    df["c"] = arr
+
+    # the array data is copied
+    assert not np.shares_memory(df["c"].values, arr)
+    # and thus modifying the array does not modify the DataFrame
+    arr[0] = 0
+    tm.assert_series_equal(df["c"], Series([1, 2, 3], name="c"))
+
+
+def test_set_column_with_series(using_copy_on_write):
+    # Case: setting a series as a new column (df[col] = s) copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    ser = Series([1, 2, 3])
+
+    df["c"] = ser
+
+    if using_copy_on_write:
+        # TODO(CoW) with CoW we can delay the copy
+        # assert np.shares_memory(df["c"].values, ser.values)
+        assert not np.shares_memory(df["c"].values, ser.values)
+    else:
+        # the series data is copied
+        assert not np.shares_memory(df["c"].values, ser.values)
+
+    # and modifying the series does not modify the DataFrame
+    ser.iloc[0] = 0
+    assert ser.iloc[0] == 0
+    tm.assert_series_equal(df["c"], Series([1, 2, 3], name="c"))
+
+
+def test_set_column_with_index(using_copy_on_write):
+    # Case: setting an index as a new column (df[col] = idx) copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    idx = Index([1, 2, 3])
+
+    df["c"] = idx
+
+    # the index data is copied
+    assert not np.shares_memory(df["c"].values, idx.values)
+
+    # and thus modifying the index does not modify the DataFrame
+    idx.values[0] = 0
+    tm.assert_series_equal(df["c"], Series([1, 2, 3], name="c"))
+
+    idx = RangeIndex(1, 4)
+    arr = idx.values
+
+    df["d"] = idx
+
+    assert not np.shares_memory(df["d"].values, arr)
+    arr[0] = 0
+    tm.assert_series_equal(df["d"], Series([1, 2, 3], name="d"))
+
+
+def test_set_columns_with_dataframe(using_copy_on_write):
+    # Case: setting a DataFrame as new columns copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df2 = DataFrame({"c": [7, 8, 9], "d": [10, 11, 12]})
+
+    df[["c", "d"]] = df2
+
+    if using_copy_on_write:
+        # TODO(CoW) with CoW we can delay the copy
+        # assert np.shares_memory(df["c"].values, df2["c"].values)
+        assert not np.shares_memory(df["c"].values, df2["c"].values)
+    else:
+        # the data is copied
+        assert not np.shares_memory(df["c"].values, df2["c"].values)
+
+    # and modifying the set DataFrame does not modify the original DataFrame
+    df2.iloc[0, 0] = 0
+    tm.assert_series_equal(df["c"], Series([7, 8, 9], name="c"))
diff --git a/pandas/tests/copy_view/util.py b/pandas/tests/copy_view/util.py
new file mode 100644
index 0000000000000..9e358c7eec749
--- /dev/null
+++ b/pandas/tests/copy_view/util.py
@@ -0,0 +1,11 @@
+def get_array(df, col):
+    """
+    Helper method to get array for a DataFrame column.
+
+    Equivalent of df[col].values, but without going through normal getitem,
+    which triggers tracking references / CoW (and we might be testing that
+    this is done by some other operation).
+    """
+    icol = df.columns.get_loc(col)
+    assert isinstance(icol, int)
+    return df._get_column_array(icol)
diff --git a/pandas/tests/dtypes/cast/test_can_hold_element.py b/pandas/tests/dtypes/cast/test_can_hold_element.py
index 906123b1aee74..3b7d76ead119a 100644
--- a/pandas/tests/dtypes/cast/test_can_hold_element.py
+++ b/pandas/tests/dtypes/cast/test_can_hold_element.py
@@ -33,11 +33,11 @@ def test_can_hold_element_range(any_int_numpy_dtype):
         assert can_hold_element(arr, rng)
 
     # empty
-    rng = range(-(10 ** 10), -(10 ** 10))
+    rng = range(-(10**10), -(10**10))
     assert len(rng) == 0
     # assert can_hold_element(arr, rng)
 
-    rng = range(10 ** 10, 10 ** 10)
+    rng = range(10**10, 10**10)
     assert len(rng) == 0
     assert can_hold_element(arr, rng)
 
@@ -51,7 +51,7 @@ def test_can_hold_element_int_values_float_ndarray():
     assert not can_hold_element(arr, element + 0.5)
 
     # integer but not losslessly castable to int64
-    element = np.array([3, 2 ** 65], dtype=np.float64)
+    element = np.array([3, 2**65], dtype=np.float64)
     assert not can_hold_element(arr, element)
 
 
@@ -68,3 +68,12 @@ def test_can_hold_element_int8_int():
     assert can_hold_element(arr, np.uint32(element))
     assert can_hold_element(arr, np.int64(element))
     assert can_hold_element(arr, np.uint64(element))
+
+    element = 2**9
+    assert not can_hold_element(arr, element)
+    assert not can_hold_element(arr, np.int16(element))
+    assert not can_hold_element(arr, np.uint16(element))
+    assert not can_hold_element(arr, np.int32(element))
+    assert not can_hold_element(arr, np.uint32(element))
+    assert not can_hold_element(arr, np.int64(element))
+    assert not can_hold_element(arr, np.uint64(element))
diff --git a/pandas/tests/dtypes/cast/test_downcast.py b/pandas/tests/dtypes/cast/test_downcast.py
index b1efc1e5677fd..c01eac746455c 100644
--- a/pandas/tests/dtypes/cast/test_downcast.py
+++ b/pandas/tests/dtypes/cast/test_downcast.py
@@ -5,7 +5,10 @@
 
 from pandas.core.dtypes.cast import maybe_downcast_to_dtype
 
-from pandas import Series
+from pandas import (
+    Series,
+    Timedelta,
+)
 import pandas._testing as tm
 
 
@@ -34,6 +37,13 @@
             "int64",
             np.array([decimal.Decimal(0.0)]),
         ),
+        (
+            # GH#45837
+            np.array([Timedelta(days=1), Timedelta(days=2)], dtype=object),
+            "infer",
+            np.array([1, 2], dtype="m8[D]").astype("m8[ns]"),
+        ),
+        # TODO: similar for dt64, dt64tz, Period, Interval?
     ],
 )
 def test_downcast(arr, expected, dtype):
diff --git a/pandas/tests/dtypes/cast/test_promote.py b/pandas/tests/dtypes/cast/test_promote.py
index a514a9ce9b0e4..02bd03f5ea266 100644
--- a/pandas/tests/dtypes/cast/test_promote.py
+++ b/pandas/tests/dtypes/cast/test_promote.py
@@ -348,7 +348,7 @@ def test_maybe_promote_bytes_with_any(bytes_dtype, any_numpy_dtype_reduced):
     _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_any_with_bytes(any_numpy_dtype_reduced, bytes_dtype):
+def test_maybe_promote_any_with_bytes(any_numpy_dtype_reduced):
     dtype = np.dtype(any_numpy_dtype_reduced)
 
     # create array of given dtype
@@ -391,9 +391,7 @@ def test_maybe_promote_datetime64_with_any(datetime64_dtype, any_numpy_dtype_red
     ],
     ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
 )
-def test_maybe_promote_any_with_datetime64(
-    any_numpy_dtype_reduced, datetime64_dtype, fill_value
-):
+def test_maybe_promote_any_with_datetime64(any_numpy_dtype_reduced, fill_value):
     dtype = np.dtype(any_numpy_dtype_reduced)
 
     # filling datetime with anything but datetime casts to object
@@ -465,9 +463,7 @@ def test_maybe_promote_timedelta64_with_any(timedelta64_dtype, any_numpy_dtype_r
     [pd.Timedelta(days=1), np.timedelta64(24, "h"), datetime.timedelta(1)],
     ids=["pd.Timedelta", "np.timedelta64", "datetime.timedelta"],
 )
-def test_maybe_promote_any_with_timedelta64(
-    any_numpy_dtype_reduced, timedelta64_dtype, fill_value
-):
+def test_maybe_promote_any_with_timedelta64(any_numpy_dtype_reduced, fill_value):
     dtype = np.dtype(any_numpy_dtype_reduced)
 
     # filling anything but timedelta with timedelta casts to object
@@ -496,7 +492,7 @@ def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype_reduced):
     _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_any_with_string(any_numpy_dtype_reduced, string_dtype):
+def test_maybe_promote_any_with_string(any_numpy_dtype_reduced):
     dtype = np.dtype(any_numpy_dtype_reduced)
 
     # create array of given dtype
@@ -523,7 +519,7 @@ def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype_reduced):
     _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_any_with_object(any_numpy_dtype_reduced, object_dtype):
+def test_maybe_promote_any_with_object(any_numpy_dtype_reduced):
     dtype = np.dtype(any_numpy_dtype_reduced)
 
     # create array of object dtype from a scalar value (i.e. passing
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index e2c5f893b6a2c..984655c68d56b 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -7,7 +7,7 @@
 
 import pandas.util._test_decorators as td
 
-from pandas.core.dtypes.cast import astype_nansafe
+from pandas.core.dtypes.astype import astype_nansafe
 import pandas.core.dtypes.common as com
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
@@ -474,6 +474,9 @@ def test_is_datetime64_ns_dtype():
         pd.DatetimeIndex([1, 2, 3], dtype=np.dtype("datetime64[ns]"))
     )
 
+    # non-nano dt64tz
+    assert not com.is_datetime64_ns_dtype(DatetimeTZDtype("us", "US/Eastern"))
+
 
 def test_is_timedelta64_ns_dtype():
     assert not com.is_timedelta64_ns_dtype(np.dtype("m8[ps]"))
@@ -562,12 +565,14 @@ def test_is_bool_dtype():
     assert not com.is_bool_dtype(int)
     assert not com.is_bool_dtype(str)
     assert not com.is_bool_dtype(pd.Series([1, 2]))
+    assert not com.is_bool_dtype(pd.Series(["a", "b"], dtype="category"))
     assert not com.is_bool_dtype(np.array(["a", "b"]))
     assert not com.is_bool_dtype(pd.Index(["a", "b"]))
     assert not com.is_bool_dtype("Int64")
 
     assert com.is_bool_dtype(bool)
     assert com.is_bool_dtype(np.bool_)
+    assert com.is_bool_dtype(pd.Series([True, False], dtype="category"))
     assert com.is_bool_dtype(np.array([True, False]))
     assert com.is_bool_dtype(pd.Index([True, False]))
 
@@ -743,9 +748,7 @@ def test_astype_nansafe(val, typ):
 
     msg = "Cannot convert NaT values to integer"
     with pytest.raises(ValueError, match=msg):
-        with tm.assert_produces_warning(FutureWarning):
-            # datetimelike astype(int64) deprecated
-            astype_nansafe(arr, dtype=typ)
+        astype_nansafe(arr, dtype=typ)
 
 
 def test_astype_nansafe_copy_false(any_int_numpy_dtype):
diff --git a/pandas/tests/dtypes/test_concat.py b/pandas/tests/dtypes/test_concat.py
index f624c56b54001..772dfdfe8fb03 100644
--- a/pandas/tests/dtypes/test_concat.py
+++ b/pandas/tests/dtypes/test_concat.py
@@ -38,7 +38,9 @@ def test_concat_periodarray_2d():
     result = _concat.concat_compat([arr[:, :2], arr[:, 2:]], axis=1)
     tm.assert_period_array_equal(result, arr)
 
-    msg = "all the input array dimensions for the concatenation axis must match exactly"
+    msg = (
+        "all the input array dimensions.* for the concatenation axis must match exactly"
+    )
     with pytest.raises(ValueError, match=msg):
         _concat.concat_compat([arr[:, :2], arr[:, 2:]], axis=0)
 
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 30447de874aaa..aeae5fec481ec 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -4,6 +4,8 @@
 import pytest
 import pytz
 
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
 from pandas.core.dtypes.base import _registry as registry
 from pandas.core.dtypes.common import (
     is_bool_dtype,
@@ -263,10 +265,17 @@ def test_hash_vs_equality(self, dtype):
         assert dtype2 != dtype4
         assert hash(dtype2) != hash(dtype4)
 
-    def test_construction(self):
-        msg = "DatetimeTZDtype only supports ns units"
+    def test_construction_non_nanosecond(self):
+        res = DatetimeTZDtype("ms", "US/Eastern")
+        assert res.unit == "ms"
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res.str == "|M8[ms]"
+        assert str(res) == "datetime64[ms, US/Eastern]"
+
+    def test_day_not_supported(self):
+        msg = "DatetimeTZDtype only supports s, ms, us, ns units"
         with pytest.raises(ValueError, match=msg):
-            DatetimeTZDtype("ms", "US/Eastern")
+            DatetimeTZDtype("D", "US/Eastern")
 
     def test_subclass(self):
         a = DatetimeTZDtype.construct_from_string("datetime64[ns, US/Eastern]")
@@ -848,7 +857,7 @@ def test_categories(self):
         tm.assert_index_equal(result.categories, pd.Index(["a", "b", "c"]))
         assert result.ordered is False
 
-    def test_equal_but_different(self, ordered):
+    def test_equal_but_different(self):
         c1 = CategoricalDtype([1, 2, 3])
         c2 = CategoricalDtype([1.0, 2.0, 3.0])
         assert c1 is not c2
@@ -1107,3 +1116,15 @@ def test_compare_complex_dtypes():
 
     with pytest.raises(TypeError, match=msg):
         df.lt(df.astype(object))
+
+
+def test_multi_column_dtype_assignment():
+    # GH #27583
+    df = pd.DataFrame({"a": [0.0], "b": 0.0})
+    expected = pd.DataFrame({"a": [0], "b": 0})
+
+    df[["a", "b"]] = 0
+    tm.assert_frame_equal(df, expected)
+
+    df["b"] = 0
+    tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/dtypes/test_generic.py b/pandas/tests/dtypes/test_generic.py
index 0612348297bd0..4f73754d2708f 100644
--- a/pandas/tests/dtypes/test_generic.py
+++ b/pandas/tests/dtypes/test_generic.py
@@ -1,3 +1,4 @@
+import re
 from warnings import catch_warnings
 
 import numpy as np
@@ -49,13 +50,28 @@ class TestABCClasses:
 
     @pytest.mark.parametrize("abctype1, inst", abc_pairs)
     @pytest.mark.parametrize("abctype2, _", abc_pairs)
-    def test_abc_pairs(self, abctype1, abctype2, inst, _):
-        # GH 38588
+    def test_abc_pairs_instance_check(self, abctype1, abctype2, inst, _):
+        # GH 38588, 46719
         if abctype1 == abctype2:
             assert isinstance(inst, getattr(gt, abctype2))
+            assert not isinstance(type(inst), getattr(gt, abctype2))
         else:
             assert not isinstance(inst, getattr(gt, abctype2))
 
+    @pytest.mark.parametrize("abctype1, inst", abc_pairs)
+    @pytest.mark.parametrize("abctype2, _", abc_pairs)
+    def test_abc_pairs_subclass_check(self, abctype1, abctype2, inst, _):
+        # GH 38588, 46719
+        if abctype1 == abctype2:
+            assert issubclass(type(inst), getattr(gt, abctype2))
+
+            with pytest.raises(
+                TypeError, match=re.escape("issubclass() arg 1 must be a class")
+            ):
+                issubclass(inst, getattr(gt, abctype2))
+        else:
+            assert not issubclass(type(inst), getattr(gt, abctype2))
+
     abc_subclasses = {
         "ABCIndex": [
             abctype
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 7953d650636be..948d14c1bd1f9 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -17,6 +17,11 @@
 import itertools
 from numbers import Number
 import re
+import sys
+from typing import (
+    Generic,
+    TypeVar,
+)
 
 import numpy as np
 import pytest
@@ -91,7 +96,7 @@ class MockNumpyLikeArray:
     a scalar (`is_scalar(np.array(1)) == False`), but it is not list-like either.
     """
 
-    def __init__(self, values):
+    def __init__(self, values) -> None:
         self._values = values
 
     def __iter__(self):
@@ -205,8 +210,14 @@ def foo():
         inference.is_list_like([])
         foo()
 
-    with tm.external_error_raised(RecursionError):
-        foo()
+    rec_limit = sys.getrecursionlimit()
+    try:
+        # Limit to avoid stack overflow on Windows CI
+        sys.setrecursionlimit(100)
+        with tm.external_error_raised(RecursionError):
+            foo()
+    finally:
+        sys.setrecursionlimit(rec_limit)
 
 
 def test_is_list_like_iter_is_none():
@@ -221,6 +232,22 @@ def __getitem__(self, item):
     assert not inference.is_list_like(NotListLike())
 
 
+def test_is_list_like_generic():
+    # GH 49649
+    # is_list_like was yielding false positives for Generic classes in python 3.11
+    T = TypeVar("T")
+
+    class MyDataFrame(DataFrame, Generic[T]):
+        ...
+
+    tstc = MyDataFrame[int]
+    tst = MyDataFrame[int]({"x": [1, 2, 3]})
+
+    assert not inference.is_list_like(tstc)
+    assert isinstance(tst, DataFrame)
+    assert inference.is_list_like(tst)
+
+
 def test_is_sequence():
     is_seq = inference.is_sequence
     assert is_seq((1, 2))
@@ -229,7 +256,7 @@ def test_is_sequence():
     assert not is_seq(np.int64)
 
     class A:
-        def __getitem__(self):
+        def __getitem__(self, item):
             return 1
 
     assert not is_seq(A())
@@ -323,7 +350,7 @@ def test_is_dict_like_fails(ll):
 @pytest.mark.parametrize("has_contains", [True, False])
 def test_is_dict_like_duck_type(has_keys, has_getitem, has_contains):
     class DictLike:
-        def __init__(self, d):
+        def __init__(self, d) -> None:
             self.d = d
 
         if has_keys:
@@ -594,25 +621,25 @@ def test_convert_non_hashable(self):
         tm.assert_numpy_array_equal(result, np.array([np.nan, 1.0, np.nan]))
 
     def test_convert_numeric_uint64(self):
-        arr = np.array([2 ** 63], dtype=object)
-        exp = np.array([2 ** 63], dtype=np.uint64)
+        arr = np.array([2**63], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
 
-        arr = np.array([str(2 ** 63)], dtype=object)
-        exp = np.array([2 ** 63], dtype=np.uint64)
+        arr = np.array([str(2**63)], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
 
-        arr = np.array([np.uint64(2 ** 63)], dtype=object)
-        exp = np.array([2 ** 63], dtype=np.uint64)
+        arr = np.array([np.uint64(2**63)], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
 
     @pytest.mark.parametrize(
         "arr",
         [
-            np.array([2 ** 63, np.nan], dtype=object),
-            np.array([str(2 ** 63), np.nan], dtype=object),
-            np.array([np.nan, 2 ** 63], dtype=object),
-            np.array([np.nan, str(2 ** 63)], dtype=object),
+            np.array([2**63, np.nan], dtype=object),
+            np.array([str(2**63), np.nan], dtype=object),
+            np.array([np.nan, 2**63], dtype=object),
+            np.array([np.nan, str(2**63)], dtype=object),
         ],
     )
     def test_convert_numeric_uint64_nan(self, coerce, arr):
@@ -624,11 +651,11 @@ def test_convert_numeric_uint64_nan(self, coerce, arr):
     def test_convert_numeric_uint64_nan_values(
         self, coerce, convert_to_masked_nullable
     ):
-        arr = np.array([2 ** 63, 2 ** 63 + 1], dtype=object)
-        na_values = {2 ** 63}
+        arr = np.array([2**63, 2**63 + 1], dtype=object)
+        na_values = {2**63}
 
         expected = (
-            np.array([np.nan, 2 ** 63 + 1], dtype=float) if coerce else arr.copy()
+            np.array([np.nan, 2**63 + 1], dtype=float) if coerce else arr.copy()
         )
         result = lib.maybe_convert_numeric(
             arr,
@@ -638,7 +665,7 @@ def test_convert_numeric_uint64_nan_values(
         )
         if convert_to_masked_nullable and coerce:
             expected = IntegerArray(
-                np.array([0, 2 ** 63 + 1], dtype="u8"),
+                np.array([0, 2**63 + 1], dtype="u8"),
                 np.array([True, False], dtype="bool"),
             )
             result = IntegerArray(*result)
@@ -649,12 +676,12 @@ def test_convert_numeric_uint64_nan_values(
     @pytest.mark.parametrize(
         "case",
         [
-            np.array([2 ** 63, -1], dtype=object),
-            np.array([str(2 ** 63), -1], dtype=object),
-            np.array([str(2 ** 63), str(-1)], dtype=object),
-            np.array([-1, 2 ** 63], dtype=object),
-            np.array([-1, str(2 ** 63)], dtype=object),
-            np.array([str(-1), str(2 ** 63)], dtype=object),
+            np.array([2**63, -1], dtype=object),
+            np.array([str(2**63), -1], dtype=object),
+            np.array([str(2**63), str(-1)], dtype=object),
+            np.array([-1, 2**63], dtype=object),
+            np.array([-1, str(2**63)], dtype=object),
+            np.array([str(-1), str(2**63)], dtype=object),
         ],
     )
     @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
@@ -686,32 +713,39 @@ def test_convert_numeric_string_uint64(self, convert_to_masked_nullable):
             result = result[0]
         assert np.isnan(result)
 
-    @pytest.mark.parametrize("value", [-(2 ** 63) - 1, 2 ** 64])
+    @pytest.mark.parametrize("value", [-(2**63) - 1, 2**64])
     def test_convert_int_overflow(self, value):
         # see gh-18584
         arr = np.array([value], dtype=object)
         result = lib.maybe_convert_objects(arr)
         tm.assert_numpy_array_equal(arr, result)
 
-    def test_maybe_convert_objects_uint64(self):
-        # see gh-4471
-        arr = np.array([2 ** 63], dtype=object)
-        exp = np.array([2 ** 63], dtype=np.uint64)
-        tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp)
-
-        # NumPy bug: can't compare uint64 to int64, as that
-        # results in both casting to float64, so we should
-        # make sure that this function is robust against it
-        arr = np.array([np.uint64(2 ** 63)], dtype=object)
-        exp = np.array([2 ** 63], dtype=np.uint64)
-        tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp)
-
-        arr = np.array([2, -1], dtype=object)
-        exp = np.array([2, -1], dtype=np.int64)
-        tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp)
-
-        arr = np.array([2 ** 63, -1], dtype=object)
-        exp = np.array([2 ** 63, -1], dtype=object)
+    @pytest.mark.parametrize(
+        "value, expected_dtype",
+        [
+            # see gh-4471
+            ([2**63], np.uint64),
+            # NumPy bug: can't compare uint64 to int64, as that
+            # results in both casting to float64, so we should
+            # make sure that this function is robust against it
+            ([np.uint64(2**63)], np.uint64),
+            ([2, -1], np.int64),
+            ([2**63, -1], object),
+            # GH#47294
+            ([np.uint8(1)], np.uint8),
+            ([np.uint16(1)], np.uint16),
+            ([np.uint32(1)], np.uint32),
+            ([np.uint64(1)], np.uint64),
+            ([np.uint8(2), np.uint16(1)], np.uint16),
+            ([np.uint32(2), np.uint16(1)], np.uint32),
+            ([np.uint32(2), -1], object),
+            ([np.uint32(2), 1], np.uint64),
+            ([np.uint32(2), np.int32(1)], object),
+        ],
+    )
+    def test_maybe_convert_objects_uint(self, value, expected_dtype):
+        arr = np.array(value, dtype=object)
+        exp = np.array(value, dtype=expected_dtype)
         tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp)
 
     def test_maybe_convert_objects_datetime(self):
@@ -1134,10 +1168,20 @@ def test_unicode(self):
         # This could also return "string" or "mixed-string"
         assert result == "mixed"
 
+        # even though we use skipna, we are only skipping those NAs that are
+        #  considered matching by is_string_array
         arr = ["a", np.nan, "c"]
         result = lib.infer_dtype(arr, skipna=True)
         assert result == "string"
 
+        arr = ["a", pd.NA, "c"]
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "string"
+
+        arr = ["a", pd.NaT, "c"]
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed"
+
         arr = ["a", "c"]
         result = lib.infer_dtype(arr, skipna=False)
         assert result == "string"
@@ -1534,7 +1578,9 @@ def test_is_numeric_array(self):
         assert not lib.is_integer_array(np.array([1, 2.0]))
 
     def test_is_string_array(self):
-
+        # We should only be accepting pd.NA, np.nan,
+        # other floating point nans e.g. float('nan')]
+        # when skipna is True.
         assert lib.is_string_array(np.array(["foo", "bar"]))
         assert not lib.is_string_array(
             np.array(["foo", "bar", pd.NA], dtype=object), skipna=False
@@ -1542,11 +1588,30 @@ def test_is_string_array(self):
         assert lib.is_string_array(
             np.array(["foo", "bar", pd.NA], dtype=object), skipna=True
         )
-        # NaN is not valid for string array, just NA
-        assert not lib.is_string_array(
+        # we allow NaN/None in the StringArray constructor, so its allowed here
+        assert lib.is_string_array(
+            np.array(["foo", "bar", None], dtype=object), skipna=True
+        )
+        assert lib.is_string_array(
             np.array(["foo", "bar", np.nan], dtype=object), skipna=True
         )
+        # But not e.g. datetimelike or Decimal NAs
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", pd.NaT], dtype=object), skipna=True
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", np.datetime64("NaT")], dtype=object), skipna=True
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", Decimal("NaN")], dtype=object), skipna=True
+        )
 
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", None], dtype=object), skipna=False
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", np.nan], dtype=object), skipna=False
+        )
         assert not lib.is_string_array(np.array([1, 2]))
 
     def test_to_object_array_tuples(self):
@@ -1795,12 +1860,13 @@ def test_is_datetime_dtypes(self):
         assert not is_datetime64tz_dtype(ts)
         assert is_datetime64tz_dtype(tsa)
 
-        for tz in ["US/Eastern", "UTC"]:
-            dtype = f"datetime64[ns, {tz}]"
-            assert not is_datetime64_dtype(dtype)
-            assert is_datetime64tz_dtype(dtype)
-            assert is_datetime64_ns_dtype(dtype)
-            assert is_datetime64_any_dtype(dtype)
+    @pytest.mark.parametrize("tz", ["US/Eastern", "UTC"])
+    def test_is_datetime_dtypes_with_tz(self, tz):
+        dtype = f"datetime64[ns, {tz}]"
+        assert not is_datetime64_dtype(dtype)
+        assert is_datetime64tz_dtype(dtype)
+        assert is_datetime64_ns_dtype(dtype)
+        assert is_datetime64_any_dtype(dtype)
 
     def test_is_timedelta(self):
         assert is_timedelta64_dtype("timedelta64")
@@ -1859,26 +1925,24 @@ def test_is_scalar_numpy_array_scalars(self):
         assert is_scalar(np.datetime64("2014-01-01"))
         assert is_scalar(np.timedelta64(1, "h"))
 
-    def test_is_scalar_numpy_zerodim_arrays(self):
-        for zerodim in [
+    @pytest.mark.parametrize(
+        "zerodim",
+        [
             np.array(1),
             np.array("foobar"),
             np.array(np.datetime64("2014-01-01")),
             np.array(np.timedelta64(1, "h")),
             np.array(np.datetime64("NaT")),
-        ]:
-            assert not is_scalar(zerodim)
-            assert is_scalar(lib.item_from_zerodim(zerodim))
-
-    @pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")
-    def test_is_scalar_numpy_arrays(self):
-        for a in [
-            np.array([]),
-            np.array([[]]),
-            np.matrix("1; 2"),
-        ]:
-            assert not is_scalar(a)
-            assert not is_scalar(MockNumpyLikeArray(a))
+        ],
+    )
+    def test_is_scalar_numpy_zerodim_arrays(self, zerodim):
+        assert not is_scalar(zerodim)
+        assert is_scalar(lib.item_from_zerodim(zerodim))
+
+    @pytest.mark.parametrize("arr", [np.array([]), np.array([[]])])
+    def test_is_scalar_numpy_arrays(self, arr):
+        assert not is_scalar(arr)
+        assert not is_scalar(MockNumpyLikeArray(arr))
 
     def test_is_scalar_pandas_scalars(self):
         assert is_scalar(Timestamp("2014-01-01"))
@@ -1907,7 +1971,7 @@ def test_is_scalar_number(self):
         #  subclasses are.
 
         class Numeric(Number):
-            def __init__(self, value):
+            def __init__(self, value) -> None:
                 self.value = value
 
             def __int__(self):
@@ -1917,10 +1981,10 @@ def __int__(self):
         assert is_scalar(num)
 
 
-def test_datetimeindex_from_empty_datetime64_array():
-    for unit in ["ms", "us", "ns"]:
-        idx = DatetimeIndex(np.array([], dtype=f"datetime64[{unit}]"))
-        assert len(idx) == 0
+@pytest.mark.parametrize("unit", ["ms", "us", "ns"])
+def test_datetimeindex_from_empty_datetime64_array(unit):
+    idx = DatetimeIndex(np.array([], dtype=f"datetime64[{unit}]"))
+    assert len(idx) == 0
 
 
 def test_nan_to_nat_conversions():
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index 1917fc615118a..9a242e9491537 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -9,6 +9,7 @@
 
 from pandas._libs import missing as libmissing
 from pandas._libs.tslibs import iNaT
+from pandas.compat import is_numpy_dev
 
 from pandas.core.dtypes.common import (
     is_float,
@@ -67,15 +68,21 @@ def test_notna_notnull(notna_f):
         result = notna_f(arr)
         assert result.sum() == 2
 
+
+@pytest.mark.parametrize("null_func", [notna, notnull, isna, isnull])
+@pytest.mark.parametrize(
+    "ser",
+    [
+        tm.makeFloatSeries(),
+        tm.makeStringSeries(),
+        tm.makeObjectSeries(),
+        tm.makeTimeSeries(),
+        tm.makePeriodSeries(),
+    ],
+)
+def test_null_check_is_series(null_func, ser):
     with cf.option_context("mode.use_inf_as_na", False):
-        for s in [
-            tm.makeFloatSeries(),
-            tm.makeStringSeries(),
-            tm.makeObjectSeries(),
-            tm.makeTimeSeries(),
-            tm.makePeriodSeries(),
-        ]:
-            assert isinstance(notna_f(s), Series)
+        assert isinstance(null_func(ser), Series)
 
 
 class TestIsNA:
@@ -88,13 +95,12 @@ def test_0d_array(self):
         assert not isna(np.array(0.0, dtype=object))
         assert not isna(np.array(0, dtype=object))
 
-    def test_empty_object(self):
-
-        for shape in [(4, 0), (4,)]:
-            arr = np.empty(shape=shape, dtype=object)
-            result = isna(arr)
-            expected = np.ones(shape=shape, dtype=bool)
-            tm.assert_numpy_array_equal(result, expected)
+    @pytest.mark.parametrize("shape", [(4, 0), (4,)])
+    def test_empty_object(self, shape):
+        arr = np.empty(shape=shape, dtype=object)
+        result = isna(arr)
+        expected = np.ones(shape=shape, dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize("isna_f", [isna, isnull])
     def test_isna_isnull(self, isna_f):
@@ -110,25 +116,20 @@ def test_isna_isnull(self, isna_f):
         assert not isna_f(type(Series(dtype=np.float64)))
         assert not isna_f(type(pd.DataFrame()))
 
-        # series
-        for s in [
-            tm.makeFloatSeries(),
-            tm.makeStringSeries(),
-            tm.makeObjectSeries(),
-            tm.makeTimeSeries(),
-            tm.makePeriodSeries(),
-        ]:
-            assert isinstance(isna_f(s), Series)
-
-        # frame
-        for df in [
+    @pytest.mark.parametrize("isna_f", [isna, isnull])
+    @pytest.mark.parametrize(
+        "df",
+        [
             tm.makeTimeDataFrame(),
             tm.makePeriodFrame(),
             tm.makeMixedDataFrame(),
-        ]:
-            result = isna_f(df)
-            expected = df.apply(isna_f)
-            tm.assert_frame_equal(result, expected)
+        ],
+    )
+    def test_isna_isnull_frame(self, isna_f, df):
+        # frame
+        result = isna_f(df)
+        expected = df.apply(isna_f)
+        tm.assert_frame_equal(result, expected)
 
     def test_isna_lists(self):
         result = isna([[False]])
@@ -248,7 +249,9 @@ def test_datetime_other_units(self):
         tm.assert_numpy_array_equal(isna(idx.values), exp)
         tm.assert_numpy_array_equal(notna(idx.values), ~exp)
 
-        for dtype in [
+    @pytest.mark.parametrize(
+        "dtype",
+        [
             "datetime64[D]",
             "datetime64[h]",
             "datetime64[m]",
@@ -256,20 +259,23 @@ def test_datetime_other_units(self):
             "datetime64[ms]",
             "datetime64[us]",
             "datetime64[ns]",
-        ]:
-            values = idx.values.astype(dtype)
+        ],
+    )
+    def test_datetime_other_units_astype(self, dtype):
+        idx = DatetimeIndex(["2011-01-01", "NaT", "2011-01-02"])
+        values = idx.values.astype(dtype)
 
-            exp = np.array([False, True, False])
-            tm.assert_numpy_array_equal(isna(values), exp)
-            tm.assert_numpy_array_equal(notna(values), ~exp)
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(values), exp)
+        tm.assert_numpy_array_equal(notna(values), ~exp)
 
-            exp = Series([False, True, False])
-            s = Series(values)
-            tm.assert_series_equal(isna(s), exp)
-            tm.assert_series_equal(notna(s), ~exp)
-            s = Series(values, dtype=object)
-            tm.assert_series_equal(isna(s), exp)
-            tm.assert_series_equal(notna(s), ~exp)
+        exp = Series([False, True, False])
+        s = Series(values)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+        s = Series(values, dtype=object)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
 
     def test_timedelta_other_units(self):
         idx = TimedeltaIndex(["1 days", "NaT", "2 days"])
@@ -279,7 +285,9 @@ def test_timedelta_other_units(self):
         tm.assert_numpy_array_equal(isna(idx.values), exp)
         tm.assert_numpy_array_equal(notna(idx.values), ~exp)
 
-        for dtype in [
+    @pytest.mark.parametrize(
+        "dtype",
+        [
             "timedelta64[D]",
             "timedelta64[h]",
             "timedelta64[m]",
@@ -287,20 +295,23 @@ def test_timedelta_other_units(self):
             "timedelta64[ms]",
             "timedelta64[us]",
             "timedelta64[ns]",
-        ]:
-            values = idx.values.astype(dtype)
+        ],
+    )
+    def test_timedelta_other_units_dtype(self, dtype):
+        idx = TimedeltaIndex(["1 days", "NaT", "2 days"])
+        values = idx.values.astype(dtype)
 
-            exp = np.array([False, True, False])
-            tm.assert_numpy_array_equal(isna(values), exp)
-            tm.assert_numpy_array_equal(notna(values), ~exp)
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(values), exp)
+        tm.assert_numpy_array_equal(notna(values), ~exp)
 
-            exp = Series([False, True, False])
-            s = Series(values)
-            tm.assert_series_equal(isna(s), exp)
-            tm.assert_series_equal(notna(s), ~exp)
-            s = Series(values, dtype=object)
-            tm.assert_series_equal(isna(s), exp)
-            tm.assert_series_equal(notna(s), ~exp)
+        exp = Series([False, True, False])
+        s = Series(values)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+        s = Series(values, dtype=object)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
 
     def test_period(self):
         idx = pd.PeriodIndex(["2011-01", "NaT", "2012-01"], freq="M")
@@ -415,23 +426,28 @@ def test_array_equivalent(dtype_equal):
         TimedeltaIndex([1, np.nan]),
         dtype_equal=dtype_equal,
     )
+
+    msg = "will be interpreted as nanosecond UTC timestamps instead of wall-times"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        dti1 = DatetimeIndex([0, np.nan], tz="US/Eastern")
+        dti2 = DatetimeIndex([0, np.nan], tz="CET")
+        dti3 = DatetimeIndex([1, np.nan], tz="US/Eastern")
+
     assert array_equivalent(
-        DatetimeIndex([0, np.nan], tz="US/Eastern"),
-        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+        dti1,
+        dti1,
         dtype_equal=dtype_equal,
     )
     assert not array_equivalent(
-        DatetimeIndex([0, np.nan], tz="US/Eastern"),
-        DatetimeIndex([1, np.nan], tz="US/Eastern"),
+        dti1,
+        dti3,
         dtype_equal=dtype_equal,
     )
     # The rest are not dtype_equal
+    assert not array_equivalent(DatetimeIndex([0, np.nan]), dti1)
     assert not array_equivalent(
-        DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan], tz="US/Eastern")
-    )
-    assert not array_equivalent(
-        DatetimeIndex([0, np.nan], tz="CET"),
-        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+        dti2,
+        dti1,
     )
 
     assert not array_equivalent(DatetimeIndex([0, np.nan]), TimedeltaIndex([0, np.nan]))
@@ -446,7 +462,7 @@ def test_array_equivalent_series(val):
     cm = (
         # stacklevel is chosen to make sense when called from .equals
         tm.assert_produces_warning(FutureWarning, match=msg, check_stacklevel=False)
-        if isinstance(val, str)
+        if isinstance(val, str) and not is_numpy_dev
         else nullcontext()
     )
     with cm:
@@ -499,28 +515,130 @@ def test_array_equivalent_compat():
     assert not array_equivalent(m, n, strict_nan=False)
 
 
-def test_array_equivalent_str():
-    for dtype in ["O", "S", "U"]:
-        assert array_equivalent(
-            np.array(["A", "B"], dtype=dtype), np.array(["A", "B"], dtype=dtype)
-        )
-        assert not array_equivalent(
-            np.array(["A", "B"], dtype=dtype), np.array(["A", "X"], dtype=dtype)
-        )
+@pytest.mark.parametrize("dtype", ["O", "S", "U"])
+def test_array_equivalent_str(dtype):
+    assert array_equivalent(
+        np.array(["A", "B"], dtype=dtype), np.array(["A", "B"], dtype=dtype)
+    )
+    assert not array_equivalent(
+        np.array(["A", "B"], dtype=dtype), np.array(["A", "X"], dtype=dtype)
+    )
 
 
-def test_array_equivalent_nested():
+@pytest.mark.parametrize(
+    "strict_nan", [pytest.param(True, marks=pytest.mark.xfail), False]
+)
+def test_array_equivalent_nested(strict_nan):
     # reached in groupby aggregations, make sure we use np.any when checking
     #  if the comparison is truthy
-    left = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
-    right = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
+    left = np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object)
+    right = np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
 
-    assert array_equivalent(left, right, strict_nan=True)
-    assert not array_equivalent(left, right[::-1], strict_nan=True)
+    left = np.empty(2, dtype=object)
+    left[:] = [np.array([50, 70, 90]), np.array([20, 30, 40])]
+    right = np.empty(2, dtype=object)
+    right[:] = [np.array([50, 70, 90]), np.array([20, 30, 40])]
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
 
-    left = np.array([np.array([50, 50, 50]), np.array([40, 40, 40])], dtype=object)
+    left = np.array([np.array([50, 50, 50]), np.array([40, 40])], dtype=object)
     right = np.array([50, 40])
-    assert not array_equivalent(left, right, strict_nan=True)
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.parametrize(
+    "strict_nan", [pytest.param(True, marks=pytest.mark.xfail), False]
+)
+def test_array_equivalent_nested2(strict_nan):
+    # more than one level of nesting
+    left = np.array(
+        [
+            np.array([np.array([50, 70]), np.array([90])], dtype=object),
+            np.array([np.array([20, 30])], dtype=object),
+        ],
+        dtype=object,
+    )
+    right = np.array(
+        [
+            np.array([np.array([50, 70]), np.array([90])], dtype=object),
+            np.array([np.array([20, 30])], dtype=object),
+        ],
+        dtype=object,
+    )
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.array([np.array([np.array([50, 50, 50])], dtype=object)], dtype=object)
+    right = np.array([50])
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.parametrize(
+    "strict_nan", [pytest.param(True, marks=pytest.mark.xfail), False]
+)
+def test_array_equivalent_nested_list(strict_nan):
+    left = np.array([[50, 70, 90], [20, 30]], dtype=object)
+    right = np.array([[50, 70, 90], [20, 30]], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.array([[50, 50, 50], [40, 40]], dtype=object)
+    right = np.array([50, 40])
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.xfail(reason="failing")
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested_mixed_list(strict_nan):
+    # mixed arrays / lists in left and right
+    # https://github.com/pandas-dev/pandas/issues/50360
+    left = np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object)
+    right = np.array([[1, 2, 3], [4, 5]], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    # multiple levels of nesting
+    left = np.array(
+        [
+            np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+            np.array([np.array([6]), np.array([7, 8]), np.array([9])], dtype=object),
+        ],
+        dtype=object,
+    )
+    right = np.array([[[1, 2, 3], [4, 5]], [[6], [7, 8], [9]]], dtype=object)
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    # same-length lists
+    subarr = np.empty(2, dtype=object)
+    subarr[:] = [
+        np.array([None, "b"], dtype=object),
+        np.array(["c", "d"], dtype=object),
+    ]
+    left = np.array([subarr, None], dtype=object)
+    right = np.array([list([[None, "b"], ["c", "d"]]), None], dtype=object)
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+
+@pytest.mark.xfail(reason="failing")
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested_dicts(strict_nan):
+    left = np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object)
+    right = np.array(
+        [{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object
+    )
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    right2 = np.array([{"f1": 1, "f2": ["a", "b"]}], dtype=object)
+    assert array_equivalent(left, right2, strict_nan=strict_nan)
+    assert not array_equivalent(left, right2[::-1], strict_nan=strict_nan)
 
 
 @pytest.mark.parametrize(
@@ -656,31 +774,44 @@ def test_empty_like(self):
 
 class TestLibMissing:
     @pytest.mark.parametrize("func", [libmissing.checknull, isna])
-    def test_checknull(self, func):
-        for value in na_vals + sometimes_na_vals:
-            assert func(value)
+    @pytest.mark.parametrize(
+        "value", na_vals + sometimes_na_vals  # type: ignore[operator]
+    )
+    def test_checknull_na_vals(self, func, value):
+        assert func(value)
 
-        for value in inf_vals:
-            assert not func(value)
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", inf_vals)
+    def test_checknull_inf_vals(self, func, value):
+        assert not func(value)
 
-        for value in int_na_vals:
-            assert not func(value)
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_intna_vals(self, func, value):
+        assert not func(value)
 
-        for value in never_na_vals:
-            assert not func(value)
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", never_na_vals)
+    def test_checknull_never_na_vals(self, func, value):
+        assert not func(value)
 
-    def test_checknull_old(self):
-        for value in na_vals + sometimes_na_vals:
-            assert libmissing.checknull(value, inf_as_na=True)
+    @pytest.mark.parametrize(
+        "value", na_vals + sometimes_na_vals  # type: ignore[operator]
+    )
+    def test_checknull_old_na_vals(self, value):
+        assert libmissing.checknull(value, inf_as_na=True)
 
-        for value in inf_vals:
-            assert libmissing.checknull(value, inf_as_na=True)
+    @pytest.mark.parametrize("value", inf_vals)
+    def test_checknull_old_inf_vals(self, value):
+        assert libmissing.checknull(value, inf_as_na=True)
 
-        for value in int_na_vals:
-            assert not libmissing.checknull(value, inf_as_na=True)
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_old_intna_vals(self, value):
+        assert not libmissing.checknull(value, inf_as_na=True)
 
-        for value in never_na_vals:
-            assert not libmissing.checknull(value, inf_as_na=True)
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_old_never_na_vals(self, value):
+        assert not libmissing.checknull(value, inf_as_na=True)
 
     def test_is_matching_na(self, nulls_fixture, nulls_fixture2):
         left = nulls_fixture
diff --git a/pandas/tests/extension/array_with_attr/__init__.py b/pandas/tests/extension/array_with_attr/__init__.py
new file mode 100644
index 0000000000000..49da6af024a31
--- /dev/null
+++ b/pandas/tests/extension/array_with_attr/__init__.py
@@ -0,0 +1,6 @@
+from pandas.tests.extension.array_with_attr.array import (
+    FloatAttrArray,
+    FloatAttrDtype,
+)
+
+__all__ = ["FloatAttrArray", "FloatAttrDtype"]
diff --git a/pandas/tests/extension/array_with_attr/array.py b/pandas/tests/extension/array_with_attr/array.py
new file mode 100644
index 0000000000000..d9327ca9f2f3f
--- /dev/null
+++ b/pandas/tests/extension/array_with_attr/array.py
@@ -0,0 +1,84 @@
+"""
+Test extension array that has custom attribute information (not stored on the dtype).
+
+"""
+from __future__ import annotations
+
+import numbers
+
+import numpy as np
+
+from pandas._typing import type_t
+
+from pandas.core.dtypes.base import ExtensionDtype
+
+import pandas as pd
+from pandas.core.arrays import ExtensionArray
+
+
+class FloatAttrDtype(ExtensionDtype):
+    type = float
+    name = "float_attr"
+    na_value = np.nan
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[FloatAttrArray]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return FloatAttrArray
+
+
+class FloatAttrArray(ExtensionArray):
+    dtype = FloatAttrDtype()
+    __array_priority__ = 1000
+
+    def __init__(self, values, attr=None) -> None:
+        if not isinstance(values, np.ndarray):
+            raise TypeError("Need to pass a numpy array of float64 dtype as values")
+        if not values.dtype == "float64":
+            raise TypeError("Need to pass a numpy array of float64 dtype as values")
+        self.data = values
+        self.attr = attr
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        data = np.array(scalars, dtype="float64", copy=copy)
+        return cls(data)
+
+    def __getitem__(self, item):
+        if isinstance(item, numbers.Integral):
+            return self.data[item]
+        else:
+            # slice, list-like, mask
+            item = pd.api.indexers.check_array_indexer(self, item)
+            return type(self)(self.data[item], self.attr)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def isna(self):
+        return np.isnan(self.data)
+
+    def take(self, indexer, allow_fill=False, fill_value=None):
+        from pandas.api.extensions import take
+
+        data = self.data
+        if allow_fill and fill_value is None:
+            fill_value = self.dtype.na_value
+
+        result = take(data, indexer, fill_value=fill_value, allow_fill=allow_fill)
+        return type(self)(result, self.attr)
+
+    def copy(self):
+        return type(self)(self.data.copy(), self.attr)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat):
+        data = np.concatenate([x.data for x in to_concat])
+        attr = to_concat[0].attr if len(to_concat) else None
+        return cls(data, attr)
diff --git a/pandas/tests/extension/array_with_attr/test_array_with_attr.py b/pandas/tests/extension/array_with_attr/test_array_with_attr.py
new file mode 100644
index 0000000000000..3735fe40a0d67
--- /dev/null
+++ b/pandas/tests/extension/array_with_attr/test_array_with_attr.py
@@ -0,0 +1,33 @@
+import numpy as np
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.extension.array_with_attr import FloatAttrArray
+
+
+def test_concat_with_all_na():
+    # https://github.com/pandas-dev/pandas/pull/47762
+    # ensure that attribute of the column array is preserved (when it gets
+    # preserved in reindexing the array) during merge/concat
+    arr = FloatAttrArray(np.array([np.nan, np.nan], dtype="float64"), attr="test")
+
+    df1 = pd.DataFrame({"col": arr, "key": [0, 1]})
+    df2 = pd.DataFrame({"key": [0, 1], "col2": [1, 2]})
+    result = pd.merge(df1, df2, on="key")
+    expected = pd.DataFrame({"col": arr, "key": [0, 1], "col2": [1, 2]})
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"
+
+    df1 = pd.DataFrame({"col": arr, "key": [0, 1]})
+    df2 = pd.DataFrame({"key": [0, 2], "col2": [1, 2]})
+    result = pd.merge(df1, df2, on="key")
+    expected = pd.DataFrame({"col": arr.take([0]), "key": [0], "col2": [1]})
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"
+
+    result = pd.concat([df1.set_index("key"), df2.set_index("key")], axis=1)
+    expected = pd.DataFrame(
+        {"col": arr.take([0, 1, -1]), "col2": [1, np.nan, 2], "key": [0, 1, 2]}
+    ).set_index("key")
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"
diff --git a/pandas/tests/extension/arrow/arrays.py b/pandas/tests/extension/arrow/arrays.py
index fad28c1896ad0..26b94ebe5a8da 100644
--- a/pandas/tests/extension/arrow/arrays.py
+++ b/pandas/tests/extension/arrow/arrays.py
@@ -8,7 +8,6 @@
 """
 from __future__ import annotations
 
-import copy
 import itertools
 import operator
 
@@ -19,13 +18,12 @@
 
 import pandas as pd
 from pandas.api.extensions import (
-    ExtensionArray,
     ExtensionDtype,
     register_extension_dtype,
     take,
 )
 from pandas.api.types import is_scalar
-from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays.arrow import ArrowExtensionArray as _ArrowExtensionArray
 from pandas.core.construction import extract_array
 
 
@@ -73,11 +71,13 @@ def construct_array_type(cls) -> type_t[ArrowStringArray]:
         return ArrowStringArray
 
 
-class ArrowExtensionArray(OpsMixin, ExtensionArray):
+class ArrowExtensionArray(_ArrowExtensionArray):
     _data: pa.ChunkedArray
 
     @classmethod
-    def from_scalars(cls, values):
+    def _from_sequence(cls, values, dtype=None, copy=False):
+        # TODO: respect dtype, copy
+
         if isinstance(values, cls):
             # in particular for empty cases the pa.array(np.asarray(...))
             #  does not round-trip
@@ -91,15 +91,6 @@ def from_scalars(cls, values):
         arr = pa.chunked_array([pa.array(np.asarray(values))])
         return cls(arr)
 
-    @classmethod
-    def from_array(cls, arr):
-        assert isinstance(arr, pa.Array)
-        return cls(pa.chunked_array([arr]))
-
-    @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
-        return cls.from_scalars(scalars)
-
     def __repr__(self):
         return f"{type(self).__name__}({repr(self._data)})"
 
@@ -116,10 +107,7 @@ def __getitem__(self, item):
             return self._data.to_pandas()[item]
         else:
             vals = self._data.to_pandas()[item]
-            return type(self).from_scalars(vals)
-
-    def __len__(self):
-        return len(self._data)
+            return type(self)._from_sequence(vals)
 
     def astype(self, dtype, copy=True):
         # needed to fix this astype for the Series constructor.
@@ -149,19 +137,6 @@ def __eq__(self, other):
 
         return self._logical_method(other, operator.eq)
 
-    @property
-    def nbytes(self) -> int:
-        return sum(
-            x.size
-            for chunk in self._data.chunks
-            for x in chunk.buffers()
-            if x is not None
-        )
-
-    def isna(self):
-        nas = pd.isna(self._data.to_pandas())
-        return type(self).from_scalars(nas)
-
     def take(self, indices, allow_fill=False, fill_value=None):
         data = self._data.to_pandas()
         data = extract_array(data, extract_numpy=True)
@@ -172,9 +147,6 @@ def take(self, indices, allow_fill=False, fill_value=None):
         result = take(data, indices, fill_value=fill_value, allow_fill=allow_fill)
         return self._from_sequence(result, dtype=self.dtype)
 
-    def copy(self):
-        return type(self)(copy.copy(self._data))
-
     @classmethod
     def _concat_same_type(cls, to_concat):
         chunks = list(itertools.chain.from_iterable(x._data.chunks for x in to_concat))
@@ -182,7 +154,7 @@ def _concat_same_type(cls, to_concat):
         return cls(arr)
 
     def __invert__(self):
-        return type(self).from_scalars(~self._data.to_pandas())
+        return type(self)._from_sequence(~self._data.to_pandas())
 
     def _reduce(self, name: str, *, skipna: bool = True, **kwargs):
         if skipna:
@@ -206,20 +178,20 @@ def all(self, axis=0, out=None):
 
 
 class ArrowBoolArray(ArrowExtensionArray):
-    def __init__(self, values):
+    def __init__(self, values) -> None:
         if not isinstance(values, pa.ChunkedArray):
             raise ValueError
 
         assert values.type == pa.bool_()
         self._data = values
-        self._dtype = ArrowBoolDtype()
+        self._dtype = ArrowBoolDtype()  # type: ignore[assignment]
 
 
 class ArrowStringArray(ArrowExtensionArray):
-    def __init__(self, values):
+    def __init__(self, values) -> None:
         if not isinstance(values, pa.ChunkedArray):
             raise ValueError
 
         assert values.type == pa.string()
         self._data = values
-        self._dtype = ArrowStringDtype()
+        self._dtype = ArrowStringDtype()  # type: ignore[assignment]
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index a73684868e3ae..0205b8aad9431 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -1,6 +1,11 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_windows,
+)
+
 import pandas as pd
 import pandas._testing as tm
 from pandas.api.types import is_bool_dtype
@@ -23,12 +28,12 @@ def dtype():
 def data():
     values = np.random.randint(0, 2, size=100, dtype=bool)
     values[1] = ~values[0]
-    return ArrowBoolArray.from_scalars(values)
+    return ArrowBoolArray._from_sequence(values)
 
 
 @pytest.fixture
 def data_missing():
-    return ArrowBoolArray.from_scalars([None, True])
+    return ArrowBoolArray._from_sequence([None, True])
 
 
 def test_basic_equals(data):
@@ -62,11 +67,6 @@ def test_contains(self, data, data_missing):
 
 
 class TestConstructors(BaseArrowTests, base.BaseConstructorsTests):
-    # seems like some bug in isna on empty BoolArray returning floats.
-    @pytest.mark.xfail(reason="bad is-na for empty data")
-    def test_from_sequence_from_cls(self, data):
-        super().test_from_sequence_from_cls(data)
-
     @pytest.mark.xfail(reason="pa.NULL is not recognised as scalar, GH-33899")
     def test_series_constructor_no_data_with_index(self, dtype, na_value):
         # pyarrow.lib.ArrowInvalid: only handle 1-dimensional arrays
@@ -77,10 +77,6 @@ def test_series_constructor_scalar_na_with_index(self, dtype, na_value):
         # pyarrow.lib.ArrowInvalid: only handle 1-dimensional arrays
         super().test_series_constructor_scalar_na_with_index(dtype, na_value)
 
-    @pytest.mark.xfail(reason="ufunc 'invert' not supported for the input types")
-    def test_construct_empty_dataframe(self, dtype):
-        super().test_construct_empty_dataframe(dtype)
-
     @pytest.mark.xfail(reason="_from_sequence ignores dtype keyword")
     def test_empty(self, dtype):
         super().test_empty(dtype)
@@ -91,6 +87,10 @@ def test_reduce_series_boolean(self):
         pass
 
 
+@pytest.mark.skipif(
+    is_ci_environment() and is_platform_windows(),
+    reason="Causes stack overflow on Windows CI",
+)
 class TestReduceBoolean(base.BaseBooleanReduceTests):
     pass
 
diff --git a/pandas/tests/extension/arrow/test_timestamp.py b/pandas/tests/extension/arrow/test_timestamp.py
index fe2c484731019..5b81940e5a6c0 100644
--- a/pandas/tests/extension/arrow/test_timestamp.py
+++ b/pandas/tests/extension/arrow/test_timestamp.py
@@ -40,21 +40,18 @@ def construct_array_type(cls) -> type_t[ArrowTimestampUSArray]:
 
 
 class ArrowTimestampUSArray(ArrowExtensionArray):
-    def __init__(self, values):
+    def __init__(self, values) -> None:
         if not isinstance(values, pa.ChunkedArray):
             raise ValueError
 
         assert values.type == pa.timestamp("us")
         self._data = values
-        self._dtype = ArrowTimestampUSDtype()
+        self._dtype = ArrowTimestampUSDtype()  # type: ignore[assignment]
 
 
 def test_constructor_extensionblock():
     # GH 34986
-    pd.DataFrame(
-        {
-            "timestamp": ArrowTimestampUSArray.from_scalars(
-                [None, datetime.datetime(2010, 9, 8, 7, 6, 5, 4)]
-            )
-        }
+    arr = ArrowTimestampUSArray._from_sequence(
+        [None, datetime.datetime(2010, 9, 8, 7, 6, 5, 4)]
     )
+    pd.DataFrame({"timestamp": arr})
diff --git a/pandas/tests/extension/base/casting.py b/pandas/tests/extension/base/casting.py
index 4987751f31dac..0eb8123e6bdb8 100644
--- a/pandas/tests/extension/base/casting.py
+++ b/pandas/tests/extension/base/casting.py
@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p20
+from pandas.compat import np_version_under1p21
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -32,8 +32,7 @@ def test_astype_object_frame(self, all_data):
         assert result._mgr.arrays[0].dtype == np.dtype(object)
 
         # earlier numpy raises TypeError on e.g. np.dtype(np.int64) == "Int64"
-        #  instead of returning False
-        if not np_version_under1p20:
+        if not np_version_under1p21:
             # check that we can compare the dtypes
             comp = result.dtypes == df.dtypes
             assert not comp.any()
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index c86054aed7e4d..b9f8f8512a995 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -135,3 +135,8 @@ def test_empty(self, dtype):
         assert isinstance(result2, cls)
         assert result2.dtype == dtype
         assert result2.shape == (4,)
+
+        result2 = dtype.empty(4)
+        assert isinstance(result2, cls)
+        assert result2.dtype == dtype
+        assert result2.shape == (4,)
diff --git a/pandas/tests/extension/base/dim2.py b/pandas/tests/extension/base/dim2.py
index f71f3cf164bfc..1d5a5c4532a5d 100644
--- a/pandas/tests/extension/base/dim2.py
+++ b/pandas/tests/extension/base/dim2.py
@@ -12,6 +12,9 @@
 
 
 class Dim2CompatTests(BaseExtensionTests):
+    # Note: these are ONLY for ExtensionArray subclasses that support 2D arrays.
+    #  i.e. not for pyarrow-backed EAs.
+
     def test_transpose(self, data):
         arr2d = data.repeat(2).reshape(-1, 2)
         shape = arr2d.shape
diff --git a/pandas/tests/extension/base/getitem.py b/pandas/tests/extension/base/getitem.py
index 71e1e61b50256..cf51d9d693155 100644
--- a/pandas/tests/extension/base/getitem.py
+++ b/pandas/tests/extension/base/getitem.py
@@ -336,7 +336,9 @@ def test_get(self, data):
 
         # GH 21257
         s = pd.Series(data)
-        s2 = s[::2]
+        with tm.assert_produces_warning(None):
+            # GH#45324 make sure we aren't giving a spurious FutureWarning
+            s2 = s[::2]
         assert s2.get(1) is None
 
     def test_take_sequence(self, data):
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index db0190d488d42..711f1835446a5 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -1,5 +1,7 @@
 import pytest
 
+from pandas.core.dtypes.common import is_numeric_dtype
+
 import pandas as pd
 import pandas._testing as tm
 from pandas.tests.extension.base.base import BaseExtensionTests
@@ -68,10 +70,10 @@ def test_groupby_extension_transform(self, data_for_grouping):
 
     def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
         df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
-        df.groupby("B").apply(groupby_apply_op)
-        df.groupby("B").A.apply(groupby_apply_op)
-        df.groupby("A").apply(groupby_apply_op)
-        df.groupby("A").B.apply(groupby_apply_op)
+        df.groupby("B", group_keys=False).apply(groupby_apply_op)
+        df.groupby("B", group_keys=False).A.apply(groupby_apply_op)
+        df.groupby("A", group_keys=False).apply(groupby_apply_op)
+        df.groupby("A", group_keys=False).B.apply(groupby_apply_op)
 
     def test_groupby_apply_identity(self, data_for_grouping):
         df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
@@ -96,7 +98,15 @@ def test_in_numeric_groupby(self, data_for_grouping):
                 "C": [1, 1, 1, 1, 1, 1, 1, 1],
             }
         )
-        result = df.groupby("A").sum().columns
+
+        dtype = data_for_grouping.dtype
+        if is_numeric_dtype(dtype) or dtype.name == "decimal":
+            warn = None
+        else:
+            warn = FutureWarning
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = df.groupby("A").sum().columns
 
         if data_for_grouping.dtype._is_numeric:
             expected = pd.Index(["B", "C"])
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index c96e2fb49e397..838c9f5b8a35f 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -5,6 +5,7 @@
 import pytest
 
 from pandas.core.dtypes.common import is_bool_dtype
+from pandas.core.dtypes.missing import na_value_for_dtype
 
 import pandas as pd
 import pandas._testing as tm
@@ -18,7 +19,7 @@ class BaseMethodsTests(BaseExtensionTests):
     def test_value_counts_default_dropna(self, data):
         # make sure we have consistent default dropna kwarg
         if not hasattr(data, "value_counts"):
-            pytest.skip("value_counts is not implemented")
+            pytest.skip(f"value_counts is not implemented for {type(data)}")
         sig = inspect.signature(data.value_counts)
         kwarg = sig.parameters["dropna"]
         assert kwarg.default is True
@@ -27,7 +28,7 @@ def test_value_counts_default_dropna(self, data):
     def test_value_counts(self, all_data, dropna):
         all_data = all_data[:10]
         if dropna:
-            other = np.array(all_data[~all_data.isna()])
+            other = all_data[~all_data.isna()]
         else:
             other = all_data
 
@@ -49,6 +50,9 @@ def test_value_counts_with_normalize(self, data):
         else:
             expected = pd.Series(0.0, index=result.index)
             expected[result > 0] = 1 / len(values)
+        if na_value_for_dtype(data.dtype) is pd.NA:
+            # TODO(GH#44692): avoid special-casing
+            expected = expected.astype("Float64")
 
         self.assert_series_equal(result, expected)
 
@@ -209,7 +213,12 @@ def test_unique(self, data, box, method):
 
     @pytest.mark.parametrize("na_sentinel", [-1, -2])
     def test_factorize(self, data_for_grouping, na_sentinel):
-        codes, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
+        if na_sentinel == -1:
+            msg = "Specifying `na_sentinel=-1` is deprecated"
+        else:
+            msg = "Specifying the specific value to use for `na_sentinel` is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            codes, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
         expected_codes = np.array(
             [0, 0, na_sentinel, na_sentinel, 1, 1, 0, 2], dtype=np.intp
         )
@@ -220,8 +229,15 @@ def test_factorize(self, data_for_grouping, na_sentinel):
 
     @pytest.mark.parametrize("na_sentinel", [-1, -2])
     def test_factorize_equivalence(self, data_for_grouping, na_sentinel):
-        codes_1, uniques_1 = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
-        codes_2, uniques_2 = data_for_grouping.factorize(na_sentinel=na_sentinel)
+        if na_sentinel == -1:
+            msg = "Specifying `na_sentinel=-1` is deprecated"
+        else:
+            msg = "Specifying the specific value to use for `na_sentinel` is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            codes_1, uniques_1 = pd.factorize(
+                data_for_grouping, na_sentinel=na_sentinel
+            )
+            codes_2, uniques_2 = data_for_grouping.factorize(na_sentinel=na_sentinel)
 
         tm.assert_numpy_array_equal(codes_1, codes_2)
         self.assert_extension_array_equal(uniques_1, uniques_2)
@@ -382,6 +398,7 @@ def test_shift_empty_array(self, data, periods):
         self.assert_extension_array_equal(result, expected)
 
     def test_shift_zero_copies(self, data):
+        # GH#31502
         result = data.shift(0)
         assert result is not data
 
@@ -442,7 +459,8 @@ def test_where_series(self, data, na_value, as_frame):
         cls = type(data)
         a, b = data[:2]
 
-        ser = pd.Series(cls._from_sequence([a, a, b, b], dtype=data.dtype))
+        orig = pd.Series(cls._from_sequence([a, a, b, b], dtype=data.dtype))
+        ser = orig.copy()
         cond = np.array([True, True, False, False])
 
         if as_frame:
@@ -458,7 +476,13 @@ def test_where_series(self, data, na_value, as_frame):
             expected = expected.to_frame(name="a")
         self.assert_equal(result, expected)
 
+        ser.mask(~cond, inplace=True)
+        self.assert_equal(ser, expected)
+
         # array other
+        ser = orig.copy()
+        if as_frame:
+            ser = ser.to_frame(name="a")
         cond = np.array([True, False, True, True])
         other = cls._from_sequence([a, b, a, b], dtype=data.dtype)
         if as_frame:
@@ -470,6 +494,9 @@ def test_where_series(self, data, na_value, as_frame):
             expected = expected.to_frame(name="a")
         self.assert_equal(result, expected)
 
+        ser.mask(~cond, other, inplace=True)
+        self.assert_equal(ser, expected)
+
     @pytest.mark.parametrize("repeats", [0, 1, 2, [1, 2, 3]])
     def test_repeat(self, data, repeats, as_series, use_numpy):
         arr = type(data)._from_sequence(data[:3], dtype=data.dtype)
diff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py
index 1d3d736ca7ee2..569782e55fd72 100644
--- a/pandas/tests/extension/base/ops.py
+++ b/pandas/tests/extension/base/ops.py
@@ -67,10 +67,10 @@ class BaseArithmeticOpsTests(BaseOpsUtil):
     * divmod_exc = TypeError
     """
 
-    series_scalar_exc: type[TypeError] | None = TypeError
-    frame_scalar_exc: type[TypeError] | None = TypeError
-    series_array_exc: type[TypeError] | None = TypeError
-    divmod_exc: type[TypeError] | None = TypeError
+    series_scalar_exc: type[Exception] | None = TypeError
+    frame_scalar_exc: type[Exception] | None = TypeError
+    series_array_exc: type[Exception] | None = TypeError
+    divmod_exc: type[Exception] | None = TypeError
 
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
         # series & scalar
@@ -114,17 +114,22 @@ def test_add_series_with_extension_array(self, data):
         self.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("box", [pd.Series, pd.DataFrame])
-    def test_direct_arith_with_ndframe_returns_not_implemented(self, data, box):
+    def test_direct_arith_with_ndframe_returns_not_implemented(
+        self, request, data, box
+    ):
         # EAs should return NotImplemented for ops with Series/DataFrame
         # Pandas takes care of unboxing the series and calling the EA's op.
         other = pd.Series(data)
         if box is pd.DataFrame:
             other = other.to_frame()
-        if hasattr(data, "__add__"):
-            result = data.__add__(other)
-            assert result is NotImplemented
-        else:
-            raise pytest.skip(f"{type(data).__name__} does not implement add")
+        if not hasattr(data, "__add__"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{type(data).__name__} does not implement add"
+                )
+            )
+        result = data.__add__(other)
+        assert result is NotImplemented
 
 
 class BaseComparisonOpsTests(BaseOpsUtil):
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index 45bc5b7caaf6f..babb2868a4421 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -4,6 +4,7 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.api.extensions import ExtensionArray
 from pandas.core.internals.blocks import EABackedBlock
 from pandas.tests.extension.base.base import BaseExtensionTests
@@ -318,15 +319,22 @@ def test_unstack(self, data, index, obj):
                 alt = df.unstack(level=level).droplevel(0, axis=1)
                 self.assert_frame_equal(result, alt)
 
-            expected = ser.astype(object).unstack(
-                level=level, fill_value=data.dtype.na_value
-            )
-            if obj == "series" and not isinstance(ser.dtype, pd.SparseDtype):
+            if obj == "series":
+                is_sparse = isinstance(ser.dtype, pd.SparseDtype)
+            else:
+                is_sparse = isinstance(ser.dtypes.iat[0], pd.SparseDtype)
+            warn = None if not is_sparse else FutureWarning
+            with tm.assert_produces_warning(warn, match="astype from Sparse"):
+                obj_ser = ser.astype(object)
+
+            expected = obj_ser.unstack(level=level, fill_value=data.dtype.na_value)
+            if obj == "series" and not is_sparse:
                 # GH#34457 SparseArray.astype(object) gives Sparse[object]
                 #  instead of np.dtype(object)
                 assert (expected.dtypes == object).all()
 
-            result = result.astype(object)
+            with tm.assert_produces_warning(warn, match="astype from Sparse"):
+                result = result.astype(object)
 
             self.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py
index 208a1a1757be2..83b1679b0da7e 100644
--- a/pandas/tests/extension/base/setitem.py
+++ b/pandas/tests/extension/base/setitem.py
@@ -349,6 +349,20 @@ def test_setitem_with_expansion_dataframe_column(self, data, full_indexer):
 
         self.assert_frame_equal(result, expected)
 
+    def test_setitem_with_expansion_row(self, data, na_value):
+        df = pd.DataFrame({"data": data[:1]})
+
+        df.loc[1, "data"] = data[1]
+        expected = pd.DataFrame({"data": data[:2]})
+        self.assert_frame_equal(df, expected)
+
+        # https://github.com/pandas-dev/pandas/issues/47284
+        df.loc[2, "data"] = na_value
+        expected = pd.DataFrame(
+            {"data": pd.Series([data[0], data[1], na_value], dtype=data.dtype)}
+        )
+        self.assert_frame_equal(df, expected)
+
     def test_setitem_series(self, data, full_indexer):
         # https://github.com/pandas-dev/pandas/issues/32395
         ser = pd.Series(data, name="data")
@@ -364,32 +378,47 @@ def test_setitem_series(self, data, full_indexer):
         )
         self.assert_series_equal(result, expected)
 
-    def test_setitem_frame_2d_values(self, data, request):
+    def test_setitem_frame_2d_values(self, data):
         # GH#44514
         df = pd.DataFrame({"A": data})
 
+        # These dtypes have non-broken implementations of _can_hold_element
+        has_can_hold_element = isinstance(
+            data.dtype, (PandasDtype, PeriodDtype, IntervalDtype, DatetimeTZDtype)
+        )
+
         # Avoiding using_array_manager fixture
         #  https://github.com/pandas-dev/pandas/pull/44514#discussion_r754002410
         using_array_manager = isinstance(df._mgr, pd.core.internals.ArrayManager)
-        if using_array_manager:
-            if not isinstance(
-                data.dtype, (PandasDtype, PeriodDtype, IntervalDtype, DatetimeTZDtype)
-            ):
-                # These dtypes have non-broken implementations of _can_hold_element
-                mark = pytest.mark.xfail(reason="Goes through split path, loses dtype")
-                request.node.add_marker(mark)
+        using_copy_on_write = pd.options.mode.copy_on_write
+
+        blk_data = df._mgr.arrays[0]
 
-        df = pd.DataFrame({"A": data})
         orig = df.copy()
 
-        df.iloc[:] = df
+        msg = "will attempt to set the values inplace instead"
+        warn = None
+        if has_can_hold_element and not isinstance(data.dtype, PandasDtype):
+            # PandasDtype excluded because it isn't *really* supported.
+            warn = DeprecationWarning
+
+        with tm.assert_produces_warning(warn, match=msg):
+            df.iloc[:] = df
         self.assert_frame_equal(df, orig)
 
         df.iloc[:-1] = df.iloc[:-1]
         self.assert_frame_equal(df, orig)
 
-        df.iloc[:] = df.values
+        if isinstance(data.dtype, DatetimeTZDtype):
+            # no warning bc df.values casts to object dtype
+            warn = None
+        with tm.assert_produces_warning(warn, match=msg):
+            df.iloc[:] = df.values
         self.assert_frame_equal(df, orig)
+        if not using_array_manager and not using_copy_on_write:
+            # GH#33457 Check that this setting occurred in-place
+            # FIXME(ArrayManager): this should work there too
+            assert df._mgr.arrays[0] is blk_data
 
         df.iloc[:-1] = df.values[:-1]
         self.assert_frame_equal(df, orig)
diff --git a/pandas/tests/extension/date/array.py b/pandas/tests/extension/date/array.py
index d29ed293e71ed..eca935cdc9128 100644
--- a/pandas/tests/extension/date/array.py
+++ b/pandas/tests/extension/date/array.py
@@ -109,7 +109,9 @@ def __init__(
             self._month = np.zeros(ldates, dtype=np.uint8)  # 255 (1, 31)
             self._day = np.zeros(ldates, dtype=np.uint8)  # 255 (1, 12)
 
-            for (i,), (y, m, d) in np.ndenumerate(np.char.split(dates, sep="-")):
+            # error: "object_" object is not iterable
+            obj = np.char.split(dates, sep="-")
+            for (i,), (y, m, d) in np.ndenumerate(obj):  # type: ignore[misc]
                 self._year[i] = int(y)
                 self._month[i] = int(m)
                 self._day[i] = int(d)
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index 1dbafb2dbb648..6eaa90d7b868a 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -41,7 +41,7 @@ class DecimalDtype(ExtensionDtype):
     na_value = decimal.Decimal("NaN")
     _metadata = ("context",)
 
-    def __init__(self, context=None):
+    def __init__(self, context=None) -> None:
         self.context = context or decimal.getcontext()
 
     def __repr__(self) -> str:
@@ -66,7 +66,7 @@ def _is_numeric(self) -> bool:
 class DecimalArray(OpsMixin, ExtensionScalarOpsMixin, ExtensionArray):
     __array_priority__ = 1000
 
-    def __init__(self, values, dtype=None, copy=False, context=None):
+    def __init__(self, values, dtype=None, copy=False, context=None) -> None:
         for i, val in enumerate(values):
             if is_float(val):
                 if np.isnan(val):
@@ -105,7 +105,11 @@ def _from_factorized(cls, values, original):
     _HANDLED_TYPES = (decimal.Decimal, numbers.Number, np.ndarray)
 
     def to_numpy(
-        self, dtype=None, copy: bool = False, na_value=no_default, decimals=None
+        self,
+        dtype=None,
+        copy: bool = False,
+        na_value: object = no_default,
+        decimals=None,
     ) -> np.ndarray:
         result = np.asarray(self, dtype=dtype)
         if decimals is not None:
@@ -119,6 +123,18 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
         ):
             return NotImplemented
 
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
+            self, ufunc, method, *inputs, **kwargs
+        )
+        if result is not NotImplemented:
+            # e.g. test_array_ufunc_series_scalar_other
+            return result
+
+        if "out" in kwargs:
+            return arraylike.dispatch_ufunc_with_out(
+                self, ufunc, method, *inputs, **kwargs
+            )
+
         inputs = tuple(x._data if isinstance(x, DecimalArray) else x for x in inputs)
         result = getattr(ufunc, method)(*inputs, **kwargs)
 
diff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py
index 538ca83667ef5..125a0aee2089d 100644
--- a/pandas/tests/extension/json/array.py
+++ b/pandas/tests/extension/json/array.py
@@ -67,7 +67,7 @@ class JSONArray(ExtensionArray):
     dtype = JSONDtype()
     __array_priority__ = 1000
 
-    def __init__(self, values, dtype=None, copy=False):
+    def __init__(self, values, dtype=None, copy=False) -> None:
         for val in values:
             if not isinstance(val, self.dtype.type):
                 raise TypeError("All values must be of type " + str(self.dtype.type))
@@ -145,6 +145,9 @@ def __ne__(self, other):
     def __array__(self, dtype=None):
         if dtype is None:
             dtype = object
+        if dtype == object:
+            # on py38 builds it looks like numpy is inferring to a non-1D array
+            return construct_1d_object_array_from_listlike(list(self))
         return np.asarray(self.data, dtype=dtype)
 
     @property
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index d530a75b74c8f..f3129a89124f4 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -1,5 +1,6 @@
 import collections
 import operator
+import sys
 
 import pytest
 
@@ -155,35 +156,54 @@ def test_contains(self, data):
 
 
 class TestConstructors(BaseJSON, base.BaseConstructorsTests):
-    @pytest.mark.skip(reason="not implemented constructor from dtype")
+    @pytest.mark.xfail(reason="not implemented constructor from dtype")
     def test_from_dtype(self, data):
         # construct from our dtype & string dtype
-        pass
+        super(self).test_from_dtype(data)
 
     @pytest.mark.xfail(reason="RecursionError, GH-33900")
     def test_series_constructor_no_data_with_index(self, dtype, na_value):
         # RecursionError: maximum recursion depth exceeded in comparison
-        super().test_series_constructor_no_data_with_index(dtype, na_value)
+        rec_limit = sys.getrecursionlimit()
+        try:
+            # Limit to avoid stack overflow on Windows CI
+            sys.setrecursionlimit(100)
+            super().test_series_constructor_no_data_with_index(dtype, na_value)
+        finally:
+            sys.setrecursionlimit(rec_limit)
 
     @pytest.mark.xfail(reason="RecursionError, GH-33900")
     def test_series_constructor_scalar_na_with_index(self, dtype, na_value):
         # RecursionError: maximum recursion depth exceeded in comparison
-        super().test_series_constructor_scalar_na_with_index(dtype, na_value)
+        rec_limit = sys.getrecursionlimit()
+        try:
+            # Limit to avoid stack overflow on Windows CI
+            sys.setrecursionlimit(100)
+            super().test_series_constructor_scalar_na_with_index(dtype, na_value)
+        finally:
+            sys.setrecursionlimit(rec_limit)
 
     @pytest.mark.xfail(reason="collection as scalar, GH-33901")
     def test_series_constructor_scalar_with_index(self, data, dtype):
         # TypeError: All values must be of type <class 'collections.abc.Mapping'>
-        super().test_series_constructor_scalar_with_index(data, dtype)
+        rec_limit = sys.getrecursionlimit()
+        try:
+            # Limit to avoid stack overflow on Windows CI
+            sys.setrecursionlimit(100)
+            super().test_series_constructor_scalar_with_index(data, dtype)
+        finally:
+            sys.setrecursionlimit(rec_limit)
 
 
 class TestReshaping(BaseJSON, base.BaseReshapingTests):
-    @pytest.mark.skip(reason="Different definitions of NA")
+    @pytest.mark.xfail(reason="Different definitions of NA")
     def test_stack(self):
         """
         The test does .astype(object).stack(). If we happen to have
         any missing values in `data`, then we'll end up with different
         rows since we consider `{}` NA, but `.astype(object)` doesn't.
         """
+        super().test_stack()
 
     @pytest.mark.xfail(reason="dict for NA")
     def test_unstack(self, data, index):
@@ -201,16 +221,18 @@ class TestIndex(BaseJSON, base.BaseIndexTests):
 
 
 class TestMissing(BaseJSON, base.BaseMissingTests):
-    @pytest.mark.skip(reason="Setting a dict as a scalar")
+    @pytest.mark.xfail(reason="Setting a dict as a scalar")
     def test_fillna_series(self):
         """We treat dictionaries as a mapping in fillna, not a scalar."""
+        super().test_fillna_series()
 
-    @pytest.mark.skip(reason="Setting a dict as a scalar")
+    @pytest.mark.xfail(reason="Setting a dict as a scalar")
     def test_fillna_frame(self):
         """We treat dictionaries as a mapping in fillna, not a scalar."""
+        super().test_fillna_frame()
 
 
-unhashable = pytest.mark.skip(reason="Unhashable")
+unhashable = pytest.mark.xfail(reason="Unhashable")
 
 
 class TestReduce(base.BaseNoReduceTests):
@@ -220,16 +242,16 @@ class TestReduce(base.BaseNoReduceTests):
 class TestMethods(BaseJSON, base.BaseMethodsTests):
     @unhashable
     def test_value_counts(self, all_data, dropna):
-        pass
+        super().test_value_counts(all_data, dropna)
 
     @unhashable
     def test_value_counts_with_normalize(self, data):
-        pass
+        super().test_value_counts_with_normalize(data)
 
     @unhashable
     def test_sort_values_frame(self):
         # TODO (EA.factorize): see if _values_for_factorize allows this.
-        pass
+        super().test_sort_values_frame()
 
     @pytest.mark.parametrize("ascending", [True, False])
     def test_sort_values(self, data_for_sorting, ascending, sort_by_key):
@@ -243,45 +265,50 @@ def test_sort_values_missing(
             data_missing_for_sorting, ascending, sort_by_key
         )
 
-    @pytest.mark.skip(reason="combine for JSONArray not supported")
+    @pytest.mark.xfail(reason="combine for JSONArray not supported")
     def test_combine_le(self, data_repeated):
-        pass
+        super().test_combine_le(data_repeated)
 
-    @pytest.mark.skip(reason="combine for JSONArray not supported")
+    @pytest.mark.xfail(reason="combine for JSONArray not supported")
     def test_combine_add(self, data_repeated):
-        pass
+        super().test_combine_add(data_repeated)
 
-    @pytest.mark.skip(reason="combine for JSONArray not supported")
+    @pytest.mark.xfail(
+        reason="combine for JSONArray not supported - "
+        "may pass depending on random data",
+        strict=False,
+    )
     def test_combine_first(self, data):
-        pass
+        super().test_combine_first(data)
 
     @unhashable
     def test_hash_pandas_object_works(self, data, kind):
         super().test_hash_pandas_object_works(data, kind)
 
-    @pytest.mark.skip(reason="broadcasting error")
+    @pytest.mark.xfail(reason="broadcasting error")
     def test_where_series(self, data, na_value):
         # Fails with
         # *** ValueError: operands could not be broadcast together
         # with shapes (4,) (4,) (0,)
         super().test_where_series(data, na_value)
 
-    @pytest.mark.skip(reason="Can't compare dicts.")
+    @pytest.mark.xfail(reason="Can't compare dicts.")
     def test_searchsorted(self, data_for_sorting):
         super().test_searchsorted(data_for_sorting)
 
-    @pytest.mark.skip(reason="Can't compare dicts.")
+    @pytest.mark.xfail(reason="Can't compare dicts.")
     def test_equals(self, data, na_value, as_series):
-        pass
+        super().test_equals(data, na_value, as_series)
 
 
 class TestCasting(BaseJSON, base.BaseCastingTests):
-    @pytest.mark.skip(reason="failing on np.array(self, dtype=str)")
+    @pytest.mark.xfail(reason="failing on np.array(self, dtype=str)")
     def test_astype_str(self):
         """This currently fails in NumPy on np.array(self, dtype=str) with
 
         *** ValueError: setting an array element with a sequence
         """
+        super().test_astype_str()
 
 
 # We intentionally don't run base.BaseSetitemTests because pandas'
@@ -297,6 +324,7 @@ def test_groupby_extension_transform(self):
         I think this is what we want, i.e. `.name` should be the original
         values, and not the values for factorization.
         """
+        super().test_groupby_extension_transform()
 
     @unhashable
     def test_groupby_extension_apply(self):
@@ -309,6 +337,7 @@ def test_groupby_extension_apply(self):
         I suspect that once we support Index[ExtensionArray],
         we'll be able to dispatch unique.
         """
+        super().test_groupby_extension_apply()
 
     @unhashable
     def test_groupby_extension_agg(self):
@@ -316,6 +345,7 @@ def test_groupby_extension_agg(self):
         This fails when we get to tm.assert_series_equal when left.index
         contains dictionaries, which are not hashable.
         """
+        super().test_groupby_extension_agg()
 
     @unhashable
     def test_groupby_extension_no_sort(self):
@@ -323,6 +353,7 @@ def test_groupby_extension_no_sort(self):
         This fails when we get to tm.assert_series_equal when left.index
         contains dictionaries, which are not hashable.
         """
+        super().test_groupby_extension_no_sort()
 
     @pytest.mark.xfail(reason="GH#39098: Converts agg result to object")
     def test_groupby_agg_extension(self, data_for_grouping):
@@ -341,10 +372,11 @@ def test_add_series_with_extension_array(self, data):
         with pytest.raises(TypeError, match="unsupported"):
             ser + data
 
+    @pytest.mark.xfail(reason="not implemented")
     def test_divmod_series_array(self):
         # GH 23287
         # skipping because it is not implemented
-        pass
+        super().test_divmod_series_array()
 
     def _check_divmod_op(self, s, op, other, exc=NotImplementedError):
         return super()._check_divmod_op(s, op, other, exc=TypeError)
diff --git a/pandas/tests/extension/list/array.py b/pandas/tests/extension/list/array.py
index 47015ed334ddf..f281a0f82e0e7 100644
--- a/pandas/tests/extension/list/array.py
+++ b/pandas/tests/extension/list/array.py
@@ -44,7 +44,7 @@ class ListArray(ExtensionArray):
     dtype = ListDtype()
     __array_priority__ = 1000
 
-    def __init__(self, values, dtype=None, copy=False):
+    def __init__(self, values, dtype=None, copy=False) -> None:
         if not isinstance(values, np.ndarray):
             raise TypeError("Need to pass a numpy array as values")
         for val in values:
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
new file mode 100644
index 0000000000000..b7ddb1f248765
--- /dev/null
+++ b/pandas/tests/extension/test_arrow.py
@@ -0,0 +1,1709 @@
+"""
+This file contains a minimal set of tests for compliance with the extension
+array interface test suite, and should contain no other tests.
+The test suite for the full functionality of the array is located in
+`pandas/tests/arrays/`.
+The tests in this file are inherited from the BaseExtensionTests, and only
+minimal tweaks should be applied to get the tests passing (by overwriting a
+parent method).
+Additional tests should either be added to one of the BaseExtensionTests
+classes (if they are relevant for the extension interface for all dtypes), or
+be added to the array-specific tests in `pandas/tests/arrays/`.
+"""
+from datetime import (
+    date,
+    datetime,
+    time,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_windows,
+    pa_version_under2p0,
+    pa_version_under3p0,
+    pa_version_under4p0,
+    pa_version_under6p0,
+    pa_version_under7p0,
+    pa_version_under8p0,
+    pa_version_under9p0,
+)
+from pandas.errors import PerformanceWarning
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.extension import base
+
+pa = pytest.importorskip("pyarrow", minversion="1.0.1")
+
+from pandas.core.arrays.arrow.array import ArrowExtensionArray
+
+from pandas.core.arrays.arrow.dtype import ArrowDtype  # isort:skip
+
+
+@pytest.fixture(params=tm.ALL_PYARROW_DTYPES, ids=str)
+def dtype(request):
+    return ArrowDtype(pyarrow_dtype=request.param)
+
+
+@pytest.fixture
+def data(dtype):
+    pa_dtype = dtype.pyarrow_dtype
+    if pa.types.is_boolean(pa_dtype):
+        data = [True, False] * 4 + [None] + [True, False] * 44 + [None] + [True, False]
+    elif pa.types.is_floating(pa_dtype):
+        data = [1.0, 0.0] * 4 + [None] + [-2.0, -1.0] * 44 + [None] + [0.5, 99.5]
+    elif pa.types.is_signed_integer(pa_dtype):
+        data = [1, 0] * 4 + [None] + [-2, -1] * 44 + [None] + [1, 99]
+    elif pa.types.is_unsigned_integer(pa_dtype):
+        data = [1, 0] * 4 + [None] + [2, 1] * 44 + [None] + [1, 99]
+    elif pa.types.is_date(pa_dtype):
+        data = (
+            [date(2022, 1, 1), date(1999, 12, 31)] * 4
+            + [None]
+            + [date(2022, 1, 1), date(2022, 1, 1)] * 44
+            + [None]
+            + [date(1999, 12, 31), date(1999, 12, 31)]
+        )
+    elif pa.types.is_timestamp(pa_dtype):
+        data = (
+            [datetime(2020, 1, 1, 1, 1, 1, 1), datetime(1999, 1, 1, 1, 1, 1, 1)] * 4
+            + [None]
+            + [datetime(2020, 1, 1, 1), datetime(1999, 1, 1, 1)] * 44
+            + [None]
+            + [datetime(2020, 1, 1), datetime(1999, 1, 1)]
+        )
+    elif pa.types.is_duration(pa_dtype):
+        data = (
+            [timedelta(1), timedelta(1, 1)] * 4
+            + [None]
+            + [timedelta(-1), timedelta(0)] * 44
+            + [None]
+            + [timedelta(-10), timedelta(10)]
+        )
+    elif pa.types.is_time(pa_dtype):
+        data = (
+            [time(12, 0), time(0, 12)] * 4
+            + [None]
+            + [time(0, 0), time(1, 1)] * 44
+            + [None]
+            + [time(0, 5), time(5, 0)]
+        )
+    else:
+        raise NotImplementedError
+    return pd.array(data, dtype=dtype)
+
+
+@pytest.fixture
+def data_missing(data):
+    """Length-2 array with [NA, Valid]"""
+    return type(data)._from_sequence([None, data[0]])
+
+
+@pytest.fixture(params=["data", "data_missing"])
+def all_data(request, data, data_missing):
+    """Parametrized fixture returning 'data' or 'data_missing' integer arrays.
+
+    Used to test dtype conversion with and without missing values.
+    """
+    if request.param == "data":
+        return data
+    elif request.param == "data_missing":
+        return data_missing
+
+
+@pytest.fixture
+def data_for_grouping(dtype):
+    """
+    Data for factorization, grouping, and unique tests.
+
+    Expected to be like [B, B, NA, NA, A, A, B, C]
+
+    Where A < B < C and NA is missing
+    """
+    pa_dtype = dtype.pyarrow_dtype
+    if pa.types.is_boolean(pa_dtype):
+        A = False
+        B = True
+        C = True
+    elif pa.types.is_floating(pa_dtype):
+        A = -1.1
+        B = 0.0
+        C = 1.1
+    elif pa.types.is_signed_integer(pa_dtype):
+        A = -1
+        B = 0
+        C = 1
+    elif pa.types.is_unsigned_integer(pa_dtype):
+        A = 0
+        B = 1
+        C = 10
+    elif pa.types.is_date(pa_dtype):
+        A = date(1999, 12, 31)
+        B = date(2010, 1, 1)
+        C = date(2022, 1, 1)
+    elif pa.types.is_timestamp(pa_dtype):
+        A = datetime(1999, 1, 1, 1, 1, 1, 1)
+        B = datetime(2020, 1, 1)
+        C = datetime(2020, 1, 1, 1)
+    elif pa.types.is_duration(pa_dtype):
+        A = timedelta(-1)
+        B = timedelta(0)
+        C = timedelta(1, 4)
+    elif pa.types.is_time(pa_dtype):
+        A = time(0, 0)
+        B = time(0, 12)
+        C = time(12, 12)
+    else:
+        raise NotImplementedError
+    return pd.array([B, B, None, None, A, A, B, C], dtype=dtype)
+
+
+@pytest.fixture
+def data_for_sorting(data_for_grouping):
+    """
+    Length-3 array with a known sort order.
+
+    This should be three items [B, C, A] with
+    A < B < C
+    """
+    return type(data_for_grouping)._from_sequence(
+        [data_for_grouping[0], data_for_grouping[7], data_for_grouping[4]]
+    )
+
+
+@pytest.fixture
+def data_missing_for_sorting(data_for_grouping):
+    """
+    Length-3 array with a known sort order.
+
+    This should be three items [B, NA, A] with
+    A < B and NA missing.
+    """
+    return type(data_for_grouping)._from_sequence(
+        [data_for_grouping[0], data_for_grouping[2], data_for_grouping[4]]
+    )
+
+
+@pytest.fixture
+def data_for_twos(data):
+    """Length-100 array in which all the elements are two."""
+    pa_dtype = data.dtype.pyarrow_dtype
+    if pa.types.is_integer(pa_dtype) or pa.types.is_floating(pa_dtype):
+        return pd.array([2] * 100, dtype=data.dtype)
+    # tests will be xfailed where 2 is not a valid scalar for pa_dtype
+    return data
+
+
+@pytest.fixture
+def na_value():
+    """The scalar missing value for this type. Default 'None'"""
+    return pd.NA
+
+
+class TestBaseCasting(base.BaseCastingTests):
+    pass
+
+
+class TestConstructors(base.BaseConstructorsTests):
+    def test_from_dtype(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_timestamp(pa_dtype) and pa_dtype.tz:
+            if pa_version_under2p0:
+                request.node.add_marker(
+                    pytest.mark.xfail(
+                        reason=f"timestamp data with tz={pa_dtype.tz} "
+                        "converted to integer when pyarrow < 2.0",
+                    )
+                )
+            else:
+                request.node.add_marker(
+                    pytest.mark.xfail(
+                        raises=NotImplementedError,
+                        reason=f"pyarrow.type_for_alias cannot infer {pa_dtype}",
+                    )
+                )
+        super().test_from_dtype(data)
+
+    def test_from_sequence_pa_array(self, data, request):
+        # https://github.com/pandas-dev/pandas/pull/47034#discussion_r955500784
+        # data._data = pa.ChunkedArray
+        if pa_version_under3p0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="ChunkedArray has no attribute combine_chunks",
+                )
+            )
+        result = type(data)._from_sequence(data._data)
+        tm.assert_extension_array_equal(result, data)
+        assert isinstance(result._data, pa.ChunkedArray)
+
+        result = type(data)._from_sequence(data._data.combine_chunks())
+        tm.assert_extension_array_equal(result, data)
+        assert isinstance(result._data, pa.ChunkedArray)
+
+    def test_from_sequence_pa_array_notimplemented(self, request):
+        if pa_version_under6p0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=AttributeError,
+                    reason="month_day_nano_interval not implemented by pyarrow.",
+                )
+            )
+        with pytest.raises(NotImplementedError, match="Converting strings to"):
+            ArrowExtensionArray._from_sequence_of_strings(
+                ["12-1"], dtype=pa.month_day_nano_interval()
+            )
+
+    def test_from_sequence_of_strings_pa_array(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa_version_under3p0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="ChunkedArray has no attribute combine_chunks",
+                )
+            )
+        elif pa.types.is_time64(pa_dtype) and pa_dtype.equals("time64[ns]"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Nanosecond time parsing not supported.",
+                )
+            )
+        elif pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support parsing {pa_dtype}",
+                )
+            )
+        elif pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Iterating over ChunkedArray[bool] returns PyArrow scalars.",
+                )
+            )
+        elif pa.types.is_timestamp(pa_dtype) and pa_dtype.tz is not None:
+            if pa_version_under7p0:
+                request.node.add_marker(
+                    pytest.mark.xfail(
+                        raises=pa.ArrowNotImplementedError,
+                        reason=f"pyarrow doesn't support string cast from {pa_dtype}",
+                    )
+                )
+            elif is_platform_windows() and is_ci_environment():
+                request.node.add_marker(
+                    pytest.mark.xfail(
+                        raises=pa.ArrowInvalid,
+                        reason=(
+                            "TODO: Set ARROW_TIMEZONE_DATABASE environment variable "
+                            "on CI to path to the tzdata for pyarrow."
+                        ),
+                    )
+                )
+        elif pa_version_under6p0 and pa.types.is_temporal(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support string cast from {pa_dtype}",
+                )
+            )
+        pa_array = data._data.cast(pa.string())
+        result = type(data)._from_sequence_of_strings(pa_array, dtype=data.dtype)
+        tm.assert_extension_array_equal(result, data)
+
+        pa_array = pa_array.combine_chunks()
+        result = type(data)._from_sequence_of_strings(pa_array, dtype=data.dtype)
+        tm.assert_extension_array_equal(result, data)
+
+
+class TestGetitemTests(base.BaseGetitemTests):
+    @pytest.mark.xfail(
+        reason=(
+            "data.dtype.type return pyarrow.DataType "
+            "but this (intentionally) returns "
+            "Python scalars or pd.Na"
+        )
+    )
+    def test_getitem_scalar(self, data):
+        super().test_getitem_scalar(data)
+
+    def test_take_series(self, request, data):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        unit = getattr(data.dtype.pyarrow_dtype, "unit", None)
+        bad_units = ["ns"]
+        if pa_version_under2p0:
+            bad_units.extend(["s", "ms", "us"])
+        if pa_version_under3p0 and tz not in (None, "UTC") and unit in bad_units:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"Not supported by pyarrow < 3.0 "
+                        f"with timestamp type {tz} and {unit}"
+                    )
+                )
+            )
+        super().test_take_series(data)
+
+    def test_reindex(self, request, data, na_value):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        unit = getattr(data.dtype.pyarrow_dtype, "unit", None)
+        bad_units = ["ns"]
+        if pa_version_under2p0:
+            bad_units.extend(["s", "ms", "us"])
+        if pa_version_under3p0 and tz not in (None, "UTC") and unit in bad_units:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"Not supported by pyarrow < 3.0 "
+                        f"with timestamp type {tz} and {unit}"
+                    )
+                )
+            )
+        super().test_reindex(data, na_value)
+
+    def test_loc_iloc_frame_single_dtype(self, request, using_array_manager, data):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        unit = getattr(data.dtype.pyarrow_dtype, "unit", None)
+        bad_units = ["ns"]
+        if pa_version_under2p0:
+            bad_units.extend(["s", "ms", "us"])
+        if (
+            pa_version_under3p0
+            and not using_array_manager
+            and tz not in (None, "UTC")
+            and unit in bad_units
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"Not supported by pyarrow < 3.0 "
+                        f"with timestamp type {tz} and {unit}"
+                    )
+                )
+            )
+        super().test_loc_iloc_frame_single_dtype(data)
+
+
+class TestBaseNumericReduce(base.BaseNumericReduceTests):
+    def check_reduce(self, ser, op_name, skipna):
+        pa_dtype = ser.dtype.pyarrow_dtype
+        result = getattr(ser, op_name)(skipna=skipna)
+        if pa.types.is_boolean(pa_dtype):
+            # Can't convert if ser contains NA
+            pytest.skip(
+                "pandas boolean data with NA does not fully support all reductions"
+            )
+        elif pa.types.is_integer(pa_dtype) or pa.types.is_floating(pa_dtype):
+            ser = ser.astype("Float64")
+        expected = getattr(ser, op_name)(skipna=skipna)
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_reduce_series(self, data, all_numeric_reductions, skipna, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        xfail_mark = pytest.mark.xfail(
+            raises=TypeError,
+            reason=(
+                f"{all_numeric_reductions} is not implemented in "
+                f"pyarrow={pa.__version__} for {pa_dtype}"
+            ),
+        )
+        if all_numeric_reductions in {"skew", "kurt"}:
+            request.node.add_marker(xfail_mark)
+        elif (
+            all_numeric_reductions in {"median", "var", "std", "prod", "max", "min"}
+            and pa_version_under6p0
+        ):
+            request.node.add_marker(xfail_mark)
+        elif all_numeric_reductions in {"sum", "mean"} and pa_version_under2p0:
+            request.node.add_marker(xfail_mark)
+        elif (
+            all_numeric_reductions in {"sum", "mean"}
+            and skipna is False
+            and pa_version_under6p0
+            and (pa.types.is_integer(pa_dtype) or pa.types.is_floating(pa_dtype))
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=AssertionError,
+                    reason=(
+                        f"{all_numeric_reductions} with skip_nulls={skipna} did not "
+                        f"return NA for {pa_dtype} with pyarrow={pa.__version__}"
+                    ),
+                )
+            )
+        elif not (
+            pa.types.is_integer(pa_dtype)
+            or pa.types.is_floating(pa_dtype)
+            or pa.types.is_boolean(pa_dtype)
+        ) and not (
+            all_numeric_reductions in {"min", "max"}
+            and (pa.types.is_temporal(pa_dtype) and not pa.types.is_duration(pa_dtype))
+        ):
+            request.node.add_marker(xfail_mark)
+        elif pa.types.is_boolean(pa_dtype) and all_numeric_reductions in {
+            "std",
+            "var",
+            "median",
+        }:
+            request.node.add_marker(xfail_mark)
+        super().test_reduce_series(data, all_numeric_reductions, skipna)
+
+
+class TestBaseBooleanReduce(base.BaseBooleanReduceTests):
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_reduce_series(
+        self, data, all_boolean_reductions, skipna, na_value, request
+    ):
+        pa_dtype = data.dtype.pyarrow_dtype
+        xfail_mark = pytest.mark.xfail(
+            raises=TypeError,
+            reason=(
+                f"{all_boolean_reductions} is not implemented in "
+                f"pyarrow={pa.__version__} for {pa_dtype}"
+            ),
+        )
+        if not pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(xfail_mark)
+        elif pa_version_under3p0:
+            request.node.add_marker(xfail_mark)
+        op_name = all_boolean_reductions
+        s = pd.Series(data)
+        result = getattr(s, op_name)(skipna=skipna)
+        assert result is (op_name == "any")
+
+
+class TestBaseGroupby(base.BaseGroupbyTests):
+    def test_groupby_agg_extension(self, data_for_grouping, request):
+        tz = getattr(data_for_grouping.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}."
+                )
+            )
+        super().test_groupby_agg_extension(data_for_grouping)
+
+    def test_groupby_extension_no_sort(self, data_for_grouping, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        elif pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support factorizing {pa_dtype}",
+                )
+            )
+        super().test_groupby_extension_no_sort(data_for_grouping)
+
+    def test_groupby_extension_transform(self, data_for_grouping, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        elif pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support factorizing {pa_dtype}",
+                )
+            )
+        super().test_groupby_extension_transform(data_for_grouping)
+
+    def test_groupby_extension_apply(
+        self, data_for_grouping, groupby_apply_op, request
+    ):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support factorizing {pa_dtype}",
+                )
+            )
+        with tm.maybe_produces_warning(
+            PerformanceWarning, pa_version_under7p0, check_stacklevel=False
+        ):
+            super().test_groupby_extension_apply(data_for_grouping, groupby_apply_op)
+
+    def test_in_numeric_groupby(self, data_for_grouping, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_integer(pa_dtype) or pa.types.is_floating(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="ArrowExtensionArray doesn't support .sum() yet.",
+                )
+            )
+        super().test_in_numeric_groupby(data_for_grouping)
+
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_groupby_extension_agg(self, as_index, data_for_grouping, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=ValueError,
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        elif pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow doesn't support factorizing {pa_dtype}",
+                )
+            )
+        with tm.maybe_produces_warning(
+            PerformanceWarning, pa_version_under7p0, check_stacklevel=False
+        ):
+            super().test_groupby_extension_agg(as_index, data_for_grouping)
+
+
+class TestBaseDtype(base.BaseDtypeTests):
+    def test_construct_from_string_own_name(self, dtype, request):
+        pa_dtype = dtype.pyarrow_dtype
+        if pa.types.is_timestamp(pa_dtype) and pa_dtype.tz is not None:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason=f"pyarrow.type_for_alias cannot infer {pa_dtype}",
+                )
+            )
+        super().test_construct_from_string_own_name(dtype)
+
+    def test_is_dtype_from_name(self, dtype, request):
+        pa_dtype = dtype.pyarrow_dtype
+        if pa.types.is_timestamp(pa_dtype) and pa_dtype.tz is not None:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason=f"pyarrow.type_for_alias cannot infer {pa_dtype}",
+                )
+            )
+        super().test_is_dtype_from_name(dtype)
+
+    def test_construct_from_string(self, dtype, request):
+        pa_dtype = dtype.pyarrow_dtype
+        if pa.types.is_timestamp(pa_dtype) and pa_dtype.tz is not None:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason=f"pyarrow.type_for_alias cannot infer {pa_dtype}",
+                )
+            )
+        super().test_construct_from_string(dtype)
+
+    def test_construct_from_string_another_type_raises(self, dtype):
+        msg = r"'another_type' must end with '\[pyarrow\]'"
+        with pytest.raises(TypeError, match=msg):
+            type(dtype).construct_from_string("another_type")
+
+    def test_get_common_dtype(self, dtype, request):
+        pa_dtype = dtype.pyarrow_dtype
+        if (
+            pa.types.is_date(pa_dtype)
+            or pa.types.is_time(pa_dtype)
+            or (
+                pa.types.is_timestamp(pa_dtype)
+                and (pa_dtype.unit != "ns" or pa_dtype.tz is not None)
+            )
+            or (pa.types.is_duration(pa_dtype) and pa_dtype.unit != "ns")
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"{pa_dtype} does not have associated numpy "
+                        f"dtype findable by find_common_type"
+                    )
+                )
+            )
+        super().test_get_common_dtype(dtype)
+
+
+class TestBaseIndex(base.BaseIndexTests):
+    pass
+
+
+class TestBaseInterface(base.BaseInterfaceTests):
+    def test_contains(self, data, data_missing, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        unit = getattr(data.dtype.pyarrow_dtype, "unit", None)
+        if pa_version_under2p0 and tz not in (None, "UTC") and unit == "us":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"Not supported by pyarrow < 2.0 "
+                        f"with timestamp type {tz} and {unit}"
+                    )
+                )
+            )
+        super().test_contains(data, data_missing)
+
+    @pytest.mark.xfail(reason="pyarrow.ChunkedArray does not support views.")
+    def test_view(self, data):
+        super().test_view(data)
+
+
+class TestBaseMissing(base.BaseMissingTests):
+    @pytest.mark.filterwarnings("ignore:Falling back:pandas.errors.PerformanceWarning")
+    def test_dropna_array(self, data_missing):
+        super().test_dropna_array(data_missing)
+
+
+class TestBasePrinting(base.BasePrintingTests):
+    pass
+
+
+class TestBaseReshaping(base.BaseReshapingTests):
+    def test_concat_columns(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_concat_columns(data, na_value)
+
+    def test_concat_extension_arrays_copy_false(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_concat_extension_arrays_copy_false(data, na_value)
+
+    def test_align(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_align(data, na_value)
+
+    def test_align_frame(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_align_frame(data, na_value)
+
+    def test_align_series_frame(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_align_series_frame(data, na_value)
+
+    def test_merge(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_merge(data, na_value)
+
+    def test_ravel(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_ravel(data)
+
+    @pytest.mark.xfail(reason="GH 45419: pyarrow.ChunkedArray does not support views")
+    def test_transpose(self, data):
+        super().test_transpose(data)
+
+    def test_transpose_frame(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_transpose_frame(data)
+
+
+class TestBaseSetitem(base.BaseSetitemTests):
+    def test_setitem_scalar_series(self, data, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_scalar_series(data, box_in_series)
+
+    def test_setitem_sequence(self, data, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_sequence(data, box_in_series)
+
+    def test_setitem_sequence_broadcasts(self, data, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_sequence_broadcasts(data, box_in_series)
+
+    @pytest.mark.parametrize("setter", ["loc", "iloc"])
+    def test_setitem_scalar(self, data, setter, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_scalar(data, setter)
+
+    def test_setitem_loc_scalar_mixed(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_loc_scalar_mixed(data)
+
+    def test_setitem_loc_scalar_single(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_loc_scalar_single(data)
+
+    def test_setitem_loc_scalar_multiple_homogoneous(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_loc_scalar_multiple_homogoneous(data)
+
+    def test_setitem_iloc_scalar_mixed(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_iloc_scalar_mixed(data)
+
+    def test_setitem_iloc_scalar_single(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_iloc_scalar_single(data)
+
+    def test_setitem_iloc_scalar_multiple_homogoneous(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_iloc_scalar_multiple_homogoneous(data)
+
+    @pytest.mark.parametrize(
+        "mask",
+        [
+            np.array([True, True, True, False, False]),
+            pd.array([True, True, True, False, False], dtype="boolean"),
+            pd.array([True, True, True, pd.NA, pd.NA], dtype="boolean"),
+        ],
+        ids=["numpy-array", "boolean-array", "boolean-array-na"],
+    )
+    def test_setitem_mask(self, data, mask, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_mask(data, mask, box_in_series)
+
+    def test_setitem_mask_boolean_array_with_na(self, data, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        unit = getattr(data.dtype.pyarrow_dtype, "unit", None)
+        if pa_version_under2p0 and tz not in (None, "UTC") and unit == "us":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_mask_boolean_array_with_na(data, box_in_series)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [[0, 1, 2], pd.array([0, 1, 2], dtype="Int64"), np.array([0, 1, 2])],
+        ids=["list", "integer-array", "numpy-array"],
+    )
+    def test_setitem_integer_array(self, data, idx, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_integer_array(data, idx, box_in_series)
+
+    @pytest.mark.parametrize("as_callable", [True, False])
+    @pytest.mark.parametrize("setter", ["loc", None])
+    def test_setitem_mask_aligned(self, data, as_callable, setter, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_mask_aligned(data, as_callable, setter)
+
+    @pytest.mark.parametrize("setter", ["loc", None])
+    def test_setitem_mask_broadcast(self, data, setter, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_mask_broadcast(data, setter)
+
+    def test_setitem_tuple_index(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_tuple_index(data)
+
+    def test_setitem_slice(self, data, box_in_series, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_slice(data, box_in_series)
+
+    def test_setitem_loc_iloc_slice(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_loc_iloc_slice(data)
+
+    def test_setitem_slice_array(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_slice_array(data)
+
+    def test_setitem_with_expansion_dataframe_column(self, data, full_indexer, request):
+        # Is there a better way to get the full_indexer id "null_slice"?
+        is_null_slice = "null_slice" in request.node.nodeid
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC") and not is_null_slice:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_with_expansion_dataframe_column(data, full_indexer)
+
+    def test_setitem_with_expansion_row(self, data, na_value, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(f"Not supported by pyarrow < 2.0 with timestamp type {tz}")
+                )
+            )
+        super().test_setitem_with_expansion_row(data, na_value)
+
+    def test_setitem_frame_2d_values(self, data, request):
+        tz = getattr(data.dtype.pyarrow_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_setitem_frame_2d_values(data)
+
+    @pytest.mark.xfail(reason="GH 45419: pyarrow.ChunkedArray does not support views")
+    def test_setitem_preserves_views(self, data):
+        super().test_setitem_preserves_views(data)
+
+
+class TestBaseParsing(base.BaseParsingTests):
+    @pytest.mark.parametrize("engine", ["c", "python"])
+    def test_EA_types(self, engine, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(raises=TypeError, reason="GH 47534")
+            )
+        elif pa.types.is_timestamp(pa_dtype) and pa_dtype.tz is not None:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason=f"Parameterized types with tz={pa_dtype.tz} not supported.",
+                )
+            )
+        super().test_EA_types(engine, data)
+
+
+class TestBaseUnaryOps(base.BaseUnaryOpsTests):
+    @pytest.mark.xfail(
+        pa_version_under2p0,
+        raises=NotImplementedError,
+        reason="pyarrow.compute.invert not supported in pyarrow<2.0",
+    )
+    def test_invert(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if not pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"pyarrow.compute.invert does support {pa_dtype}",
+                )
+            )
+        super().test_invert(data)
+
+
+class TestBaseMethods(base.BaseMethodsTests):
+    @pytest.mark.parametrize("periods", [1, -2])
+    def test_diff(self, data, periods, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_unsigned_integer(pa_dtype) and periods == 1:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason=(
+                        f"diff with {pa_dtype} and periods={periods} will overflow"
+                    ),
+                )
+            )
+        super().test_diff(data, periods)
+
+    @pytest.mark.parametrize("dropna", [True, False])
+    def test_value_counts(self, all_data, dropna, request):
+        pa_dtype = all_data.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"value_count has no kernel for {pa_dtype}",
+                )
+            )
+        super().test_value_counts(all_data, dropna)
+
+    def test_value_counts_with_normalize(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"value_count has no pyarrow kernel for {pa_dtype}",
+                )
+            )
+        super().test_value_counts_with_normalize(data)
+
+    @pytest.mark.xfail(
+        pa_version_under6p0,
+        raises=NotImplementedError,
+        reason="argmin/max only implemented for pyarrow version >= 6.0",
+    )
+    def test_argmin_argmax(
+        self, data_for_sorting, data_missing_for_sorting, na_value, request
+    ):
+        pa_dtype = data_for_sorting.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        elif pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"min_max not supported in pyarrow for {pa_dtype}",
+                )
+            )
+        super().test_argmin_argmax(data_for_sorting, data_missing_for_sorting, na_value)
+
+    @pytest.mark.parametrize(
+        "op_name, skipna, expected",
+        [
+            ("idxmax", True, 0),
+            ("idxmin", True, 2),
+            ("argmax", True, 0),
+            ("argmin", True, 2),
+            ("idxmax", False, np.nan),
+            ("idxmin", False, np.nan),
+            ("argmax", False, -1),
+            ("argmin", False, -1),
+        ],
+    )
+    def test_argreduce_series(
+        self, data_missing_for_sorting, op_name, skipna, expected, request
+    ):
+        pa_dtype = data_missing_for_sorting.dtype.pyarrow_dtype
+        if pa_version_under6p0 and skipna:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason="min_max not supported in pyarrow",
+                )
+            )
+        elif not pa_version_under6p0 and pa.types.is_duration(pa_dtype) and skipna:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"min_max not supported in pyarrow for {pa_dtype}",
+                )
+            )
+        super().test_argreduce_series(
+            data_missing_for_sorting, op_name, skipna, expected
+        )
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_values(self, data_for_sorting, ascending, sort_by_key, request):
+        pa_dtype = data_for_sorting.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype) and not ascending and not pa_version_under2p0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=(
+                        f"unique has no pyarrow kernel "
+                        f"for {pa_dtype} when ascending={ascending}"
+                    ),
+                )
+            )
+        super().test_sort_values(data_for_sorting, ascending, sort_by_key)
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_values_frame(self, data_for_sorting, ascending, request):
+        pa_dtype = data_for_sorting.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=(
+                        f"dictionary_encode has no pyarrow kernel "
+                        f"for {pa_dtype} when ascending={ascending}"
+                    ),
+                )
+            )
+        super().test_sort_values_frame(data_for_sorting, ascending)
+
+    @pytest.mark.parametrize("box", [pd.Series, lambda x: x])
+    @pytest.mark.parametrize("method", [lambda x: x.unique(), pd.unique])
+    def test_unique(self, data, box, method, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype) and not pa_version_under2p0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"unique has no pyarrow kernel for {pa_dtype}.",
+                )
+            )
+        super().test_unique(data, box, method)
+
+    @pytest.mark.parametrize("na_sentinel", [-1, -2])
+    def test_factorize(self, data_for_grouping, na_sentinel, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"dictionary_encode has no pyarrow kernel for {pa_dtype}",
+                )
+            )
+        elif pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        super().test_factorize(data_for_grouping, na_sentinel)
+
+    @pytest.mark.parametrize("na_sentinel", [-1, -2])
+    def test_factorize_equivalence(self, data_for_grouping, na_sentinel, request):
+        pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"dictionary_encode has no pyarrow kernel for {pa_dtype}",
+                )
+            )
+        super().test_factorize_equivalence(data_for_grouping, na_sentinel)
+
+    def test_factorize_empty(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_duration(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"dictionary_encode has no pyarrow kernel for {pa_dtype}",
+                )
+            )
+        super().test_factorize_empty(data)
+
+    def test_shift_fill_value(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        tz = getattr(pa_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_shift_fill_value(data)
+
+    @pytest.mark.parametrize("repeats", [0, 1, 2, [1, 2, 3]])
+    def test_repeat(self, data, repeats, as_series, use_numpy, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        tz = getattr(pa_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC") and repeats != 0:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"Not supported by pyarrow < 2.0 with "
+                        f"timestamp type {tz} when repeats={repeats}"
+                    )
+                )
+            )
+        super().test_repeat(data, repeats, as_series, use_numpy)
+
+    def test_insert(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        tz = getattr(pa_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_insert(data)
+
+    def test_combine_first(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        tz = getattr(pa_dtype, "tz", None)
+        if pa_version_under2p0 and tz not in (None, "UTC"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"Not supported by pyarrow < 2.0 with timestamp type {tz}"
+                )
+            )
+        super().test_combine_first(data)
+
+    @pytest.mark.xfail(
+        reason="result dtype pyarrow[bool] better than expected dtype object"
+    )
+    def test_combine_le(self, data_repeated):
+        super().test_combine_le(data_repeated)
+
+    def test_combine_add(self, data_repeated, request):
+        pa_dtype = next(data_repeated(1)).dtype.pyarrow_dtype
+        if pa.types.is_temporal(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=TypeError,
+                    reason=f"{pa_dtype} cannot be added to {pa_dtype}",
+                )
+            )
+        super().test_combine_add(data_repeated)
+
+    def test_searchsorted(self, data_for_sorting, as_series, request):
+        pa_dtype = data_for_sorting.dtype.pyarrow_dtype
+        if pa.types.is_boolean(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{pa_dtype} only has 2 unique possible values",
+                )
+            )
+        super().test_searchsorted(data_for_sorting, as_series)
+
+    def test_where_series(self, data, na_value, as_frame, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if pa.types.is_temporal(pa_dtype):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowNotImplementedError,
+                    reason=f"Unsupported cast from double to {pa_dtype}",
+                )
+            )
+        super().test_where_series(data, na_value, as_frame)
+
+
+class TestBaseArithmeticOps(base.BaseArithmeticOpsTests):
+
+    divmod_exc = NotImplementedError
+
+    def _patch_combine(self, obj, other, op):
+        # BaseOpsUtil._combine can upcast expected dtype
+        # (because it generates expected on python scalars)
+        # while ArrowExtensionArray maintains original type
+        expected = base.BaseArithmeticOpsTests._combine(self, obj, other, op)
+        was_frame = False
+        if isinstance(expected, pd.DataFrame):
+            was_frame = True
+            expected_data = expected.iloc[:, 0]
+            original_dtype = obj.iloc[:, 0].dtype
+        else:
+            expected_data = expected
+            original_dtype = obj.dtype
+        pa_array = pa.array(expected_data._values).cast(original_dtype.pyarrow_dtype)
+        pd_array = type(expected_data._values)(pa_array)
+        if was_frame:
+            expected = pd.DataFrame(
+                pd_array, index=expected.index, columns=expected.columns
+            )
+        else:
+            expected = pd.Series(pd_array)
+        return expected
+
+    def test_arith_series_with_scalar(
+        self, data, all_arithmetic_operators, request, monkeypatch
+    ):
+        pa_dtype = data.dtype.pyarrow_dtype
+
+        arrow_temporal_supported = not pa_version_under8p0 and (
+            all_arithmetic_operators in ("__add__", "__radd__")
+            and pa.types.is_duration(pa_dtype)
+            or all_arithmetic_operators in ("__sub__", "__rsub__")
+            and pa.types.is_temporal(pa_dtype)
+        )
+        if (
+            all_arithmetic_operators
+            in {
+                "__mod__",
+                "__rmod__",
+            }
+            or pa_version_under2p0
+        ):
+            self.series_scalar_exc = NotImplementedError
+        elif arrow_temporal_supported:
+            self.series_scalar_exc = None
+        elif not (
+            pa.types.is_floating(pa_dtype)
+            or pa.types.is_integer(pa_dtype)
+            or arrow_temporal_supported
+        ):
+            self.series_scalar_exc = pa.ArrowNotImplementedError
+        else:
+            self.series_scalar_exc = None
+        if (
+            all_arithmetic_operators == "__rpow__"
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"GH 29997: 1**pandas.NA == 1 while 1**pyarrow.NA == NULL "
+                        f"for {pa_dtype}"
+                    )
+                )
+            )
+        elif arrow_temporal_supported:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=TypeError,
+                    reason=(
+                        f"{all_arithmetic_operators} not supported between"
+                        f"pd.NA and {pa_dtype} Python scalar"
+                    ),
+                )
+            )
+        elif (
+            all_arithmetic_operators in {"__rtruediv__", "__rfloordiv__"}
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason="divide by 0",
+                )
+            )
+        if all_arithmetic_operators == "__floordiv__" and pa.types.is_integer(pa_dtype):
+            # BaseOpsUtil._combine always returns int64, while ArrowExtensionArray does
+            # not upcast
+            monkeypatch.setattr(TestBaseArithmeticOps, "_combine", self._patch_combine)
+        super().test_arith_series_with_scalar(data, all_arithmetic_operators)
+
+    def test_arith_frame_with_scalar(
+        self, data, all_arithmetic_operators, request, monkeypatch
+    ):
+        pa_dtype = data.dtype.pyarrow_dtype
+
+        arrow_temporal_supported = not pa_version_under8p0 and (
+            all_arithmetic_operators in ("__add__", "__radd__")
+            and pa.types.is_duration(pa_dtype)
+            or all_arithmetic_operators in ("__sub__", "__rsub__")
+            and pa.types.is_temporal(pa_dtype)
+        )
+        if (
+            all_arithmetic_operators
+            in {
+                "__mod__",
+                "__rmod__",
+            }
+            or pa_version_under2p0
+        ):
+            self.frame_scalar_exc = NotImplementedError
+        elif arrow_temporal_supported:
+            self.frame_scalar_exc = None
+        elif not (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype)):
+            self.frame_scalar_exc = pa.ArrowNotImplementedError
+        else:
+            self.frame_scalar_exc = None
+        if (
+            all_arithmetic_operators == "__rpow__"
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"GH 29997: 1**pandas.NA == 1 while 1**pyarrow.NA == NULL "
+                        f"for {pa_dtype}"
+                    )
+                )
+            )
+        elif arrow_temporal_supported:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=TypeError,
+                    reason=(
+                        f"{all_arithmetic_operators} not supported between"
+                        f"pd.NA and {pa_dtype} Python scalar"
+                    ),
+                )
+            )
+        elif (
+            all_arithmetic_operators in {"__rtruediv__", "__rfloordiv__"}
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason="divide by 0",
+                )
+            )
+        if all_arithmetic_operators == "__floordiv__" and pa.types.is_integer(pa_dtype):
+            # BaseOpsUtil._combine always returns int64, while ArrowExtensionArray does
+            # not upcast
+            monkeypatch.setattr(TestBaseArithmeticOps, "_combine", self._patch_combine)
+        super().test_arith_frame_with_scalar(data, all_arithmetic_operators)
+
+    def test_arith_series_with_array(
+        self, data, all_arithmetic_operators, request, monkeypatch
+    ):
+        pa_dtype = data.dtype.pyarrow_dtype
+
+        arrow_temporal_supported = not pa_version_under8p0 and (
+            all_arithmetic_operators in ("__add__", "__radd__")
+            and pa.types.is_duration(pa_dtype)
+            or all_arithmetic_operators in ("__sub__", "__rsub__")
+            and pa.types.is_temporal(pa_dtype)
+        )
+        if (
+            all_arithmetic_operators
+            in {
+                "__mod__",
+                "__rmod__",
+            }
+            or pa_version_under2p0
+        ):
+            self.series_array_exc = NotImplementedError
+        elif arrow_temporal_supported:
+            self.series_array_exc = None
+        elif not (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype)):
+            self.series_array_exc = pa.ArrowNotImplementedError
+        else:
+            self.series_array_exc = None
+        if (
+            all_arithmetic_operators == "__rpow__"
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        f"GH 29997: 1**pandas.NA == 1 while 1**pyarrow.NA == NULL "
+                        f"for {pa_dtype}"
+                    )
+                )
+            )
+        elif (
+            all_arithmetic_operators
+            in (
+                "__sub__",
+                "__rsub__",
+            )
+            and pa.types.is_unsigned_integer(pa_dtype)
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason=(
+                        f"Implemented pyarrow.compute.subtract_checked "
+                        f"which raises on overflow for {pa_dtype}"
+                    ),
+                )
+            )
+        elif arrow_temporal_supported:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=TypeError,
+                    reason=(
+                        f"{all_arithmetic_operators} not supported between"
+                        f"pd.NA and {pa_dtype} Python scalar"
+                    ),
+                )
+            )
+        elif (
+            all_arithmetic_operators in {"__rtruediv__", "__rfloordiv__"}
+            and (pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype))
+            and not pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason="divide by 0",
+                )
+            )
+        op_name = all_arithmetic_operators
+        ser = pd.Series(data)
+        # pd.Series([ser.iloc[0]] * len(ser)) may not return ArrowExtensionArray
+        # since ser.iloc[0] is a python scalar
+        other = pd.Series(pd.array([ser.iloc[0]] * len(ser), dtype=data.dtype))
+        if pa.types.is_floating(pa_dtype) or (
+            pa.types.is_integer(pa_dtype) and all_arithmetic_operators != "__truediv__"
+        ):
+            monkeypatch.setattr(TestBaseArithmeticOps, "_combine", self._patch_combine)
+        self.check_opname(ser, op_name, other, exc=self.series_array_exc)
+
+    def test_add_series_with_extension_array(self, data, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        if (
+            not (
+                pa.types.is_integer(pa_dtype)
+                or pa.types.is_floating(pa_dtype)
+                or (not pa_version_under8p0 and pa.types.is_duration(pa_dtype))
+            )
+            or pa_version_under2p0
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason=f"add_checked not implemented for {pa_dtype}",
+                )
+            )
+        elif pa_dtype.equals("int8"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=pa.ArrowInvalid,
+                    reason=f"raises on overflow for {pa_dtype}",
+                )
+            )
+        super().test_add_series_with_extension_array(data)
+
+
+class TestBaseComparisonOps(base.BaseComparisonOpsTests):
+    def assert_series_equal(self, left, right, *args, **kwargs):
+        # Series.combine for "expected" retains bool[pyarrow] dtype
+        # While "result" return "boolean" dtype
+        right = pd.Series(right._values.to_numpy(), dtype="boolean")
+        super().assert_series_equal(left, right, *args, **kwargs)
+
+    def test_compare_array(self, data, comparison_op, na_value, request):
+        pa_dtype = data.dtype.pyarrow_dtype
+        ser = pd.Series(data)
+        # pd.Series([ser.iloc[0]] * len(ser)) may not return ArrowExtensionArray
+        # since ser.iloc[0] is a python scalar
+        other = pd.Series(pd.array([ser.iloc[0]] * len(ser), dtype=data.dtype))
+        if comparison_op.__name__ in ["eq", "ne"]:
+            # comparison should match point-wise comparisons
+            result = comparison_op(ser, other)
+            # Series.combine does not calculate the NA mask correctly
+            # when comparing over an array
+            assert result[8] is na_value
+            assert result[97] is na_value
+            expected = ser.combine(other, comparison_op)
+            expected[8] = na_value
+            expected[97] = na_value
+            self.assert_series_equal(result, expected)
+
+        else:
+            exc = None
+            try:
+                result = comparison_op(ser, other)
+            except Exception as err:
+                exc = err
+
+            if exc is None:
+                # Didn't error, then should match point-wise behavior
+                if pa.types.is_temporal(pa_dtype):
+                    # point-wise comparison with pd.NA raises TypeError
+                    assert result[8] is na_value
+                    assert result[97] is na_value
+                    result = result.drop([8, 97]).reset_index(drop=True)
+                    ser = ser.drop([8, 97])
+                    other = other.drop([8, 97])
+                expected = ser.combine(other, comparison_op)
+                self.assert_series_equal(result, expected)
+            else:
+                with pytest.raises(type(exc)):
+                    ser.combine(other, comparison_op)
+
+    def test_invalid_other_comp(self, data, comparison_op):
+        # GH 48833
+        with pytest.raises(
+            NotImplementedError, match=".* not implemented for <class 'object'>"
+        ):
+            comparison_op(data, object())
+
+
+def test_arrowdtype_construct_from_string_type_with_unsupported_parameters():
+    with pytest.raises(NotImplementedError, match="Passing pyarrow type"):
+        ArrowDtype.construct_from_string("timestamp[s, tz=UTC][pyarrow]")
+
+
+@pytest.mark.xfail(
+    pa_version_under4p0,
+    raises=NotImplementedError,
+    reason="quantile only supported for pyarrow version >= 4.0",
+)
+@pytest.mark.parametrize(
+    "interpolation", ["linear", "lower", "higher", "nearest", "midpoint"]
+)
+@pytest.mark.parametrize("quantile", [0.5, [0.5, 0.5]])
+def test_quantile(data, interpolation, quantile, request):
+    pa_dtype = data.dtype.pyarrow_dtype
+    if not (pa.types.is_integer(pa_dtype) or pa.types.is_floating(pa_dtype)):
+        request.node.add_marker(
+            pytest.mark.xfail(
+                raises=pa.ArrowNotImplementedError,
+                reason=f"quantile not supported by pyarrow for {pa_dtype}",
+            )
+        )
+    data = data.take([0, 0, 0])
+    ser = pd.Series(data)
+    result = ser.quantile(q=quantile, interpolation=interpolation)
+    if quantile == 0.5:
+        assert result == data[0]
+    else:
+        # Just check the values
+        result = result.astype("float64[pyarrow]")
+        expected = pd.Series(
+            data.take([0, 0]).astype("float64[pyarrow]"), index=[0.5, 0.5]
+        )
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.xfail(
+    pa_version_under6p0,
+    raises=NotImplementedError,
+    reason="mode only supported for pyarrow version >= 6.0",
+)
+@pytest.mark.parametrize("dropna", [True, False])
+@pytest.mark.parametrize(
+    "take_idx, exp_idx",
+    [[[0, 0, 2, 2, 4, 4], [4, 0]], [[0, 0, 0, 2, 4, 4], [0]]],
+    ids=["multi_mode", "single_mode"],
+)
+def test_mode(data_for_grouping, dropna, take_idx, exp_idx, request):
+    pa_dtype = data_for_grouping.dtype.pyarrow_dtype
+    if pa.types.is_temporal(pa_dtype):
+        request.node.add_marker(
+            pytest.mark.xfail(
+                raises=pa.ArrowNotImplementedError,
+                reason=f"mode not supported by pyarrow for {pa_dtype}",
+            )
+        )
+    elif (
+        pa.types.is_boolean(pa_dtype)
+        and "multi_mode" in request.node.nodeid
+        and pa_version_under9p0
+    ):
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="https://issues.apache.org/jira/browse/ARROW-17096",
+            )
+        )
+    data = data_for_grouping.take(take_idx)
+    ser = pd.Series(data)
+    result = ser.mode(dropna=dropna)
+    expected = pd.Series(data_for_grouping.take(exp_idx))
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/extension/test_boolean.py b/pandas/tests/extension/test_boolean.py
index 1f44889cdd88a..dd067102aba6c 100644
--- a/pandas/tests/extension/test_boolean.py
+++ b/pandas/tests/extension/test_boolean.py
@@ -108,7 +108,11 @@ class TestArithmeticOps(base.BaseArithmeticOpsTests):
 
     def check_opname(self, s, op_name, other, exc=None):
         # overwriting to indicate ops don't raise an error
-        super().check_opname(s, op_name, other, exc=None)
+        exc = None
+        if op_name.strip("_").lstrip("r") in ["pow", "truediv", "floordiv"]:
+            # match behavior with non-masked bool dtype
+            exc = NotImplementedError
+        super().check_opname(s, op_name, other, exc=exc)
 
     def _check_op(self, obj, op, other, op_name, exc=NotImplementedError):
         if exc is None:
@@ -144,9 +148,19 @@ def _check_op(self, obj, op, other, op_name, exc=NotImplementedError):
             with pytest.raises(exc):
                 op(obj, other)
 
-    def _check_divmod_op(self, s, op, other, exc=None):
-        # override to not raise an error
-        super()._check_divmod_op(s, op, other, None)
+    @pytest.mark.xfail(
+        reason="Inconsistency between floordiv and divmod; we raise for floordiv "
+        "but not for divmod. This matches what we do for non-masked bool dtype."
+    )
+    def test_divmod_series_array(self, data, data_for_twos):
+        super().test_divmod_series_array(data, data_for_twos)
+
+    @pytest.mark.xfail(
+        reason="Inconsistency between floordiv and divmod; we raise for floordiv "
+        "but not for divmod. This matches what we do for non-masked bool dtype."
+    )
+    def test_divmod(self, data):
+        super().test_divmod(data)
 
 
 class TestComparisonOps(base.BaseComparisonOpsTests):
@@ -163,7 +177,12 @@ class TestMethods(base.BaseMethodsTests):
     @pytest.mark.parametrize("na_sentinel", [-1, -2])
     def test_factorize(self, data_for_grouping, na_sentinel):
         # override because we only have 2 unique values
-        labels, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
+        if na_sentinel == -1:
+            msg = "Specifying `na_sentinel=-1` is deprecated"
+        else:
+            msg = "Specifying the specific value to use for `na_sentinel` is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            labels, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
         expected_labels = np.array(
             [0, 0, na_sentinel, na_sentinel, 1, 1, 0], dtype=np.intp
         )
@@ -212,14 +231,6 @@ def test_searchsorted(self, data_for_sorting, as_series):
         sorter = np.array([1, 0])
         assert data_for_sorting.searchsorted(a, sorter=sorter) == 0
 
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts(self, all_data, dropna):
-        return super().test_value_counts(all_data, dropna)
-
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts_with_normalize(self, data):
-        super().test_value_counts_with_normalize(data)
-
     def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting):
         # override because there are only 2 unique values
 
@@ -308,10 +319,10 @@ def test_groupby_extension_transform(self, data_for_grouping):
 
     def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
         df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
-        df.groupby("B").apply(groupby_apply_op)
-        df.groupby("B").A.apply(groupby_apply_op)
-        df.groupby("A").apply(groupby_apply_op)
-        df.groupby("A").B.apply(groupby_apply_op)
+        df.groupby("B", group_keys=False).apply(groupby_apply_op)
+        df.groupby("B", group_keys=False).A.apply(groupby_apply_op)
+        df.groupby("A", group_keys=False).apply(groupby_apply_op)
+        df.groupby("A", group_keys=False).B.apply(groupby_apply_op)
 
     def test_groupby_apply_identity(self, data_for_grouping):
         df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index d21110e078709..1e17bf33c806c 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -50,7 +50,7 @@ def data():
     """Length-100 array for this type.
 
     * data[0] and data[1] should both be non missing
-    * data[0] and data[1] should not gbe equal
+    * data[0] and data[1] should not be equal
     """
     return Categorical(make_data())
 
@@ -86,7 +86,7 @@ class TestDtype(base.BaseDtypeTests):
 
 
 class TestInterface(base.BaseInterfaceTests):
-    @pytest.mark.skip(reason="Memory usage doesn't match")
+    @pytest.mark.xfail(reason="Memory usage doesn't match")
     def test_memory_usage(self, data):
         # Is this deliberate?
         super().test_memory_usage(data)
@@ -149,13 +149,7 @@ class TestIndex(base.BaseIndexTests):
 
 
 class TestMissing(base.BaseMissingTests):
-    @pytest.mark.skip(reason="Not implemented")
-    def test_fillna_limit_pad(self, data_missing):
-        super().test_fillna_limit_pad(data_missing)
-
-    @pytest.mark.skip(reason="Not implemented")
-    def test_fillna_limit_backfill(self, data_missing):
-        super().test_fillna_limit_backfill(data_missing)
+    pass
 
 
 class TestReduce(base.BaseNoReduceTests):
@@ -163,7 +157,7 @@ class TestReduce(base.BaseNoReduceTests):
 
 
 class TestMethods(base.BaseMethodsTests):
-    @pytest.mark.skip(reason="Unobserved categories included")
+    @pytest.mark.xfail(reason="Unobserved categories included")
     def test_value_counts(self, all_data, dropna):
         return super().test_value_counts(all_data, dropna)
 
@@ -184,10 +178,6 @@ def test_combine_add(self, data_repeated):
         expected = pd.Series([a + val for a in list(orig_data1)])
         self.assert_series_equal(result, expected)
 
-    @pytest.mark.skip(reason="Not Applicable")
-    def test_fillna_length_mismatch(self, data_missing):
-        super().test_fillna_length_mismatch(data_missing)
-
 
 class TestCasting(base.BaseCastingTests):
     @pytest.mark.parametrize("cls", [Categorical, CategoricalIndex])
diff --git a/pandas/tests/extension/test_common.py b/pandas/tests/extension/test_common.py
index e43650c291200..62bc250193564 100644
--- a/pandas/tests/extension/test_common.py
+++ b/pandas/tests/extension/test_common.py
@@ -14,7 +14,7 @@ class DummyDtype(dtypes.ExtensionDtype):
 
 
 class DummyArray(ExtensionArray):
-    def __init__(self, data):
+    def __init__(self, data) -> None:
         self.data = data
 
     def __array__(self, dtype):
diff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py
index a64b42fad9415..92796c604333d 100644
--- a/pandas/tests/extension/test_datetime.py
+++ b/pandas/tests/extension/test_datetime.py
@@ -175,9 +175,7 @@ class TestMissing(BaseDatetimeTests, base.BaseMissingTests):
 
 
 class TestReshaping(BaseDatetimeTests, base.BaseReshapingTests):
-    @pytest.mark.skip(reason="We have DatetimeTZBlock")
-    def test_concat(self, data, in_frame):
-        pass
+    pass
 
 
 class TestSetitem(BaseDatetimeTests, base.BaseSetitemTests):
diff --git a/pandas/tests/extension/test_extension.py b/pandas/tests/extension/test_extension.py
index 939b836a11556..a4b1a4b43ef2b 100644
--- a/pandas/tests/extension/test_extension.py
+++ b/pandas/tests/extension/test_extension.py
@@ -4,11 +4,12 @@
 import numpy as np
 import pytest
 
+import pandas._testing as tm
 from pandas.core.arrays import ExtensionArray
 
 
 class MyEA(ExtensionArray):
-    def __init__(self, values):
+    def __init__(self, values) -> None:
         self._values = values
 
 
@@ -24,3 +25,16 @@ def test_errors(self, data, all_arithmetic_operators):
         op_name = all_arithmetic_operators
         with pytest.raises(AttributeError):
             getattr(data, op_name)
+
+
+def test_depr_na_sentinel():
+    # GH#46910
+    msg = "The `na_sentinel` argument of `MyEA.factorize` is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+
+        class MyEA(ExtensionArray):
+            def factorize(self, na_sentinel=-1):
+                pass
+
+        with tm.assert_produces_warning(None):
+            MyEA()
diff --git a/pandas/tests/extension/test_floating.py b/pandas/tests/extension/test_floating.py
index 4f8c46c8720f2..ff0ff7399e3e6 100644
--- a/pandas/tests/extension/test_floating.py
+++ b/pandas/tests/extension/test_floating.py
@@ -173,24 +173,7 @@ class TestMissing(base.BaseMissingTests):
 
 
 class TestMethods(base.BaseMethodsTests):
-    @pytest.mark.parametrize("dropna", [True, False])
-    def test_value_counts(self, all_data, dropna):
-        all_data = all_data[:10]
-        if dropna:
-            other = np.array(all_data[~all_data.isna()])
-        else:
-            other = all_data
-
-        result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
-        expected = pd.Series(other).value_counts(dropna=dropna).sort_index()
-        expected = expected.astype("Int64")
-        expected.index = expected.index.astype(all_data.dtype)
-
-        self.assert_series_equal(result, expected)
-
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts_with_normalize(self, data):
-        super().test_value_counts_with_normalize(data)
+    pass
 
 
 class TestCasting(base.BaseCastingTests):
diff --git a/pandas/tests/extension/test_integer.py b/pandas/tests/extension/test_integer.py
index 8c8202e49ac3f..a6cf820dc7609 100644
--- a/pandas/tests/extension/test_integer.py
+++ b/pandas/tests/extension/test_integer.py
@@ -196,24 +196,7 @@ class TestMissing(base.BaseMissingTests):
 
 
 class TestMethods(base.BaseMethodsTests):
-    @pytest.mark.parametrize("dropna", [True, False])
-    def test_value_counts(self, all_data, dropna):
-        all_data = all_data[:10]
-        if dropna:
-            other = np.array(all_data[~all_data.isna()])
-        else:
-            other = all_data
-
-        result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
-        expected = pd.Series(other).value_counts(dropna=dropna).sort_index()
-        expected = expected.astype("Int64")
-        expected.index = expected.index.astype(all_data.dtype)
-
-        self.assert_series_equal(result, expected)
-
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts_with_normalize(self, data):
-        super().test_value_counts_with_normalize(data)
+    pass
 
 
 class TestCasting(base.BaseCastingTests):
diff --git a/pandas/tests/extension/test_interval.py b/pandas/tests/extension/test_interval.py
index e2f4d69c489ba..0f916cea9d518 100644
--- a/pandas/tests/extension/test_interval.py
+++ b/pandas/tests/extension/test_interval.py
@@ -121,9 +121,9 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
 
 
 class TestMethods(BaseInterval, base.BaseMethodsTests):
-    @pytest.mark.skip(reason="addition is not defined for intervals")
+    @pytest.mark.xfail(reason="addition is not defined for intervals")
     def test_combine_add(self, data_repeated):
-        pass
+        super().test_combine_add(data_repeated)
 
     @pytest.mark.xfail(
         reason="Raises with incorrect message bc it disallows *all* listlikes "
@@ -134,29 +134,31 @@ def test_fillna_length_mismatch(self, data_missing):
 
 
 class TestMissing(BaseInterval, base.BaseMissingTests):
-    # Index.fillna only accepts scalar `value`, so we have to skip all
+    # Index.fillna only accepts scalar `value`, so we have to xfail all
     # non-scalar fill tests.
-    unsupported_fill = pytest.mark.skip("Unsupported fillna option.")
+    unsupported_fill = pytest.mark.xfail(
+        reason="Unsupported fillna option for Interval."
+    )
 
     @unsupported_fill
     def test_fillna_limit_pad(self):
-        pass
+        super().test_fillna_limit_pad()
 
     @unsupported_fill
     def test_fillna_series_method(self):
-        pass
+        super().test_fillna_series_method()
 
     @unsupported_fill
     def test_fillna_limit_backfill(self):
-        pass
+        super().test_fillna_limit_backfill()
 
     @unsupported_fill
     def test_fillna_no_op_returns_copy(self):
-        pass
+        super().test_fillna_no_op_returns_copy()
 
     @unsupported_fill
     def test_fillna_series(self):
-        pass
+        super().test_fillna_series()
 
     def test_fillna_non_scalar_raises(self, data_missing):
         msg = "can only insert Interval objects and NA into an IntervalArray"
@@ -173,9 +175,9 @@ class TestSetitem(BaseInterval, base.BaseSetitemTests):
 
 
 class TestPrinting(BaseInterval, base.BasePrintingTests):
-    @pytest.mark.skip(reason="custom repr")
+    @pytest.mark.xfail(reason="Interval has custom repr")
     def test_array_repr(self, data, size):
-        pass
+        super().test_array_repr()
 
 
 class TestParsing(BaseInterval, base.BaseParsingTests):
diff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py
index 2e1112ccf2205..148059a6a16f3 100644
--- a/pandas/tests/extension/test_numpy.py
+++ b/pandas/tests/extension/test_numpy.py
@@ -208,10 +208,15 @@ def test_series_constructor_scalar_with_index(self, data, dtype):
 
 
 class TestDtype(BaseNumPyTests, base.BaseDtypeTests):
-    @pytest.mark.skip(reason="Incorrect expected.")
-    # we unsurprisingly clash with a NumPy name.
-    def test_check_dtype(self, data):
-        pass
+    def test_check_dtype(self, data, request):
+        if data.dtype.numpy_dtype == "object":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"PandasArray expectedly clashes with a "
+                    f"NumPy name: {data.dtype.numpy_dtype}"
+                )
+            )
+        super().test_check_dtype(data)
 
 
 class TestGetitem(BaseNumPyTests, base.BaseGetitemTests):
@@ -222,16 +227,7 @@ def test_getitem_scalar(self, data):
 
 
 class TestGroupby(BaseNumPyTests, base.BaseGroupbyTests):
-    def test_groupby_extension_apply(
-        self, data_for_grouping, groupby_apply_op, request
-    ):
-        dummy = groupby_apply_op([None])
-        if (
-            isinstance(dummy, pd.Series)
-            and data_for_grouping.dtype.numpy_dtype == object
-        ):
-            mark = pytest.mark.xfail(reason="raises in MultiIndex construction")
-            request.node.add_marker(mark)
+    def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
         super().test_groupby_extension_apply(data_for_grouping, groupby_apply_op)
 
 
@@ -345,11 +341,6 @@ def test_fillna_frame(self, data_missing):
 
 
 class TestReshaping(BaseNumPyTests, base.BaseReshapingTests):
-    @pytest.mark.skip(reason="Incorrect expected.")
-    def test_merge(self, data, na_value):
-        # Fails creating expected (key column becomes a PandasDtype because)
-        super().test_merge(data, na_value)
-
     @pytest.mark.parametrize(
         "in_frame",
         [
diff --git a/pandas/tests/extension/test_period.py b/pandas/tests/extension/test_period.py
index bbb464cb7dfed..06b372abf66f5 100644
--- a/pandas/tests/extension/test_period.py
+++ b/pandas/tests/extension/test_period.py
@@ -25,9 +25,9 @@
 from pandas.tests.extension import base
 
 
-@pytest.fixture
-def dtype():
-    return PeriodDtype(freq="D")
+@pytest.fixture(params=["D", "2D"])
+def dtype(request):
+    return PeriodDtype(freq=request.param)
 
 
 @pytest.fixture
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index 3a37ea4d673af..0a2686a24c732 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -17,7 +17,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p20
 from pandas.errors import PerformanceWarning
 
 from pandas.core.dtypes.common import is_object_dtype
@@ -54,7 +53,7 @@ def data(request):
 
 
 @pytest.fixture
-def data_for_twos(request):
+def data_for_twos():
     return SparseArray(np.ones(100) * 2)
 
 
@@ -100,6 +99,11 @@ def data_for_grouping(request):
     return SparseArray([1, 1, np.nan, np.nan, 2, 2, 1, 3], fill_value=request.param)
 
 
+@pytest.fixture(params=[0, np.nan])
+def data_for_compare(request):
+    return SparseArray([0, 0, np.nan, -2, -1, 4, 2, 3, 0, 0], fill_value=request.param)
+
+
 class BaseSparseTests:
     def _check_unsupported(self, data):
         if data.dtype == SparseDtype(int, 0):
@@ -145,6 +149,21 @@ def test_concat_mixed_dtypes(self, data):
         )
         self.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "columns",
+        [
+            ["A", "B"],
+            pd.MultiIndex.from_tuples(
+                [("A", "a"), ("A", "b")], names=["outer", "inner"]
+            ),
+        ],
+    )
+    def test_stack(self, data, columns):
+        with tm.assert_produces_warning(
+            FutureWarning, check_stacklevel=False, match="astype from Sparse"
+        ):
+            super().test_stack(data, columns)
+
     def test_concat_columns(self, data, na_value):
         self._check_unsupported(data)
         super().test_concat_columns(data, na_value)
@@ -227,11 +246,11 @@ def test_isna(self, data_missing):
         self.assert_equal(sarr.isna(), expected)
 
     def test_fillna_limit_pad(self, data_missing):
-        with tm.assert_produces_warning(PerformanceWarning):
+        with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
             super().test_fillna_limit_pad(data_missing)
 
     def test_fillna_limit_backfill(self, data_missing):
-        with tm.assert_produces_warning(PerformanceWarning):
+        with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
             super().test_fillna_limit_backfill(data_missing)
 
     def test_fillna_no_op_returns_copy(self, data, request):
@@ -239,17 +258,17 @@ def test_fillna_no_op_returns_copy(self, data, request):
             request.node.add_marker(
                 pytest.mark.xfail(reason="returns array with different fill value")
             )
-        with tm.assert_produces_warning(PerformanceWarning):
+        with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
             super().test_fillna_no_op_returns_copy(data)
 
     def test_fillna_series_method(self, data_missing):
-        with tm.assert_produces_warning(PerformanceWarning):
+        with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
             super().test_fillna_limit_backfill(data_missing)
 
-    @pytest.mark.skip(reason="Unsupported")
+    @pytest.mark.xfail(reason="Unsupported")
     def test_fillna_series(self):
         # this one looks doable.
-        pass
+        super(self).test_fillna_series()
 
     def test_fillna_frame(self, data_missing):
         # Have to override to specify that fill_value will change.
@@ -273,14 +292,6 @@ def test_fillna_frame(self, data_missing):
 
 
 class TestMethods(BaseSparseTests, base.BaseMethodsTests):
-    @pytest.mark.parametrize("ascending", [True, False])
-    def test_sort_values_frame(self, data_for_sorting, ascending):
-        msg = "will store that array directly"
-        with tm.assert_produces_warning(
-            FutureWarning, match=msg, check_stacklevel=False
-        ):
-            super().test_sort_values_frame(data_for_sorting, ascending)
-
     def test_combine_le(self, data_repeated):
         # We return a Series[SparseArray].__le__ returns a
         # Series[Sparse[bool]]
@@ -325,9 +336,9 @@ def test_fillna_copy_series(self, data_missing):
         assert ser._values is not result._values
         assert ser._values.to_dense() is arr.to_dense()
 
-    @pytest.mark.skip(reason="Not Applicable")
+    @pytest.mark.xfail(reason="Not Applicable")
     def test_fillna_length_mismatch(self, data_missing):
-        pass
+        super().test_fillna_length_mismatch(data_missing)
 
     def test_where_series(self, data, na_value):
         assert data[0] != data[1]
@@ -362,7 +373,7 @@ def test_combine_first(self, data, request):
         super().test_combine_first(data)
 
     def test_searchsorted(self, data_for_sorting, as_series):
-        with tm.assert_produces_warning(PerformanceWarning):
+        with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
             super().test_searchsorted(data_for_sorting, as_series)
 
     def test_shift_0_periods(self, data):
@@ -389,7 +400,8 @@ def test_astype_object_series(self, all_data):
         # Unlike the base class, we do not expect the resulting Block
         #  to be ObjectBlock / resulting array to be np.dtype("object")
         ser = pd.Series(all_data, name="A")
-        result = ser.astype(object)
+        with tm.assert_produces_warning(FutureWarning, match="astype from Sparse"):
+            result = ser.astype(object)
         assert is_object_dtype(result.dtype)
         assert is_object_dtype(result._mgr.array.dtype)
 
@@ -398,18 +410,17 @@ def test_astype_object_frame(self, all_data):
         #  to be ObjectBlock / resulting array to be np.dtype("object")
         df = pd.DataFrame({"A": all_data})
 
-        result = df.astype(object)
+        with tm.assert_produces_warning(FutureWarning, match="astype from Sparse"):
+            result = df.astype(object)
         assert is_object_dtype(result._mgr.arrays[0].dtype)
 
-        # earlier numpy raises TypeError on e.g. np.dtype(np.int64) == "Int64"
-        #  instead of returning False
-        if not np_version_under1p20:
-            # check that we can compare the dtypes
-            comp = result.dtypes == df.dtypes
-            assert not comp.any()
+        # check that we can compare the dtypes
+        comp = result.dtypes == df.dtypes
+        assert not comp.any()
 
     def test_astype_str(self, data):
-        result = pd.Series(data[:5]).astype(str)
+        with tm.assert_produces_warning(FutureWarning, match="astype from Sparse"):
+            result = pd.Series(data[:5]).astype(str)
         expected_dtype = SparseDtype(str, str(data.fill_value))
         expected = pd.Series([str(x) for x in data[:5]], dtype=expected_dtype)
         self.assert_series_equal(result, expected)
@@ -430,7 +441,7 @@ def _skip_if_different_combine(self, data):
             # arith ops call on dtype.fill_value so that the sparsity
             # is maintained. Combine can't be called on a dtype in
             # general, so we can't make the expected. This is tested elsewhere
-            raise pytest.skip("Incorrected expected from Series.combine")
+            pytest.skip("Incorrected expected from Series.combine and tested elsewhere")
 
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
         self._skip_if_different_combine(data)
@@ -461,32 +472,45 @@ def _check_divmod_op(self, ser, op, other, exc=NotImplementedError):
         super()._check_divmod_op(ser, op, other, exc=None)
 
 
-class TestComparisonOps(BaseSparseTests, base.BaseComparisonOpsTests):
-    def _compare_other(self, s, data, comparison_op, other):
+class TestComparisonOps(BaseSparseTests):
+    def _compare_other(self, data_for_compare: SparseArray, comparison_op, other):
         op = comparison_op
 
-        # array
-        result = pd.Series(op(data, other))
-        # hard to test the fill value, since we don't know what expected
-        # is in general.
-        # Rely on tests in `tests/sparse` to validate that.
-        assert isinstance(result.dtype, SparseDtype)
-        assert result.dtype.subtype == np.dtype("bool")
-
-        with np.errstate(all="ignore"):
-            expected = pd.Series(
-                SparseArray(
-                    op(np.asarray(data), np.asarray(other)),
-                    fill_value=result.values.fill_value,
-                )
+        result = op(data_for_compare, other)
+        assert isinstance(result, SparseArray)
+        assert result.dtype.subtype == np.bool_
+
+        if isinstance(other, SparseArray):
+            fill_value = op(data_for_compare.fill_value, other.fill_value)
+        else:
+            fill_value = np.all(
+                op(np.asarray(data_for_compare.fill_value), np.asarray(other))
+            )
+
+            expected = SparseArray(
+                op(data_for_compare.to_dense(), np.asarray(other)),
+                fill_value=fill_value,
+                dtype=np.bool_,
             )
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_scalar(self, data_for_compare: SparseArray, comparison_op):
+        self._compare_other(data_for_compare, comparison_op, 0)
+        self._compare_other(data_for_compare, comparison_op, 1)
+        self._compare_other(data_for_compare, comparison_op, -1)
+        self._compare_other(data_for_compare, comparison_op, np.nan)
 
-        tm.assert_series_equal(result, expected)
+    @pytest.mark.xfail(reason="Wrong indices")
+    def test_array(self, data_for_compare: SparseArray, comparison_op):
+        arr = np.linspace(-4, 5, 10)
+        self._compare_other(data_for_compare, comparison_op, arr)
 
-        # series
-        ser = pd.Series(data)
-        result = op(ser, other)
-        tm.assert_series_equal(result, expected)
+    @pytest.mark.xfail(reason="Wrong indices")
+    def test_sparse_array(self, data_for_compare: SparseArray, comparison_op):
+        arr = data_for_compare + 1
+        self._compare_other(data_for_compare, comparison_op, arr)
+        arr = data_for_compare * 2
+        self._compare_other(data_for_compare, comparison_op, arr)
 
 
 class TestPrinting(BaseSparseTests, base.BasePrintingTests):
@@ -500,4 +524,5 @@ class TestParsing(BaseSparseTests, base.BaseParsingTests):
     def test_EA_types(self, engine, data):
         expected_msg = r".*must implement _from_sequence_of_strings.*"
         with pytest.raises(NotImplementedError, match=expected_msg):
-            super().test_EA_types(engine, data)
+            with tm.assert_produces_warning(FutureWarning, match="astype from"):
+                super().test_EA_types(engine, data)
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
index 4256142556894..73a2e01770028 100644
--- a/pandas/tests/extension/test_string.py
+++ b/pandas/tests/extension/test_string.py
@@ -18,9 +18,14 @@
 import numpy as np
 import pytest
 
-from pandas.compat import pa_version_under2p0
+from pandas.compat import (
+    pa_version_under6p0,
+    pa_version_under7p0,
+)
+from pandas.errors import PerformanceWarning
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import ArrowStringArray
 from pandas.core.arrays.string_ import StringDtype
 from pandas.tests.extension import base
@@ -28,7 +33,7 @@
 
 def split_array(arr):
     if arr.dtype.storage != "pyarrow":
-        pytest.skip("chunked array n/a")
+        pytest.skip("only applicable for pyarrow chunked array n/a")
 
     def _split_array(arr):
         import pyarrow as pa
@@ -141,7 +146,14 @@ class TestIndex(base.BaseIndexTests):
 
 
 class TestMissing(base.BaseMissingTests):
-    pass
+    def test_dropna_array(self, data_missing):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under6p0 and data_missing.dtype.storage == "pyarrow",
+        ):
+            result = data_missing.dropna()
+        expected = data_missing[[1]]
+        self.assert_extension_array_equal(result, expected)
 
 
 class TestNoReduce(base.BaseNoReduceTests):
@@ -158,13 +170,154 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
 
 
 class TestMethods(base.BaseMethodsTests):
-    @pytest.mark.skip(reason="returns nullable")
-    def test_value_counts(self, all_data, dropna):
-        return super().test_value_counts(all_data, dropna)
+    def test_argsort(self, data_for_sorting):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_argsort(data_for_sorting)
+
+    def test_argsort_missing(self, data_missing_for_sorting):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_missing_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_argsort_missing(data_missing_for_sorting)
+
+    def test_argmin_argmax(
+        self, data_for_sorting, data_missing_for_sorting, na_value, request
+    ):
+        if pa_version_under6p0 and data_missing_for_sorting.dtype.storage == "pyarrow":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason="min_max not supported in pyarrow",
+                )
+            )
+        super().test_argmin_argmax(data_for_sorting, data_missing_for_sorting, na_value)
+
+    @pytest.mark.parametrize(
+        "op_name, skipna, expected",
+        [
+            ("idxmax", True, 0),
+            ("idxmin", True, 2),
+            ("argmax", True, 0),
+            ("argmin", True, 2),
+            ("idxmax", False, np.nan),
+            ("idxmin", False, np.nan),
+            ("argmax", False, -1),
+            ("argmin", False, -1),
+        ],
+    )
+    def test_argreduce_series(
+        self, data_missing_for_sorting, op_name, skipna, expected, request
+    ):
+        if (
+            pa_version_under6p0
+            and data_missing_for_sorting.dtype.storage == "pyarrow"
+            and skipna
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason="min_max not supported in pyarrow",
+                )
+            )
+        super().test_argreduce_series(
+            data_missing_for_sorting, op_name, skipna, expected
+        )
+
+    @pytest.mark.parametrize("dropna", [True, False])
+    def test_value_counts(self, all_data, dropna, request):
+        all_data = all_data[:10]
+        if dropna:
+            other = all_data[~all_data.isna()]
+        else:
+            other = all_data
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(all_data.dtype, "storage", "") == "pyarrow"
+            and not (dropna and "data_missing" in request.node.nodeid),
+        ):
+            result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(other.dtype, "storage", "") == "pyarrow"
+            and not (dropna and "data_missing" in request.node.nodeid),
+        ):
+            expected = pd.Series(other).value_counts(dropna=dropna).sort_index()
 
-    @pytest.mark.skip(reason="returns nullable")
+        self.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:Falling back:pandas.errors.PerformanceWarning")
     def test_value_counts_with_normalize(self, data):
-        pass
+        super().test_value_counts_with_normalize(data)
+
+    def test_argsort_missing_array(self, data_missing_for_sorting):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_missing_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_argsort_missing(data_missing_for_sorting)
+
+    @pytest.mark.parametrize(
+        "na_position, expected",
+        [
+            ("last", np.array([2, 0, 1], dtype=np.dtype("intp"))),
+            ("first", np.array([1, 2, 0], dtype=np.dtype("intp"))),
+        ],
+    )
+    def test_nargsort(self, data_missing_for_sorting, na_position, expected):
+        # GH 25439
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_missing_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_nargsort(data_missing_for_sorting, na_position, expected)
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_values(self, data_for_sorting, ascending, sort_by_key):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_sort_values(data_for_sorting, ascending, sort_by_key)
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_values_missing(
+        self, data_missing_for_sorting, ascending, sort_by_key
+    ):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_missing_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_sort_values_missing(
+                data_missing_for_sorting, ascending, sort_by_key
+            )
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_values_frame(self, data_for_sorting, ascending):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_sorting.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_sort_values_frame(data_for_sorting, ascending)
 
 
 class TestCasting(base.BaseCastingTests):
@@ -192,12 +345,42 @@ class TestPrinting(base.BasePrintingTests):
 
 
 class TestGroupBy(base.BaseGroupbyTests):
-    def test_groupby_extension_transform(self, data_for_grouping, request):
-        if data_for_grouping.dtype.storage == "pyarrow" and pa_version_under2p0:
-            # failure observed in 1.0.1, not in 2.0 or later
-            mark = pytest.mark.xfail(reason="pyarrow raises in self._data[item]")
-            request.node.add_marker(mark)
-        super().test_groupby_extension_transform(data_for_grouping)
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_groupby_extension_agg(self, as_index, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_grouping.dtype, "storage", "") == "pyarrow",
+        ):
+            result = df.groupby("B", as_index=as_index).A.mean()
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_grouping.dtype, "storage", "") == "pyarrow",
+        ):
+            _, uniques = pd.factorize(data_for_grouping, sort=True)
+
+        if as_index:
+            index = pd.Index._with_infer(uniques, name="B")
+            expected = pd.Series([3.0, 1.0, 4.0], index=index, name="A")
+            self.assert_series_equal(result, expected)
+        else:
+            expected = pd.DataFrame({"B": uniques, "A": [3.0, 1.0, 4.0]})
+            self.assert_frame_equal(result, expected)
+
+    def test_groupby_extension_transform(self, data_for_grouping):
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            pa_version_under7p0
+            and getattr(data_for_grouping.dtype, "storage", "") == "pyarrow",
+            check_stacklevel=False,
+        ):
+            super().test_groupby_extension_transform(data_for_grouping)
+
+    @pytest.mark.filterwarnings("ignore:Falling back:pandas.errors.PerformanceWarning")
+    def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
+        super().test_groupby_extension_apply(data_for_grouping, groupby_apply_op)
 
 
 class Test2DCompat(base.Dim2CompatTests):
diff --git a/pandas/tests/frame/conftest.py b/pandas/tests/frame/conftest.py
index b512664b57ade..8dbed84b85837 100644
--- a/pandas/tests/frame/conftest.py
+++ b/pandas/tests/frame/conftest.py
@@ -212,7 +212,7 @@ def uint64_frame():
     Columns are ['A', 'B']
     """
     return DataFrame(
-        {"A": np.arange(3), "B": [2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10]}, dtype=np.uint64
+        {"A": np.arange(3), "B": [2**63, 2**63 + 5, 2**63 + 10]}, dtype=np.uint64
     )
 
 
diff --git a/pandas/tests/frame/constructors/test_from_dict.py b/pandas/tests/frame/constructors/test_from_dict.py
index 72107d849f598..7c2b009673bb7 100644
--- a/pandas/tests/frame/constructors/test_from_dict.py
+++ b/pandas/tests/frame/constructors/test_from_dict.py
@@ -17,11 +17,6 @@ class TestFromDict:
     # Note: these tests are specific to the from_dict method, not for
     #  passing dictionaries to DataFrame.__init__
 
-    def test_from_dict_scalars_requires_index(self):
-        msg = "If using all scalar values, you must pass an index"
-        with pytest.raises(ValueError, match=msg):
-            DataFrame.from_dict(OrderedDict([("b", 8), ("a", 5), ("a", 6)]))
-
     def test_constructor_list_of_odicts(self):
         data = [
             OrderedDict([["a", 1.5], ["b", 3], ["c", 4], ["d", 6]]),
@@ -189,3 +184,16 @@ def test_frame_dict_constructor_empty_series(self):
         # it works!
         DataFrame({"foo": s1, "bar": s2, "baz": s3})
         DataFrame.from_dict({"foo": s1, "baz": s3, "bar": s2})
+
+    def test_from_dict_scalars_requires_index(self):
+        msg = "If using all scalar values, you must pass an index"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame.from_dict(OrderedDict([("b", 8), ("a", 5), ("a", 6)]))
+
+    def test_from_dict_orient_invalid(self):
+        msg = (
+            "Expected 'index', 'columns' or 'tight' for orient parameter. "
+            "Got 'abc' instead"
+        )
+        with pytest.raises(ValueError, match=msg):
+            DataFrame.from_dict({"foo": 1, "baz": 3, "bar": 2}, orient="abc")
diff --git a/pandas/tests/frame/constructors/test_from_records.py b/pandas/tests/frame/constructors/test_from_records.py
index 4aa150afadef6..c6d54e28ca1c8 100644
--- a/pandas/tests/frame/constructors/test_from_records.py
+++ b/pandas/tests/frame/constructors/test_from_records.py
@@ -194,7 +194,7 @@ def test_from_records_bad_index_column(self):
 
     def test_from_records_non_tuple(self):
         class Record:
-            def __init__(self, *args):
+            def __init__(self, *args) -> None:
                 self.args = args
 
             def __getitem__(self, i):
diff --git a/pandas/tests/frame/indexing/test_coercion.py b/pandas/tests/frame/indexing/test_coercion.py
new file mode 100644
index 0000000000000..c970558162707
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_coercion.py
@@ -0,0 +1,188 @@
+"""
+Tests for values coercion in setitem-like operations on DataFrame.
+
+For the most part, these should be multi-column DataFrames, otherwise
+we would share the tests with Series.
+"""
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameSetitemCoercion:
+    @pytest.mark.xfail(reason="Unnecessary cast.")
+    @pytest.mark.parametrize("consolidate", [True, False])
+    def test_loc_setitem_multiindex_columns(self, consolidate):
+        # GH#18415 Setting values in a single column preserves dtype,
+        #  while setting them in multiple columns did unwanted cast.
+
+        # Note that A here has 2 blocks, below we do the same thing
+        #  with a consolidated frame.
+        A = DataFrame(np.zeros((6, 5), dtype=np.float32))
+        A = pd.concat([A, A], axis=1, keys=[1, 2])
+        if consolidate:
+            A = A._consolidate()
+
+        A.loc[2:3, (1, slice(2, 3))] = np.ones((2, 2), dtype=np.float32)
+        assert (A.dtypes == np.float32).all()
+
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            A.loc[0:5, (1, slice(2, 3))] = np.ones((6, 2), dtype=np.float32)
+
+        assert (A.dtypes == np.float32).all()
+
+        A.loc[:, (1, slice(2, 3))] = np.ones((6, 2), dtype=np.float32)
+        assert (A.dtypes == np.float32).all()
+
+        # TODO: i think this isn't about MultiIndex and could be done with iloc?
+
+
+def test_37477():
+    # fixed by GH#45121
+    orig = DataFrame({"A": [1, 2, 3], "B": [3, 4, 5]})
+    expected = DataFrame({"A": [1, 2, 3], "B": [3, 1.2, 5]})
+
+    df = orig.copy()
+    df.at[1, "B"] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    df.loc[1, "B"] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    df.iat[1, 1] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    df.iloc[1, 1] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+
+def test_6942(indexer_al):
+    # check that the .at __setitem__ after setting "Live" actually sets the data
+    start = Timestamp("2014-04-01")
+    t1 = Timestamp("2014-04-23 12:42:38.883082")
+    t2 = Timestamp("2014-04-24 01:33:30.040039")
+
+    dti = date_range(start, periods=1)
+    orig = DataFrame(index=dti, columns=["timenow", "Live"])
+
+    df = orig.copy()
+    indexer_al(df)[start, "timenow"] = t1
+
+    df["Live"] = True
+
+    df.at[start, "timenow"] = t2
+    assert df.iloc[0, 0] == t2
+
+
+def test_26395(indexer_al):
+    # .at case fixed by GH#45121 (best guess)
+    df = DataFrame(index=["A", "B", "C"])
+    df["D"] = 0
+
+    indexer_al(df)["C", "D"] = 2
+    expected = DataFrame({"D": [0, 0, 2]}, index=["A", "B", "C"], dtype=np.int64)
+    tm.assert_frame_equal(df, expected)
+
+    indexer_al(df)["C", "D"] = 44.5
+    expected = DataFrame({"D": [0, 0, 44.5]}, index=["A", "B", "C"], dtype=np.float64)
+    tm.assert_frame_equal(df, expected)
+
+    indexer_al(df)["C", "D"] = "hello"
+    expected = DataFrame({"D": [0, 0, "hello"]}, index=["A", "B", "C"], dtype=object)
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.xfail(reason="unwanted upcast")
+def test_15231():
+    df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"])
+    df.loc[2] = Series({"a": 5, "b": 6})
+    assert (df.dtypes == np.int64).all()
+
+    df.loc[3] = Series({"a": 7})
+
+    # df["a"] doesn't have any NaNs, should not have been cast
+    exp_dtypes = Series([np.int64, np.float64], dtype=object, index=["a", "b"])
+    tm.assert_series_equal(df.dtypes, exp_dtypes)
+
+
+@pytest.mark.xfail(reason="Unnecessarily upcasts to float64")
+def test_iloc_setitem_unnecesssary_float_upcasting():
+    # GH#12255
+    df = DataFrame(
+        {
+            0: np.array([1, 3], dtype=np.float32),
+            1: np.array([2, 4], dtype=np.float32),
+            2: ["a", "b"],
+        }
+    )
+    orig = df.copy()
+
+    values = df[0].values.reshape(2, 1)
+
+    msg = "will attempt to set the values inplace instead"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.iloc[:, 0:1] = values
+
+    tm.assert_frame_equal(df, orig)
+
+
+@pytest.mark.xfail(reason="unwanted casting to dt64")
+def test_12499():
+    # TODO: OP in GH#12499 used np.datetim64("NaT") instead of pd.NaT,
+    #  which has consequences for the expected df["two"] (though i think at
+    #  the time it might not have because of a separate bug). See if it makes
+    #  a difference which one we use here.
+    ts = Timestamp("2016-03-01 03:13:22.98986", tz="UTC")
+
+    data = [{"one": 0, "two": ts}]
+    orig = DataFrame(data)
+    df = orig.copy()
+    df.loc[1] = [np.nan, NaT]
+
+    expected = DataFrame(
+        {"one": [0, np.nan], "two": Series([ts, NaT], dtype="datetime64[ns, UTC]")}
+    )
+    tm.assert_frame_equal(df, expected)
+
+    data = [{"one": 0, "two": ts}]
+    df = orig.copy()
+    df.loc[1, :] = [np.nan, NaT]
+    tm.assert_frame_equal(df, expected)
+
+
+def test_20476():
+    mi = MultiIndex.from_product([["A", "B"], ["a", "b", "c"]])
+    df = DataFrame(-1, index=range(3), columns=mi)
+    filler = DataFrame([[1, 2, 3.0]] * 3, index=range(3), columns=["a", "b", "c"])
+    df["A"] = filler
+
+    expected = DataFrame(
+        {
+            0: [1, 1, 1],
+            1: [2, 2, 2],
+            2: [3.0, 3.0, 3.0],
+            3: [-1, -1, -1],
+            4: [-1, -1, -1],
+            5: [-1, -1, -1],
+        }
+    )
+    expected.columns = mi
+    exp_dtypes = Series(
+        [np.dtype(np.int64)] * 2 + [np.dtype(np.float64)] + [np.dtype(np.int64)] * 3,
+        index=mi,
+    )
+    tm.assert_series_equal(df.dtypes, exp_dtypes)
diff --git a/pandas/tests/frame/indexing/test_getitem.py b/pandas/tests/frame/indexing/test_getitem.py
index 0d4ab84175aab..f5c85bd98d8ad 100644
--- a/pandas/tests/frame/indexing/test_getitem.py
+++ b/pandas/tests/frame/indexing/test_getitem.py
@@ -8,12 +8,14 @@
     CategoricalDtype,
     CategoricalIndex,
     DataFrame,
+    DateOffset,
     DatetimeIndex,
     Index,
     MultiIndex,
     Series,
     Timestamp,
     concat,
+    date_range,
     get_dummies,
     period_range,
 )
@@ -72,6 +74,13 @@ def test_getitem_sparse_column_return_type_and_dtype(self):
         result = df.loc[:, "A"]
         tm.assert_series_equal(result, expected)
 
+    def test_getitem_string_columns(self):
+        # GH#46185
+        df = DataFrame([[1, 2]], columns=Index(["A", "B"], dtype="string"))
+        result = df.A
+        expected = df["A"]
+        tm.assert_series_equal(result, expected)
+
 
 class TestGetitemListLike:
     def test_getitem_list_missing_key(self):
@@ -165,6 +174,47 @@ def test_getitem_iloc_two_dimensional_generator(self):
         expected = Series([5, 6], name="b", index=[1, 2])
         tm.assert_series_equal(result, expected)
 
+    def test_getitem_iloc_dateoffset_days(self):
+        # GH 46671
+        df = DataFrame(
+            list(range(10)),
+            index=date_range("01-01-2022", periods=10, freq=DateOffset(days=1)),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        expected = DataFrame(
+            [0, 1, 2],
+            index=DatetimeIndex(
+                ["2022-01-01", "2022-01-02", "2022-01-03"],
+                dtype="datetime64[ns]",
+                freq=DateOffset(days=1),
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            list(range(10)),
+            index=date_range(
+                "01-01-2022", periods=10, freq=DateOffset(days=1, hours=2)
+            ),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        expected = DataFrame(
+            [0, 1, 2],
+            index=DatetimeIndex(
+                ["2022-01-01 00:00:00", "2022-01-02 02:00:00", "2022-01-03 04:00:00"],
+                dtype="datetime64[ns]",
+                freq=DateOffset(days=1, hours=2),
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            list(range(10)),
+            index=date_range("01-01-2022", periods=10, freq=DateOffset(minutes=3)),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        tm.assert_frame_equal(result, df)
+
 
 class TestGetitemCallable:
     def test_getitem_callable(self, float_frame):
@@ -350,6 +400,27 @@ def test_getitem_empty_frame_with_boolean(self):
         df2 = df[df > 0]
         tm.assert_frame_equal(df, df2)
 
+    def test_getitem_returns_view_when_column_is_unique_in_df(
+        self, using_copy_on_write
+    ):
+        # GH#45316
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+        df_orig = df.copy()
+        view = df["b"]
+        view.loc[:] = 100
+        if using_copy_on_write:
+            expected = df_orig
+        else:
+            expected = DataFrame([[1, 2, 100], [4, 5, 100]], columns=["a", "a", "b"])
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_frozenset_unique_in_column(self):
+        # GH#41062
+        df = DataFrame([[1, 2, 3, 4]], columns=[frozenset(["KEY"]), "B", "C", "C"])
+        result = df[frozenset(["KEY"])]
+        expected = Series([1], name=frozenset(["KEY"]))
+        tm.assert_series_equal(result, expected)
+
 
 class TestGetitemSlice:
     def test_getitem_slice_float64(self, frame_or_series):
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 8f9caf1cd13aa..e2a99348f45aa 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1,3 +1,4 @@
+from collections import namedtuple
 from datetime import (
     datetime,
     timedelta,
@@ -8,7 +9,10 @@
 import pytest
 
 from pandas._libs import iNaT
-from pandas.errors import InvalidIndexError
+from pandas.errors import (
+    InvalidIndexError,
+    SettingWithCopyError,
+)
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import is_integer
@@ -27,7 +31,6 @@
     notna,
 )
 import pandas._testing as tm
-import pandas.core.common as com
 
 # We pass through a TypeError raised by numpy
 _slice_msg = "slice indices must be integers or None or have an __index__ method"
@@ -195,17 +198,14 @@ def test_getitem_boolean_casting(self, datetime_frame):
         )
         tm.assert_series_equal(result, expected)
 
-    def test_getitem_boolean_list(self):
+    @pytest.mark.parametrize(
+        "lst", [[True, False, True], [True, True, True], [False, False, False]]
+    )
+    def test_getitem_boolean_list(self, lst):
         df = DataFrame(np.arange(12).reshape(3, 4))
-
-        def _checkit(lst):
-            result = df[lst]
-            expected = df.loc[df.index[lst]]
-            tm.assert_frame_equal(result, expected)
-
-        _checkit([True, False, True])
-        _checkit([True, True, True])
-        _checkit([False, False, False])
+        result = df[lst]
+        expected = df.loc[df.index[lst]]
+        tm.assert_frame_equal(result, expected)
 
     def test_getitem_boolean_iadd(self):
         arr = np.random.randn(5, 5)
@@ -270,7 +270,7 @@ def test_setattr_column(self):
         df.foobar = 5
         assert (df.foobar == 5).all()
 
-    def test_setitem(self, float_frame):
+    def test_setitem(self, float_frame, using_copy_on_write):
         # not sure what else to do here
         series = float_frame["A"][::2]
         float_frame["col5"] = series
@@ -306,8 +306,12 @@ def test_setitem(self, float_frame):
         smaller = float_frame[:2]
 
         msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            # With CoW, adding a new column doesn't raise a warning
             smaller["col10"] = ["1", "2"]
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                smaller["col10"] = ["1", "2"]
 
         assert smaller["col10"].dtype == np.object_
         assert (smaller["col10"] == ["1", "2"]).all()
@@ -537,22 +541,29 @@ def test_getitem_setitem_integer_slice_keyerrors(self):
             df2.loc[3:11] = 0
 
     @td.skip_array_manager_invalid_test  # already covered in test_iloc_col_slice_view
-    def test_fancy_getitem_slice_mixed(self, float_frame, float_string_frame):
+    def test_fancy_getitem_slice_mixed(
+        self, float_frame, float_string_frame, using_copy_on_write
+    ):
 
         sliced = float_string_frame.iloc[:, -3:]
         assert sliced["D"].dtype == np.float64
 
         # get view with single block
         # setting it triggers setting with copy
+        original = float_frame.copy()
         sliced = float_frame.iloc[:, -3:]
 
         assert np.shares_memory(sliced["C"]._values, float_frame["C"]._values)
 
         msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
-        with pytest.raises(com.SettingWithCopyError, match=msg):
-            sliced.loc[:, "C"] = 4.0
+        if not using_copy_on_write:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                sliced.loc[:, "C"] = 4.0
 
-        assert (float_frame["C"] == 4).all()
+            assert (float_frame["C"] == 4).all()
+        else:
+            sliced.loc[:, "C"] = 4.0
+            tm.assert_frame_equal(float_frame, original)
 
     def test_getitem_setitem_non_ix_labels(self):
         df = tm.makeTimeDataFrame()
@@ -691,7 +702,7 @@ def test_getitem_setitem_boolean_multi(self):
         expected.loc[[0, 2], [1]] = 5
         tm.assert_frame_equal(df, expected)
 
-    def test_getitem_setitem_float_labels(self):
+    def test_getitem_setitem_float_labels(self, using_array_manager):
         index = Index([1.5, 2, 3, 4, 5])
         df = DataFrame(np.random.randn(5, 5), index=index)
 
@@ -774,7 +785,10 @@ def test_getitem_setitem_float_labels(self):
         assert len(result) == 5
 
         cp = df.copy()
-        cp.loc[1.0:5.0] = 0
+        warn = DeprecationWarning if using_array_manager else None
+        msg = "will attempt to set the values inplace"
+        with tm.assert_produces_warning(warn, match=msg):
+            cp.loc[1.0:5.0] = 0
         result = cp.loc[1.0:5.0]
         assert (result == 0).values.all()
 
@@ -992,7 +1006,7 @@ def test_iloc_row(self):
         expected = df.reindex(df.index[[1, 2, 4, 6]])
         tm.assert_frame_equal(result, expected)
 
-    def test_iloc_row_slice_view(self, using_array_manager):
+    def test_iloc_row_slice_view(self, using_array_manager, using_copy_on_write):
         df = DataFrame(np.random.randn(10, 4), index=range(0, 20, 2))
         original = df.copy()
 
@@ -1002,14 +1016,17 @@ def test_iloc_row_slice_view(self, using_array_manager):
 
         assert np.shares_memory(df[2], subset[2])
 
+        exp_col = original[2].copy()
         msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
             subset.loc[:, 2] = 0.0
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                subset.loc[:, 2] = 0.0
 
-        exp_col = original[2].copy()
-        # TODO(ArrayManager) verify it is expected that the original didn't change
-        if not using_array_manager:
-            exp_col[4:8] = 0.0
+            # TODO(ArrayManager) verify it is expected that the original didn't change
+            if not using_array_manager:
+                exp_col._values[4:8] = 0.0
         tm.assert_series_equal(df[2], exp_col)
 
     def test_iloc_col(self):
@@ -1034,24 +1051,25 @@ def test_iloc_col(self):
         expected = df.reindex(columns=df.columns[[1, 2, 4, 6]])
         tm.assert_frame_equal(result, expected)
 
-    def test_iloc_col_slice_view(self, using_array_manager):
+    def test_iloc_col_slice_view(self, using_array_manager, using_copy_on_write):
         df = DataFrame(np.random.randn(4, 10), columns=range(0, 20, 2))
         original = df.copy()
         subset = df.iloc[:, slice(4, 8)]
 
-        if not using_array_manager:
+        if not using_array_manager and not using_copy_on_write:
             # verify slice is view
-
             assert np.shares_memory(df[8]._values, subset[8]._values)
 
             # and that we are setting a copy
             msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            with pytest.raises(SettingWithCopyError, match=msg):
                 subset.loc[:, 8] = 0.0
 
             assert (df[8] == 0).all()
         else:
-            # TODO(ArrayManager) verify this is the desired behaviour
+            if using_copy_on_write:
+                # verify slice is view
+                assert np.shares_memory(df[8]._values, subset[8]._values)
             subset[8] = 0.0
             # subset changed
             assert (subset[8] == 0).all()
@@ -1212,8 +1230,6 @@ def test_setitem_array_as_cell_value(self):
         expected = DataFrame({"a": [np.zeros((2,))], "b": [np.zeros((2, 2))]})
         tm.assert_frame_equal(df, expected)
 
-    # with AM goes through split-path, loses dtype
-    @td.skip_array_manager_not_yet_implemented
     def test_iloc_setitem_nullable_2d_values(self):
         df = DataFrame({"A": [1, 2, 3]}, dtype="Int64")
         orig = df.copy()
@@ -1227,6 +1243,13 @@ def test_iloc_setitem_nullable_2d_values(self):
         df.iloc[:] = df.iloc[:, :]
         tm.assert_frame_equal(df, orig)
 
+    def test_getitem_segfault_with_empty_like_object(self):
+        # GH#46848
+        df = DataFrame(np.empty((1, 1), dtype=object))
+        df[0] = np.empty_like(df[0])
+        # this produces the segfault
+        df[[0]]
+
     @pytest.mark.parametrize(
         "null", [pd.NaT, pd.NaT.to_numpy("M8[ns]"), pd.NaT.to_numpy("m8[ns]")]
     )
@@ -1240,12 +1263,10 @@ def test_setting_mismatched_na_into_nullable_fails(
 
         msg = "|".join(
             [
-                r"int\(\) argument must be a string, a bytes-like object or a "
-                "(real )?number, not 'NaTType'",
-                r"timedelta64\[ns\] cannot be converted to an? (Floating|Integer)Dtype",
-                r"datetime64\[ns\] cannot be converted to an? (Floating|Integer)Dtype",
-                "object cannot be converted to a FloatingDtype",
+                r"timedelta64\[ns\] cannot be converted to (Floating|Integer)Dtype",
+                r"datetime64\[ns\] cannot be converted to (Floating|Integer)Dtype",
                 "'values' contains non-numeric NA",
+                r"Invalid value '.*' for dtype (U?Int|Float)\d{1,2}",
             ]
         )
         with pytest.raises(TypeError, match=msg):
@@ -1281,6 +1302,127 @@ def test_setting_mismatched_na_into_nullable_fails(
         with pytest.raises(TypeError, match=msg):
             df2.iloc[:2, 0] = [null, null]
 
+    def test_loc_expand_empty_frame_keep_index_name(self):
+        # GH#45621
+        df = DataFrame(columns=["b"], index=Index([], name="a"))
+        df.loc[0] = 1
+        expected = DataFrame({"b": [1]}, index=Index([0], name="a"))
+        tm.assert_frame_equal(df, expected)
+
+    def test_loc_expand_empty_frame_keep_midx_names(self):
+        # GH#46317
+        df = DataFrame(
+            columns=["d"], index=MultiIndex.from_tuples([], names=["a", "b", "c"])
+        )
+        df.loc[(1, 2, 3)] = "foo"
+        expected = DataFrame(
+            {"d": ["foo"]},
+            index=MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"]),
+        )
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("val", ["x", 1])
+    @pytest.mark.parametrize("idxr", ["a", ["a"]])
+    def test_loc_setitem_rhs_frame(self, idxr, val):
+        # GH#47578
+        df = DataFrame({"a": [1, 2]})
+        with tm.assert_produces_warning(None):
+            df.loc[:, idxr] = DataFrame({"a": [val, 11]}, index=[1, 2])
+        expected = DataFrame({"a": [np.nan, val]})
+        tm.assert_frame_equal(df, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_iloc_setitem_enlarge_no_warning(self):
+        # GH#47381
+        df = DataFrame(columns=["a", "b"])
+        expected = df.copy()
+        view = df[:]
+        with tm.assert_produces_warning(None):
+            df.iloc[:, 0] = np.array([1, 2], dtype=np.float64)
+        tm.assert_frame_equal(view, expected)
+
+    def test_loc_internals_not_updated_correctly(self):
+        # GH#47867 all steps are necessary to reproduce the initial bug
+        df = DataFrame(
+            {"bool_col": True, "a": 1, "b": 2.5},
+            index=MultiIndex.from_arrays([[1, 2], [1, 2]], names=["idx1", "idx2"]),
+        )
+        idx = [(1, 1)]
+
+        df["c"] = 3
+        df.loc[idx, "c"] = 0
+
+        df.loc[idx, "c"]
+        df.loc[idx, ["a", "b"]]
+
+        df.loc[idx, "c"] = 15
+        result = df.loc[idx, "c"]
+        expected = df = Series(
+            15,
+            index=MultiIndex.from_arrays([[1], [1]], names=["idx1", "idx2"]),
+            name="c",
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [None, [None], pd.NA, [pd.NA]])
+    def test_iloc_setitem_string_list_na(self, val):
+        # GH#45469
+        df = DataFrame({"a": ["a", "b", "c"]}, dtype="string")
+        df.iloc[[0], :] = val
+        expected = DataFrame({"a": [pd.NA, "b", "c"]}, dtype="string")
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("val", [None, pd.NA])
+    def test_iloc_setitem_string_na(self, val):
+        # GH#45469
+        df = DataFrame({"a": ["a", "b", "c"]}, dtype="string")
+        df.iloc[0, :] = val
+        expected = DataFrame({"a": [pd.NA, "b", "c"]}, dtype="string")
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("func", [list, Series, np.array])
+    def test_iloc_setitem_ea_null_slice_length_one_list(self, func):
+        # GH#48016
+        df = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+        df.iloc[:, func([0])] = 5
+        expected = DataFrame({"a": [5, 5, 5]}, dtype="Int64")
+        tm.assert_frame_equal(df, expected)
+
+    def test_loc_named_tuple_for_midx(self):
+        # GH#48124
+        df = DataFrame(
+            index=MultiIndex.from_product(
+                [["A", "B"], ["a", "b", "c"]], names=["first", "second"]
+            )
+        )
+        indexer_tuple = namedtuple("Indexer", df.index.names)
+        idxr = indexer_tuple(first="A", second=["a", "b"])
+        result = df.loc[idxr, :]
+        expected = DataFrame(
+            index=MultiIndex.from_tuples(
+                [("A", "a"), ("A", "b")], names=["first", "second"]
+            )
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("col", [{}, {"name": "a"}])
+    def test_loc_setitem_reordering_with_all_true_indexer(self, col):
+        # GH#48701
+        n = 17
+        df = DataFrame({**col, "x": range(n), "y": range(n)})
+        expected = df.copy()
+        df.loc[n * [True], ["x", "y"]] = df[["x", "y"]]
+        tm.assert_frame_equal(df, expected)
+
+    def test_loc_rhs_empty_warning(self):
+        # GH48480
+        df = DataFrame(columns=["a", "b"])
+        expected = df.copy()
+        rhs = DataFrame(columns=["a"])
+        with tm.assert_produces_warning(None):
+            df.loc[:, "a"] = rhs
+        tm.assert_frame_equal(df, expected)
+
 
 class TestDataFrameIndexingUInt64:
     def test_setitem(self, uint64_frame):
@@ -1343,7 +1485,7 @@ def test_object_casting_indexing_wraps_datetimelike(using_array_manager):
 
     mgr = df._mgr
     mgr._rebuild_blknos_and_blklocs()
-    arr = mgr.fast_xs(0)
+    arr = mgr.fast_xs(0).array
     assert isinstance(arr[1], Timestamp)
     assert isinstance(arr[2], pd.Timedelta)
 
@@ -1528,6 +1670,33 @@ def test_loc_iloc_setitem_non_categorical_rhs(
         with pytest.raises(TypeError, match=msg1):
             indexer(df)[key] = ["c", "c"]
 
+    @pytest.mark.parametrize("indexer", [tm.getitem, tm.loc, tm.iloc])
+    def test_getitem_preserve_object_index_with_dates(self, indexer):
+        # https://github.com/pandas-dev/pandas/pull/42950 - when selecting a column
+        # from dataframe, don't try to infer object dtype index on Series construction
+        idx = date_range("2012", periods=3).astype(object)
+        df = DataFrame({0: [1, 2, 3]}, index=idx)
+        assert df.index.dtype == object
+
+        if indexer is tm.getitem:
+            ser = indexer(df)[0]
+        else:
+            ser = indexer(df)[:, 0]
+
+        assert ser.index.dtype == object
+
+    def test_loc_on_multiindex_one_level(self):
+        # GH#45779
+        df = DataFrame(
+            data=[[0], [1]],
+            index=MultiIndex.from_tuples([("a",), ("b",)], names=["first"]),
+        )
+        expected = DataFrame(
+            data=[[0]], index=MultiIndex.from_tuples([("a",)], names=["first"])
+        )
+        result = df.loc["a"]
+        tm.assert_frame_equal(result, expected)
+
 
 class TestDepreactedIndexers:
     @pytest.mark.parametrize(
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index cd0a0a0467742..e33c6d6a805cf 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -57,7 +57,9 @@ class mystring(str):
         expected = DataFrame({"a": [1], "b": [2], mystring("c"): [3]}, index=index)
         tm.assert_equal(df, expected)
 
-    @pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"])
+    @pytest.mark.parametrize(
+        "dtype", ["int32", "int64", "uint32", "uint64", "float32", "float64"]
+    )
     def test_setitem_dtype(self, dtype, float_frame):
         arr = np.random.randn(len(float_frame))
 
@@ -89,8 +91,8 @@ def test_setitem_error_msmgs(self):
         # GH 4107, more descriptive error message
         df = DataFrame(np.random.randint(0, 2, (4, 4)), columns=["a", "b", "c", "d"])
 
-        msg = "incompatible index of inserted column with frame index"
-        with pytest.raises(TypeError, match=msg):
+        msg = "Cannot set a DataFrame with multiple columns to the single column gr"
+        with pytest.raises(ValueError, match=msg):
             df["gr"] = df.groupby(["b", "c"]).count()
 
     def test_setitem_benchmark(self):
@@ -210,6 +212,7 @@ def test_setitem_dict_preserves_dtypes(self):
                 "a": Series([0, 1, 2], dtype="int64"),
                 "b": Series([1, 2, 3], dtype=float),
                 "c": Series([1, 2, 3], dtype=float),
+                "d": Series([1, 2, 3], dtype="uint32"),
             }
         )
         df = DataFrame(
@@ -217,10 +220,16 @@ def test_setitem_dict_preserves_dtypes(self):
                 "a": Series([], dtype="int64"),
                 "b": Series([], dtype=float),
                 "c": Series([], dtype=float),
+                "d": Series([], dtype="uint32"),
             }
         )
         for idx, b in enumerate([1, 2, 3]):
-            df.loc[df.shape[0]] = {"a": int(idx), "b": float(b), "c": float(b)}
+            df.loc[df.shape[0]] = {
+                "a": int(idx),
+                "b": float(b),
+                "c": float(b),
+                "d": np.uint32(b),
+            }
         tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize(
@@ -397,12 +406,16 @@ def test_setitem_frame_length_0_str_key(self, indexer):
         expected["A"] = expected["A"].astype("object")
         tm.assert_frame_equal(df, expected)
 
-    def test_setitem_frame_duplicate_columns(self, using_array_manager, request):
+    def test_setitem_frame_duplicate_columns(self, using_array_manager):
         # GH#15695
+        warn = DeprecationWarning if using_array_manager else None
+        msg = "will attempt to set the values inplace"
+
         cols = ["A", "B", "C"] * 2
         df = DataFrame(index=range(3), columns=cols)
         df.loc[0, "A"] = (0, 3)
-        df.loc[:, "B"] = (1, 4)
+        with tm.assert_produces_warning(warn, match=msg):
+            df.loc[:, "B"] = (1, 4)
         df["C"] = (2, 5)
         expected = DataFrame(
             [
@@ -421,10 +434,6 @@ def test_setitem_frame_duplicate_columns(self, using_array_manager, request):
             # TODO(ArrayManager) .loc still overwrites
             expected["B"] = expected["B"].astype("int64")
 
-            mark = pytest.mark.xfail(
-                reason="Both 'A' columns get set with 3 instead of 0 and 3"
-            )
-            request.node.add_marker(mark)
         else:
             # set these with unique columns to be extra-unambiguous
             expected[2] = expected[2].astype(np.int64)
@@ -680,6 +689,13 @@ def test_boolean_mask_nullable_int64(self):
         )
         tm.assert_frame_equal(result, expected)
 
+    def test_setitem_ea_dtype_rhs_series(self):
+        # GH#47425
+        df = DataFrame({"a": [1, 2]})
+        df["a"] = Series([1, 2], dtype="Int64")
+        expected = DataFrame({"a": [1, 2]}, dtype="Int64")
+        tm.assert_frame_equal(df, expected)
+
     # TODO(ArrayManager) set column with 2d column array, see #44788
     @td.skip_array_manager_not_yet_implemented
     def test_setitem_npmatrix_2d(self):
@@ -699,6 +715,41 @@ def test_setitem_npmatrix_2d(self):
 
         tm.assert_frame_equal(df, expected)
 
+    @pytest.mark.parametrize("vals", [{}, {"d": "a"}])
+    def test_setitem_aligning_dict_with_index(self, vals):
+        # GH#47216
+        df = DataFrame({"a": [1, 2], "b": [3, 4], **vals})
+        df.loc[:, "a"] = {1: 100, 0: 200}
+        df.loc[:, "c"] = {0: 5, 1: 6}
+        df.loc[:, "e"] = {1: 5}
+        expected = DataFrame(
+            {"a": [200, 100], "b": [3, 4], **vals, "c": [5, 6], "e": [np.nan, 5]}
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_setitem_rhs_dataframe(self):
+        # GH#47578
+        df = DataFrame({"a": [1, 2]})
+        df["a"] = DataFrame({"a": [10, 11]}, index=[1, 2])
+        expected = DataFrame({"a": [np.nan, 10]})
+        tm.assert_frame_equal(df, expected)
+
+        df = DataFrame({"a": [1, 2]})
+        df.isetitem(0, DataFrame({"a": [10, 11]}, index=[1, 2]))
+        tm.assert_frame_equal(df, expected)
+
+    def test_setitem_frame_overwrite_with_ea_dtype(self, any_numeric_ea_dtype):
+        # GH#46896
+        df = DataFrame(columns=["a", "b"], data=[[1, 2], [3, 4]])
+        df["a"] = DataFrame({"a": [10, 11]}, dtype=any_numeric_ea_dtype)
+        expected = DataFrame(
+            {
+                "a": Series([10, 11], dtype=any_numeric_ea_dtype),
+                "b": [2, 4],
+            }
+        )
+        tm.assert_frame_equal(df, expected)
+
 
 class TestSetitemTZAwareValues:
     @pytest.fixture
@@ -747,7 +798,7 @@ def test_setitem_object_array_of_tzaware_datetimes(self, idx, expected):
 
 
 class TestDataFrameSetItemWithExpansion:
-    def test_setitem_listlike_views(self):
+    def test_setitem_listlike_views(self, using_copy_on_write):
         # GH#38148
         df = DataFrame({"a": [1, 2, 3], "b": [4, 4, 6]})
 
@@ -760,7 +811,10 @@ def test_setitem_listlike_views(self):
         # edit in place the first column to check view semantics
         df.iloc[0, 0] = 100
 
-        expected = Series([100, 2, 3], name="a")
+        if using_copy_on_write:
+            expected = Series([1, 2, 3], name="a")
+        else:
+            expected = Series([100, 2, 3], name="a")
         tm.assert_series_equal(ser, expected)
 
     def test_setitem_string_column_numpy_dtype_raising(self):
@@ -770,7 +824,7 @@ def test_setitem_string_column_numpy_dtype_raising(self):
         expected = DataFrame([[1, 2, 5], [3, 4, 6]], columns=[0, 1, "0 - Name"])
         tm.assert_frame_equal(df, expected)
 
-    def test_setitem_empty_df_duplicate_columns(self):
+    def test_setitem_empty_df_duplicate_columns(self, using_copy_on_write):
         # GH#38521
         df = DataFrame(columns=["a", "b", "b"], dtype="float64")
         df.loc[:, "a"] = list(range(2))
@@ -852,6 +906,28 @@ def test_frame_setitem_newcol_timestamp(self):
         data[ts] = np.nan  # works, mostly a smoke-test
         assert np.isnan(data[ts]).all()
 
+    def test_frame_setitem_rangeindex_into_new_col(self):
+        # GH#47128
+        df = DataFrame({"a": ["a", "b"]})
+        df["b"] = df.index
+        df.loc[[False, True], "b"] = 100
+        result = df.loc[[1], :]
+        expected = DataFrame({"a": ["b"], "b": [100]}, index=[1])
+        tm.assert_frame_equal(result, expected)
+
+    def test_setitem_frame_keep_ea_dtype(self, any_numeric_ea_dtype):
+        # GH#46896
+        df = DataFrame(columns=["a", "b"], data=[[1, 2], [3, 4]])
+        df["c"] = DataFrame({"a": [10, 11]}, dtype=any_numeric_ea_dtype)
+        expected = DataFrame(
+            {
+                "a": [1, 3],
+                "b": [2, 4],
+                "c": Series([10, 11], dtype=any_numeric_ea_dtype),
+            }
+        )
+        tm.assert_frame_equal(df, expected)
+
 
 class TestDataFrameSetItemSlicing:
     def test_setitem_slice_position(self):
@@ -1058,7 +1134,9 @@ def test_setitem_always_copy(self, float_frame):
         assert notna(s[5:10]).all()
 
     @pytest.mark.parametrize("consolidate", [True, False])
-    def test_setitem_partial_column_inplace(self, consolidate, using_array_manager):
+    def test_setitem_partial_column_inplace(
+        self, consolidate, using_array_manager, using_copy_on_write
+    ):
         # This setting should be in-place, regardless of whether frame is
         #  single-block or multi-block
         # GH#304 this used to be incorrectly not-inplace, in which case
@@ -1083,10 +1161,9 @@ def test_setitem_partial_column_inplace(self, consolidate, using_array_manager):
         tm.assert_series_equal(df["z"], expected)
 
         # check setting occurred in-place
-        tm.assert_numpy_array_equal(zvals, expected.values)
-        assert np.shares_memory(zvals, df["z"]._values)
-        if not consolidate:
-            assert df["z"]._values is zvals
+        if not using_copy_on_write:
+            tm.assert_numpy_array_equal(zvals, expected.values)
+            assert np.shares_memory(zvals, df["z"]._values)
 
     def test_setitem_duplicate_columns_not_inplace(self):
         # GH#39510
@@ -1103,7 +1180,7 @@ def test_setitem_duplicate_columns_not_inplace(self):
     @pytest.mark.parametrize(
         "value", [1, np.array([[1], [1]], dtype="int64"), [[1], [1]]]
     )
-    def test_setitem_same_dtype_not_inplace(self, value, using_array_manager, request):
+    def test_setitem_same_dtype_not_inplace(self, value, using_array_manager):
         # GH#39510
         cols = ["A", "B"]
         df = DataFrame(0, index=[0, 1], columns=cols)
@@ -1158,3 +1235,21 @@ def test_setitem_not_operating_inplace(self, value, set_value, indexer):
         view = df[:]
         df[indexer] = set_value
         tm.assert_frame_equal(view, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_setitem_column_update_inplace(self, using_copy_on_write):
+        # https://github.com/pandas-dev/pandas/issues/47172
+
+        labels = [f"c{i}" for i in range(10)]
+        df = DataFrame({col: np.zeros(len(labels)) for col in labels}, index=labels)
+        values = df._mgr.blocks[0].values
+
+        for label in df.columns:
+            df[label][label] = 1
+
+        if not using_copy_on_write:
+            # diagonal values all updated
+            assert np.all(values[np.arange(10), np.arange(10)] == 1)
+        else:
+            # original dataframe not updated
+            assert np.all(values[np.arange(10), np.arange(10)] == 0)
diff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py
index 197c3ac9bd225..c7e0a10c0d7d0 100644
--- a/pandas/tests/frame/indexing/test_where.py
+++ b/pandas/tests/frame/indexing/test_where.py
@@ -1,20 +1,16 @@
 from datetime import datetime
 
-from hypothesis import (
-    given,
-    settings,
-)
+from hypothesis import given
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p19
-
 from pandas.core.dtypes.common import is_scalar
 
 import pandas as pd
 from pandas import (
     DataFrame,
     DatetimeIndex,
+    Index,
     Series,
     StringDtype,
     Timestamp,
@@ -98,7 +94,7 @@ def test_where_upcasting(self):
 
         tm.assert_series_equal(result, expected)
 
-    def test_where_alignment(self, where_frame, float_string_frame, mixed_int_frame):
+    def test_where_alignment(self, where_frame, float_string_frame):
         # aligning
         def _check_align(df, cond, other, check_dtypes=True):
             rs = df.where(cond, other)
@@ -141,11 +137,7 @@ def _check_align(df, cond, other, check_dtypes=True):
 
         # check other is ndarray
         cond = df > 0
-        warn = None
-        if df is mixed_int_frame:
-            warn = FutureWarning
-        with tm.assert_produces_warning(warn, match="Downcasting integer-dtype"):
-            _check_align(df, cond, (_safe_add(df).values))
+        _check_align(df, cond, (_safe_add(df).values))
 
         # integers are upcast, so don't check the dtypes
         cond = df > 0
@@ -371,7 +363,7 @@ def test_where_bug_transposition(self):
         result = a.where(do_not_replace, b)
         tm.assert_frame_equal(result, expected)
 
-    def test_where_datetime(self):
+    def test_where_datetime(self, using_array_manager):
 
         # GH 3311
         df = DataFrame(
@@ -391,7 +383,11 @@ def test_where_datetime(self):
 
         expected = df.copy()
         expected.loc[[0, 1], "A"] = np.nan
-        expected.loc[:, "C"] = np.nan
+
+        warn = DeprecationWarning if using_array_manager else None
+        msg = "will attempt to set the values inplace"
+        with tm.assert_produces_warning(warn, match=msg):
+            expected.loc[:, "C"] = np.nan
         tm.assert_frame_equal(result, expected)
 
     def test_where_none(self):
@@ -469,44 +465,43 @@ def test_where_axis(self, using_array_manager):
         # GH 9736
         df = DataFrame(np.random.randn(2, 2))
         mask = DataFrame([[False, False], [False, False]])
-        s = Series([0, 1])
+        ser = Series([0, 1])
 
         expected = DataFrame([[0, 0], [1, 1]], dtype="float64")
-        result = df.where(mask, s, axis="index")
+        result = df.where(mask, ser, axis="index")
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        return_value = result.where(mask, s, axis="index", inplace=True)
+        return_value = result.where(mask, ser, axis="index", inplace=True)
         assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame([[0, 1], [0, 1]], dtype="float64")
-        result = df.where(mask, s, axis="columns")
+        result = df.where(mask, ser, axis="columns")
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        return_value = result.where(mask, s, axis="columns", inplace=True)
+        return_value = result.where(mask, ser, axis="columns", inplace=True)
         assert return_value is None
         tm.assert_frame_equal(result, expected)
 
+    def test_where_axis_with_upcast(self):
         # Upcast needed
         df = DataFrame([[1, 2], [3, 4]], dtype="int64")
         mask = DataFrame([[False, False], [False, False]])
-        s = Series([0, np.nan])
+        ser = Series([0, np.nan])
 
         expected = DataFrame([[0, 0], [np.nan, np.nan]], dtype="float64")
-        result = df.where(mask, s, axis="index")
+        result = df.where(mask, ser, axis="index")
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        return_value = result.where(mask, s, axis="index", inplace=True)
+        return_value = result.where(mask, ser, axis="index", inplace=True)
         assert return_value is None
         tm.assert_frame_equal(result, expected)
 
-        warn = FutureWarning if using_array_manager else None
         expected = DataFrame([[0, np.nan], [0, np.nan]])
-        with tm.assert_produces_warning(warn, match="Downcasting integer-dtype"):
-            result = df.where(mask, s, axis="columns")
+        result = df.where(mask, ser, axis="columns")
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
@@ -516,11 +511,11 @@ def test_where_axis(self, using_array_manager):
             }
         )
         result = df.copy()
-        return_value = result.where(mask, s, axis="columns", inplace=True)
+        return_value = result.where(mask, ser, axis="columns", inplace=True)
         assert return_value is None
         tm.assert_frame_equal(result, expected)
 
-    def test_where_axis_multiple_dtypes(self):
+    def test_where_axis_multiple_dtypes(self, using_array_manager):
         # Multiple dtypes (=> multiple Blocks)
         df = pd.concat(
             [
@@ -576,7 +571,10 @@ def test_where_axis_multiple_dtypes(self):
 
         d2 = df.copy().drop(1, axis=1)
         expected = df.copy()
-        expected.loc[:, 1] = np.nan
+        warn = DeprecationWarning if using_array_manager else None
+        msg = "will attempt to set the values inplace"
+        with tm.assert_produces_warning(warn, match=msg):
+            expected.loc[:, 1] = np.nan
 
         result = df.where(mask, d2)
         tm.assert_frame_equal(result, expected)
@@ -711,6 +709,20 @@ def test_where_interval_noop(self):
         res = ser.where(ser.notna())
         tm.assert_series_equal(res, ser)
 
+    def test_where_interval_fullop_downcast(self, frame_or_series):
+        # GH#45768
+        obj = frame_or_series([pd.Interval(0, 0)] * 2)
+        other = frame_or_series([1.0, 2.0])
+        res = obj.where(~obj.notna(), other)
+
+        # since all entries are being changed, we will downcast result
+        #  from object to ints (not floats)
+        tm.assert_equal(res, other.astype(np.int64))
+
+        # unlike where, Block.putmask does not downcast
+        obj.mask(obj.notna(), other, inplace=True)
+        tm.assert_equal(obj, other.astype(object))
+
     @pytest.mark.parametrize(
         "dtype",
         [
@@ -724,7 +736,7 @@ def test_where_datetimelike_noop(self, dtype):
         # GH#45135, analogue to GH#44181 for Period don't raise on no-op
         # For td64/dt64/dt64tz we already don't raise, but also are
         #  checking that we don't unnecessarily upcast to object.
-        ser = Series(np.arange(3) * 10 ** 9, dtype=np.int64).view(dtype)
+        ser = Series(np.arange(3) * 10**9, dtype=np.int64).view(dtype)
         df = ser.to_frame()
         mask = np.array([False, False, False])
 
@@ -741,6 +753,16 @@ def test_where_datetimelike_noop(self, dtype):
         res4 = df.mask(mask2, "foo")
         tm.assert_frame_equal(res4, df)
 
+        # opposite case where we are replacing *all* values -> we downcast
+        #  from object dtype # GH#45768
+        res5 = df.where(mask2, 4)
+        expected = DataFrame(4, index=df.index, columns=df.columns)
+        tm.assert_frame_equal(res5, expected)
+
+        # unlike where, Block.putmask does not downcast
+        df.mask(~mask2, 4, inplace=True)
+        tm.assert_frame_equal(df, expected.astype(object))
+
 
 def test_where_try_cast_deprecated(frame_or_series):
     obj = DataFrame(np.random.randn(4, 3))
@@ -753,7 +775,7 @@ def test_where_try_cast_deprecated(frame_or_series):
         obj.where(mask, -1, try_cast=False)
 
 
-def test_where_int_downcasting_deprecated(using_array_manager):
+def test_where_int_downcasting_deprecated():
     # GH#44597
     arr = np.arange(6).astype(np.int16).reshape(3, 2)
     df = DataFrame(arr)
@@ -761,12 +783,9 @@ def test_where_int_downcasting_deprecated(using_array_manager):
     mask = np.zeros(arr.shape, dtype=bool)
     mask[:, 0] = True
 
-    msg = "Downcasting integer-dtype"
-    warn = FutureWarning if not using_array_manager else None
-    with tm.assert_produces_warning(warn, match=msg):
-        res = df.where(mask, 2 ** 17)
+    res = df.where(mask, 2**17)
 
-    expected = DataFrame({0: arr[:, 0], 1: np.array([2 ** 17] * 3, dtype=np.int32)})
+    expected = DataFrame({0: arr[:, 0], 1: np.array([2**17] * 3, dtype=np.int32)})
     tm.assert_frame_equal(res, expected)
 
 
@@ -805,6 +824,12 @@ def test_where_string_dtype(frame_or_series):
     )
     tm.assert_equal(result, expected)
 
+    result = obj.mask(~filter_ser, filtered_obj)
+    tm.assert_equal(result, expected)
+
+    obj.mask(~filter_ser, filtered_obj, inplace=True)
+    tm.assert_equal(result, expected)
+
 
 def test_where_bool_comparison():
     # GH 10336
@@ -834,6 +859,21 @@ def test_where_none_nan_coerce():
     tm.assert_frame_equal(result, expected)
 
 
+def test_where_duplicate_axes_mixed_dtypes():
+    # GH 25399, verify manually masking is not affected anymore by dtype of column for
+    # duplicate axes.
+    result = DataFrame(data=[[0, np.nan]], columns=Index(["A", "A"]))
+    index, columns = result.axes
+    mask = DataFrame(data=[[True, True]], columns=columns, index=index)
+    a = result.astype(object).where(mask)
+    b = result.astype("f8").where(mask)
+    c = result.T.where(mask.T).T
+    d = result.where(mask)  # used to fail with "cannot reindex from a duplicate axis"
+    tm.assert_frame_equal(a.astype("f8"), b.astype("f8"))
+    tm.assert_frame_equal(b.astype("f8"), c.astype("f8"))
+    tm.assert_frame_equal(c.astype("f8"), d.astype("f8"))
+
+
 def test_where_non_keyword_deprecation(frame_or_series):
     # GH 41485
     obj = frame_or_series(range(5))
@@ -876,21 +916,32 @@ def test_where_period_invalid_na(frame_or_series, as_cat, request):
             r"Cannot setitem on a Categorical with a new category \(NaT\), "
             "set the categories first"
         )
-        if np_version_under1p19:
-            mark = pytest.mark.xfail(
-                reason="When evaluating the f-string to generate the exception "
-                "message, numpy somehow ends up trying to cast None to int, so "
-                "ends up raising TypeError but with an unrelated message."
-            )
-            request.node.add_marker(mark)
     else:
         msg = "value should be a 'Period'"
 
-    with pytest.raises(TypeError, match=msg):
-        obj.where(mask, tdnat)
+    if as_cat:
+        with pytest.raises(TypeError, match=msg):
+            obj.where(mask, tdnat)
+
+        with pytest.raises(TypeError, match=msg):
+            obj.mask(mask, tdnat)
+
+        with pytest.raises(TypeError, match=msg):
+            obj.mask(mask, tdnat, inplace=True)
+
+    else:
+        # With PeriodDtype, ser[i] = tdnat coerces instead of raising,
+        #  so for consistency, ser[mask] = tdnat must as well
+        expected = obj.astype(object).where(mask, tdnat)
+        result = obj.where(mask, tdnat)
+        tm.assert_equal(result, expected)
+
+        expected = obj.astype(object).mask(mask, tdnat)
+        result = obj.mask(mask, tdnat)
+        tm.assert_equal(result, expected)
 
-    with pytest.raises(TypeError, match=msg):
-        obj.mask(mask, tdnat)
+        obj.mask(mask, tdnat, inplace=True)
+        tm.assert_equal(obj, expected)
 
 
 def test_where_nullable_invalid_na(frame_or_series, any_numeric_ea_dtype):
@@ -900,16 +951,7 @@ def test_where_nullable_invalid_na(frame_or_series, any_numeric_ea_dtype):
 
     mask = np.array([True, True, False], ndmin=obj.ndim).T
 
-    msg = "|".join(
-        [
-            r"datetime64\[.{1,2}\] cannot be converted to an? (Integer|Floating)Dtype",
-            r"timedelta64\[.{1,2}\] cannot be converted to an? (Integer|Floating)Dtype",
-            r"int\(\) argument must be a string, a bytes-like object or a number, "
-            "not 'NaTType'",
-            "object cannot be converted to a FloatingDtype",
-            "'values' contains non-numeric NA",
-        ]
-    )
+    msg = r"Invalid value '.*' for dtype (U?Int|Float)\d{1,2}"
 
     for null in tm.NP_NAT_OBJECTS + [pd.NaT]:
         # NaT is an NA value that we should *not* cast to pd.NA dtype
@@ -921,10 +963,96 @@ def test_where_nullable_invalid_na(frame_or_series, any_numeric_ea_dtype):
 
 
 @given(data=OPTIONAL_ONE_OF_ALL)
-@settings(deadline=None)  # GH 44969
 def test_where_inplace_casting(data):
     # GH 22051
     df = DataFrame({"a": data})
     df_copy = df.where(pd.notnull(df), None).copy()
     df.where(pd.notnull(df), None, inplace=True)
     tm.assert_equal(df, df_copy)
+
+
+def test_where_downcast_to_td64():
+    ser = Series([1, 2, 3])
+
+    mask = np.array([False, False, False])
+
+    td = pd.Timedelta(days=1)
+
+    res = ser.where(mask, td)
+    expected = Series([td, td, td], dtype="m8[ns]")
+    tm.assert_series_equal(res, expected)
+
+
+def _check_where_equivalences(df, mask, other, expected):
+    # similar to tests.series.indexing.test_setitem.SetitemCastingEquivalences
+    #  but with DataFrame in mind and less fleshed-out
+    res = df.where(mask, other)
+    tm.assert_frame_equal(res, expected)
+
+    res = df.mask(~mask, other)
+    tm.assert_frame_equal(res, expected)
+
+    # Note: frame.mask(~mask, other, inplace=True) takes some more work bc
+    #  Block.putmask does *not* downcast.  The change to 'expected' here
+    #  is specific to the cases in test_where_dt64_2d.
+    df = df.copy()
+    df.mask(~mask, other, inplace=True)
+    if not mask.all():
+        # with mask.all(), Block.putmask is a no-op, so does not downcast
+        expected = expected.copy()
+        expected["A"] = expected["A"].astype(object)
+    tm.assert_frame_equal(df, expected)
+
+
+def test_where_dt64_2d():
+    dti = date_range("2016-01-01", periods=6)
+    dta = dti._data.reshape(3, 2)
+    other = dta - dta[0, 0]
+
+    df = DataFrame(dta, columns=["A", "B"])
+
+    mask = np.asarray(df.isna())
+    mask[:, 1] = True
+
+    # setting all of one column, none of the other
+    expected = DataFrame({"A": other[:, 0], "B": dta[:, 1]})
+    _check_where_equivalences(df, mask, other, expected)
+
+    # setting part of one column, none of the other
+    mask[1, 0] = True
+    expected = DataFrame(
+        {
+            "A": np.array([other[0, 0], dta[1, 0], other[2, 0]], dtype=object),
+            "B": dta[:, 1],
+        }
+    )
+    _check_where_equivalences(df, mask, other, expected)
+
+    # setting nothing in either column
+    mask[:] = True
+    expected = df
+    _check_where_equivalences(df, mask, other, expected)
+
+
+def test_where_mask_deprecated(frame_or_series):
+    # GH 47728
+    obj = DataFrame(np.random.randn(4, 3))
+    obj = tm.get_obj(obj, frame_or_series)
+
+    mask = obj > 0
+
+    with tm.assert_produces_warning(FutureWarning):
+        obj.where(mask, -1, errors="raise")
+
+    with tm.assert_produces_warning(FutureWarning):
+        obj.mask(mask, -1, errors="raise")
+
+
+def test_where_producing_ea_cond_for_np_dtype():
+    # GH#44014
+    df = DataFrame({"a": Series([1, pd.NA, 2], dtype="Int64"), "b": [1, 2, 3]})
+    result = df.where(lambda x: x.apply(lambda y: y > 1, axis=1))
+    expected = DataFrame(
+        {"a": Series([pd.NA, pd.NA, 2], dtype="Int64"), "b": [np.nan, 2, 3]}
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/indexing/test_xs.py b/pandas/tests/frame/indexing/test_xs.py
index c6938abb57d64..5951c1dd6e45e 100644
--- a/pandas/tests/frame/indexing/test_xs.py
+++ b/pandas/tests/frame/indexing/test_xs.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SettingWithCopyError
+
 from pandas import (
     DataFrame,
     Index,
@@ -12,7 +14,6 @@
     concat,
 )
 import pandas._testing as tm
-import pandas.core.common as com
 
 from pandas.tseries.offsets import BDay
 
@@ -110,17 +111,21 @@ def test_xs_keep_level(self):
             result = df.xs([2008, "sat"], level=["year", "day"], drop_level=False)
         tm.assert_frame_equal(result, expected)
 
-    def test_xs_view(self, using_array_manager):
+    def test_xs_view(self, using_array_manager, using_copy_on_write):
         # in 0.14 this will return a view if possible a copy otherwise, but
         # this is numpy dependent
 
         dm = DataFrame(np.arange(20.0).reshape(4, 5), index=range(4), columns=range(5))
+        df_orig = dm.copy()
 
-        if using_array_manager:
+        if using_copy_on_write:
+            dm.xs(2)[:] = 20
+            tm.assert_frame_equal(dm, df_orig)
+        elif using_array_manager:
             # INFO(ArrayManager) with ArrayManager getting a row as a view is
             # not possible
             msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            with pytest.raises(SettingWithCopyError, match=msg):
                 dm.xs(2)[:] = 20
             assert not (dm.xs(2) == 20).any()
         else:
@@ -175,27 +180,41 @@ def test_xs_level_eq_2(self):
         result = df.xs("c", level=2)
         tm.assert_frame_equal(result, expected)
 
-    def test_xs_setting_with_copy_error(self, multiindex_dataframe_random_data):
+    def test_xs_setting_with_copy_error(
+        self, multiindex_dataframe_random_data, using_copy_on_write
+    ):
         # this is a copy in 0.14
         df = multiindex_dataframe_random_data
+        df_orig = df.copy()
         result = df.xs("two", level="second")
 
-        # setting this will give a SettingWithCopyError
-        # as we are trying to write a view
-        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
             result[:] = 10
-
-    def test_xs_setting_with_copy_error_multiple(self, four_level_index_dataframe):
+        else:
+            # setting this will give a SettingWithCopyError
+            # as we are trying to write a view
+            msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+            with pytest.raises(SettingWithCopyError, match=msg):
+                result[:] = 10
+        tm.assert_frame_equal(df, df_orig)
+
+    def test_xs_setting_with_copy_error_multiple(
+        self, four_level_index_dataframe, using_copy_on_write
+    ):
         # this is a copy in 0.14
         df = four_level_index_dataframe
+        df_orig = df.copy()
         result = df.xs(("a", 4), level=["one", "four"])
 
-        # setting this will give a SettingWithCopyError
-        # as we are trying to write a view
-        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
             result[:] = 10
+        else:
+            # setting this will give a SettingWithCopyError
+            # as we are trying to write a view
+            msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+            with pytest.raises(SettingWithCopyError, match=msg):
+                result[:] = 10
+        tm.assert_frame_equal(df, df_orig)
 
     @pytest.mark.parametrize("key, level", [("one", "second"), (["one"], ["second"])])
     def test_xs_with_duplicates(self, key, level, multiindex_dataframe_random_data):
@@ -358,15 +377,20 @@ def test_xs_droplevel_false(self):
         expected = DataFrame({"a": [1]})
         tm.assert_frame_equal(result, expected)
 
-    def test_xs_droplevel_false_view(self, using_array_manager):
+    def test_xs_droplevel_false_view(self, using_array_manager, using_copy_on_write):
         # GH#37832
         df = DataFrame([[1, 2, 3]], columns=Index(["a", "b", "c"]))
         result = df.xs("a", axis=1, drop_level=False)
         # check that result still views the same data as df
         assert np.shares_memory(result.iloc[:, 0]._values, df.iloc[:, 0]._values)
-        # modifying original df also modifies result when having a single block
+
         df.iloc[0, 0] = 2
-        expected = DataFrame({"a": [2]})
+        if using_copy_on_write:
+            # with copy on write the subset is never modified
+            expected = DataFrame({"a": [1]})
+        else:
+            # modifying original df also modifies result when having a single block
+            expected = DataFrame({"a": [2]})
         tm.assert_frame_equal(result, expected)
 
         # with mixed dataframe, modifying the parent doesn't modify result
@@ -374,7 +398,10 @@ def test_xs_droplevel_false_view(self, using_array_manager):
         df = DataFrame([[1, 2.5, "a"]], columns=Index(["a", "b", "c"]))
         result = df.xs("a", axis=1, drop_level=False)
         df.iloc[0, 0] = 2
-        if using_array_manager:
+        if using_copy_on_write:
+            # with copy on write the subset is never modified
+            expected = DataFrame({"a": [1]})
+        elif using_array_manager:
             # Here the behavior is consistent
             expected = DataFrame({"a": [2]})
         else:
diff --git a/pandas/tests/frame/methods/test_align.py b/pandas/tests/frame/methods/test_align.py
index 03ea6492c07f3..575db40f171a2 100644
--- a/pandas/tests/frame/methods/test_align.py
+++ b/pandas/tests/frame/methods/test_align.py
@@ -243,6 +243,105 @@ def test_align_series_combinations(self):
         tm.assert_series_equal(res1, exp2)
         tm.assert_frame_equal(res2, exp1)
 
+    def test_multiindex_align_to_series_with_common_index_level(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_left(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series(
+            [1, 2, 3, 4], index=Index([1, 2, 3, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_right(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2, 3, 4], name="bar")
+
+        series = Series([1, 2], index=Index([1, 2], name="bar"), name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(12)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series(
+            [1, 2, np.nan, np.nan] * 3, index=df.index, name="foo_series"
+        )
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_both(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 3, 4], name="bar")
+
+        series = Series(
+            [1, 2, 3], index=Index([1, 2, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(9)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, np.nan, 3] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_non_unique_cols(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            np.arange(18).reshape(6, 3),
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+        df.columns = ["cfoo", "cbar", "cfoo"]
+
+        expected = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_left, result_right = df.align(series, axis=0)
+
+        tm.assert_series_equal(result_right, expected)
+        tm.assert_index_equal(result_left.columns, df.columns)
+
+    def test_missing_axis_specification_exception(self):
+        df = DataFrame(np.arange(50).reshape((10, 5)))
+        series = Series(np.arange(5))
+
+        with pytest.raises(ValueError, match=r"axis=0 or 1"):
+            df.align(series)
+
     def _check_align(self, a, b, axis, fill_axis, how, method, limit=None):
         aa, ab = a.align(
             b, axis=axis, join=how, method=method, limit=limit, fill_axis=fill_axis
diff --git a/pandas/tests/frame/methods/test_append.py b/pandas/tests/frame/methods/test_append.py
index 5cfad472e0134..f07ffee20a55f 100644
--- a/pandas/tests/frame/methods/test_append.py
+++ b/pandas/tests/frame/methods/test_append.py
@@ -159,7 +159,7 @@ def test_append_empty_dataframe(self):
         expected = df1.copy()
         tm.assert_frame_equal(result, expected)
 
-    def test_append_dtypes(self):
+    def test_append_dtypes(self, using_array_manager):
 
         # GH 5754
         # row appends of different dtypes (so need to do by-item)
@@ -183,7 +183,10 @@ def test_append_dtypes(self):
         expected = DataFrame(
             {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
         )
-        expected = expected.astype(object)
+        if using_array_manager:
+            # TODO(ArrayManager) decide on exact casting rules in concat
+            # With ArrayManager, all-NaN float is not ignored
+            expected = expected.astype(object)
         tm.assert_frame_equal(result, expected)
 
         df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
@@ -192,7 +195,9 @@ def test_append_dtypes(self):
         expected = DataFrame(
             {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
         )
-        expected = expected.astype(object)
+        if using_array_manager:
+            # With ArrayManager, all-NaN float is not ignored
+            expected = expected.astype(object)
         tm.assert_frame_equal(result, expected)
 
         df1 = DataFrame({"bar": np.nan}, index=range(1))
@@ -201,7 +206,9 @@ def test_append_dtypes(self):
         expected = DataFrame(
             {"bar": Series([np.nan, Timestamp("20130101")], dtype="M8[ns]")}
         )
-        expected = expected.astype(object)
+        if using_array_manager:
+            # With ArrayManager, all-NaN float is not ignored
+            expected = expected.astype(object)
         tm.assert_frame_equal(result, expected)
 
         df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
@@ -231,9 +238,16 @@ def test_append_timestamps_aware_or_naive(self, tz_naive_fixture, timestamp):
             ([1], pd.SparseDtype()),
         ],
     )
-    def test_other_dtypes(self, data, dtype):
+    def test_other_dtypes(self, data, dtype, using_array_manager):
         df = DataFrame(data, dtype=dtype)
-        result = df._append(df.iloc[0]).iloc[-1]
+
+        warn = None
+        if using_array_manager and isinstance(dtype, pd.SparseDtype):
+            warn = FutureWarning
+
+        with tm.assert_produces_warning(warn, match="astype from SparseDtype"):
+            result = df._append(df.iloc[0]).iloc[-1]
+
         expected = Series(data, name=0, dtype=dtype)
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 6931dd0ea2d4c..0b27fe591f794 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -68,6 +68,8 @@ def test_subset(self, date_range_frame):
         result = df.asof(dates, subset="B")
         expected = df.resample("25s", closed="right").ffill().reindex(dates)
         expected.iloc[20:] = 9
+        # no "missing", so "B" can retain int dtype (df["A"].dtype platform-dependent)
+        expected["B"] = expected["B"].astype(df["B"].dtype)
 
         tm.assert_frame_equal(result, expected)
 
@@ -135,11 +137,11 @@ def test_all_nans(self, date_range_frame):
         [
             (
                 Timestamp("2018-01-01 23:22:43.325+00:00"),
-                Series(2.0, name=Timestamp("2018-01-01 23:22:43.325+00:00")),
+                Series(2, name=Timestamp("2018-01-01 23:22:43.325+00:00")),
             ),
             (
                 Timestamp("2018-01-01 22:33:20.682+01:00"),
-                Series(1.0, name=Timestamp("2018-01-01 22:33:20.682+01:00")),
+                Series(1, name=Timestamp("2018-01-01 22:33:20.682+01:00")),
             ),
         ],
     )
@@ -180,3 +182,14 @@ def test_asof_periodindex_mismatched_freq(self):
         msg = "Input has different freq"
         with pytest.raises(IncompatibleFrequency, match=msg):
             df.asof(rng.asfreq("D"))
+
+    def test_asof_preserves_bool_dtype(self):
+        # GH#16063 was casting bools to floats
+        dti = date_range("2017-01-01", freq="MS", periods=4)
+        ser = Series([True, False, True], index=dti[:-1])
+
+        ts = dti[-1]
+        res = ser.asof([ts])
+
+        expected = Series([True], index=[ts])
+        tm.assert_series_equal(res, expected)
diff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py
index d326ca3493977..6d343de9f5d3a 100644
--- a/pandas/tests/frame/methods/test_astype.py
+++ b/pandas/tests/frame/methods/test_astype.py
@@ -23,7 +23,6 @@
 )
 import pandas._testing as tm
 from pandas.core.api import UInt64Index
-from pandas.core.arrays.integer import coerce_to_array
 
 
 def _check_cast(df, v):
@@ -455,10 +454,10 @@ def test_astype_to_incorrect_datetimelike(self, unit):
         msg = "|".join(
             [
                 # BlockManager path
-                fr"Cannot cast DatetimeArray to dtype timedelta64\[{unit}\]",
+                rf"Cannot cast DatetimeArray to dtype timedelta64\[{unit}\]",
                 # ArrayManager path
                 "cannot astype a datetimelike from "
-                fr"\[datetime64\[ns\]\] to \[timedelta64\[{unit}\]\]",
+                rf"\[datetime64\[ns\]\] to \[timedelta64\[{unit}\]\]",
             ]
         )
         with pytest.raises(TypeError, match=msg):
@@ -467,10 +466,10 @@ def test_astype_to_incorrect_datetimelike(self, unit):
         msg = "|".join(
             [
                 # BlockManager path
-                fr"Cannot cast TimedeltaArray to dtype datetime64\[{unit}\]",
+                rf"Cannot cast TimedeltaArray to dtype datetime64\[{unit}\]",
                 # ArrayManager path
                 "cannot astype a timedelta from "
-                fr"\[timedelta64\[ns\]\] to \[datetime64\[{unit}\]\]",
+                rf"\[timedelta64\[ns\]\] to \[datetime64\[{unit}\]\]",
             ]
         )
         df = DataFrame(np.array([[1, 2, 3]], dtype=other))
@@ -763,11 +762,6 @@ def test_astype_categorical_to_string_missing(self):
 class IntegerArrayNoCopy(pd.core.arrays.IntegerArray):
     # GH 42501
 
-    @classmethod
-    def _from_sequence(cls, scalars, *, dtype=None, copy=False):
-        values, mask = coerce_to_array(scalars, dtype=dtype, copy=copy)
-        return IntegerArrayNoCopy(values, mask)
-
     def copy(self):
         assert False
 
diff --git a/pandas/tests/frame/methods/test_between_time.py b/pandas/tests/frame/methods/test_between_time.py
index d8a742c644e9e..eb5cfbc2bfbe8 100644
--- a/pandas/tests/frame/methods/test_between_time.py
+++ b/pandas/tests/frame/methods/test_between_time.py
@@ -18,7 +18,7 @@
 
 
 class TestBetweenTime:
-    @td.skip_if_has_locale
+    @td.skip_if_not_us_locale
     def test_between_time_formats(self, frame_or_series):
         # GH#11818
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py
index e692948c92a26..c851e65a7ad4f 100644
--- a/pandas/tests/frame/methods/test_clip.py
+++ b/pandas/tests/frame/methods/test_clip.py
@@ -136,7 +136,7 @@ def test_clip_against_unordered_columns(self):
         tm.assert_frame_equal(result_lower, expected_lower)
         tm.assert_frame_equal(result_lower_upper, expected_lower_upper)
 
-    def test_clip_with_na_args(self, float_frame, using_array_manager):
+    def test_clip_with_na_args(self, float_frame):
         """Should process np.nan argument as None"""
         # GH#17276
         tm.assert_frame_equal(float_frame.clip(np.nan), float_frame)
@@ -151,9 +151,7 @@ def test_clip_with_na_args(self, float_frame, using_array_manager):
         )
         tm.assert_frame_equal(result, expected)
 
-        warn = FutureWarning if using_array_manager else None
-        with tm.assert_produces_warning(warn, match="Downcasting integer-dtype"):
-            result = df.clip(lower=[4, 5, np.nan], axis=1)
+        result = df.clip(lower=[4, 5, np.nan], axis=1)
         expected = DataFrame(
             {"col_0": [4, 4, 4], "col_1": [5, 5, 6], "col_2": [7, 8, 9]}
         )
diff --git a/pandas/tests/frame/methods/test_combine_first.py b/pandas/tests/frame/methods/test_combine_first.py
index daddca7891b93..47ebca0b9bf5c 100644
--- a/pandas/tests/frame/methods/test_combine_first.py
+++ b/pandas/tests/frame/methods/test_combine_first.py
@@ -66,7 +66,7 @@ def test_combine_first(self, float_frame):
         assert (combined["A"][:10] == 1).all()
 
         # reverse overlap
-        tail["A"][:10] = 0
+        tail.iloc[:10, tail.columns.get_loc("A")] = 0
         combined = tail.combine_first(head)
         assert (combined["A"][:10] == 0).all()
 
diff --git a/pandas/tests/frame/methods/test_compare.py b/pandas/tests/frame/methods/test_compare.py
index 468811eba0d39..55e5db9603fe5 100644
--- a/pandas/tests/frame/methods/test_compare.py
+++ b/pandas/tests/frame/methods/test_compare.py
@@ -180,3 +180,75 @@ def test_compare_unaligned_objects():
         df1 = pd.DataFrame(np.ones((3, 3)))
         df2 = pd.DataFrame(np.zeros((2, 1)))
         df1.compare(df2)
+
+
+def test_compare_result_names():
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    result = df1.compare(df2, result_names=("left", "right"))
+    expected = pd.DataFrame(
+        {
+            ("col1", "left"): {0: "a", 2: np.nan},
+            ("col1", "right"): {0: "c", 2: np.nan},
+            ("col3", "left"): {0: np.nan, 2: 3.0},
+            ("col3", "right"): {0: np.nan, 2: np.nan},
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "result_names",
+    [
+        [1, 2],
+        "HK",
+        {"2": 2, "3": 3},
+        3,
+        3.0,
+    ],
+)
+def test_invalid_input_result_names(result_names):
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    with pytest.raises(
+        TypeError,
+        match=(
+            f"Passing 'result_names' as a {type(result_names)} is not "
+            "supported. Provide 'result_names' as a tuple instead."
+        ),
+    ):
+        df1.compare(df2, result_names=result_names)
+
+
+def test_compare_ea_and_np_dtype():
+    # GH#44014
+    df1 = pd.DataFrame({"a": [4.0, 4], "b": [1.0, 2]})
+    df2 = pd.DataFrame({"a": pd.Series([1, pd.NA], dtype="Int64"), "b": [1.0, 2]})
+    result = df1.compare(df2, keep_shape=True)
+    expected = pd.DataFrame(
+        {
+            ("a", "self"): [4.0, np.nan],
+            ("a", "other"): pd.Series([1, pd.NA], dtype="Int64"),
+            ("b", "self"): np.nan,
+            ("b", "other"): np.nan,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_cov_corr.py b/pandas/tests/frame/methods/test_cov_corr.py
index 60d5d8c8ccaca..25ef49718fbe7 100644
--- a/pandas/tests/frame/methods/test_cov_corr.py
+++ b/pandas/tests/frame/methods/test_cov_corr.py
@@ -27,8 +27,8 @@ def test_cov(self, float_frame, float_string_frame):
 
         # with NAs
         frame = float_frame.copy()
-        frame["A"][:5] = np.nan
-        frame["B"][5:10] = np.nan
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+        frame.iloc[5:10, frame.columns.get_loc("B")] = np.nan
         result = frame.cov(min_periods=len(frame) - 8)
         expected = frame.cov()
         expected.loc["A", "B"] = np.nan
@@ -41,7 +41,10 @@ def test_cov(self, float_frame, float_string_frame):
         tm.assert_almost_equal(result["A"]["C"], expected)
 
         # exclude non-numeric types
-        result = float_string_frame.cov()
+        with tm.assert_produces_warning(
+            FutureWarning, match="The default value of numeric_only"
+        ):
+            result = float_string_frame.cov()
         expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].cov()
         tm.assert_frame_equal(result, expected)
 
@@ -83,6 +86,20 @@ def test_cov_nullable_integer(self, other_column):
         expected = DataFrame(arr, columns=["a", "b"], index=["a", "b"])
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_cov_numeric_only(self, numeric_only):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        df = DataFrame({"a": [1, 0], "c": ["x", "y"]})
+        expected = DataFrame(0.5, index=["a"], columns=["a"])
+        if numeric_only:
+            result = df.cov(numeric_only=numeric_only)
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="could not convert string to float"):
+                df.cov(numeric_only=numeric_only)
+
 
 class TestDataFrameCorr:
     # DataFrame.corr(), as opposed to DataFrame.corrwith
@@ -102,7 +119,10 @@ def test_corr_scipy_method(self, float_frame, method):
 
     def test_corr_non_numeric(self, float_string_frame):
         # exclude non-numeric types
-        result = float_string_frame.corr()
+        with tm.assert_produces_warning(
+            FutureWarning, match="The default value of numeric_only"
+        ):
+            result = float_string_frame.corr()
         expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].corr()
         tm.assert_frame_equal(result, expected)
 
@@ -235,6 +255,22 @@ def test_corr_min_periods_greater_than_length(self, method):
         )
         tm.assert_frame_equal(result, expected)
 
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_corr_numeric_only(self, meth, numeric_only):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        df = DataFrame({"a": [1, 0], "b": [1, 0], "c": ["x", "y"]})
+        expected = DataFrame(np.ones((2, 2)), index=["a", "b"], columns=["a", "b"])
+        if numeric_only:
+            result = df.corr(meth, numeric_only=numeric_only)
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="could not convert string to float"):
+                df.corr(meth, numeric_only=numeric_only)
+
 
 class TestDataFrameCorrWith:
     def test_corrwith(self, datetime_frame):
@@ -277,11 +313,17 @@ def test_corrwith_with_objects(self):
         df1["obj"] = "foo"
         df2["obj"] = "bar"
 
-        result = df1.corrwith(df2)
+        with tm.assert_produces_warning(
+            FutureWarning, match="The default value of numeric_only"
+        ):
+            result = df1.corrwith(df2)
         expected = df1.loc[:, cols].corrwith(df2.loc[:, cols])
         tm.assert_series_equal(result, expected)
 
-        result = df1.corrwith(df2, axis=1)
+        with tm.assert_produces_warning(
+            FutureWarning, match="The default value of numeric_only"
+        ):
+            result = df1.corrwith(df2, axis=1)
         expected = df1.loc[:, cols].corrwith(df2.loc[:, cols], axis=1)
         tm.assert_series_equal(result, expected)
 
@@ -300,16 +342,24 @@ def test_corrwith_matches_corrcoef(self):
         tm.assert_almost_equal(c1, c2)
         assert c1 < 1
 
-    def test_corrwith_mixed_dtypes(self):
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_corrwith_mixed_dtypes(self, numeric_only):
         # GH#18570
         df = DataFrame(
             {"a": [1, 4, 3, 2], "b": [4, 6, 7, 3], "c": ["a", "b", "c", "d"]}
         )
         s = Series([0, 6, 7, 3])
-        result = df.corrwith(s)
-        corrs = [df["a"].corr(s), df["b"].corr(s)]
-        expected = Series(data=corrs, index=["a", "b"])
-        tm.assert_series_equal(result, expected)
+        if numeric_only:
+            result = df.corrwith(s, numeric_only=numeric_only)
+            corrs = [df["a"].corr(s), df["b"].corr(s)]
+            expected = Series(data=corrs, index=["a", "b"])
+            tm.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(
+                TypeError,
+                match=r"unsupported operand type\(s\) for /: 'str' and 'int'",
+            ):
+                df.corrwith(s, numeric_only=numeric_only)
 
     def test_corrwith_index_intersection(self):
         df1 = DataFrame(np.random.random(size=(10, 2)), columns=["a", "b"])
@@ -337,11 +387,18 @@ def test_corrwith_dup_cols(self):
         expected = Series(np.ones(4), index=[0, 0, 1, 2])
         tm.assert_series_equal(result, expected)
 
+    def test_corr_numerical_instabilities(self):
+        # GH#45640
+        df = DataFrame([[0.2, 0.4], [0.4, 0.2]])
+        result = df.corr()
+        expected = DataFrame({0: [1.0, -1.0], 1: [-1.0, 1.0]})
+        tm.assert_frame_equal(result - 1, expected - 1, atol=1e-17)
+
     @td.skip_if_no_scipy
     def test_corrwith_spearman(self):
         # GH#21925
         df = DataFrame(np.random.random(size=(100, 3)))
-        result = df.corrwith(df ** 2, method="spearman")
+        result = df.corrwith(df**2, method="spearman")
         expected = Series(np.ones(len(result)))
         tm.assert_series_equal(result, expected)
 
@@ -349,6 +406,29 @@ def test_corrwith_spearman(self):
     def test_corrwith_kendall(self):
         # GH#21925
         df = DataFrame(np.random.random(size=(100, 3)))
-        result = df.corrwith(df ** 2, method="kendall")
+        result = df.corrwith(df**2, method="kendall")
         expected = Series(np.ones(len(result)))
         tm.assert_series_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    def test_corrwith_spearman_with_tied_data(self):
+        # GH#48826
+        df1 = DataFrame(
+            {
+                "A": [1, np.nan, 7, 8],
+                "B": [False, True, True, False],
+                "C": [10, 4, 9, 3],
+            }
+        )
+        df2 = df1[["B", "C"]]
+        result = (df1 + 1).corrwith(df2.B, method="spearman")
+        expected = Series([0.0, 1.0, 0.0], index=["A", "B", "C"])
+        tm.assert_series_equal(result, expected)
+
+        df_bool = DataFrame(
+            {"A": [True, True, False, False], "B": [True, False, False, True]}
+        )
+        ser_bool = Series([True, True, False, True])
+        result = df_bool.corrwith(ser_bool)
+        expected = Series([0.57735, 0.57735], index=["A", "B"])
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_describe.py b/pandas/tests/frame/methods/test_describe.py
index 3a1228ee5c4a5..24d327a101143 100644
--- a/pandas/tests/frame/methods/test_describe.py
+++ b/pandas/tests/frame/methods/test_describe.py
@@ -397,3 +397,15 @@ def test_describe_with_duplicate_columns(self):
         ser = df.iloc[:, 0].describe()
         expected = pd.concat([ser, ser, ser], keys=df.columns, axis=1)
         tm.assert_frame_equal(result, expected)
+
+    def test_ea_with_na(self, any_numeric_ea_dtype):
+        # GH#48778
+
+        df = DataFrame({"a": [1, pd.NA, pd.NA], "b": pd.NA}, dtype=any_numeric_ea_dtype)
+        result = df.describe()
+        expected = DataFrame(
+            {"a": [1.0, 1.0, pd.NA] + [1.0] * 5, "b": [0.0] + [pd.NA] * 7},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype="Float64",
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_diff.py b/pandas/tests/frame/methods/test_diff.py
index f61529659e9d5..9a9fea3462752 100644
--- a/pandas/tests/frame/methods/test_diff.py
+++ b/pandas/tests/frame/methods/test_diff.py
@@ -82,7 +82,7 @@ def test_diff_datetime_axis0_with_nat(self, tz):
         expected = Series(ex_index).to_frame()
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.parametrize("tz", [None, "UTC"])
+    @pytest.mark.parametrize("tz", [pytest.param(None, marks=pytest.mark.xfail), "UTC"])
     def test_diff_datetime_with_nat_zero_periods(self, tz):
         # diff on NaT values should give NaT, not timedelta64(0)
         dti = date_range("2016-01-01", periods=4, tz=tz)
@@ -90,7 +90,9 @@ def test_diff_datetime_with_nat_zero_periods(self, tz):
         df = ser.to_frame()
 
         df[1] = ser.copy()
-        df.iloc[:, 0] = pd.NaT
+
+        with tm.assert_produces_warning(None):
+            df.iloc[:, 0] = pd.NaT
 
         expected = df - df
         assert expected[0].isna().all()
diff --git a/pandas/tests/frame/methods/test_drop.py b/pandas/tests/frame/methods/test_drop.py
index 4f8ea6eda1b5f..50b60f9e06ef1 100644
--- a/pandas/tests/frame/methods/test_drop.py
+++ b/pandas/tests/frame/methods/test_drop.py
@@ -537,3 +537,15 @@ def test_drop_level_missing_label_multiindex(self):
         df = DataFrame(index=MultiIndex.from_product([range(3), range(3)]))
         with pytest.raises(KeyError, match="labels \\[5\\] not found in level"):
             df.drop(5, level=0)
+
+    @pytest.mark.parametrize("idx, level", [(["a", "b"], 0), (["a"], None)])
+    def test_drop_index_ea_dtype(self, any_numeric_ea_dtype, idx, level):
+        # GH#45860
+        df = DataFrame(
+            {"a": [1, 2, 2, pd.NA], "b": 100}, dtype=any_numeric_ea_dtype
+        ).set_index(idx)
+        result = df.drop(Index([2, pd.NA]), level=level)
+        expected = DataFrame(
+            {"a": [1], "b": 100}, dtype=any_numeric_ea_dtype
+        ).set_index(idx)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_dropna.py b/pandas/tests/frame/methods/test_dropna.py
index d0b9eebb31b93..53d9f75494d92 100644
--- a/pandas/tests/frame/methods/test_dropna.py
+++ b/pandas/tests/frame/methods/test_dropna.py
@@ -158,9 +158,6 @@ def test_dropna_corner(self, float_frame):
         msg = "invalid how option: foo"
         with pytest.raises(ValueError, match=msg):
             float_frame.dropna(how="foo")
-        msg = "must specify how or thresh"
-        with pytest.raises(TypeError, match=msg):
-            float_frame.dropna(how=None)
         # non-existent column - 8303
         with pytest.raises(KeyError, match=r"^\['X'\]$"):
             float_frame.dropna(subset=["A", "X"])
@@ -223,7 +220,9 @@ def test_dropna_with_duplicate_columns(self):
         df.iloc[2, [0, 1, 2]] = np.nan
         df.iloc[0, 0] = np.nan
         df.iloc[1, 1] = np.nan
-        df.iloc[:, 3] = np.nan
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 3] = np.nan
         expected = df.dropna(subset=["A", "B", "C"], how="all")
         expected.columns = ["A", "A", "B", "C"]
 
@@ -274,3 +273,16 @@ def test_no_nans_in_frame(self, axis):
         expected = df.copy()
         result = df.dropna(axis=axis)
         tm.assert_frame_equal(result, expected, check_index_type=True)
+
+    def test_how_thresh_param_incompatible(self):
+        # GH46575
+        df = DataFrame([1, 2, pd.NA])
+        msg = "You cannot set both the how and thresh arguments at the same time"
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how="all", thresh=2)
+
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how="any", thresh=2)
+
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how=None, thresh=None)
diff --git a/pandas/tests/frame/methods/test_dtypes.py b/pandas/tests/frame/methods/test_dtypes.py
index 84841ad7a634e..87e6ed5b1b135 100644
--- a/pandas/tests/frame/methods/test_dtypes.py
+++ b/pandas/tests/frame/methods/test_dtypes.py
@@ -1,6 +1,7 @@
 from datetime import timedelta
 
 import numpy as np
+import pytest
 
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
@@ -79,6 +80,20 @@ def test_dtypes_are_correct_after_column_slice(self):
             Series({"a": np.float_, "b": np.float_, "c": np.float_}),
         )
 
+    @pytest.mark.parametrize(
+        "data",
+        [pd.NA, True],
+    )
+    def test_dtypes_are_correct_after_groupby_last(self, data):
+        # GH46409
+        df = DataFrame(
+            {"id": [1, 2, 3, 4], "test": [True, pd.NA, data, False]}
+        ).convert_dtypes()
+        result = df.groupby("id").last().test
+        expected = df.set_index("id").test
+        assert result.dtype == pd.BooleanDtype()
+        tm.assert_series_equal(expected, result)
+
     def test_dtypes_gh8722(self, float_string_frame):
         float_string_frame["bool"] = float_string_frame["A"] > 0
         result = float_string_frame.dtypes
@@ -131,3 +146,10 @@ def test_dtypes_timedeltas(self):
             index=list("ABCD"),
         )
         tm.assert_series_equal(result, expected)
+
+    def test_frame_apply_np_array_return_type(self):
+        # GH 35517
+        df = DataFrame([["foo"]])
+        result = df.apply(lambda col: np.array("bar"))
+        expected = Series(["bar"])
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_duplicated.py b/pandas/tests/frame/methods/test_duplicated.py
index 0b90914281d3b..9d46a8abb9b46 100644
--- a/pandas/tests/frame/methods/test_duplicated.py
+++ b/pandas/tests/frame/methods/test_duplicated.py
@@ -62,7 +62,7 @@ def test_duplicated_keep(keep, expected):
     ],
 )
 def test_duplicated_nan_none(keep, expected):
-    df = DataFrame({"C": [np.nan, 3, 3, None, np.nan]}, dtype=object)
+    df = DataFrame({"C": [np.nan, 3, 3, None, np.nan], "x": 1}, dtype=object)
 
     result = df.duplicated(keep=keep)
     tm.assert_series_equal(result, expected)
@@ -109,5 +109,5 @@ def test_frame_datetime64_duplicated():
     assert (-result).all()
 
     tst = DataFrame({"date": dates})
-    result = tst.duplicated()
+    result = tst.date.duplicated()
     assert (-result).all()
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index b5bdf6a70199c..ccd564b46cffa 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 from pandas import (
     Categorical,
     DataFrame,
@@ -11,12 +13,53 @@
     TimedeltaIndex,
     Timestamp,
     date_range,
+    to_datetime,
 )
 import pandas._testing as tm
 from pandas.tests.frame.common import _check_mixed_float
 
 
 class TestFillNA:
+    @td.skip_array_manager_not_yet_implemented
+    def test_fillna_dict_inplace_nonunique_columns(self, using_copy_on_write):
+        df = DataFrame(
+            {"A": [np.nan] * 3, "B": [NaT, Timestamp(1), NaT], "C": [np.nan, "foo", 2]}
+        )
+        df.columns = ["A", "A", "A"]
+        orig = df[:]
+
+        df.fillna({"A": 2}, inplace=True)
+        # The first and third columns can be set inplace, while the second cannot.
+
+        expected = DataFrame(
+            {"A": [2.0] * 3, "B": [2, Timestamp(1), 2], "C": [2, "foo", 2]}
+        )
+        expected.columns = ["A", "A", "A"]
+        tm.assert_frame_equal(df, expected)
+
+        # TODO: what's the expected/desired behavior with CoW?
+        if not using_copy_on_write:
+            assert tm.shares_memory(df.iloc[:, 0], orig.iloc[:, 0])
+        assert not tm.shares_memory(df.iloc[:, 1], orig.iloc[:, 1])
+        if not using_copy_on_write:
+            assert tm.shares_memory(df.iloc[:, 2], orig.iloc[:, 2])
+
+    @td.skip_array_manager_not_yet_implemented
+    def test_fillna_on_column_view(self, using_copy_on_write):
+        # GH#46149 avoid unnecessary copies
+        arr = np.full((40, 50), np.nan)
+        df = DataFrame(arr)
+
+        df[0].fillna(-1, inplace=True)
+        if using_copy_on_write:
+            assert np.isnan(arr[:, 0]).all()
+        else:
+            assert (arr[:, 0] == -1).all()
+
+        # i.e. we didn't create a new 49-column block
+        assert len(df._mgr.arrays) == 1
+        assert np.shares_memory(df.values, arr)
+
     def test_fillna_datetime(self, datetime_frame):
         tf = datetime_frame
         tf.loc[tf.index[:5], "A"] = np.nan
@@ -244,6 +287,31 @@ def test_fillna_downcast(self):
         expected = DataFrame({"a": [1, 0]})
         tm.assert_frame_equal(result, expected)
 
+    def test_fillna_downcast_false(self, frame_or_series):
+        # GH#45603 preserve object dtype with downcast=False
+        obj = frame_or_series([1, 2, 3], dtype="object")
+        result = obj.fillna("", downcast=False)
+        tm.assert_equal(result, obj)
+
+    def test_fillna_downcast_noop(self, frame_or_series):
+        # GH#45423
+        # Two relevant paths:
+        #  1) not _can_hold_na (e.g. integer)
+        #  2) _can_hold_na + noop + not can_hold_element
+
+        obj = frame_or_series([1, 2, 3], dtype=np.int64)
+        res = obj.fillna("foo", downcast=np.dtype(np.int32))
+        expected = obj.astype(np.int32)
+        tm.assert_equal(res, expected)
+
+        obj2 = obj.astype(np.float64)
+        res2 = obj2.fillna("foo", downcast="infer")
+        expected2 = obj  # get back int64
+        tm.assert_equal(res2, expected2)
+
+        res3 = obj2.fillna("foo", downcast=np.dtype(np.int32))
+        tm.assert_equal(res3, expected)
+
     @pytest.mark.parametrize("columns", [["A", "A", "B"], ["A", "A"]])
     def test_fillna_dictlike_value_duplicate_colnames(self, columns):
         # GH#43476
@@ -615,6 +683,18 @@ def test_fillna_with_columns_and_limit(self):
         tm.assert_frame_equal(result, expected)
         tm.assert_frame_equal(result2, expected2)
 
+    def test_fillna_datetime_inplace(self):
+        # GH#48863
+        df = DataFrame(
+            {
+                "date1": to_datetime(["2018-05-30", None]),
+                "date2": to_datetime(["2018-09-30", None]),
+            }
+        )
+        expected = df.copy()
+        df.fillna(np.nan, inplace=True)
+        tm.assert_frame_equal(df, expected)
+
     def test_fillna_inplace_with_columns_limit_and_value(self):
         # GH40989
         df = DataFrame(
@@ -633,6 +713,72 @@ def test_fillna_inplace_with_columns_limit_and_value(self):
         df.fillna(axis=1, value=100, limit=1, inplace=True)
         tm.assert_frame_equal(df, expected)
 
+    @td.skip_array_manager_invalid_test
+    @pytest.mark.parametrize("val", [-1, {"x": -1, "y": -1}])
+    def test_inplace_dict_update_view(self, val, using_copy_on_write):
+        # GH#47188
+        df = DataFrame({"x": [np.nan, 2], "y": [np.nan, 2]})
+        df_orig = df.copy()
+        result_view = df[:]
+        df.fillna(val, inplace=True)
+        expected = DataFrame({"x": [-1, 2.0], "y": [-1.0, 2]})
+        tm.assert_frame_equal(df, expected)
+        if using_copy_on_write:
+            tm.assert_frame_equal(result_view, df_orig)
+        else:
+            tm.assert_frame_equal(result_view, expected)
+
+    def test_single_block_df_with_horizontal_axis(self):
+        # GH 47713
+        df = DataFrame(
+            {
+                "col1": [5, 0, np.nan, 10, np.nan],
+                "col2": [7, np.nan, np.nan, 5, 3],
+                "col3": [12, np.nan, 1, 2, 0],
+                "col4": [np.nan, 1, 1, np.nan, 18],
+            }
+        )
+        result = df.fillna(50, limit=1, axis=1)
+        expected = DataFrame(
+            [
+                [5.0, 7.0, 12.0, 50.0],
+                [0.0, 50.0, np.nan, 1.0],
+                [50.0, np.nan, 1.0, 1.0],
+                [10.0, 5.0, 2.0, 50.0],
+                [50.0, 3.0, 0.0, 18.0],
+            ],
+            columns=["col1", "col2", "col3", "col4"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_with_multi_index_frame(self):
+        # GH 47649
+        pdf = DataFrame(
+            {
+                ("x", "a"): [np.nan, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, np.nan],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        expected = DataFrame(
+            {
+                ("x", "a"): [-1.0, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, -1.0],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        tm.assert_frame_equal(pdf.fillna({"x": -1}), expected)
+        tm.assert_frame_equal(pdf.fillna({"x": -1, ("x", "b"): -2}), expected)
+
+        expected = DataFrame(
+            {
+                ("x", "a"): [-1.0, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, -2.0],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        tm.assert_frame_equal(pdf.fillna({("x", "b"): -2, "x": -1}), expected)
+
 
 def test_fillna_nonconsolidated_frame():
     # https://github.com/pandas-dev/pandas/issues/36495
@@ -644,6 +790,19 @@ def test_fillna_nonconsolidated_frame():
         ],
         columns=["i1", "i2", "i3", "f1"],
     )
-    df_nonconsol = df.pivot("i1", "i2")
+    df_nonconsol = df.pivot(index="i1", columns="i2")
     result = df_nonconsol.fillna(0)
     assert result.isna().sum().sum() == 0
+
+
+def test_fillna_nones_inplace():
+    # GH 48480
+    df = DataFrame(
+        [[None, None], [None, None]],
+        columns=["A", "B"],
+    )
+    with tm.assert_produces_warning(False):
+        df.fillna(value={"A": 1, "B": 2}, inplace=True)
+
+    expected = DataFrame([[1, 2], [1, 2]], columns=["A", "B"])
+    tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py
index 37fb0754baffd..7d6cf43c530a7 100644
--- a/pandas/tests/frame/methods/test_interpolate.py
+++ b/pandas/tests/frame/methods/test_interpolate.py
@@ -49,6 +49,38 @@ def test_interp_basic(self):
         result = df.interpolate()
         tm.assert_frame_equal(result, expected)
 
+        # check we didn't operate inplace GH#45791
+        cvalues = df["C"]._values
+        dvalues = df["D"].values
+        assert not np.shares_memory(cvalues, result["C"]._values)
+        assert not np.shares_memory(dvalues, result["D"]._values)
+
+        res = df.interpolate(inplace=True)
+        assert res is None
+        tm.assert_frame_equal(df, expected)
+
+        # check we DID operate inplace
+        assert np.shares_memory(df["C"]._values, cvalues)
+        assert np.shares_memory(df["D"]._values, dvalues)
+
+    def test_interp_basic_with_non_range_index(self):
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": [1.0, 2.0, 3.0, 4.0],
+                "B": [1.0, 4.0, 9.0, 9.0],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+
         result = df.set_index("C").interpolate()
         expected = df.set_index("C")
         expected.loc[3, "A"] = 3
@@ -271,7 +303,10 @@ def test_interp_raise_on_all_object_dtype(self):
         with pytest.raises(TypeError, match=msg):
             df.interpolate()
 
-    def test_interp_inplace(self):
+    def test_interp_inplace(self, using_copy_on_write):
+        # TODO(CoW) inplace keyword (it is still mutating the parent)
+        if using_copy_on_write:
+            pytest.skip("CoW: inplace keyword not yet handled")
         df = DataFrame({"a": [1.0, 2.0, np.nan, 4.0]})
         expected = DataFrame({"a": [1.0, 2.0, 3.0, 4.0]})
         result = df.copy()
@@ -320,7 +355,7 @@ def test_interp_ignore_all_good(self):
         result = df[["B", "D"]].interpolate(downcast=None)
         tm.assert_frame_equal(result, df[["B", "D"]])
 
-    def test_interp_time_inplace_axis(self, axis):
+    def test_interp_time_inplace_axis(self):
         # GH 9687
         periods = 5
         idx = date_range(start="2014-01-01", periods=periods)
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index c6bfd94b84908..7db26f7eb570b 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import MergeError
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -12,6 +14,7 @@
     period_range,
 )
 import pandas._testing as tm
+from pandas.core.reshape.concat import concat
 
 
 @pytest.fixture
@@ -33,6 +36,39 @@ def right():
     return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
 
 
+@pytest.fixture
+def left_no_dup():
+    return DataFrame(
+        {"a": ["a", "b", "c", "d"], "b": ["cat", "dog", "weasel", "horse"]},
+        index=range(4),
+    )
+
+
+@pytest.fixture
+def right_no_dup():
+    return DataFrame(
+        {
+            "a": ["a", "b", "c", "d", "e"],
+            "c": ["meow", "bark", "um... weasel noise?", "nay", "chirp"],
+        },
+        index=range(5),
+    ).set_index("a")
+
+
+@pytest.fixture
+def left_w_dups(left_no_dup):
+    return concat(
+        [left_no_dup, DataFrame({"a": ["a"], "b": ["cow"]}, index=[3])], sort=True
+    )
+
+
+@pytest.fixture
+def right_w_dups(right_no_dup):
+    return concat(
+        [right_no_dup, DataFrame({"a": ["e"], "c": ["moo"]}, index=[3])]
+    ).set_index("a")
+
+
 @pytest.mark.parametrize(
     "how, sort, expected",
     [
@@ -78,10 +114,138 @@ def right():
 )
 def test_join(left, right, how, sort, expected):
 
-    result = left.join(right, how=how, sort=sort)
+    result = left.join(right, how=how, sort=sort, validate="1:1")
     tm.assert_frame_equal(result, expected)
 
 
+def test_suffix_on_list_join():
+    first = DataFrame({"key": [1, 2, 3, 4, 5]})
+    second = DataFrame({"key": [1, 8, 3, 2, 5], "v1": [1, 2, 3, 4, 5]})
+    third = DataFrame({"keys": [5, 2, 3, 4, 1], "v2": [1, 2, 3, 4, 5]})
+
+    # check proper errors are raised
+    msg = "Suffixes not supported when joining multiple DataFrames"
+    with pytest.raises(ValueError, match=msg):
+        first.join([second], lsuffix="y")
+    with pytest.raises(ValueError, match=msg):
+        first.join([second, third], rsuffix="x")
+    with pytest.raises(ValueError, match=msg):
+        first.join([second, third], lsuffix="y", rsuffix="x")
+    with pytest.raises(ValueError, match="Indexes have overlapping values"):
+        first.join([second, third])
+
+    # no errors should be raised
+    arr_joined = first.join([third])
+    norm_joined = first.join(third)
+    tm.assert_frame_equal(arr_joined, norm_joined)
+
+
+def test_join_invalid_validate(left_no_dup, right_no_dup):
+    # GH 46622
+    # Check invalid arguments
+    msg = "Not a valid argument for validate"
+    with pytest.raises(ValueError, match=msg):
+        left_no_dup.merge(right_no_dup, on="a", validate="invalid")
+
+
+def test_join_on_single_col_dup_on_right(left_no_dup, right_w_dups):
+    # GH 46622
+    # Dups on right allowed by one_to_many constraint
+    left_no_dup.join(
+        right_w_dups,
+        on="a",
+        validate="one_to_many",
+    )
+
+    # Dups on right not allowed by one_to_one constraint
+    msg = "Merge keys are not unique in right dataset; not a one-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_no_dup.join(
+            right_w_dups,
+            on="a",
+            validate="one_to_one",
+        )
+
+
+def test_join_on_single_col_dup_on_left(left_w_dups, right_no_dup):
+    # GH 46622
+    # Dups on left allowed by many_to_one constraint
+    left_w_dups.join(
+        right_no_dup,
+        on="a",
+        validate="many_to_one",
+    )
+
+    # Dups on left not allowed by one_to_one constraint
+    msg = "Merge keys are not unique in left dataset; not a one-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_no_dup,
+            on="a",
+            validate="one_to_one",
+        )
+
+
+def test_join_on_single_col_dup_on_both(left_w_dups, right_w_dups):
+    # GH 46622
+    # Dups on both allowed by many_to_many constraint
+    left_w_dups.join(right_w_dups, on="a", validate="many_to_many")
+
+    # Dups on both not allowed by many_to_one constraint
+    msg = "Merge keys are not unique in right dataset; not a many-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_w_dups,
+            on="a",
+            validate="many_to_one",
+        )
+
+    # Dups on both not allowed by one_to_many constraint
+    msg = "Merge keys are not unique in left dataset; not a one-to-many merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_w_dups,
+            on="a",
+            validate="one_to_many",
+        )
+
+
+def test_join_on_multi_col_check_dup():
+    # GH 46622
+    # Two column join, dups in both, but jointly no dups
+    left = DataFrame(
+        {
+            "a": ["a", "a", "b", "b"],
+            "b": [0, 1, 0, 1],
+            "c": ["cat", "dog", "weasel", "horse"],
+        },
+        index=range(4),
+    ).set_index(["a", "b"])
+
+    right = DataFrame(
+        {
+            "a": ["a", "a", "b"],
+            "b": [0, 1, 0],
+            "d": ["meow", "bark", "um... weasel noise?"],
+        },
+        index=range(3),
+    ).set_index(["a", "b"])
+
+    expected_multi = DataFrame(
+        {
+            "a": ["a", "a", "b"],
+            "b": [0, 1, 0],
+            "c": ["cat", "dog", "weasel"],
+            "d": ["meow", "bark", "um... weasel noise?"],
+        },
+        index=range(3),
+    ).set_index(["a", "b"])
+
+    # Jointly no dups allowed by one_to_one constraint
+    result = left.join(right, how="inner", validate="1:1")
+    tm.assert_frame_equal(result, expected_multi)
+
+
 def test_join_index(float_frame):
     # left / right
 
@@ -203,6 +367,15 @@ def test_join_left_sequence_non_unique_index():
     tm.assert_frame_equal(joined, expected)
 
 
+def test_join_list_series(float_frame):
+    # GH#46850
+    # Join a DataFrame with a list containing both a Series and a DataFrame
+    left = float_frame.A.to_frame()
+    right = [float_frame.B, float_frame[["C", "D"]]]
+    result = left.join(right)
+    tm.assert_frame_equal(result, float_frame)
+
+
 @pytest.mark.parametrize("sort_kw", [True, False])
 def test_suppress_future_warning_with_sort_kw(sort_kw):
     a = DataFrame({"col1": [1, 2]}, index=["c", "a"])
@@ -323,6 +496,26 @@ def test_join_multiindex_leftright(self):
         tm.assert_frame_equal(df1.join(df2, how="right"), exp)
         tm.assert_frame_equal(df2.join(df1, how="left"), exp[["value2", "value1"]])
 
+    def test_join_multiindex_dates(self):
+        # GH 33692
+        date = pd.Timestamp(2000, 1, 1).date()
+
+        df1_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df1 = DataFrame({"col1": [0]}, index=df1_index)
+        df2_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df2 = DataFrame({"col2": [0]}, index=df2_index)
+        df3_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df3 = DataFrame({"col3": [0]}, index=df3_index)
+
+        result = df1.join([df2, df3])
+
+        expected_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        expected = DataFrame(
+            {"col1": [0], "col2": [0], "col3": [0]}, index=expected_index
+        )
+
+        tm.assert_equal(result, expected)
+
     def test_merge_join_different_levels(self):
         # GH#9455
 
diff --git a/pandas/tests/frame/methods/test_nlargest.py b/pandas/tests/frame/methods/test_nlargest.py
index 1b2db80d782ce..a317dae562ae0 100644
--- a/pandas/tests/frame/methods/test_nlargest.py
+++ b/pandas/tests/frame/methods/test_nlargest.py
@@ -216,3 +216,24 @@ def test_nlargest_nan(self):
         result = df.nlargest(5, 0)
         expected = df.sort_values(0, ascending=False).head(5)
         tm.assert_frame_equal(result, expected)
+
+    def test_nsmallest_nan_after_n_element(self):
+        # GH#46589
+        df = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, None, 7],
+                "b": [7, 6, 5, 4, 3, 2, 1],
+                "c": [1, 1, 2, 2, 3, 3, 3],
+            },
+            index=range(7),
+        )
+        result = df.nsmallest(5, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5],
+                "b": [7, 6, 5, 4, 3],
+                "c": [1, 1, 2, 2, 3],
+            },
+            index=range(5),
+        ).astype({"a": "float"})
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_pipe.py b/pandas/tests/frame/methods/test_pipe.py
index 1d7cc16f49280..5bcc4360487f3 100644
--- a/pandas/tests/frame/methods/test_pipe.py
+++ b/pandas/tests/frame/methods/test_pipe.py
@@ -15,7 +15,7 @@ def test_pipe(self, frame_or_series):
             obj = obj["A"]
             expected = expected["A"]
 
-        f = lambda x, y: x ** y
+        f = lambda x, y: x**y
         result = obj.pipe(f, 2)
         tm.assert_equal(result, expected)
 
diff --git a/pandas/tests/frame/methods/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py
index 8ff1b211c0db1..139360d332916 100644
--- a/pandas/tests/frame/methods/test_quantile.py
+++ b/pandas/tests/frame/methods/test_quantile.py
@@ -1,7 +1,10 @@
 import numpy as np
 import pytest
 
-from pandas.compat.numpy import np_percentile_argname
+from pandas.compat.numpy import (
+    np_percentile_argname,
+    np_version_under1p21,
+)
 
 import pandas as pd
 from pandas import (
@@ -13,7 +16,46 @@
 import pandas._testing as tm
 
 
+@pytest.fixture(
+    params=[["linear", "single"], ["nearest", "table"]], ids=lambda x: "-".join(x)
+)
+def interp_method(request):
+    """(interpolation, method) arguments for quantile"""
+    return request.param
+
+
 class TestDataFrameQuantile:
+    @pytest.mark.parametrize(
+        "non_num_col",
+        [
+            pd.date_range("2014-01-01", periods=3, freq="m"),
+            ["a", "b", "c"],
+            [DataFrame, Series, Timestamp],
+        ],
+    )
+    def test_numeric_only_default_false_warning(
+        self, non_num_col, interp_method, request, using_array_manager
+    ):
+        # GH #7308
+        interpolation, method = interp_method
+        df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]})
+        df["C"] = non_num_col
+
+        expected = Series(
+            [2.0, 3.0],
+            index=["A", "B"],
+            name=0.5,
+        )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        with tm.assert_produces_warning(FutureWarning, match="numeric_only"):
+            result = df.quantile(0.5, interpolation=interpolation, method=method)
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize(
         "df,expected",
         [
@@ -39,66 +81,142 @@ def test_quantile_sparse(self, df, expected):
 
         tm.assert_series_equal(result, expected)
 
-    def test_quantile(self, datetime_frame):
-        from numpy import percentile
-
+    def test_quantile(
+        self, datetime_frame, interp_method, using_array_manager, request
+    ):
+        interpolation, method = interp_method
         df = datetime_frame
-        q = df.quantile(0.1, axis=0)
-        assert q["A"] == percentile(df["A"], 10)
-        tm.assert_index_equal(q.index, df.columns)
+        result = df.quantile(
+            0.1, axis=0, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series(
+            [np.percentile(df[col], 10) for col in df.columns],
+            index=df.columns,
+            name=0.1,
+        )
+        if interpolation == "linear":
+            # np.percentile values only comparable to linear interpolation
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.index, expected.index)
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    using_array_manager, reason="Name set incorrectly for arraymanager"
+                )
+            )
+            assert result.name == expected.name
 
-        q = df.quantile(0.9, axis=1)
-        assert q["2000-01-17"] == percentile(df.loc["2000-01-17"], 90)
-        tm.assert_index_equal(q.index, df.index)
+        result = df.quantile(
+            0.9, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series(
+            [np.percentile(df.loc[date], 90) for date in df.index],
+            index=df.index,
+            name=0.9,
+        )
+        if interpolation == "linear":
+            # np.percentile values only comparable to linear interpolation
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.index, expected.index)
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    using_array_manager, reason="Name set incorrectly for arraymanager"
+                )
+            )
+            assert result.name == expected.name
 
-        # test degenerate case
-        q = DataFrame({"x": [], "y": []}).quantile(0.1, axis=0)
+    def test_empty(self, interp_method):
+        interpolation, method = interp_method
+        q = DataFrame({"x": [], "y": []}).quantile(
+            0.1, axis=0, numeric_only=True, interpolation=interpolation, method=method
+        )
         assert np.isnan(q["x"]) and np.isnan(q["y"])
 
-        # non-numeric exclusion
+    def test_non_numeric_exclusion(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
         df = DataFrame({"col1": ["A", "A", "B", "B"], "col2": [1, 2, 3, 4]})
-        rs = df.quantile(0.5)
+        rs = df.quantile(
+            0.5, numeric_only=True, interpolation=interpolation, method=method
+        )
         with tm.assert_produces_warning(FutureWarning, match="Select only valid"):
             xp = df.median().rename(0.5)
+        if interpolation == "nearest":
+            xp = (xp + 0.5).astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         tm.assert_series_equal(rs, xp)
 
+    def test_axis(self, interp_method, request, using_array_manager):
         # axis
+        interpolation, method = interp_method
         df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
-        result = df.quantile(0.5, axis=1)
+        result = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
         expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         tm.assert_series_equal(result, expected)
 
-        result = df.quantile([0.5, 0.75], axis=1)
+        result = df.quantile(
+            [0.5, 0.75], axis=1, interpolation=interpolation, method=method
+        )
         expected = DataFrame(
             {1: [1.5, 1.75], 2: [2.5, 2.75], 3: [3.5, 3.75]}, index=[0.5, 0.75]
         )
+        if interpolation == "nearest":
+            expected.iloc[0, :] -= 0.5
+            expected.iloc[1, :] += 0.25
+            expected = expected.astype(np.int64)
         tm.assert_frame_equal(result, expected, check_index_type=True)
 
+    def test_axis_numeric_only_true(self, interp_method, request, using_array_manager):
         # We may want to break API in the future to change this
         # so that we exclude non-numeric along the same axis
         # See GH #7312
+        interpolation, method = interp_method
         df = DataFrame([[1, 2, 3], ["a", "b", 4]])
-        result = df.quantile(0.5, axis=1)
+        result = df.quantile(
+            0.5, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
         expected = Series([3.0, 4.0], index=[0, 1], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         tm.assert_series_equal(result, expected)
 
-    def test_quantile_date_range(self):
+    def test_quantile_date_range(self, interp_method, request, using_array_manager):
         # GH 2460
-
+        interpolation, method = interp_method
         dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
         ser = Series(dti)
         df = DataFrame(ser)
 
-        result = df.quantile(numeric_only=False)
+        result = df.quantile(
+            numeric_only=False, interpolation=interpolation, method=method
+        )
         expected = Series(
             ["2016-01-02 00:00:00"], name=0.5, dtype="datetime64[ns, US/Pacific]"
         )
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
 
         tm.assert_series_equal(result, expected)
 
-    def test_quantile_axis_mixed(self):
+    def test_quantile_axis_mixed(self, interp_method, request, using_array_manager):
 
         # mixed on axis=1
+        interpolation, method = interp_method
         df = DataFrame(
             {
                 "A": [1, 2, 3],
@@ -107,8 +225,16 @@ def test_quantile_axis_mixed(self):
                 "D": ["foo", "bar", "baz"],
             }
         )
-        result = df.quantile(0.5, axis=1)
+        result = df.quantile(
+            0.5, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
         expected = Series([1.5, 2.5, 3.5], name=0.5)
+        if interpolation == "nearest":
+            expected -= 0.5
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         tm.assert_series_equal(result, expected)
 
         # must raise
@@ -116,30 +242,44 @@ def test_quantile_axis_mixed(self):
         with pytest.raises(TypeError, match=msg):
             df.quantile(0.5, axis=1, numeric_only=False)
 
-    def test_quantile_axis_parameter(self):
+    def test_quantile_axis_parameter(self, interp_method, request, using_array_manager):
         # GH 9543/9544
-
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
 
-        result = df.quantile(0.5, axis=0)
+        result = df.quantile(0.5, axis=0, interpolation=interpolation, method=method)
 
         expected = Series([2.0, 3.0], index=["A", "B"], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
         tm.assert_series_equal(result, expected)
 
-        expected = df.quantile(0.5, axis="index")
+        expected = df.quantile(
+            0.5, axis="index", interpolation=interpolation, method=method
+        )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
         tm.assert_series_equal(result, expected)
 
-        result = df.quantile(0.5, axis=1)
+        result = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
 
         expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
         tm.assert_series_equal(result, expected)
 
-        result = df.quantile(0.5, axis="columns")
+        result = df.quantile(
+            0.5, axis="columns", interpolation=interpolation, method=method
+        )
         tm.assert_series_equal(result, expected)
 
         msg = "No axis named -1 for object type DataFrame"
         with pytest.raises(ValueError, match=msg):
-            df.quantile(0.1, axis=-1)
+            df.quantile(0.1, axis=-1, interpolation=interpolation, method=method)
         msg = "No axis named column for object type DataFrame"
         with pytest.raises(ValueError, match=msg):
             df.quantile(0.1, axis="column")
@@ -206,7 +346,7 @@ def test_quantile_interpolation_datetime(self, datetime_frame):
 
         # interpolation = linear (default case)
         df = datetime_frame
-        q = df.quantile(0.1, axis=0, interpolation="linear")
+        q = df.quantile(0.1, axis=0, numeric_only=True, interpolation="linear")
         assert q["A"] == np.percentile(df["A"], 10)
 
     def test_quantile_interpolation_int(self, int_frame):
@@ -222,24 +362,45 @@ def test_quantile_interpolation_int(self, int_frame):
         assert q1["A"] == np.percentile(df["A"], 10)
         tm.assert_series_equal(q, q1)
 
-    def test_quantile_multi(self):
+    def test_quantile_multi(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
         df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
-        result = df.quantile([0.25, 0.5])
+        result = df.quantile([0.25, 0.5], interpolation=interpolation, method=method)
         expected = DataFrame(
             [[1.5, 1.5, 1.5], [2.0, 2.0, 2.0]],
             index=[0.25, 0.5],
             columns=["a", "b", "c"],
         )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         tm.assert_frame_equal(result, expected)
 
-        # axis = 1
-        result = df.quantile([0.25, 0.5], axis=1)
+    def test_quantile_multi_axis_1(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
+        result = df.quantile(
+            [0.25, 0.5], axis=1, interpolation=interpolation, method=method
+        )
         expected = DataFrame(
-            [[1.5, 1.5, 1.5], [2.0, 2.0, 2.0]], index=[0.25, 0.5], columns=[0, 1, 2]
+            [[1.0, 2.0, 3.0]] * 2, index=[0.25, 0.5], columns=[0, 1, 2]
         )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_frame_equal(result, expected)
 
-        # empty
-        result = DataFrame({"x": [], "y": []}).quantile([0.1, 0.9], axis=0)
+    def test_quantile_multi_empty(self, interp_method):
+        interpolation, method = interp_method
+        result = DataFrame({"x": [], "y": []}).quantile(
+            [0.1, 0.9], axis=0, interpolation=interpolation, method=method
+        )
         expected = DataFrame(
             {"x": [np.nan, np.nan], "y": [np.nan, np.nan]}, index=[0.1, 0.9]
         )
@@ -249,8 +410,9 @@ def test_quantile_datetime(self):
         df = DataFrame({"a": pd.to_datetime(["2010", "2011"]), "b": [0, 5]})
 
         # exclude datetime
-        result = df.quantile(0.5)
-        expected = Series([2.5], index=["b"])
+        result = df.quantile(0.5, numeric_only=True)
+        expected = Series([2.5], index=["b"], name=0.5)
+        tm.assert_series_equal(result, expected)
 
         # datetime
         result = df.quantile(0.5, numeric_only=False)
@@ -285,21 +447,58 @@ def test_quantile_datetime(self):
         tm.assert_frame_equal(result, expected)
 
         # empty when numeric_only=True
-        result = df[["a", "c"]].quantile(0.5)
+        result = df[["a", "c"]].quantile(0.5, numeric_only=True)
         expected = Series([], index=[], dtype=np.float64, name=0.5)
         tm.assert_series_equal(result, expected)
 
-        result = df[["a", "c"]].quantile([0.5])
+        result = df[["a", "c"]].quantile([0.5], numeric_only=True)
         expected = DataFrame(index=[0.5])
         tm.assert_frame_equal(result, expected)
 
-    def test_quantile_invalid(self, datetime_frame):
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "datetime64[ns]",
+            "datetime64[ns, US/Pacific]",
+            "timedelta64[ns]",
+            "Period[D]",
+        ],
+    )
+    def test_quantile_dt64_empty(self, dtype, interp_method):
+        # GH#41544
+        interpolation, method = interp_method
+        df = DataFrame(columns=["a", "b"], dtype=dtype)
+
+        res = df.quantile(
+            0.5, axis=1, numeric_only=False, interpolation=interpolation, method=method
+        )
+        expected = Series([], index=[], name=0.5, dtype=dtype)
+        tm.assert_series_equal(res, expected)
+
+        # no columns in result, so no dtype preservation
+        res = df.quantile(
+            [0.5],
+            axis=1,
+            numeric_only=False,
+            interpolation=interpolation,
+            method=method,
+        )
+        expected = DataFrame(index=[0.5])
+        tm.assert_frame_equal(res, expected)
+
+    @pytest.mark.parametrize("invalid", [-1, 2, [0.5, -1], [0.5, 2]])
+    def test_quantile_invalid(self, invalid, datetime_frame, interp_method):
         msg = "percentiles should all be in the interval \\[0, 1\\]"
-        for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
-            with pytest.raises(ValueError, match=msg):
-                datetime_frame.quantile(invalid)
+        interpolation, method = interp_method
+        with pytest.raises(ValueError, match=msg):
+            datetime_frame.quantile(invalid, interpolation=interpolation, method=method)
 
-    def test_quantile_box(self):
+    def test_quantile_box(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         df = DataFrame(
             {
                 "A": [
@@ -320,7 +519,9 @@ def test_quantile_box(self):
             }
         )
 
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
 
         exp = Series(
             [
@@ -333,7 +534,9 @@ def test_quantile_box(self):
         )
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5], numeric_only=False)
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = DataFrame(
             [
                 [
@@ -347,6 +550,7 @@ def test_quantile_box(self):
         )
         tm.assert_frame_equal(res, exp)
 
+    def test_quantile_box_nat(self):
         # DatetimeLikeBlock may be consolidated and contain NaT in different loc
         df = DataFrame(
             {
@@ -422,49 +626,73 @@ def test_quantile_box(self):
         )
         tm.assert_frame_equal(res, exp)
 
-    def test_quantile_nan(self):
-
+    def test_quantile_nan(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         # GH 14357 - float block where some cols have missing values
         df = DataFrame({"a": np.arange(1, 6.0), "b": np.arange(1, 6.0)})
         df.iloc[-1, 1] = np.nan
 
-        res = df.quantile(0.5)
-        exp = Series([3.0, 2.5], index=["a", "b"], name=0.5)
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
+        exp = Series(
+            [3.0, 2.5 if interpolation == "linear" else 3.0], index=["a", "b"], name=0.5
+        )
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5, 0.75])
-        exp = DataFrame({"a": [3.0, 4.0], "b": [2.5, 3.25]}, index=[0.5, 0.75])
+        res = df.quantile([0.5, 0.75], interpolation=interpolation, method=method)
+        exp = DataFrame(
+            {
+                "a": [3.0, 4.0],
+                "b": [2.5, 3.25] if interpolation == "linear" else [3.0, 4.0],
+            },
+            index=[0.5, 0.75],
+        )
         tm.assert_frame_equal(res, exp)
 
-        res = df.quantile(0.5, axis=1)
+        res = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
         exp = Series(np.arange(1.0, 6.0), name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5, 0.75], axis=1)
+        res = df.quantile(
+            [0.5, 0.75], axis=1, interpolation=interpolation, method=method
+        )
         exp = DataFrame([np.arange(1.0, 6.0)] * 2, index=[0.5, 0.75])
+        if interpolation == "nearest":
+            exp.iloc[1, -1] = np.nan
         tm.assert_frame_equal(res, exp)
 
         # full-nan column
         df["b"] = np.nan
 
-        res = df.quantile(0.5)
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
         exp = Series([3.0, np.nan], index=["a", "b"], name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5, 0.75])
+        res = df.quantile([0.5, 0.75], interpolation=interpolation, method=method)
         exp = DataFrame({"a": [3.0, 4.0], "b": [np.nan, np.nan]}, index=[0.5, 0.75])
         tm.assert_frame_equal(res, exp)
 
-    def test_quantile_nat(self):
-
+    def test_quantile_nat(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
         # full NaT column
         df = DataFrame({"a": [pd.NaT, pd.NaT, pd.NaT]})
 
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = Series([pd.NaT], index=["a"], name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5], numeric_only=False)
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = DataFrame({"a": [pd.NaT]}, index=[0.5])
         tm.assert_frame_equal(res, exp)
 
@@ -480,50 +708,57 @@ def test_quantile_nat(self):
             }
         )
 
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = Series([Timestamp("2012-01-02"), pd.NaT], index=["a", "b"], name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5], numeric_only=False)
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = DataFrame(
             [[Timestamp("2012-01-02"), pd.NaT]], index=[0.5], columns=["a", "b"]
         )
         tm.assert_frame_equal(res, exp)
 
-    def test_quantile_empty_no_rows_floats(self):
+    def test_quantile_empty_no_rows_floats(self, interp_method):
+        interpolation, method = interp_method
 
-        # floats
         df = DataFrame(columns=["a", "b"], dtype="float64")
 
-        res = df.quantile(0.5)
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
         exp = Series([np.nan, np.nan], index=["a", "b"], name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5])
+        res = df.quantile([0.5], interpolation=interpolation, method=method)
         exp = DataFrame([[np.nan, np.nan]], columns=["a", "b"], index=[0.5])
         tm.assert_frame_equal(res, exp)
 
-        res = df.quantile(0.5, axis=1)
+        res = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
         exp = Series([], index=[], dtype="float64", name=0.5)
         tm.assert_series_equal(res, exp)
 
-        res = df.quantile([0.5], axis=1)
+        res = df.quantile([0.5], axis=1, interpolation=interpolation, method=method)
         exp = DataFrame(columns=[], index=[0.5])
         tm.assert_frame_equal(res, exp)
 
-    def test_quantile_empty_no_rows_ints(self):
-        # ints
+    def test_quantile_empty_no_rows_ints(self, interp_method):
+        interpolation, method = interp_method
         df = DataFrame(columns=["a", "b"], dtype="int64")
 
-        res = df.quantile(0.5)
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
         exp = Series([np.nan, np.nan], index=["a", "b"], name=0.5)
         tm.assert_series_equal(res, exp)
 
-    def test_quantile_empty_no_rows_dt64(self):
+    def test_quantile_empty_no_rows_dt64(self, interp_method):
+        interpolation, method = interp_method
         # datetimes
         df = DataFrame(columns=["a", "b"], dtype="datetime64[ns]")
 
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = Series(
             [pd.NaT, pd.NaT], index=["a", "b"], dtype="datetime64[ns]", name=0.5
         )
@@ -531,43 +766,61 @@ def test_quantile_empty_no_rows_dt64(self):
 
         # Mixed dt64/dt64tz
         df["a"] = df["a"].dt.tz_localize("US/Central")
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = exp.astype(object)
         tm.assert_series_equal(res, exp)
 
         # both dt64tz
         df["b"] = df["b"].dt.tz_localize("US/Central")
-        res = df.quantile(0.5, numeric_only=False)
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
         exp = exp.astype(df["b"].dtype)
         tm.assert_series_equal(res, exp)
 
-    def test_quantile_empty_no_columns(self):
+    def test_quantile_empty_no_columns(self, interp_method):
         # GH#23925 _get_numeric_data may drop all columns
+        interpolation, method = interp_method
         df = DataFrame(pd.date_range("1/1/18", periods=5))
         df.columns.name = "captain tightpants"
-        result = df.quantile(0.5)
+        result = df.quantile(
+            0.5, numeric_only=True, interpolation=interpolation, method=method
+        )
         expected = Series([], index=[], name=0.5, dtype=np.float64)
         expected.index.name = "captain tightpants"
         tm.assert_series_equal(result, expected)
 
-        result = df.quantile([0.5])
+        result = df.quantile(
+            [0.5], numeric_only=True, interpolation=interpolation, method=method
+        )
         expected = DataFrame([], index=[0.5], columns=[])
         expected.columns.name = "captain tightpants"
         tm.assert_frame_equal(result, expected)
 
-    def test_quantile_item_cache(self, using_array_manager):
+    def test_quantile_item_cache(self, using_array_manager, interp_method):
         # previous behavior incorrect retained an invalid _item_cache entry
+        interpolation, method = interp_method
         df = DataFrame(np.random.randn(4, 3), columns=["A", "B", "C"])
         df["D"] = df["A"] * 2
         ser = df["A"]
         if not using_array_manager:
             assert len(df._mgr.blocks) == 2
 
-        df.quantile(numeric_only=False)
+        df.quantile(numeric_only=False, interpolation=interpolation, method=method)
         ser.values[0] = 99
 
         assert df.iloc[0, 0] == df["A"][0]
 
+    def test_invalid_method(self):
+        with pytest.raises(ValueError, match="Invalid method: foo"):
+            DataFrame(range(1)).quantile(0.5, method="foo")
+
+    def test_table_invalid_interpolation(self):
+        with pytest.raises(ValueError, match="Invalid interpolation: foo"):
+            DataFrame(range(1)).quantile(0.5, method="table", interpolation="foo")
+
 
 class TestQuantileExtensionDtype:
     # TODO: tests for axis=1?
@@ -611,7 +864,7 @@ def compute_quantile(self, obj, qs):
             result = obj.quantile(qs, numeric_only=False)
         return result
 
-    def test_quantile_ea(self, obj, index):
+    def test_quantile_ea(self, request, obj, index):
 
         # result should be invariant to shuffling
         indexer = np.arange(len(index), dtype=np.intp)
@@ -621,9 +874,19 @@ def test_quantile_ea(self, obj, index):
         qs = [0.5, 0, 1]
         result = self.compute_quantile(obj, qs)
 
+        if np_version_under1p21 and index.dtype == "timedelta64[ns]":
+            msg = "failed on Numpy 1.20.3; TypeError: data type 'Int64' not understood"
+            mark = pytest.mark.xfail(reason=msg, raises=TypeError)
+            request.node.add_marker(mark)
+
+        exp_dtype = index.dtype
+        if index.dtype == "Int64":
+            # match non-nullable casting behavior
+            exp_dtype = "Float64"
+
         # expected here assumes len(index) == 9
         expected = Series(
-            [index[4], index[0], index[-1]], dtype=index.dtype, index=qs, name="A"
+            [index[4], index[0], index[-1]], dtype=exp_dtype, index=qs, name="A"
         )
         expected = type(obj)(expected)
 
@@ -651,23 +914,11 @@ def test_quantile_ea_with_na(self, obj, index):
 
     # TODO(GH#39763): filtering can be removed after GH#39763 is fixed
     @pytest.mark.filterwarnings("ignore:Using .astype to convert:FutureWarning")
-    def test_quantile_ea_all_na(
-        self, obj, index, frame_or_series, using_array_manager, request
-    ):
-        if (
-            using_array_manager
-            and frame_or_series is DataFrame
-            and index.dtype == "m8[ns]"
-        ):
-            mark = pytest.mark.xfail(
-                reason="obj.astype fails bc obj is incorrectly dt64 at this point"
-            )
-            request.node.add_marker(mark)
-
+    def test_quantile_ea_all_na(self, request, obj, index):
         obj.iloc[:] = index._na_value
 
         # TODO(ArrayManager): this casting should be unnecessary after GH#39763 is fixed
-        obj[:] = obj.astype(index.dtype)
+        obj = obj.astype(index.dtype)
         assert np.all(obj.dtypes == index.dtype)
 
         # result should be invariant to shuffling
@@ -683,7 +934,7 @@ def test_quantile_ea_all_na(
         expected = type(obj)(expected)
         tm.assert_equal(result, expected)
 
-    def test_quantile_ea_scalar(self, obj, index):
+    def test_quantile_ea_scalar(self, request, obj, index):
         # scalar qs
 
         # result should be invariant to shuffling
@@ -694,7 +945,16 @@ def test_quantile_ea_scalar(self, obj, index):
         qs = 0.5
         result = self.compute_quantile(obj, qs)
 
-        expected = Series({"A": index[4]}, dtype=index.dtype, name=0.5)
+        if np_version_under1p21 and index.dtype == "timedelta64[ns]":
+            msg = "failed on Numpy 1.20.3; TypeError: data type 'Int64' not understood"
+            mark = pytest.mark.xfail(reason=msg, raises=TypeError)
+            request.node.add_marker(mark)
+
+        exp_dtype = index.dtype
+        if index.dtype == "Int64":
+            exp_dtype = "Float64"
+
+        expected = Series({"A": index[4]}, dtype=exp_dtype, name=0.5)
         if isinstance(obj, Series):
             expected = expected["A"]
             assert result == expected
@@ -722,14 +982,7 @@ def test_empty_numeric(self, dtype, expected_data, expected_index, axis):
     @pytest.mark.parametrize(
         "dtype, expected_data, expected_index, axis, expected_dtype",
         [
-            pytest.param(
-                "datetime64[ns]",
-                [],
-                [],
-                1,
-                "datetime64[ns]",
-                marks=pytest.mark.xfail(reason="#GH 41544"),
-            ),
+            ["datetime64[ns]", [], [], 1, "datetime64[ns]"],
             ["datetime64[ns]", [pd.NaT, pd.NaT], ["a", "b"], 0, "datetime64[ns]"],
         ],
     )
@@ -760,7 +1013,7 @@ def test_datelike_numeric_only(self, expected_data, expected_index, axis):
                 "c": pd.to_datetime(["2011", "2012"]),
             }
         )
-        result = df[["a", "c"]].quantile(0.5, axis=axis)
+        result = df[["a", "c"]].quantile(0.5, axis=axis, numeric_only=True)
         expected = Series(
             expected_data, name=0.5, index=Index(expected_index), dtype=np.float64
         )
diff --git a/pandas/tests/frame/methods/test_rank.py b/pandas/tests/frame/methods/test_rank.py
index 48188b66c45b5..7b2f7908673e3 100644
--- a/pandas/tests/frame/methods/test_rank.py
+++ b/pandas/tests/frame/methods/test_rank.py
@@ -327,12 +327,11 @@ def test_rank_pct_true(self, method, exp):
         expected = DataFrame(exp)
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.single
-    @pytest.mark.high_memory
+    @pytest.mark.single_cpu
     def test_pct_max_many_rows(self):
         # GH 18271
         df = DataFrame(
-            {"A": np.arange(2 ** 24 + 1), "B": np.arange(2 ** 24 + 1, 0, -1)}
+            {"A": np.arange(2**24 + 1), "B": np.arange(2**24 + 1, 0, -1)}
         )
         result = df.rank(pct=True).max()
         assert (result == 1).all()
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index 6eee1c57287e2..8575e7895ae5a 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -8,6 +8,7 @@
 import pytest
 
 from pandas._libs.tslibs.timezones import dateutil_gettz as gettz
+import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
@@ -133,6 +134,7 @@ def test_reindex_copies(self):
         result2 = df.reindex(columns=cols, index=df.index, copy=True)
         assert not np.shares_memory(result2[0]._values, df[0]._values)
 
+    @td.skip_array_manager_not_yet_implemented
     def test_reindex_date_fill_value(self):
         # passing date to dt64 is deprecated
         arr = date_range("2016-01-01", periods=6).values.reshape(3, 2)
@@ -149,6 +151,11 @@ def test_reindex_date_fill_value(self):
         )
         tm.assert_frame_equal(res, expected)
 
+        # only reindexing rows
+        with tm.assert_produces_warning(FutureWarning):
+            res = df.reindex(index=range(4), fill_value=fv)
+        tm.assert_frame_equal(res, expected[["A", "B"]])
+
         # same with a datetime-castable str
         res = df.reindex(
             index=range(4), columns=["A", "B", "C"], fill_value="2016-01-01"
diff --git a/pandas/tests/frame/methods/test_rename.py b/pandas/tests/frame/methods/test_rename.py
index 33fb191027c27..405518c372b2c 100644
--- a/pandas/tests/frame/methods/test_rename.py
+++ b/pandas/tests/frame/methods/test_rename.py
@@ -171,13 +171,23 @@ def test_rename_multiindex(self):
         tm.assert_index_equal(renamed.index, new_index)
 
     @td.skip_array_manager_not_yet_implemented  # TODO(ArrayManager) setitem copy/view
-    def test_rename_nocopy(self, float_frame):
+    def test_rename_nocopy(self, float_frame, using_copy_on_write):
         renamed = float_frame.rename(columns={"C": "foo"}, copy=False)
 
         assert np.shares_memory(renamed["foo"]._values, float_frame["C"]._values)
 
-        renamed.loc[:, "foo"] = 1.0
-        assert (float_frame["C"] == 1.0).all()
+        # TODO(CoW) this also shouldn't warn in case of CoW, but the heuristic
+        # checking if the array shares memory doesn't work if CoW happened
+        with tm.assert_produces_warning(
+            DeprecationWarning if using_copy_on_write else None
+        ):
+            # This loc setitem already happens inplace, so no warning
+            #  that this will change in the future
+            renamed.loc[:, "foo"] = 1.0
+        if using_copy_on_write:
+            assert not (float_frame["C"] == 1.0).all()
+        else:
+            assert (float_frame["C"] == 1.0).all()
 
     def test_rename_inplace(self, float_frame):
         float_frame.rename(columns={"C": "foo"})
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index b9024b4233d7f..f4de685688b00 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -6,8 +6,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_version_under1p20
-
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -661,6 +659,39 @@ def test_replace_simple_nested_dict_with_nonexistent_value(self):
         result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
         tm.assert_frame_equal(expected, result)
 
+    def test_replace_NA_with_None(self):
+        # gh-45601
+        df = DataFrame({"value": [42, None]}).astype({"value": "Int64"})
+        result = df.replace({pd.NA: None})
+        expected = DataFrame({"value": [42, None]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_NAT_with_None(self):
+        # gh-45836
+        df = DataFrame([pd.NaT, pd.NaT])
+        result = df.replace({pd.NaT: None, np.NaN: None})
+        expected = DataFrame([None, None])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_None_keeps_categorical(self):
+        # gh-46634
+        cat_series = Series(["b", "b", "b", "d"], dtype="category")
+        df = DataFrame(
+            {
+                "id": Series([5, 4, 3, 2], dtype="float64"),
+                "col": cat_series,
+            }
+        )
+        result = df.replace({3: None})
+
+        expected = DataFrame(
+            {
+                "id": Series([5.0, 4.0, None, 2.0], dtype="object"),
+                "col": cat_series,
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_replace_value_is_none(self, datetime_frame):
         orig_value = datetime_frame.iloc[0, 0]
         orig2 = datetime_frame.iloc[1, 0]
@@ -753,6 +784,13 @@ def test_replace_for_new_dtypes(self, datetime_frame):
                 "bar",
                 DataFrame({"dt": [datetime(3017, 12, 20)], "str": ["bar"]}),
             ),
+            # GH 36782
+            (
+                DataFrame({"dt": [datetime(2920, 10, 1)]}),
+                datetime(2920, 10, 1),
+                datetime(2020, 10, 1),
+                DataFrame({"dt": [datetime(2020, 10, 1)]}),
+            ),
             (
                 DataFrame(
                     {
@@ -869,6 +907,7 @@ def test_replace_input_formats_scalar(self):
         tm.assert_frame_equal(result, expected)
 
     def test_replace_limit(self):
+        # TODO
         pass
 
     def test_replace_dict_no_regex(self):
@@ -1275,12 +1314,6 @@ def test_replace_commutative(self, df, to_replace, exp):
     )
     def test_replace_replacer_dtype(self, request, replacer):
         # GH26632
-        if np.isscalar(replacer) and replacer.dtype.itemsize < 8:
-            request.node.add_marker(
-                pytest.mark.xfail(
-                    np_version_under1p20, reason="np.putmask doesn't coerce dtype"
-                )
-            )
         df = DataFrame(["a"])
         result = df.replace({"a": replacer, "b": replacer})
         expected = DataFrame([replacer])
@@ -1463,6 +1496,18 @@ def test_replace_list_with_mixed_type(
         result = obj.replace(box(to_replace), value)
         tm.assert_equal(result, expected)
 
+    @pytest.mark.parametrize("val", [2, np.nan, 2.0])
+    def test_replace_value_none_dtype_numeric(self, val):
+        # GH#48231
+        df = DataFrame({"a": [1, val]})
+        result = df.replace(val, None)
+        expected = DataFrame({"a": [1, None]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame({"a": [1, val]})
+        result = df.replace({val: None})
+        tm.assert_frame_equal(result, expected)
+
 
 class TestDataFrameReplaceRegex:
     @pytest.mark.parametrize(
@@ -1519,3 +1564,24 @@ def test_replace_regex_dtype_frame(self, regex):
         expected_df2 = DataFrame({"A": [1], "B": ["1"]})
         result_df2 = df2.replace(to_replace="0", value=1, regex=regex)
         tm.assert_frame_equal(result_df2, expected_df2)
+
+    def test_replace_with_value_also_being_replaced(self):
+        # GH46306
+        df = DataFrame({"A": [0, 1, 2], "B": [1, 0, 2]})
+        result = df.replace({0: 1, 1: np.nan})
+        expected = DataFrame({"A": [1, np.nan, 2], "B": [np.nan, 1, 2]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_categorical_no_replacement(self):
+        # GH#46672
+        df = DataFrame(
+            {
+                "a": ["one", "two", None, "three"],
+                "b": ["one", None, "two", "three"],
+            },
+            dtype="category",
+        )
+        expected = df.copy()
+
+        result = df.replace(to_replace=[".", "def"], value=["_", None])
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_reset_index.py b/pandas/tests/frame/methods/test_reset_index.py
index a707bbb377f24..37431bc291b76 100644
--- a/pandas/tests/frame/methods/test_reset_index.py
+++ b/pandas/tests/frame/methods/test_reset_index.py
@@ -27,10 +27,27 @@
 import pandas._testing as tm
 
 
+@pytest.fixture()
+def multiindex_df():
+    levels = [["A", ""], ["B", "b"]]
+    return DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
+
+
 class TestResetIndex:
+    def test_reset_index_empty_rangeindex(self):
+        # GH#45230
+        df = DataFrame(
+            columns=["brand"], dtype=np.int64, index=RangeIndex(0, 0, 1, name="foo")
+        )
+
+        df2 = df.set_index([df.index, "brand"])
+
+        result = df2.reset_index([1], drop=True)
+        tm.assert_frame_equal(result, df[[]], check_index_type=True)
+
     def test_set_reset(self):
 
-        idx = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10], name="foo")
+        idx = Index([2**63, 2**63 + 5, 2**63 + 10], name="foo")
 
         # set/reset
         df = DataFrame({"A": [0, 1, 2]}, index=idx)
@@ -184,44 +201,47 @@ def test_reset_index_name(self):
         assert return_value is None
         assert df.index.name is None
 
-    def test_reset_index_level(self):
+    @pytest.mark.parametrize("levels", [["A", "B"], [0, 1]])
+    def test_reset_index_level(self, levels):
         df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
 
-        for levels in ["A", "B"], [0, 1]:
-            # With MultiIndex
-            result = df.set_index(["A", "B"]).reset_index(level=levels[0])
-            tm.assert_frame_equal(result, df.set_index("B"))
+        # With MultiIndex
+        result = df.set_index(["A", "B"]).reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df.set_index("B"))
 
-            result = df.set_index(["A", "B"]).reset_index(level=levels[:1])
-            tm.assert_frame_equal(result, df.set_index("B"))
+        result = df.set_index(["A", "B"]).reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df.set_index("B"))
 
-            result = df.set_index(["A", "B"]).reset_index(level=levels)
-            tm.assert_frame_equal(result, df)
+        result = df.set_index(["A", "B"]).reset_index(level=levels)
+        tm.assert_frame_equal(result, df)
 
-            result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
-            tm.assert_frame_equal(result, df[["C", "D"]])
+        result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
+        tm.assert_frame_equal(result, df[["C", "D"]])
 
-            # With single-level Index (GH 16263)
-            result = df.set_index("A").reset_index(level=levels[0])
-            tm.assert_frame_equal(result, df)
+        # With single-level Index (GH 16263)
+        result = df.set_index("A").reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df)
 
-            result = df.set_index("A").reset_index(level=levels[:1])
-            tm.assert_frame_equal(result, df)
+        result = df.set_index("A").reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df)
 
-            result = df.set_index(["A"]).reset_index(level=levels[0], drop=True)
-            tm.assert_frame_equal(result, df[["B", "C", "D"]])
+        result = df.set_index(["A"]).reset_index(level=levels[0], drop=True)
+        tm.assert_frame_equal(result, df[["B", "C", "D"]])
 
+    @pytest.mark.parametrize("idx_lev", [["A", "B"], ["A"]])
+    def test_reset_index_level_missing(self, idx_lev):
         # Missing levels - for both MultiIndex and single-level Index:
-        for idx_lev in ["A", "B"], ["A"]:
-            with pytest.raises(KeyError, match=r"(L|l)evel \(?E\)?"):
-                df.set_index(idx_lev).reset_index(level=["A", "E"])
-            with pytest.raises(IndexError, match="Too many levels"):
-                df.set_index(idx_lev).reset_index(level=[0, 1, 2])
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
+
+        with pytest.raises(KeyError, match=r"(L|l)evel \(?E\)?"):
+            df.set_index(idx_lev).reset_index(level=["A", "E"])
+        with pytest.raises(IndexError, match="Too many levels"):
+            df.set_index(idx_lev).reset_index(level=[0, 1, 2])
 
     def test_reset_index_right_dtype(self):
         time = np.arange(0.0, 10, np.sqrt(2) / 2)
         s1 = Series(
-            (9.81 * time ** 2) / 2, index=Index(time, name="time"), name="speed"
+            (9.81 * time**2) / 2, index=Index(time, name="time"), name="speed"
         )
         df = DataFrame(s1)
 
@@ -370,33 +390,31 @@ def test_reset_index_range(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_reset_index_multiindex_columns(self):
-        levels = [["A", ""], ["B", "b"]]
-        df = DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
-        result = df[["B"]].rename_axis("A").reset_index()
-        tm.assert_frame_equal(result, df)
+    def test_reset_index_multiindex_columns(self, multiindex_df):
+        result = multiindex_df[["B"]].rename_axis("A").reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
 
         # GH#16120: already existing column
         msg = r"cannot insert \('A', ''\), already exists"
         with pytest.raises(ValueError, match=msg):
-            df.rename_axis("A").reset_index()
+            multiindex_df.rename_axis("A").reset_index()
 
         # GH#16164: multiindex (tuple) full key
-        result = df.set_index([("A", "")]).reset_index()
-        tm.assert_frame_equal(result, df)
+        result = multiindex_df.set_index([("A", "")]).reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
 
         # with additional (unnamed) index level
         idx_col = DataFrame(
             [[0], [1]], columns=MultiIndex.from_tuples([("level_0", "")])
         )
-        expected = pd.concat([idx_col, df[[("B", "b"), ("A", "")]]], axis=1)
-        result = df.set_index([("B", "b")], append=True).reset_index()
+        expected = pd.concat([idx_col, multiindex_df[[("B", "b"), ("A", "")]]], axis=1)
+        result = multiindex_df.set_index([("B", "b")], append=True).reset_index()
         tm.assert_frame_equal(result, expected)
 
         # with index name which is a too long tuple...
         msg = "Item must have length equal to number of levels."
         with pytest.raises(ValueError, match=msg):
-            df.rename_axis([("C", "c", "i")]).reset_index()
+            multiindex_df.rename_axis([("C", "c", "i")]).reset_index()
 
         # or too short...
         levels = [["A", "a", ""], ["B", "b", "i"]]
@@ -422,6 +440,45 @@ def test_reset_index_multiindex_columns(self):
         result = df2.rename_axis([("c", "ii")]).reset_index(col_level=1, col_fill="C")
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize("flag", [False, True])
+    @pytest.mark.parametrize("allow_duplicates", [False, True])
+    def test_reset_index_duplicate_columns_allow(
+        self, multiindex_df, flag, allow_duplicates
+    ):
+        # GH#44755 reset_index with duplicate column labels
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        if flag and allow_duplicates:
+            result = df.reset_index(allow_duplicates=allow_duplicates)
+            levels = [["A", ""], ["A", ""], ["B", "b"]]
+            expected = DataFrame(
+                [[0, 0, 2], [1, 1, 3]], columns=MultiIndex.from_tuples(levels)
+            )
+            tm.assert_frame_equal(result, expected)
+        else:
+            if not flag and allow_duplicates:
+                msg = "Cannot specify 'allow_duplicates=True' when "
+                "'self.flags.allows_duplicate_labels' is False"
+            else:
+                msg = r"cannot insert \('A', ''\), already exists"
+            with pytest.raises(ValueError, match=msg):
+                df.reset_index(allow_duplicates=allow_duplicates)
+
+    @pytest.mark.parametrize("flag", [False, True])
+    def test_reset_index_duplicate_columns_default(self, multiindex_df, flag):
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        msg = r"cannot insert \('A', ''\), already exists"
+        with pytest.raises(ValueError, match=msg):
+            df.reset_index()
+
+    @pytest.mark.parametrize("allow_duplicates", ["bad value"])
+    def test_reset_index_allow_duplicates_check(self, multiindex_df, allow_duplicates):
+        with pytest.raises(ValueError, match="expected type bool"):
+            multiindex_df.reset_index(allow_duplicates=allow_duplicates)
+
     @pytest.mark.filterwarnings("ignore:Timestamp.freq is deprecated:FutureWarning")
     def test_reset_index_datetime(self, tz_naive_fixture):
         # GH#3950
@@ -697,3 +754,42 @@ def test_reset_index_interval_columns_object_cast():
         columns=Index(["Year", Interval(0, 1), Interval(1, 2)]),
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_rename(float_frame):
+    # GH 6878
+    result = float_frame.reset_index(names="new_name")
+    expected = Series(float_frame.index.values, name="new_name")
+    tm.assert_series_equal(result["new_name"], expected)
+
+    result = float_frame.reset_index(names=123)
+    expected = Series(float_frame.index.values, name=123)
+    tm.assert_series_equal(result[123], expected)
+
+
+def test_reset_index_rename_multiindex(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack()[::2]
+    stacked_df = DataFrame({"foo": stacked_df, "bar": stacked_df})
+
+    names = ["first", "second"]
+    stacked_df.index.names = names
+
+    result = stacked_df.reset_index()
+    expected = stacked_df.reset_index(names=["new_first", "new_second"])
+    tm.assert_series_equal(result["first"], expected["new_first"], check_names=False)
+    tm.assert_series_equal(result["second"], expected["new_second"], check_names=False)
+
+
+def test_errorreset_index_rename(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack()[::2]
+    stacked_df = DataFrame({"first": stacked_df, "second": stacked_df})
+
+    with pytest.raises(
+        ValueError, match="Index names must be str or 1-dimensional list"
+    ):
+        stacked_df.reset_index(names={"first": "new_first", "second": "new_second"})
+
+    with pytest.raises(IndexError, match="list index out of range"):
+        stacked_df.reset_index(names=["new_first"])
diff --git a/pandas/tests/frame/methods/test_select_dtypes.py b/pandas/tests/frame/methods/test_select_dtypes.py
index 4cfd9975652e3..9284e0c0cced6 100644
--- a/pandas/tests/frame/methods/test_select_dtypes.py
+++ b/pandas/tests/frame/methods/test_select_dtypes.py
@@ -15,7 +15,7 @@
 class DummyDtype(ExtensionDtype):
     type = int
 
-    def __init__(self, numeric):
+    def __init__(self, numeric) -> None:
         self._numeric = numeric
 
     @property
@@ -28,7 +28,7 @@ def _is_numeric(self):
 
 
 class DummyArray(ExtensionArray):
-    def __init__(self, data, dtype):
+    def __init__(self, data, dtype) -> None:
         self.data = data
         self._dtype = dtype
 
@@ -441,3 +441,27 @@ def test_select_dtypes_float_dtype(self, expected, float_dtypes):
         df = df.astype(dtype_dict)
         result = df.select_dtypes(include=float_dtypes)
         tm.assert_frame_equal(result, expected)
+
+    def test_np_bool_ea_boolean_include_number(self):
+        # GH 46870
+        df = DataFrame(
+            {
+                "a": [1, 2, 3],
+                "b": pd.Series([True, False, True], dtype="boolean"),
+                "c": np.array([True, False, True]),
+                "d": pd.Categorical([True, False, True]),
+                "e": pd.arrays.SparseArray([True, False, True]),
+            }
+        )
+        result = df.select_dtypes(include="number")
+        expected = DataFrame({"a": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_select_dtypes_no_view(self):
+        # https://github.com/pandas-dev/pandas/issues/48090
+        # result of this method is not a view on the original dataframe
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df_orig = df.copy()
+        result = df.select_dtypes(include=["number"])
+        result.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
diff --git a/pandas/tests/frame/methods/test_set_axis.py b/pandas/tests/frame/methods/test_set_axis.py
index 3284243ddac48..f105a38e6fdd0 100644
--- a/pandas/tests/frame/methods/test_set_axis.py
+++ b/pandas/tests/frame/methods/test_set_axis.py
@@ -21,9 +21,76 @@ def test_set_axis(self, obj):
         expected.index = new_index
 
         # inplace=False
-        result = obj.set_axis(new_index, axis=0, inplace=False)
+        msg = "set_axis 'inplace' keyword is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = obj.set_axis(new_index, axis=0, inplace=False)
         tm.assert_equal(expected, result)
 
+    def test_set_axis_copy(self, obj):
+        # Test copy keyword GH#47932
+        new_index = list("abcd")[: len(obj)]
+
+        orig = obj.iloc[:]
+        expected = obj.copy()
+        expected.index = new_index
+
+        with pytest.raises(
+            ValueError, match="Cannot specify both inplace=True and copy=True"
+        ):
+            with tm.assert_produces_warning(FutureWarning):
+                obj.set_axis(new_index, axis=0, inplace=True, copy=True)
+
+        result = obj.set_axis(new_index, axis=0, copy=True)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        # check we DID make a copy
+        if obj.ndim == 1:
+            assert not tm.shares_memory(result, obj)
+        else:
+            assert not any(
+                tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
+        result = obj.set_axis(new_index, axis=0, copy=False)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        # check we did NOT make a copy
+        if obj.ndim == 1:
+            assert tm.shares_memory(result, obj)
+        else:
+            assert all(
+                tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
+        # copy defaults to True
+        result = obj.set_axis(new_index, axis=0)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        # check we DID make a copy
+        if obj.ndim == 1:
+            assert not tm.shares_memory(result, obj)
+        else:
+            assert not any(
+                tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
+        # Do this last since it alters obj inplace
+        with tm.assert_produces_warning(FutureWarning):
+            res = obj.set_axis(new_index, inplace=True, copy=False)
+        assert res is None
+        tm.assert_equal(expected, obj)
+        # check we did NOT make a copy
+        if obj.ndim == 1:
+            assert tm.shares_memory(obj, orig)
+        else:
+            assert all(
+                tm.shares_memory(obj.iloc[:, i], orig.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
     @pytest.mark.parametrize("axis", [0, "index", 1, "columns"])
     def test_set_axis_inplace_axis(self, axis, obj):
         # GH#14636
@@ -40,7 +107,8 @@ def test_set_axis_inplace_axis(self, axis, obj):
             expected.columns = new_index
 
         result = obj.copy()
-        result.set_axis(new_index, axis=axis, inplace=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result.set_axis(new_index, axis=axis, inplace=True)
         tm.assert_equal(result, expected)
 
     def test_set_axis_unnamed_kwarg_warns(self, obj):
@@ -50,7 +118,9 @@ def test_set_axis_unnamed_kwarg_warns(self, obj):
         expected = obj.copy()
         expected.index = new_index
 
-        with tm.assert_produces_warning(None):
+        with tm.assert_produces_warning(
+            FutureWarning, match="set_axis 'inplace' keyword"
+        ):
             result = obj.set_axis(new_index, inplace=False)
         tm.assert_equal(result, expected)
 
diff --git a/pandas/tests/frame/methods/test_set_index.py b/pandas/tests/frame/methods/test_set_index.py
index 1b3db10ec6158..4c39cf99f18ff 100644
--- a/pandas/tests/frame/methods/test_set_index.py
+++ b/pandas/tests/frame/methods/test_set_index.py
@@ -595,7 +595,7 @@ def test_set_index_custom_label_type(self):
         # GH#24969
 
         class Thing:
-            def __init__(self, name, color):
+            def __init__(self, name, color) -> None:
                 self.name = name
                 self.color = color
 
@@ -673,7 +673,7 @@ def test_set_index_custom_label_type_raises(self):
 
         # purposefully inherit from something unhashable
         class Thing(set):
-            def __init__(self, name, color):
+            def __init__(self, name, color) -> None:
                 self.name = name
                 self.color = color
 
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index 2463e81d78edd..9b4dcf58590e3 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -92,17 +92,17 @@ def test_shift_int(self, datetime_frame, frame_or_series):
         expected = ts.astype(float).shift(1)
         tm.assert_equal(shifted, expected)
 
-    def test_shift_32bit_take(self, frame_or_series):
+    @pytest.mark.parametrize("dtype", ["int32", "int64"])
+    def test_shift_32bit_take(self, frame_or_series, dtype):
         # 32-bit taking
         # GH#8129
         index = date_range("2000-01-01", periods=5)
-        for dtype in ["int32", "int64"]:
-            arr = np.arange(5, dtype=dtype)
-            s1 = frame_or_series(arr, index=index)
-            p = arr[1]
-            result = s1.shift(periods=p)
-            expected = frame_or_series([np.nan, 0, 1, 2, 3], index=index)
-            tm.assert_equal(result, expected)
+        arr = np.arange(5, dtype=dtype)
+        s1 = frame_or_series(arr, index=index)
+        p = arr[1]
+        result = s1.shift(periods=p)
+        expected = frame_or_series([np.nan, 0, 1, 2, 3], index=index)
+        tm.assert_equal(result, expected)
 
     @pytest.mark.parametrize("periods", [1, 2, 3, 4])
     def test_shift_preserve_freqstr(self, periods, frame_or_series):
@@ -141,11 +141,15 @@ def test_shift_dst(self, frame_or_series):
         tm.assert_equal(res, exp)
         assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
 
-        for ex in [10, -10, 20, -20]:
-            res = obj.shift(ex)
-            exp = frame_or_series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
-            tm.assert_equal(res, exp)
-            assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
+    @pytest.mark.parametrize("ex", [10, -10, 20, -20])
+    def test_shift_dst_beyond(self, frame_or_series, ex):
+        # GH#13926
+        dates = date_range("2016-11-06", freq="H", periods=10, tz="US/Eastern")
+        obj = frame_or_series(dates)
+        res = obj.shift(ex)
+        exp = frame_or_series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
+        tm.assert_equal(res, exp)
+        assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
 
     def test_shift_by_zero(self, datetime_frame, frame_or_series):
         # shift by 0
@@ -255,6 +259,16 @@ def test_shift_named_axis(self):
         result = df.shift(1, axis="columns")
         tm.assert_frame_equal(result, expected)
 
+    def test_shift_other_axis_with_freq(self, datetime_frame):
+        obj = datetime_frame.T
+        offset = offsets.BDay()
+
+        # GH#47039
+        shifted = obj.shift(5, freq=offset, axis=1)
+        assert len(shifted) == len(obj)
+        unshifted = shifted.shift(-5, freq=offset, axis=1)
+        tm.assert_equal(unshifted, obj)
+
     def test_shift_bool(self):
         df = DataFrame({"high": [True, False], "low": [False, False]})
         rs = df.shift(1)
@@ -350,17 +364,23 @@ def test_shift_empty(self):
 
         tm.assert_frame_equal(df, rs)
 
-    def test_shift_duplicate_columns(self):
+    def test_shift_duplicate_columns(self, using_array_manager):
         # GH#9092; verify that position-based shifting works
         # in the presence of duplicate columns
         column_lists = [list(range(5)), [1] * 5, [1, 1, 2, 2, 1]]
         data = np.random.randn(20, 5)
 
+        warn = None
+        if using_array_manager:
+            warn = DeprecationWarning
+
         shifted = []
         for columns in column_lists:
             df = DataFrame(data.copy(), columns=columns)
             for s in range(5):
-                df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
+                msg = "will attempt to set the values inplace"
+                with tm.assert_produces_warning(warn, match=msg):
+                    df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
             df.columns = range(5)
             shifted.append(df)
 
@@ -611,14 +631,8 @@ def test_shift_dt64values_int_fill_deprecated(self):
     )
     # TODO(2.0): remove filtering
     @pytest.mark.filterwarnings("ignore:Index.ravel.*:FutureWarning")
-    def test_shift_dt64values_axis1_invalid_fill(
-        self, vals, as_cat, using_array_manager, request
-    ):
+    def test_shift_dt64values_axis1_invalid_fill(self, vals, as_cat):
         # GH#44564
-        if using_array_manager:
-            mark = pytest.mark.xfail(raises=NotImplementedError)
-            request.node.add_marker(mark)
-
         ser = Series(vals)
         if as_cat:
             ser = ser.astype("category")
@@ -665,7 +679,6 @@ def test_shift_axis1_categorical_columns(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    @td.skip_array_manager_not_yet_implemented
     def test_shift_axis1_many_periods(self):
         # GH#44978 periods > len(columns)
         df = DataFrame(np.random.rand(5, 3))
diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
index 99ff0f04afd60..5d1cc3d4ecee5 100644
--- a/pandas/tests/frame/methods/test_sort_index.py
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -25,7 +25,7 @@ def test_sort_index_and_reconstruction_doc_example(self):
             ),
         )
         assert df.index._is_lexsorted()
-        assert not df.index.is_monotonic
+        assert not df.index.is_monotonic_increasing
 
         # sort it
         expected = DataFrame(
@@ -35,23 +35,24 @@ def test_sort_index_and_reconstruction_doc_example(self):
             ),
         )
         result = df.sort_index()
-        assert result.index.is_monotonic
-
+        assert result.index.is_monotonic_increasing
         tm.assert_frame_equal(result, expected)
 
         # reconstruct
         result = df.sort_index().copy()
         result.index = result.index._sort_levels_monotonic()
-        assert result.index.is_monotonic
-
+        assert result.index.is_monotonic_increasing
         tm.assert_frame_equal(result, expected)
 
+    # FIXME: the FutureWarning is issued on a setitem-with-expansion
+    #  which will *not* change behavior, so should not get a warning.
+    @pytest.mark.filterwarnings("ignore:.*will attempt to set.*:FutureWarning")
     def test_sort_index_non_existent_label_multiindex(self):
         # GH#12261
         df = DataFrame(0, columns=[], index=MultiIndex.from_product([[], []]))
         df.loc["b", "2"] = 1
         df.loc["a", "3"] = 1
-        result = df.sort_index().index.is_monotonic
+        result = df.sort_index().index.is_monotonic_increasing
         assert result is True
 
     def test_sort_index_reorder_on_ops(self):
@@ -549,7 +550,7 @@ def test_sort_index_and_reconstruction(self):
             index=MultiIndex.from_product([[0.5, 0.8], list("ab")]),
         )
         result = result.sort_index()
-        assert result.index.is_monotonic
+        assert result.index.is_monotonic_increasing
 
         tm.assert_frame_equal(result, expected)
 
@@ -567,7 +568,7 @@ def test_sort_index_and_reconstruction(self):
         concatted = pd.concat([df, df], keys=[0.8, 0.5])
         result = concatted.sort_index()
 
-        assert result.index.is_monotonic
+        assert result.index.is_monotonic_increasing
 
         tm.assert_frame_equal(result, expected)
 
@@ -583,11 +584,11 @@ def test_sort_index_and_reconstruction(self):
         df.columns = df.columns.set_levels(
             pd.to_datetime(df.columns.levels[1]), level=1
         )
-        assert not df.columns.is_monotonic
+        assert not df.columns.is_monotonic_increasing
         result = df.sort_index(axis=1)
-        assert result.columns.is_monotonic
+        assert result.columns.is_monotonic_increasing
         result = df.sort_index(axis=1, level=1)
-        assert result.columns.is_monotonic
+        assert result.columns.is_monotonic_increasing
 
     # TODO: better name, de-duplicate with test_sort_index_level above
     def test_sort_index_level2(self, multiindex_dataframe_random_data):
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index 0a05712489147..51b590263f893 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -15,6 +15,17 @@
 
 
 class TestDataFrameSortValues:
+    @pytest.mark.parametrize("dtype", [np.uint8, bool])
+    def test_sort_values_sparse_no_warning(self, dtype):
+        # GH#45618
+        # TODO(2.0): test will be unnecessary
+        ser = pd.Series(Categorical(["a", "b", "a"], categories=["a", "b", "c"]))
+        df = pd.get_dummies(ser, dtype=dtype, sparse=True)
+
+        with tm.assert_produces_warning(None):
+            # No warnings about constructing Index from SparseArray
+            df.sort_values(by=df.columns.tolist())
+
     def test_sort_values(self):
         frame = DataFrame(
             [[1, 1, 2], [3, 1, 0], [4, 5, 6]], index=[1, 2, 3], columns=list("ABC")
diff --git a/pandas/tests/frame/methods/test_to_csv.py b/pandas/tests/frame/methods/test_to_csv.py
index 8a857c033a2de..1933278efb443 100644
--- a/pandas/tests/frame/methods/test_to_csv.py
+++ b/pandas/tests/frame/methods/test_to_csv.py
@@ -24,18 +24,6 @@
 
 from pandas.io.common import get_handle
 
-MIXED_FLOAT_DTYPES = ["float16", "float32", "float64"]
-MIXED_INT_DTYPES = [
-    "uint8",
-    "uint16",
-    "uint32",
-    "uint64",
-    "int8",
-    "int16",
-    "int32",
-    "int64",
-]
-
 
 class TestDataFrameToCSV:
     def read_csv(self, path, **kwargs):
@@ -178,46 +166,40 @@ def test_to_csv_cols_reordering(self):
 
         tm.assert_frame_equal(df[cols], rs_c, check_names=False)
 
-    def test_to_csv_new_dupe_cols(self):
-        def _check_df(df, cols=None):
-            with tm.ensure_clean() as path:
-                df.to_csv(path, columns=cols, chunksize=chunksize)
-                rs_c = read_csv(path, index_col=0)
-
-                # we wrote them in a different order
-                # so compare them in that order
-                if cols is not None:
-
-                    if df.columns.is_unique:
-                        rs_c.columns = cols
-                    else:
-                        indexer, missing = df.columns.get_indexer_non_unique(cols)
-                        rs_c.columns = df.columns.take(indexer)
-
-                    for c in cols:
-                        obj_df = df[c]
-                        obj_rs = rs_c[c]
-                        if isinstance(obj_df, Series):
-                            tm.assert_series_equal(obj_df, obj_rs)
-                        else:
-                            tm.assert_frame_equal(obj_df, obj_rs, check_names=False)
-
-                # wrote in the same order
-                else:
-                    rs_c.columns = df.columns
-                    tm.assert_frame_equal(df, rs_c, check_names=False)
-
+    @pytest.mark.parametrize("cols", [None, ["b", "a"]])
+    def test_to_csv_new_dupe_cols(self, cols):
         chunksize = 5
         N = int(chunksize * 2.5)
 
         # dupe cols
         df = tm.makeCustomDataframe(N, 3)
         df.columns = ["a", "a", "b"]
-        _check_df(df, None)
+        with tm.ensure_clean() as path:
+            df.to_csv(path, columns=cols, chunksize=chunksize)
+            rs_c = read_csv(path, index_col=0)
 
-        # dupe cols with selection
-        cols = ["b", "a"]
-        _check_df(df, cols)
+            # we wrote them in a different order
+            # so compare them in that order
+            if cols is not None:
+
+                if df.columns.is_unique:
+                    rs_c.columns = cols
+                else:
+                    indexer, missing = df.columns.get_indexer_non_unique(cols)
+                    rs_c.columns = df.columns.take(indexer)
+
+                for c in cols:
+                    obj_df = df[c]
+                    obj_rs = rs_c[c]
+                    if isinstance(obj_df, Series):
+                        tm.assert_series_equal(obj_df, obj_rs)
+                    else:
+                        tm.assert_frame_equal(obj_df, obj_rs, check_names=False)
+
+            # wrote in the same order
+            else:
+                rs_c.columns = df.columns
+                tm.assert_frame_equal(df, rs_c, check_names=False)
 
     @pytest.mark.slow
     def test_to_csv_dtnat(self):
@@ -235,11 +217,9 @@ def make_dtnat_arr(n, nnat=None):
             return s
 
         chunksize = 1000
-        # N=35000
         s1 = make_dtnat_arr(chunksize + 5)
         s2 = make_dtnat_arr(chunksize + 5, 0)
 
-        # s3=make_dtnjat_arr(chunksize+5,0)
         with tm.ensure_clean("1.csv") as pth:
             df = DataFrame({"a": s1, "b": s2})
             df.to_csv(pth, chunksize=chunksize)
@@ -247,224 +227,195 @@ def make_dtnat_arr(n, nnat=None):
             recons = self.read_csv(pth).apply(to_datetime)
             tm.assert_frame_equal(df, recons, check_names=False)
 
-    @pytest.mark.slow
-    def test_to_csv_moar(self):
-        def _do_test(
-            df, r_dtype=None, c_dtype=None, rnlvl=None, cnlvl=None, dupe_col=False
-        ):
-
-            kwargs = {"parse_dates": False}
-            if cnlvl:
-                if rnlvl is not None:
-                    kwargs["index_col"] = list(range(rnlvl))
-                kwargs["header"] = list(range(cnlvl))
-
-                with tm.ensure_clean("__tmp_to_csv_moar__") as path:
-                    df.to_csv(path, encoding="utf8", chunksize=chunksize)
-                    recons = self.read_csv(path, **kwargs)
+    def _return_result_expected(
+        self,
+        df,
+        chunksize,
+        r_dtype=None,
+        c_dtype=None,
+        rnlvl=None,
+        cnlvl=None,
+        dupe_col=False,
+    ):
+        kwargs = {"parse_dates": False}
+        if cnlvl:
+            if rnlvl is not None:
+                kwargs["index_col"] = list(range(rnlvl))
+            kwargs["header"] = list(range(cnlvl))
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+        else:
+            kwargs["header"] = 0
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+
+        def _to_uni(x):
+            if not isinstance(x, str):
+                return x.decode("utf8")
+            return x
+
+        if dupe_col:
+            # read_Csv disambiguates the columns by
+            # labeling them dupe.1,dupe.2, etc'. monkey patch columns
+            recons.columns = df.columns
+        if rnlvl and not cnlvl:
+            delta_lvl = [recons.iloc[:, i].values for i in range(rnlvl - 1)]
+            ix = MultiIndex.from_arrays([list(recons.index)] + delta_lvl)
+            recons.index = ix
+            recons = recons.iloc[:, rnlvl - 1 :]
+
+        type_map = {"i": "i", "f": "f", "s": "O", "u": "O", "dt": "O", "p": "O"}
+        if r_dtype:
+            if r_dtype == "u":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [_to_uni(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [_to_uni(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "dt":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [Timestamp(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [Timestamp(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "p":
+                r_dtype = "O"
+                idx_list = to_datetime(recons.index)
+                recons.index = np.array(
+                    [Timestamp(label) for label in idx_list], dtype=r_dtype
+                )
+                df.index = np.array(
+                    list(map(Timestamp, df.index.to_timestamp())), dtype=r_dtype
+                )
             else:
-                kwargs["header"] = 0
-
-                with tm.ensure_clean("__tmp_to_csv_moar__") as path:
-                    df.to_csv(path, encoding="utf8", chunksize=chunksize)
-                    recons = self.read_csv(path, **kwargs)
-
-            def _to_uni(x):
-                if not isinstance(x, str):
-                    return x.decode("utf8")
-                return x
-
-            if dupe_col:
-                # read_Csv disambiguates the columns by
-                # labeling them dupe.1,dupe.2, etc'. monkey patch columns
-                recons.columns = df.columns
-            if rnlvl and not cnlvl:
-                delta_lvl = [recons.iloc[:, i].values for i in range(rnlvl - 1)]
-                ix = MultiIndex.from_arrays([list(recons.index)] + delta_lvl)
-                recons.index = ix
-                recons = recons.iloc[:, rnlvl - 1 :]
-
-            type_map = {"i": "i", "f": "f", "s": "O", "u": "O", "dt": "O", "p": "O"}
-            if r_dtype:
-                if r_dtype == "u":  # unicode
-                    r_dtype = "O"
-                    recons.index = np.array(
-                        [_to_uni(label) for label in recons.index], dtype=r_dtype
-                    )
-                    df.index = np.array(
-                        [_to_uni(label) for label in df.index], dtype=r_dtype
-                    )
-                elif r_dtype == "dt":  # unicode
-                    r_dtype = "O"
-                    recons.index = np.array(
-                        [Timestamp(label) for label in recons.index], dtype=r_dtype
-                    )
-                    df.index = np.array(
-                        [Timestamp(label) for label in df.index], dtype=r_dtype
-                    )
-                elif r_dtype == "p":
-                    r_dtype = "O"
-                    idx_list = to_datetime(recons.index)
-                    recons.index = np.array(
-                        [Timestamp(label) for label in idx_list], dtype=r_dtype
-                    )
-                    df.index = np.array(
-                        list(map(Timestamp, df.index.to_timestamp())), dtype=r_dtype
-                    )
-                else:
-                    r_dtype = type_map.get(r_dtype)
-                    recons.index = np.array(recons.index, dtype=r_dtype)
-                    df.index = np.array(df.index, dtype=r_dtype)
-            if c_dtype:
-                if c_dtype == "u":
-                    c_dtype = "O"
-                    recons.columns = np.array(
-                        [_to_uni(label) for label in recons.columns], dtype=c_dtype
-                    )
-                    df.columns = np.array(
-                        [_to_uni(label) for label in df.columns], dtype=c_dtype
-                    )
-                elif c_dtype == "dt":
-                    c_dtype = "O"
-                    recons.columns = np.array(
-                        [Timestamp(label) for label in recons.columns], dtype=c_dtype
-                    )
-                    df.columns = np.array(
-                        [Timestamp(label) for label in df.columns], dtype=c_dtype
-                    )
-                elif c_dtype == "p":
-                    c_dtype = "O"
-                    col_list = to_datetime(recons.columns)
-                    recons.columns = np.array(
-                        [Timestamp(label) for label in col_list], dtype=c_dtype
-                    )
-                    col_list = df.columns.to_timestamp()
-                    df.columns = np.array(
-                        [Timestamp(label) for label in col_list], dtype=c_dtype
-                    )
-                else:
-                    c_dtype = type_map.get(c_dtype)
-                    recons.columns = np.array(recons.columns, dtype=c_dtype)
-                    df.columns = np.array(df.columns, dtype=c_dtype)
+                r_dtype = type_map.get(r_dtype)
+                recons.index = np.array(recons.index, dtype=r_dtype)
+                df.index = np.array(df.index, dtype=r_dtype)
+        if c_dtype:
+            if c_dtype == "u":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [_to_uni(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [_to_uni(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "dt":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [Timestamp(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [Timestamp(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "p":
+                c_dtype = "O"
+                col_list = to_datetime(recons.columns)
+                recons.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+                col_list = df.columns.to_timestamp()
+                df.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+            else:
+                c_dtype = type_map.get(c_dtype)
+                recons.columns = np.array(recons.columns, dtype=c_dtype)
+                df.columns = np.array(df.columns, dtype=c_dtype)
+        return df, recons
 
-            tm.assert_frame_equal(df, recons, check_names=False)
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    def test_to_csv_nrows(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 4, r_idx_type="dt", c_idx_type="s")
+        result, expected = self._return_result_expected(df, 1000, "dt", "s")
+        tm.assert_frame_equal(result, expected, check_names=False)
 
-        N = 100
-        chunksize = 1000
-        ncols = 4
-        base = chunksize // ncols
-        for nrows in [
-            2,
-            10,
-            N - 1,
-            N,
-            N + 1,
-            N + 2,
-            2 * N - 2,
-            2 * N - 1,
-            2 * N,
-            2 * N + 1,
-            2 * N + 2,
-            base - 1,
-            base,
-            base + 1,
-        ]:
-            _do_test(
-                tm.makeCustomDataframe(nrows, ncols, r_idx_type="dt", c_idx_type="s"),
-                "dt",
-                "s",
-            )
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize(
+        "r_idx_type, c_idx_type", [("i", "i"), ("s", "s"), ("s", "dt"), ("p", "p")]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    def test_to_csv_idx_types(self, nrows, r_idx_type, c_idx_type, ncols):
+        df = tm.makeCustomDataframe(
+            nrows, ncols, r_idx_type=r_idx_type, c_idx_type=c_idx_type
+        )
+        result, expected = self._return_result_expected(
+            df,
+            1000,
+            r_idx_type,
+            c_idx_type,
+        )
+        tm.assert_frame_equal(result, expected, check_names=False)
 
-        for r_idx_type, c_idx_type in [("i", "i"), ("s", "s"), ("u", "dt"), ("p", "p")]:
-            for ncols in [1, 2, 3, 4]:
-                base = chunksize // ncols
-                for nrows in [
-                    2,
-                    10,
-                    N - 1,
-                    N,
-                    N + 1,
-                    N + 2,
-                    2 * N - 2,
-                    2 * N - 1,
-                    2 * N,
-                    2 * N + 1,
-                    2 * N + 2,
-                    base - 1,
-                    base,
-                    base + 1,
-                ]:
-                    _do_test(
-                        tm.makeCustomDataframe(
-                            nrows, ncols, r_idx_type=r_idx_type, c_idx_type=c_idx_type
-                        ),
-                        r_idx_type,
-                        c_idx_type,
-                    )
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [10, 98, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    def test_to_csv_idx_ncols(self, nrows, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols)
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_names=False)
 
-        for ncols in [1, 2, 3, 4]:
-            base = chunksize // ncols
-            for nrows in [
-                10,
-                N - 2,
-                N - 1,
-                N,
-                N + 1,
-                N + 2,
-                2 * N - 2,
-                2 * N - 1,
-                2 * N,
-                2 * N + 1,
-                2 * N + 2,
-                base - 1,
-                base,
-                base + 1,
-            ]:
-                _do_test(tm.makeCustomDataframe(nrows, ncols))
-
-        for nrows in [10, N - 2, N - 1, N, N + 1, N + 2]:
-            df = tm.makeCustomDataframe(nrows, 3)
-            cols = list(df.columns)
-            cols[:2] = ["dupe", "dupe"]
-            cols[-2:] = ["dupe", "dupe"]
-            ix = list(df.index)
-            ix[:2] = ["rdupe", "rdupe"]
-            ix[-2:] = ["rdupe", "rdupe"]
-            df.index = ix
-            df.columns = cols
-            _do_test(df, dupe_col=True)
-
-        _do_test(DataFrame(index=np.arange(10)))
-        _do_test(
-            tm.makeCustomDataframe(chunksize // 2 + 1, 2, r_idx_nlevels=2), rnlvl=2
-        )
-        for ncols in [2, 3, 4]:
-            base = int(chunksize // ncols)
-            for nrows in [
-                10,
-                N - 2,
-                N - 1,
-                N,
-                N + 1,
-                N + 2,
-                2 * N - 2,
-                2 * N - 1,
-                2 * N,
-                2 * N + 1,
-                2 * N + 2,
-                base - 1,
-                base,
-                base + 1,
-            ]:
-                _do_test(tm.makeCustomDataframe(nrows, ncols, r_idx_nlevels=2), rnlvl=2)
-                _do_test(tm.makeCustomDataframe(nrows, ncols, c_idx_nlevels=2), cnlvl=2)
-                _do_test(
-                    tm.makeCustomDataframe(
-                        nrows, ncols, r_idx_nlevels=2, c_idx_nlevels=2
-                    ),
-                    rnlvl=2,
-                    cnlvl=2,
-                )
+    @pytest.mark.slow
+    @pytest.mark.parametrize("nrows", [10, 98, 99, 100, 101, 102])
+    def test_to_csv_dup_cols(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 3)
+        cols = list(df.columns)
+        cols[:2] = ["dupe", "dupe"]
+        cols[-2:] = ["dupe", "dupe"]
+        ix = list(df.index)
+        ix[:2] = ["rdupe", "rdupe"]
+        ix[-2:] = ["rdupe", "rdupe"]
+        df.index = ix
+        df.columns = cols
+        result, expected = self._return_result_expected(df, 1000, dupe_col=True)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_empty(self):
+        df = DataFrame(index=np.arange(10))
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_chunksize(self):
+        chunksize = 1000
+        df = tm.makeCustomDataframe(chunksize // 2 + 1, 2, r_idx_nlevels=2)
+        result, expected = self._return_result_expected(df, chunksize, rnlvl=2)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [2, 3, 4])
+    @pytest.mark.parametrize(
+        "df_params, func_params",
+        [
+            [{"r_idx_nlevels": 2}, {"rnlvl": 2}],
+            [{"c_idx_nlevels": 2}, {"cnlvl": 2}],
+            [{"r_idx_nlevels": 2, "c_idx_nlevels": 2}, {"rnlvl": 2, "cnlvl": 2}],
+        ],
+    )
+    def test_to_csv_params(self, nrows, df_params, func_params, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols, **df_params)
+        result, expected = self._return_result_expected(df, 1000, **func_params)
+        tm.assert_frame_equal(result, expected, check_names=False)
 
     def test_to_csv_from_csv_w_some_infs(self, float_frame):
 
@@ -794,18 +745,18 @@ def test_to_csv_dups_cols(self):
             result = result.rename(columns={"a.1": "a"})
             tm.assert_frame_equal(result, df)
 
-    def test_to_csv_chunking(self):
+    @pytest.mark.parametrize("chunksize", [10000, 50000, 100000])
+    def test_to_csv_chunking(self, chunksize):
 
         aa = DataFrame({"A": range(100000)})
         aa["B"] = aa.A + 1.0
         aa["C"] = aa.A + 2.0
         aa["D"] = aa.A + 3.0
 
-        for chunksize in [10000, 50000, 100000]:
-            with tm.ensure_clean() as filename:
-                aa.to_csv(filename, chunksize=chunksize)
-                rs = read_csv(filename, index_col=0)
-                tm.assert_frame_equal(rs, aa)
+        with tm.ensure_clean() as filename:
+            aa.to_csv(filename, chunksize=chunksize)
+            rs = read_csv(filename, index_col=0)
+            tm.assert_frame_equal(rs, aa)
 
     @pytest.mark.slow
     def test_to_csv_wide_frame_formatting(self):
@@ -882,6 +833,18 @@ def test_to_csv_float_format(self):
             )
             tm.assert_frame_equal(rs, xp)
 
+    def test_to_csv_float_format_over_decimal(self):
+        # GH#47436
+        df = DataFrame({"a": [0.5, 1.0]})
+        result = df.to_csv(
+            decimal=",",
+            float_format=lambda x: np.format_float_positional(x, trim="-"),
+            index=False,
+        )
+        expected_rows = ["a", "0.5", "1"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
     def test_to_csv_unicodewriter_quoting(self):
         df = DataFrame({"A": [1, 2, 3], "B": ["foo", "bar", "baz"]})
 
@@ -893,17 +856,17 @@ def test_to_csv_unicodewriter_quoting(self):
         expected = tm.convert_rows_list_to_csv_str(expected_rows)
         assert result == expected
 
-    def test_to_csv_quote_none(self):
+    @pytest.mark.parametrize("encoding", [None, "utf-8"])
+    def test_to_csv_quote_none(self, encoding):
         # GH4328
         df = DataFrame({"A": ["hello", '{"hello"}']})
-        for encoding in (None, "utf-8"):
-            buf = StringIO()
-            df.to_csv(buf, quoting=csv.QUOTE_NONE, encoding=encoding, index=False)
+        buf = StringIO()
+        df.to_csv(buf, quoting=csv.QUOTE_NONE, encoding=encoding, index=False)
 
-            result = buf.getvalue()
-            expected_rows = ["A", "hello", '{"hello"}']
-            expected = tm.convert_rows_list_to_csv_str(expected_rows)
-            assert result == expected
+        result = buf.getvalue()
+        expected_rows = ["A", "hello", '{"hello"}']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
 
     def test_to_csv_index_no_leading_comma(self):
         df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
@@ -915,13 +878,13 @@ def test_to_csv_index_no_leading_comma(self):
         expected = tm.convert_rows_list_to_csv_str(expected_rows)
         assert buf.getvalue() == expected
 
-    def test_to_csv_line_terminators(self):
+    def test_to_csv_lineterminators(self):
         # see gh-20353
         df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
 
         with tm.ensure_clean() as path:
             # case 1: CRLF as line terminator
-            df.to_csv(path, line_terminator="\r\n")
+            df.to_csv(path, lineterminator="\r\n")
             expected = b",A,B\r\none,1,4\r\ntwo,2,5\r\nthree,3,6\r\n"
 
             with open(path, mode="rb") as f:
@@ -929,7 +892,7 @@ def test_to_csv_line_terminators(self):
 
         with tm.ensure_clean() as path:
             # case 2: LF as line terminator
-            df.to_csv(path, line_terminator="\n")
+            df.to_csv(path, lineterminator="\n")
             expected = b",A,B\none,1,4\ntwo,2,5\nthree,3,6\n"
 
             with open(path, mode="rb") as f:
@@ -1102,7 +1065,8 @@ def test_to_csv_date_format(self, datetime_frame):
 
             tm.assert_frame_equal(test, nat_frame)
 
-    def test_to_csv_with_dst_transitions(self):
+    @pytest.mark.parametrize("td", [pd.Timedelta(0), pd.Timedelta("10s")])
+    def test_to_csv_with_dst_transitions(self, td):
 
         with tm.ensure_clean("csv_date_format_with_dst") as path:
             # make sure we are not failing on transitions
@@ -1113,20 +1077,20 @@ def test_to_csv_with_dst_transitions(self):
                 freq="H",
                 ambiguous="infer",
             )
+            i = times + td
+            i = i._with_freq(None)  # freq is not preserved by read_csv
+            time_range = np.array(range(len(i)), dtype="int64")
+            df = DataFrame({"A": time_range}, index=i)
+            df.to_csv(path, index=True)
+            # we have to reconvert the index as we
+            # don't parse the tz's
+            result = read_csv(path, index_col=0)
+            result.index = to_datetime(result.index, utc=True).tz_convert(
+                "Europe/London"
+            )
+            tm.assert_frame_equal(result, df)
 
-            for i in [times, times + pd.Timedelta("10s")]:
-                i = i._with_freq(None)  # freq is not preserved by read_csv
-                time_range = np.array(range(len(i)), dtype="int64")
-                df = DataFrame({"A": time_range}, index=i)
-                df.to_csv(path, index=True)
-                # we have to reconvert the index as we
-                # don't parse the tz's
-                result = read_csv(path, index_col=0)
-                result.index = to_datetime(result.index, utc=True).tz_convert(
-                    "Europe/London"
-                )
-                tm.assert_frame_equal(result, df)
-
+    def test_to_csv_with_dst_transitions_with_pickle(self):
         # GH11619
         idx = date_range("2015-01-01", "2015-12-31", freq="H", tz="Europe/Paris")
         idx = idx._with_freq(None)  # freq does not round-trip
@@ -1299,7 +1263,7 @@ def test_to_csv_single_level_multi_index(self):
         df = DataFrame([[1, 2, 3]], columns=index)
         df = df.reindex(columns=[(1,), (3,)])
         expected = ",1,3\n0,1,3\n"
-        result = df.to_csv(line_terminator="\n")
+        result = df.to_csv(lineterminator="\n")
         tm.assert_almost_equal(result, expected)
 
     def test_gz_lineend(self):
@@ -1333,3 +1297,32 @@ def test_to_csv_na_quoting(self):
         )
         expected = '""\n""\n'
         assert result == expected
+
+    def test_to_csv_categorical_and_ea(self):
+        # GH#46812
+        df = DataFrame({"a": "x", "b": [1, pd.NA]})
+        df["b"] = df["b"].astype("Int16")
+        df["b"] = df["b"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a,b", "0,x,1", "1,x,"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_categorical_and_interval(self):
+        # GH#46297
+        df = DataFrame(
+            {
+                "a": [
+                    pd.Interval(
+                        Timestamp("2020-01-01"),
+                        Timestamp("2020-01-02"),
+                        closed="both",
+                    )
+                ]
+            }
+        )
+        df["a"] = df["a"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a", '0,"[2020-01-01, 2020-01-02]"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
index 31ea3e582eeb2..6d5c32cae7368 100644
--- a/pandas/tests/frame/methods/test_to_dict.py
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -344,3 +344,80 @@ def test_to_dict_orient_tight(self, index, columns):
         roundtrip = DataFrame.from_dict(df.to_dict(orient="tight"), orient="tight")
 
         tm.assert_frame_equal(df, roundtrip)
+
+    @pytest.mark.parametrize(
+        "orient",
+        ["dict", "list", "split", "records", "index", "tight"],
+    )
+    @pytest.mark.parametrize(
+        "data,expected_types",
+        (
+            (
+                {
+                    "a": [np.int64(1), 1, np.int64(3)],
+                    "b": [np.float64(1.0), 2.0, np.float64(3.0)],
+                    "c": [np.float64(1.0), 2, np.int64(3)],
+                    "d": [np.float64(1.0), "a", np.int64(3)],
+                    "e": [np.float64(1.0), ["a"], np.int64(3)],
+                    "f": [np.float64(1.0), ("a",), np.int64(3)],
+                },
+                {
+                    "a": [int, int, int],
+                    "b": [float, float, float],
+                    "c": [float, float, float],
+                    "d": [float, str, int],
+                    "e": [float, list, int],
+                    "f": [float, tuple, int],
+                },
+            ),
+            (
+                {
+                    "a": [1, 2, 3],
+                    "b": [1.1, 2.2, 3.3],
+                },
+                {
+                    "a": [int, int, int],
+                    "b": [float, float, float],
+                },
+            ),
+        ),
+    )
+    def test_to_dict_returns_native_types(self, orient, data, expected_types):
+        # GH 46751
+        # Tests we get back native types for all orient types
+        df = DataFrame(data)
+        result = df.to_dict(orient)
+        if orient == "dict":
+            assertion_iterator = (
+                (i, key, value)
+                for key, index_value_map in result.items()
+                for i, value in index_value_map.items()
+            )
+        elif orient == "list":
+            assertion_iterator = (
+                (i, key, value)
+                for key, values in result.items()
+                for i, value in enumerate(values)
+            )
+        elif orient in {"split", "tight"}:
+            assertion_iterator = (
+                (i, key, result["data"][i][j])
+                for i in result["index"]
+                for j, key in enumerate(result["columns"])
+            )
+        elif orient == "records":
+            assertion_iterator = (
+                (i, key, value)
+                for i, record in enumerate(result)
+                for key, value in record.items()
+            )
+        elif orient == "index":
+            assertion_iterator = (
+                (i, key, value)
+                for i, record in result.items()
+                for key, value in record.items()
+            )
+
+        for i, key, value in assertion_iterator:
+            assert value == data[key][i]
+            assert type(value) is expected_types[key][i]
diff --git a/pandas/tests/frame/methods/test_to_dict_of_blocks.py b/pandas/tests/frame/methods/test_to_dict_of_blocks.py
index c81bed9d93cc4..eb9b78610a112 100644
--- a/pandas/tests/frame/methods/test_to_dict_of_blocks.py
+++ b/pandas/tests/frame/methods/test_to_dict_of_blocks.py
@@ -27,7 +27,7 @@ def test_copy_blocks(self, float_frame):
         # make sure we did not change the original DataFrame
         assert not _df[column].equals(df[column])
 
-    def test_no_copy_blocks(self, float_frame):
+    def test_no_copy_blocks(self, float_frame, using_copy_on_write):
         # GH#9607
         df = DataFrame(float_frame, copy=True)
         column = df.columns[0]
@@ -38,8 +38,11 @@ def test_no_copy_blocks(self, float_frame):
             if column in _df:
                 _df.loc[:, column] = _df[column] + 1
 
-        # make sure we did change the original DataFrame
-        assert _df[column].equals(df[column])
+        if not using_copy_on_write:
+            # make sure we did change the original DataFrame
+            assert _df[column].equals(df[column])
+        else:
+            assert not _df[column].equals(df[column])
 
 
 def test_to_dict_of_blocks_item_cache():
diff --git a/pandas/tests/frame/methods/test_to_records.py b/pandas/tests/frame/methods/test_to_records.py
index a2e94782142ac..32cccddc9d515 100644
--- a/pandas/tests/frame/methods/test_to_records.py
+++ b/pandas/tests/frame/methods/test_to_records.py
@@ -96,7 +96,7 @@ def test_to_records_index_name(self):
             + [np.asarray(df.iloc[:, i]) for i in range(3)],
             dtype={
                 "names": ["A", "level_1", "0", "1", "2"],
-                "formats": ["<U1", "<U1", "<f8", "<f8", "<f8"],
+                "formats": ["O", "O", "<f8", "<f8", "<f8"],
             },
         )
         tm.assert_numpy_array_equal(result, expected)
@@ -108,6 +108,33 @@ def test_to_records_with_unicode_index(self):
         expected = np.rec.array([("x", "y")], dtype=[("a", "O"), ("b", "O")])
         tm.assert_almost_equal(result, expected)
 
+    def test_to_records_index_dtype(self):
+        # GH 47263: consistent data types for Index and MultiIndex
+        df = DataFrame(
+            {
+                1: date_range("2022-01-01", periods=2),
+                2: date_range("2022-01-01", periods=2),
+                3: date_range("2022-01-01", periods=2),
+            }
+        )
+
+        expected = np.rec.array(
+            [
+                ("2022-01-01", "2022-01-01", "2022-01-01"),
+                ("2022-01-02", "2022-01-02", "2022-01-02"),
+            ],
+            dtype=[("1", "<M8[ns]"), ("2", "<M8[ns]"), ("3", "<M8[ns]")],
+        )
+
+        result = df.to_records(index=False)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index(1).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index([1, 2]).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
     def test_to_records_with_unicode_column_names(self):
         # xref issue: https://github.com/numpy/numpy/issues/2407
         # Issue GH#11879. to_records used to raise an exception when used
@@ -151,7 +178,12 @@ def test_to_records_with_categorical(self):
                 {},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
-                    dtype=[("index", "<i8"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Should have no effect in this case.
@@ -159,23 +191,38 @@ def test_to_records_with_categorical(self):
                 {"index": True},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
-                    dtype=[("index", "<i8"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Column dtype applied across the board. Index unaffected.
             (
-                {"column_dtypes": "<U4"},
+                {"column_dtypes": f"{tm.ENDIAN}U4"},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "<U4"), ("B", "<U4"), ("C", "<U4")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U4"),
+                        ("B", f"{tm.ENDIAN}U4"),
+                        ("C", f"{tm.ENDIAN}U4"),
+                    ],
                 ),
             ),
             # Index dtype applied across the board. Columns unaffected.
             (
-                {"index_dtypes": "<U1"},
+                {"index_dtypes": f"{tm.ENDIAN}U1"},
                 np.rec.array(
                     [("0", 1, 0.2, "a"), ("1", 2, 1.5, "bc")],
-                    dtype=[("index", "<U1"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U1"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Pass in a type instance.
@@ -183,7 +230,12 @@ def test_to_records_with_categorical(self):
                 {"column_dtypes": str},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "<U"), ("B", "<U"), ("C", "<U")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
                 ),
             ),
             # Pass in a dtype instance.
@@ -191,15 +243,31 @@ def test_to_records_with_categorical(self):
                 {"column_dtypes": np.dtype("unicode")},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "<U"), ("B", "<U"), ("C", "<U")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
                 ),
             ),
             # Pass in a dictionary (name-only).
             (
-                {"column_dtypes": {"A": np.int8, "B": np.float32, "C": "<U2"}},
+                {
+                    "column_dtypes": {
+                        "A": np.int8,
+                        "B": np.float32,
+                        "C": f"{tm.ENDIAN}U2",
+                    }
+                },
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "<U2")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", f"{tm.ENDIAN}U2"),
+                    ],
                 ),
             ),
             # Pass in a dictionary (indices-only).
@@ -207,15 +275,24 @@ def test_to_records_with_categorical(self):
                 {"index_dtypes": {0: "int16"}},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
-                    dtype=[("index", "i2"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Ignore index mappings if index is not True.
             (
-                {"index": False, "index_dtypes": "<U2"},
+                {"index": False, "index_dtypes": f"{tm.ENDIAN}U2"},
                 np.rec.array(
                     [(1, 0.2, "a"), (2, 1.5, "bc")],
-                    dtype=[("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Non-existent names / indices in mapping should not error.
@@ -223,7 +300,12 @@ def test_to_records_with_categorical(self):
                 {"index_dtypes": {0: "int16", "not-there": "float32"}},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
-                    dtype=[("index", "i2"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Names / indices not in mapping default to array dtype.
@@ -231,7 +313,12 @@ def test_to_records_with_categorical(self):
                 {"column_dtypes": {"A": np.int8, "B": np.float32}},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Names / indices not in dtype mapping default to array dtype.
@@ -239,18 +326,28 @@ def test_to_records_with_categorical(self):
                 {"column_dtypes": {"A": np.dtype("int8"), "B": np.dtype("float32")}},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Mixture of everything.
             (
                 {
                     "column_dtypes": {"A": np.int8, "B": np.float32},
-                    "index_dtypes": "<U2",
+                    "index_dtypes": f"{tm.ENDIAN}U2",
                 },
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-                    dtype=[("index", "<U2"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U2"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
                 ),
             ),
             # Invalid dype values.
@@ -299,7 +396,11 @@ def test_to_records_dtype(self, kwargs, expected):
                 {"column_dtypes": "float64", "index_dtypes": {0: "int32", 1: "int8"}},
                 np.rec.array(
                     [(1, 2, 3.0), (4, 5, 6.0), (7, 8, 9.0)],
-                    dtype=[("a", "<i4"), ("b", "i1"), ("c", "<f8")],
+                    dtype=[
+                        ("a", f"{tm.ENDIAN}i4"),
+                        ("b", "i1"),
+                        ("c", f"{tm.ENDIAN}f8"),
+                    ],
                 ),
             ),
             # MultiIndex in the columns.
@@ -310,14 +411,17 @@ def test_to_records_dtype(self, kwargs, expected):
                         [("a", "d"), ("b", "e"), ("c", "f")]
                     ),
                 ),
-                {"column_dtypes": {0: "<U1", 2: "float32"}, "index_dtypes": "float32"},
+                {
+                    "column_dtypes": {0: f"{tm.ENDIAN}U1", 2: "float32"},
+                    "index_dtypes": "float32",
+                },
                 np.rec.array(
                     [(0.0, "1", 2, 3.0), (1.0, "4", 5, 6.0), (2.0, "7", 8, 9.0)],
                     dtype=[
-                        ("index", "<f4"),
-                        ("('a', 'd')", "<U1"),
-                        ("('b', 'e')", "<i8"),
-                        ("('c', 'f')", "<f4"),
+                        ("index", f"{tm.ENDIAN}f4"),
+                        ("('a', 'd')", f"{tm.ENDIAN}U1"),
+                        ("('b', 'e')", f"{tm.ENDIAN}i8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f4"),
                     ],
                 ),
             ),
@@ -332,7 +436,10 @@ def test_to_records_dtype(self, kwargs, expected):
                         [("d", -4), ("d", -5), ("f", -6)], names=list("cd")
                     ),
                 ),
-                {"column_dtypes": "float64", "index_dtypes": {0: "<U2", 1: "int8"}},
+                {
+                    "column_dtypes": "float64",
+                    "index_dtypes": {0: f"{tm.ENDIAN}U2", 1: "int8"},
+                },
                 np.rec.array(
                     [
                         ("d", -4, 1.0, 2.0, 3.0),
@@ -340,11 +447,11 @@ def test_to_records_dtype(self, kwargs, expected):
                         ("f", -6, 7, 8, 9.0),
                     ],
                     dtype=[
-                        ("c", "<U2"),
+                        ("c", f"{tm.ENDIAN}U2"),
                         ("d", "i1"),
-                        ("('a', 'd')", "<f8"),
-                        ("('b', 'e')", "<f8"),
-                        ("('c', 'f')", "<f8"),
+                        ("('a', 'd')", f"{tm.ENDIAN}f8"),
+                        ("('b', 'e')", f"{tm.ENDIAN}f8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f8"),
                     ],
                 ),
             ),
@@ -358,7 +465,7 @@ def test_to_records_dtype_mi(self, df, kwargs, expected):
     def test_to_records_dict_like(self):
         # see GH#18146
         class DictLike:
-            def __init__(self, **kwargs):
+            def __init__(self, **kwargs) -> None:
                 self.d = kwargs.copy()
 
             def __getitem__(self, key):
@@ -374,13 +481,18 @@ def keys(self):
 
         dtype_mappings = {
             "column_dtypes": DictLike(**{"A": np.int8, "B": np.float32}),
-            "index_dtypes": "<U2",
+            "index_dtypes": f"{tm.ENDIAN}U2",
         }
 
         result = df.to_records(**dtype_mappings)
         expected = np.rec.array(
             [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
-            dtype=[("index", "<U2"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
+            dtype=[
+                ("index", f"{tm.ENDIAN}U2"),
+                ("A", "i1"),
+                ("B", f"{tm.ENDIAN}f4"),
+                ("C", "O"),
+            ],
         )
         tm.assert_almost_equal(result, expected)
 
diff --git a/pandas/tests/frame/methods/test_tz_convert.py b/pandas/tests/frame/methods/test_tz_convert.py
index bb9ea64d5f326..c5f6870769afc 100644
--- a/pandas/tests/frame/methods/test_tz_convert.py
+++ b/pandas/tests/frame/methods/test_tz_convert.py
@@ -104,17 +104,17 @@ def test_tz_convert_and_localize(self, fn):
         # Not DatetimeIndex / PeriodIndex
         with pytest.raises(TypeError, match="DatetimeIndex"):
             df = DataFrame(index=int_idx)
-            df = getattr(df, fn)("US/Pacific")
+            getattr(df, fn)("US/Pacific")
 
         # Not DatetimeIndex / PeriodIndex
         with pytest.raises(TypeError, match="DatetimeIndex"):
             df = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
-            df = getattr(df, fn)("US/Pacific", level=0)
+            getattr(df, fn)("US/Pacific", level=0)
 
         # Invalid level
         with pytest.raises(ValueError, match="not valid"):
             df = DataFrame(index=l0)
-            df = getattr(df, fn)("US/Pacific", level=1)
+            getattr(df, fn)("US/Pacific", level=1)
 
     @pytest.mark.parametrize("copy", [True, False])
     def test_tz_convert_copy_inplace_mutate(self, copy, frame_or_series):
diff --git a/pandas/tests/frame/methods/test_update.py b/pandas/tests/frame/methods/test_update.py
index 408113e9bc417..2903436337820 100644
--- a/pandas/tests/frame/methods/test_update.py
+++ b/pandas/tests/frame/methods/test_update.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -134,15 +136,34 @@ def test_update_from_non_df(self):
     def test_update_datetime_tz(self):
         # GH 25807
         result = DataFrame([pd.Timestamp("2019", tz="UTC")])
-        result.update(result)
+        with tm.assert_produces_warning(None):
+            result.update(result)
         expected = DataFrame([pd.Timestamp("2019", tz="UTC")])
         tm.assert_frame_equal(result, expected)
 
-    def test_update_with_different_dtype(self):
+    def test_update_with_different_dtype(self, using_copy_on_write):
         # GH#3217
         df = DataFrame({"a": [1, 3], "b": [np.nan, 2]})
         df["c"] = np.nan
-        df["c"].update(Series(["foo"], index=[0]))
+        if using_copy_on_write:
+            df.update({"c": Series(["foo"], index=[0])})
+        else:
+            df["c"].update(Series(["foo"], index=[0]))
 
         expected = DataFrame({"a": [1, 3], "b": [np.nan, 2], "c": ["foo", np.nan]})
         tm.assert_frame_equal(df, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_update_modify_view(self, using_copy_on_write):
+        # GH#47188
+        df = DataFrame({"A": ["1", np.nan], "B": ["100", np.nan]})
+        df2 = DataFrame({"A": ["a", "x"], "B": ["100", "200"]})
+        df2_orig = df2.copy()
+        result_view = df2[:]
+        df2.update(df)
+        expected = DataFrame({"A": ["1", "x"], "B": ["100", "200"]})
+        tm.assert_frame_equal(df2, expected)
+        if using_copy_on_write:
+            tm.assert_frame_equal(result_view, df2_orig)
+        else:
+            tm.assert_frame_equal(result_view, expected)
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index 3adc4ebceaad5..bc6c676568f73 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -194,15 +194,19 @@ def test_empty_nonzero(self):
         df = DataFrame(index=["a", "b"], columns=["c", "d"]).dropna()
         assert df.empty
         assert df.T.empty
-        empty_frames = [
+
+    @pytest.mark.parametrize(
+        "df",
+        [
             DataFrame(),
             DataFrame(index=[1]),
             DataFrame(columns=[1]),
             DataFrame({1: []}),
-        ]
-        for df in empty_frames:
-            assert df.empty
-            assert df.T.empty
+        ],
+    )
+    def test_empty_like(self, df):
+        assert df.empty
+        assert df.T.empty
 
     def test_with_datetimelikes(self):
 
@@ -318,7 +322,9 @@ def test_attrs(self):
         assert result.attrs == {"version": 1}
 
     @pytest.mark.parametrize("allows_duplicate_labels", [True, False, None])
-    def test_set_flags(self, allows_duplicate_labels, frame_or_series):
+    def test_set_flags(
+        self, allows_duplicate_labels, frame_or_series, using_copy_on_write
+    ):
         obj = DataFrame({"A": [1, 2]})
         key = (0, 0)
         if frame_or_series is Series:
@@ -340,15 +346,25 @@ def test_set_flags(self, allows_duplicate_labels, frame_or_series):
         assert obj.flags.allows_duplicate_labels is True
 
         # But we didn't copy data
+        if frame_or_series is Series:
+            assert np.may_share_memory(obj.values, result.values)
+        else:
+            assert np.may_share_memory(obj["A"].values, result["A"].values)
+
         result.iloc[key] = 0
-        assert obj.iloc[key] == 0
+        if using_copy_on_write:
+            assert obj.iloc[key] == 1
+        else:
+            assert obj.iloc[key] == 0
+            # set back to 1 for test below
+            result.iloc[key] = 1
 
         # Now we do copy.
         result = obj.set_flags(
             copy=True, allows_duplicate_labels=allows_duplicate_labels
         )
         result.iloc[key] = 10
-        assert obj.iloc[key] == 0
+        assert obj.iloc[key] == 1
 
     def test_constructor_expanddim(self):
         # GH#33628 accessing _constructor_expanddim should not raise NotImplementedError
@@ -366,3 +382,8 @@ def test_inspect_getmembers(self):
         df = DataFrame()
         with tm.assert_produces_warning(None):
             inspect.getmembers(df)
+
+    def test_dataframe_iteritems_deprecated(self):
+        df = DataFrame([1])
+        with tm.assert_produces_warning(FutureWarning):
+            next(df.iteritems())
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 4820fcce6486b..93c4b44da985a 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -1,5 +1,6 @@
 from collections import deque
 from datetime import datetime
+from enum import Enum
 import functools
 import operator
 import re
@@ -41,7 +42,7 @@ def switch_numexpr_min_elements(request):
 
 
 class DummyElement:
-    def __init__(self, value, dtype):
+    def __init__(self, value, dtype) -> None:
         self.value = value
         self.dtype = np.dtype(dtype)
 
@@ -181,7 +182,18 @@ def test_comparison_invalid(self, arg, arg2):
         with pytest.raises(TypeError, match=msg):
             x <= y
 
-    def test_timestamp_compare(self):
+    @pytest.mark.parametrize(
+        "left, right",
+        [
+            ("gt", "lt"),
+            ("lt", "gt"),
+            ("ge", "le"),
+            ("le", "ge"),
+            ("eq", "eq"),
+            ("ne", "ne"),
+        ],
+    )
+    def test_timestamp_compare(self, left, right):
         # make sure we can compare Timestamps on the right AND left hand side
         # GH#4982
         df = DataFrame(
@@ -194,40 +206,37 @@ def test_timestamp_compare(self):
             }
         )
         df.loc[np.random.rand(len(df)) > 0.5, "dates2"] = pd.NaT
-        ops = {"gt": "lt", "lt": "gt", "ge": "le", "le": "ge", "eq": "eq", "ne": "ne"}
-
-        for left, right in ops.items():
-            left_f = getattr(operator, left)
-            right_f = getattr(operator, right)
+        left_f = getattr(operator, left)
+        right_f = getattr(operator, right)
 
-            # no nats
-            if left in ["eq", "ne"]:
-                expected = left_f(df, pd.Timestamp("20010109"))
-                result = right_f(pd.Timestamp("20010109"), df)
-                tm.assert_frame_equal(result, expected)
-            else:
-                msg = (
-                    "'(<|>)=?' not supported between "
-                    "instances of 'numpy.ndarray' and 'Timestamp'"
-                )
-                with pytest.raises(TypeError, match=msg):
-                    left_f(df, pd.Timestamp("20010109"))
-                with pytest.raises(TypeError, match=msg):
-                    right_f(pd.Timestamp("20010109"), df)
-            # nats
-            if left in ["eq", "ne"]:
-                expected = left_f(df, pd.Timestamp("nat"))
-                result = right_f(pd.Timestamp("nat"), df)
-                tm.assert_frame_equal(result, expected)
-            else:
-                msg = (
-                    "'(<|>)=?' not supported between "
-                    "instances of 'numpy.ndarray' and 'NaTType'"
-                )
-                with pytest.raises(TypeError, match=msg):
-                    left_f(df, pd.Timestamp("nat"))
-                with pytest.raises(TypeError, match=msg):
-                    right_f(pd.Timestamp("nat"), df)
+        # no nats
+        if left in ["eq", "ne"]:
+            expected = left_f(df, pd.Timestamp("20010109"))
+            result = right_f(pd.Timestamp("20010109"), df)
+            tm.assert_frame_equal(result, expected)
+        else:
+            msg = (
+                "'(<|>)=?' not supported between "
+                "instances of 'numpy.ndarray' and 'Timestamp'"
+            )
+            with pytest.raises(TypeError, match=msg):
+                left_f(df, pd.Timestamp("20010109"))
+            with pytest.raises(TypeError, match=msg):
+                right_f(pd.Timestamp("20010109"), df)
+        # nats
+        if left in ["eq", "ne"]:
+            expected = left_f(df, pd.Timestamp("nat"))
+            result = right_f(pd.Timestamp("nat"), df)
+            tm.assert_frame_equal(result, expected)
+        else:
+            msg = (
+                "'(<|>)=?' not supported between "
+                "instances of 'numpy.ndarray' and 'NaTType'"
+            )
+            with pytest.raises(TypeError, match=msg):
+                left_f(df, pd.Timestamp("nat"))
+            with pytest.raises(TypeError, match=msg):
+                right_f(pd.Timestamp("nat"), df)
 
     def test_mixed_comparison(self):
         # GH#13128, GH#22163 != datetime64 vs non-dt64 should be False,
@@ -275,79 +284,81 @@ def test_df_string_comparison(self):
 
 class TestFrameFlexComparisons:
     # TODO: test_bool_flex_frame needs a better name
-    def test_bool_flex_frame(self):
+    @pytest.mark.parametrize("op", ["eq", "ne", "gt", "lt", "ge", "le"])
+    def test_bool_flex_frame(self, op):
         data = np.random.randn(5, 3)
         other_data = np.random.randn(5, 3)
         df = DataFrame(data)
         other = DataFrame(other_data)
         ndim_5 = np.ones(df.shape + (1, 3))
 
-        # Unaligned
-        def _check_unaligned_frame(meth, op, df, other):
-            part_o = other.loc[3:, 1:].copy()
-            rs = meth(part_o)
-            xp = op(df, part_o.reindex(index=df.index, columns=df.columns))
-            tm.assert_frame_equal(rs, xp)
-
         # DataFrame
         assert df.eq(df).values.all()
         assert not df.ne(df).values.any()
-        for op in ["eq", "ne", "gt", "lt", "ge", "le"]:
-            f = getattr(df, op)
-            o = getattr(operator, op)
-            # No NAs
-            tm.assert_frame_equal(f(other), o(df, other))
-            _check_unaligned_frame(f, o, df, other)
-            # ndarray
-            tm.assert_frame_equal(f(other.values), o(df, other.values))
-            # scalar
-            tm.assert_frame_equal(f(0), o(df, 0))
-            # NAs
-            msg = "Unable to coerce to Series/DataFrame"
-            tm.assert_frame_equal(f(np.nan), o(df, np.nan))
-            with pytest.raises(ValueError, match=msg):
-                f(ndim_5)
+        f = getattr(df, op)
+        o = getattr(operator, op)
+        # No NAs
+        tm.assert_frame_equal(f(other), o(df, other))
+        # Unaligned
+        part_o = other.loc[3:, 1:].copy()
+        rs = f(part_o)
+        xp = o(df, part_o.reindex(index=df.index, columns=df.columns))
+        tm.assert_frame_equal(rs, xp)
+        # ndarray
+        tm.assert_frame_equal(f(other.values), o(df, other.values))
+        # scalar
+        tm.assert_frame_equal(f(0), o(df, 0))
+        # NAs
+        msg = "Unable to coerce to Series/DataFrame"
+        tm.assert_frame_equal(f(np.nan), o(df, np.nan))
+        with pytest.raises(ValueError, match=msg):
+            f(ndim_5)
 
+    @pytest.mark.parametrize("box", [np.array, Series])
+    def test_bool_flex_series(self, box):
         # Series
-        def _test_seq(df, idx_ser, col_ser):
-            idx_eq = df.eq(idx_ser, axis=0)
-            col_eq = df.eq(col_ser)
-            idx_ne = df.ne(idx_ser, axis=0)
-            col_ne = df.ne(col_ser)
-            tm.assert_frame_equal(col_eq, df == Series(col_ser))
-            tm.assert_frame_equal(col_eq, -col_ne)
-            tm.assert_frame_equal(idx_eq, -idx_ne)
-            tm.assert_frame_equal(idx_eq, df.T.eq(idx_ser).T)
-            tm.assert_frame_equal(col_eq, df.eq(list(col_ser)))
-            tm.assert_frame_equal(idx_eq, df.eq(Series(idx_ser), axis=0))
-            tm.assert_frame_equal(idx_eq, df.eq(list(idx_ser), axis=0))
-
-            idx_gt = df.gt(idx_ser, axis=0)
-            col_gt = df.gt(col_ser)
-            idx_le = df.le(idx_ser, axis=0)
-            col_le = df.le(col_ser)
-
-            tm.assert_frame_equal(col_gt, df > Series(col_ser))
-            tm.assert_frame_equal(col_gt, -col_le)
-            tm.assert_frame_equal(idx_gt, -idx_le)
-            tm.assert_frame_equal(idx_gt, df.T.gt(idx_ser).T)
-
-            idx_ge = df.ge(idx_ser, axis=0)
-            col_ge = df.ge(col_ser)
-            idx_lt = df.lt(idx_ser, axis=0)
-            col_lt = df.lt(col_ser)
-            tm.assert_frame_equal(col_ge, df >= Series(col_ser))
-            tm.assert_frame_equal(col_ge, -col_lt)
-            tm.assert_frame_equal(idx_ge, -idx_lt)
-            tm.assert_frame_equal(idx_ge, df.T.ge(idx_ser).T)
+        # list/tuple
+        data = np.random.randn(5, 3)
+        df = DataFrame(data)
+        idx_ser = box(np.random.randn(5))
+        col_ser = box(np.random.randn(3))
+
+        idx_eq = df.eq(idx_ser, axis=0)
+        col_eq = df.eq(col_ser)
+        idx_ne = df.ne(idx_ser, axis=0)
+        col_ne = df.ne(col_ser)
+        tm.assert_frame_equal(col_eq, df == Series(col_ser))
+        tm.assert_frame_equal(col_eq, -col_ne)
+        tm.assert_frame_equal(idx_eq, -idx_ne)
+        tm.assert_frame_equal(idx_eq, df.T.eq(idx_ser).T)
+        tm.assert_frame_equal(col_eq, df.eq(list(col_ser)))
+        tm.assert_frame_equal(idx_eq, df.eq(Series(idx_ser), axis=0))
+        tm.assert_frame_equal(idx_eq, df.eq(list(idx_ser), axis=0))
+
+        idx_gt = df.gt(idx_ser, axis=0)
+        col_gt = df.gt(col_ser)
+        idx_le = df.le(idx_ser, axis=0)
+        col_le = df.le(col_ser)
+
+        tm.assert_frame_equal(col_gt, df > Series(col_ser))
+        tm.assert_frame_equal(col_gt, -col_le)
+        tm.assert_frame_equal(idx_gt, -idx_le)
+        tm.assert_frame_equal(idx_gt, df.T.gt(idx_ser).T)
+
+        idx_ge = df.ge(idx_ser, axis=0)
+        col_ge = df.ge(col_ser)
+        idx_lt = df.lt(idx_ser, axis=0)
+        col_lt = df.lt(col_ser)
+        tm.assert_frame_equal(col_ge, df >= Series(col_ser))
+        tm.assert_frame_equal(col_ge, -col_lt)
+        tm.assert_frame_equal(idx_ge, -idx_lt)
+        tm.assert_frame_equal(idx_ge, df.T.ge(idx_ser).T)
 
         idx_ser = Series(np.random.randn(5))
         col_ser = Series(np.random.randn(3))
-        _test_seq(df, idx_ser, col_ser)
-
-        # list/tuple
-        _test_seq(df, idx_ser.values, col_ser.values)
 
+    def test_bool_flex_frame_na(self):
+        df = DataFrame(np.random.randn(5, 3))
         # NA
         df.loc[0, 0] = np.nan
         rs = df.eq(df)
@@ -594,16 +605,16 @@ def test_arith_flex_frame_mixed(
         expected = f(int_frame, 2 * int_frame)
         tm.assert_frame_equal(result, expected)
 
-    def test_arith_flex_frame_raise(self, all_arithmetic_operators, float_frame):
+    @pytest.mark.parametrize("dim", range(3, 6))
+    def test_arith_flex_frame_raise(self, all_arithmetic_operators, float_frame, dim):
         # one instance of parametrized fixture
         op = all_arithmetic_operators
 
         # Check that arrays with dim >= 3 raise
-        for dim in range(3, 6):
-            arr = np.ones((1,) * dim)
-            msg = "Unable to coerce to Series/DataFrame"
-            with pytest.raises(ValueError, match=msg):
-                getattr(float_frame, op)(arr)
+        arr = np.ones((1,) * dim)
+        msg = "Unable to coerce to Series/DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            getattr(float_frame, op)(arr)
 
     def test_arith_flex_frame_corner(self, float_frame):
 
@@ -623,19 +634,23 @@ def test_arith_flex_frame_corner(self, float_frame):
         with pytest.raises(NotImplementedError, match="fill_value"):
             float_frame.add(float_frame.iloc[0], axis="index", fill_value=3)
 
-    def test_arith_flex_series(self, simple_frame):
+    @pytest.mark.parametrize("op", ["add", "sub", "mul", "mod"])
+    def test_arith_flex_series_ops(self, simple_frame, op):
+        # after arithmetic refactor, add truediv here
         df = simple_frame
 
         row = df.xs("a")
         col = df["two"]
-        # after arithmetic refactor, add truediv here
-        ops = ["add", "sub", "mul", "mod"]
-        for op in ops:
-            f = getattr(df, op)
-            op = getattr(operator, op)
-            tm.assert_frame_equal(f(row), op(df, row))
-            tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)
+        f = getattr(df, op)
+        op = getattr(operator, op)
+        tm.assert_frame_equal(f(row), op(df, row))
+        tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)
 
+    def test_arith_flex_series(self, simple_frame):
+        df = simple_frame
+
+        row = df.xs("a")
+        col = df["two"]
         # special case for some reason
         tm.assert_frame_equal(df.add(row, axis=None), df + row)
 
@@ -643,13 +658,10 @@ def test_arith_flex_series(self, simple_frame):
         tm.assert_frame_equal(df.div(row), df / row)
         tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
 
+    @pytest.mark.parametrize("dtype", ["int64", "float64"])
+    def test_arith_flex_series_broadcasting(self, dtype):
         # broadcasting issue in GH 7325
-        df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="int64")
-        expected = DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
-        result = df.div(df[0], axis="index")
-        tm.assert_frame_equal(result, expected)
-
-        df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="float64")
+        df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype=dtype)
         expected = DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
         result = df.div(df[0], axis="index")
         tm.assert_frame_equal(result, expected)
@@ -711,6 +723,116 @@ def test_broadcast_multiindex(self, level):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_frame_multiindex_operations(self):
+        # GH 43321
+        df = DataFrame(
+            {2010: [1, 2, 3], 2020: [3, 4, 5]},
+            index=MultiIndex.from_product(
+                [["a"], ["b"], [0, 1, 2]], names=["scen", "mod", "id"]
+            ),
+        )
+
+        series = Series(
+            [0.4],
+            index=MultiIndex.from_product([["b"], ["a"]], names=["mod", "scen"]),
+        )
+
+        expected = DataFrame(
+            {2010: [1.4, 2.4, 3.4], 2020: [3.4, 4.4, 5.4]},
+            index=MultiIndex.from_product(
+                [["a"], ["b"], [0, 1, 2]], names=["scen", "mod", "id"]
+            ),
+        )
+        result = df.add(series, axis=0)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_multiindex_operations_series_index_to_frame_index(self):
+        # GH 43321
+        df = DataFrame(
+            {2010: [1], 2020: [3]},
+            index=MultiIndex.from_product([["a"], ["b"]], names=["scen", "mod"]),
+        )
+
+        series = Series(
+            [10.0, 20.0, 30.0],
+            index=MultiIndex.from_product(
+                [["a"], ["b"], [0, 1, 2]], names=["scen", "mod", "id"]
+            ),
+        )
+
+        expected = DataFrame(
+            {2010: [11.0, 21, 31.0], 2020: [13.0, 23.0, 33.0]},
+            index=MultiIndex.from_product(
+                [["a"], ["b"], [0, 1, 2]], names=["scen", "mod", "id"]
+            ),
+        )
+        result = df.add(series, axis=0)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_multiindex_operations_no_align(self):
+        df = DataFrame(
+            {2010: [1, 2, 3], 2020: [3, 4, 5]},
+            index=MultiIndex.from_product(
+                [["a"], ["b"], [0, 1, 2]], names=["scen", "mod", "id"]
+            ),
+        )
+
+        series = Series(
+            [0.4],
+            index=MultiIndex.from_product([["c"], ["a"]], names=["mod", "scen"]),
+        )
+
+        expected = DataFrame(
+            {2010: np.nan, 2020: np.nan},
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", "b", 0),
+                    ("a", "b", 1),
+                    ("a", "b", 2),
+                    ("a", "c", np.nan),
+                ],
+                names=["scen", "mod", "id"],
+            ),
+        )
+        result = df.add(series, axis=0)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_multiindex_operations_part_align(self):
+        df = DataFrame(
+            {2010: [1, 2, 3], 2020: [3, 4, 5]},
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", "b", 0),
+                    ("a", "b", 1),
+                    ("a", "c", 2),
+                ],
+                names=["scen", "mod", "id"],
+            ),
+        )
+
+        series = Series(
+            [0.4],
+            index=MultiIndex.from_product([["b"], ["a"]], names=["mod", "scen"]),
+        )
+
+        expected = DataFrame(
+            {2010: [1.4, 2.4, np.nan], 2020: [3.4, 4.4, np.nan]},
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", "b", 0),
+                    ("a", "b", 1),
+                    ("a", "c", 2),
+                ],
+                names=["scen", "mod", "id"],
+            ),
+        )
+        result = df.add(series, axis=0)
+
+        tm.assert_frame_equal(result, expected)
+
 
 class TestFrameArithmetic:
     def test_td64_op_nat_casting(self):
@@ -847,36 +969,12 @@ def test_arith_mixed(self):
         expected = DataFrame({"A": ["aa", "bb", "cc"], "B": [2, 4, 6]})
         tm.assert_frame_equal(result, expected)
 
-    def test_arith_getitem_commute(self):
+    @pytest.mark.parametrize("col", ["A", "B"])
+    def test_arith_getitem_commute(self, all_arithmetic_functions, col):
         df = DataFrame({"A": [1.1, 3.3], "B": [2.5, -3.9]})
-
-        def _test_op(df, op):
-            result = op(df, 1)
-
-            if not df.columns.is_unique:
-                raise ValueError("Only unique columns supported by this test")
-
-            for col in result.columns:
-                tm.assert_series_equal(result[col], op(df[col], 1))
-
-        _test_op(df, operator.add)
-        _test_op(df, operator.sub)
-        _test_op(df, operator.mul)
-        _test_op(df, operator.truediv)
-        _test_op(df, operator.floordiv)
-        _test_op(df, operator.pow)
-
-        _test_op(df, lambda x, y: y + x)
-        _test_op(df, lambda x, y: y - x)
-        _test_op(df, lambda x, y: y * x)
-        _test_op(df, lambda x, y: y / x)
-        _test_op(df, lambda x, y: y ** x)
-
-        _test_op(df, lambda x, y: x + y)
-        _test_op(df, lambda x, y: x - y)
-        _test_op(df, lambda x, y: x * y)
-        _test_op(df, lambda x, y: x / y)
-        _test_op(df, lambda x, y: x ** y)
+        result = all_arithmetic_functions(df, 1)[col]
+        expected = all_arithmetic_functions(df[col], 1)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "values", [[1, 2], (1, 2), np.array([1, 2]), range(1, 3), deque([1, 2])]
@@ -949,9 +1047,9 @@ def test_frame_with_frame_reindex(self):
         [
             (1, "i8"),
             (1.0, "f8"),
-            (2 ** 63, "f8"),
+            (2**63, "f8"),
             (1j, "complex128"),
-            (2 ** 63, "complex128"),
+            (2**63, "complex128"),
             (True, "bool"),
             (np.timedelta64(20, "ns"), "<m8[ns]"),
             (np.datetime64(20, "ns"), "<M8[ns]"),
@@ -1037,6 +1135,26 @@ def test_binop_other(self, op, value, dtype, switch_numexpr_min_elements):
                 expected = op(df, value).dtypes
             tm.assert_series_equal(result, expected)
 
+    def test_arithmetic_midx_cols_different_dtypes(self):
+        # GH#49769
+        midx = MultiIndex.from_arrays([Series([1, 2]), Series([3, 4])])
+        midx2 = MultiIndex.from_arrays([Series([1, 2], dtype="Int8"), Series([3, 4])])
+        left = DataFrame([[1, 2], [3, 4]], columns=midx)
+        right = DataFrame([[1, 2], [3, 4]], columns=midx2)
+        result = left - right
+        expected = DataFrame([[0, 0], [0, 0]], columns=midx)
+        tm.assert_frame_equal(result, expected)
+
+    def test_arithmetic_midx_cols_different_dtypes_different_order(self):
+        # GH#49769
+        midx = MultiIndex.from_arrays([Series([1, 2]), Series([3, 4])])
+        midx2 = MultiIndex.from_arrays([Series([2, 1], dtype="Int8"), Series([4, 3])])
+        left = DataFrame([[1, 2], [3, 4]], columns=midx)
+        right = DataFrame([[1, 2], [3, 4]], columns=midx2)
+        result = left - right
+        expected = DataFrame([[-1, 1], [-1, 1]], columns=midx)
+        tm.assert_frame_equal(result, expected)
+
 
 def test_frame_with_zero_len_series_corner_cases():
     # GH#28600
@@ -1151,7 +1269,8 @@ def test_logical_typeerror_with_non_valid(self, op, res, float_frame):
         result = getattr(float_frame, op)("foo")
         assert bool(result.all().all()) is res
 
-    def test_binary_ops_align(self):
+    @pytest.mark.parametrize("op", ["add", "sub", "mul", "div", "truediv"])
+    def test_binary_ops_align(self, op):
 
         # test aligning binary ops
 
@@ -1168,29 +1287,29 @@ def test_binary_ops_align(self):
         ).sort_index()
 
         idx = pd.IndexSlice
-        for op in ["add", "sub", "mul", "div", "truediv"]:
-            opa = getattr(operator, op, None)
-            if opa is None:
-                continue
+        opa = getattr(operator, op, None)
+        if opa is None:
+            return
 
-            x = Series([1.0, 10.0, 100.0], [1, 2, 3])
-            result = getattr(df, op)(x, level="third", axis=0)
+        x = Series([1.0, 10.0, 100.0], [1, 2, 3])
+        result = getattr(df, op)(x, level="third", axis=0)
 
-            expected = pd.concat(
-                [opa(df.loc[idx[:, :, i], :], v) for i, v in x.items()]
-            ).sort_index()
-            tm.assert_frame_equal(result, expected)
+        expected = pd.concat(
+            [opa(df.loc[idx[:, :, i], :], v) for i, v in x.items()]
+        ).sort_index()
+        tm.assert_frame_equal(result, expected)
 
-            x = Series([1.0, 10.0], ["two", "three"])
-            result = getattr(df, op)(x, level="second", axis=0)
+        x = Series([1.0, 10.0], ["two", "three"])
+        result = getattr(df, op)(x, level="second", axis=0)
 
-            expected = (
-                pd.concat([opa(df.loc[idx[:, i], :], v) for i, v in x.items()])
-                .reindex_like(df)
-                .sort_index()
-            )
-            tm.assert_frame_equal(result, expected)
+        expected = (
+            pd.concat([opa(df.loc[idx[:, i], :], v) for i, v in x.items()])
+            .reindex_like(df)
+            .sort_index()
+        )
+        tm.assert_frame_equal(result, expected)
 
+    def test_binary_ops_align_series_dataframe(self):
         # GH9463 (alignment level of dataframe with series)
 
         midx = MultiIndex.from_product([["A", "B"], ["a", "b"]])
@@ -1235,7 +1354,8 @@ def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
         frame_copy = float_frame.reindex(float_frame.index[::2])
 
         del frame_copy["D"]
-        frame_copy["C"][:5] = np.nan
+        # adding NAs to first 5 values of column "C"
+        frame_copy.loc[: frame_copy.index[4], "C"] = np.nan
 
         added = float_frame + frame_copy
 
@@ -1392,42 +1512,38 @@ def test_combineFunc(self, float_frame, mixed_float_frame):
         assert result.index.equals(DataFrame().index)
         assert len(result.columns) == 0
 
-    def test_comparisons(self, simple_frame, float_frame):
+    @pytest.mark.parametrize(
+        "func",
+        [operator.eq, operator.ne, operator.lt, operator.gt, operator.ge, operator.le],
+    )
+    def test_comparisons(self, simple_frame, float_frame, func):
         df1 = tm.makeTimeDataFrame()
         df2 = tm.makeTimeDataFrame()
 
         row = simple_frame.xs("a")
         ndim_5 = np.ones(df1.shape + (1, 1, 1))
 
-        def test_comp(func):
-            result = func(df1, df2)
-            tm.assert_numpy_array_equal(result.values, func(df1.values, df2.values))
+        result = func(df1, df2)
+        tm.assert_numpy_array_equal(result.values, func(df1.values, df2.values))
 
-            msg = (
-                "Unable to coerce to Series/DataFrame, "
-                "dimension must be <= 2: (30, 4, 1, 1, 1)"
-            )
-            with pytest.raises(ValueError, match=re.escape(msg)):
-                func(df1, ndim_5)
-
-            result2 = func(simple_frame, row)
-            tm.assert_numpy_array_equal(
-                result2.values, func(simple_frame.values, row.values)
-            )
+        msg = (
+            "Unable to coerce to Series/DataFrame, "
+            "dimension must be <= 2: (30, 4, 1, 1, 1)"
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            func(df1, ndim_5)
 
-            result3 = func(float_frame, 0)
-            tm.assert_numpy_array_equal(result3.values, func(float_frame.values, 0))
+        result2 = func(simple_frame, row)
+        tm.assert_numpy_array_equal(
+            result2.values, func(simple_frame.values, row.values)
+        )
 
-            msg = "Can only compare identically-labeled DataFrame"
-            with pytest.raises(ValueError, match=msg):
-                func(simple_frame, simple_frame[:2])
+        result3 = func(float_frame, 0)
+        tm.assert_numpy_array_equal(result3.values, func(float_frame.values, 0))
 
-        test_comp(operator.eq)
-        test_comp(operator.ne)
-        test_comp(operator.lt)
-        test_comp(operator.gt)
-        test_comp(operator.ge)
-        test_comp(operator.le)
+        msg = "Can only compare identically-labeled DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            func(simple_frame, simple_frame[:2])
 
     def test_strings_to_numbers_comparisons_raises(self, compare_operators_no_eq_ne):
         # GH 11565
@@ -1477,7 +1593,7 @@ def test_boolean_comparison(self):
 
         with pytest.raises(ValueError, match=msg1d):
             # wrong shape
-            result = df > tup
+            df > tup
 
         # broadcasts like ndarray (GH#23000)
         result = df > b_r
@@ -1498,10 +1614,10 @@ def test_boolean_comparison(self):
         tm.assert_frame_equal(result, expected)
 
         with pytest.raises(ValueError, match=msg1d):
-            result = df == lst
+            df == lst
 
         with pytest.raises(ValueError, match=msg1d):
-            result = df == tup
+            df == tup
 
         # broadcasts like ndarray (GH#23000)
         result = df == b_r
@@ -1523,10 +1639,10 @@ def test_boolean_comparison(self):
         expected.columns = df.columns
 
         with pytest.raises(ValueError, match=msg1d):
-            result = df == lst
+            df == lst
 
         with pytest.raises(ValueError, match=msg1d):
-            result = df == tup
+            df == tup
 
     def test_inplace_ops_alignment(self):
 
@@ -1674,37 +1790,51 @@ def test_inplace_ops_identity2(self, op):
         expected = id(df)
         assert id(df) == expected
 
-    def test_alignment_non_pandas(self):
+    @pytest.mark.parametrize(
+        "val",
+        [
+            [1, 2, 3],
+            (1, 2, 3),
+            np.array([1, 2, 3], dtype=np.int64),
+            range(1, 4),
+        ],
+    )
+    def test_alignment_non_pandas(self, val):
         index = ["A", "B", "C"]
         columns = ["X", "Y", "Z"]
         df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)
 
         align = pd.core.ops.align_method_FRAME
-        for val in [
-            [1, 2, 3],
-            (1, 2, 3),
-            np.array([1, 2, 3], dtype=np.int64),
-            range(1, 4),
-        ]:
 
-            expected = DataFrame({"X": val, "Y": val, "Z": val}, index=df.index)
-            tm.assert_frame_equal(align(df, val, "index")[1], expected)
+        expected = DataFrame({"X": val, "Y": val, "Z": val}, index=df.index)
+        tm.assert_frame_equal(align(df, val, "index")[1], expected)
 
-            expected = DataFrame(
-                {"X": [1, 1, 1], "Y": [2, 2, 2], "Z": [3, 3, 3]}, index=df.index
-            )
-            tm.assert_frame_equal(align(df, val, "columns")[1], expected)
+        expected = DataFrame(
+            {"X": [1, 1, 1], "Y": [2, 2, 2], "Z": [3, 3, 3]}, index=df.index
+        )
+        tm.assert_frame_equal(align(df, val, "columns")[1], expected)
 
+    @pytest.mark.parametrize("val", [[1, 2], (1, 2), np.array([1, 2]), range(1, 3)])
+    def test_alignment_non_pandas_length_mismatch(self, val):
+        index = ["A", "B", "C"]
+        columns = ["X", "Y", "Z"]
+        df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)
+
+        align = pd.core.ops.align_method_FRAME
         # length mismatch
         msg = "Unable to coerce to Series, length must be 3: given 2"
-        for val in [[1, 2], (1, 2), np.array([1, 2]), range(1, 3)]:
+        with pytest.raises(ValueError, match=msg):
+            align(df, val, "index")
 
-            with pytest.raises(ValueError, match=msg):
-                align(df, val, "index")
+        with pytest.raises(ValueError, match=msg):
+            align(df, val, "columns")
 
-            with pytest.raises(ValueError, match=msg):
-                align(df, val, "columns")
+    def test_alignment_non_pandas_index_columns(self):
+        index = ["A", "B", "C"]
+        columns = ["X", "Y", "Z"]
+        df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)
 
+        align = pd.core.ops.align_method_FRAME
         val = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
         tm.assert_frame_equal(
             align(df, val, "index")[1],
@@ -1766,7 +1896,7 @@ def test_pow_with_realignment():
     left = DataFrame({"A": [0, 1, 2]})
     right = DataFrame(index=[0, 1, 2])
 
-    result = left ** right
+    result = left**right
     expected = DataFrame({"A": [np.nan, 1.0, np.nan]})
     tm.assert_frame_equal(result, expected)
 
@@ -1778,7 +1908,7 @@ def test_pow_nan_with_zero():
 
     expected = DataFrame({"A": [1.0, 1.0, 1.0]})
 
-    result = left ** right
+    result = left**right
     tm.assert_frame_equal(result, expected)
 
     result = left["A"] ** right["A"]
@@ -1898,6 +2028,15 @@ def test_bool_frame_mult_float():
     tm.assert_frame_equal(result, expected)
 
 
+def test_frame_sub_nullable_int(any_int_ea_dtype):
+    # GH 32822
+    series1 = Series([1, 2, None], dtype=any_int_ea_dtype)
+    series2 = Series([1, 2, 3], dtype=any_int_ea_dtype)
+    expected = DataFrame([0, 0, None], dtype=any_int_ea_dtype)
+    result = series1.to_frame() - series2.to_frame()
+    tm.assert_frame_equal(result, expected)
+
+
 def test_frame_op_subclass_nonclass_constructor():
     # GH#43201 subclass._constructor is a function, not the subclass itself
 
@@ -1932,3 +2071,15 @@ def _constructor_sliced(self):
 
     result = sdf + sdf
     tm.assert_frame_equal(result, expected)
+
+
+def test_enum_column_equality():
+    Cols = Enum("Cols", "col1 col2")
+
+    q1 = DataFrame({Cols.col1: [1, 2, 3]})
+    q2 = DataFrame({Cols.col1: [1, 2, 3]})
+
+    result = q1[Cols.col1] == q2[Cols.col1]
+    expected = Series([True, True, True], name=Cols.col1)
+
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 01a8982c5fe16..46c712cf4d458 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -118,14 +118,14 @@ def test_boolean_set_uncons(self, float_frame):
     def test_constructor_with_convert(self):
         # this is actually mostly a test of lib.maybe_convert_objects
         # #2845
-        df = DataFrame({"A": [2 ** 63 - 1]})
+        df = DataFrame({"A": [2**63 - 1]})
         result = df["A"]
-        expected = Series(np.asarray([2 ** 63 - 1], np.int64), name="A")
+        expected = Series(np.asarray([2**63 - 1], np.int64), name="A")
         tm.assert_series_equal(result, expected)
 
-        df = DataFrame({"A": [2 ** 63]})
+        df = DataFrame({"A": [2**63]})
         result = df["A"]
-        expected = Series(np.asarray([2 ** 63], np.uint64), name="A")
+        expected = Series(np.asarray([2**63], np.uint64), name="A")
         tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [datetime(2005, 1, 1), True]})
@@ -334,7 +334,7 @@ def test_is_mixed_type(self, float_frame, float_string_frame):
         assert not float_frame._is_mixed_type
         assert float_string_frame._is_mixed_type
 
-    def test_stale_cached_series_bug_473(self):
+    def test_stale_cached_series_bug_473(self, using_copy_on_write):
 
         # this is chained, but ok
         with option_context("chained_assignment", None):
@@ -349,9 +349,12 @@ def test_stale_cached_series_bug_473(self):
             repr(Y)
             result = Y.sum()  # noqa
             exp = Y["g"].sum()  # noqa
-            assert pd.isna(Y["g"]["c"])
+            if using_copy_on_write:
+                assert not pd.isna(Y["g"]["c"])
+            else:
+                assert pd.isna(Y["g"]["c"])
 
-    def test_strange_column_corruption_issue(self):
+    def test_strange_column_corruption_issue(self, using_copy_on_write):
         # TODO(wesm): Unclear how exactly this is related to internal matters
         df = DataFrame(index=[0, 1])
         df[0] = np.nan
@@ -363,7 +366,10 @@ def test_strange_column_corruption_issue(self):
                     if col not in wasCol:
                         wasCol[col] = 1
                         df[col] = np.nan
-                    df[col][dt] = i
+                    if using_copy_on_write:
+                        df.loc[dt, col] = i
+                    else:
+                        df[col][dt] = i
 
         myid = 100
 
@@ -396,7 +402,7 @@ def test_add_column_with_pandas_array(self):
         tm.assert_frame_equal(df, df2)
 
 
-def test_update_inplace_sets_valid_block_values():
+def test_update_inplace_sets_valid_block_values(using_copy_on_write):
     # https://github.com/pandas-dev/pandas/issues/33457
     df = DataFrame({"a": Series([1, 2, None], dtype="category")})
 
@@ -406,8 +412,9 @@ def test_update_inplace_sets_valid_block_values():
     # check we haven't put a Series into any block.values
     assert isinstance(df._mgr.blocks[0].values, Categorical)
 
-    # smoketest for OP bug from GH#35731
-    assert df.isnull().sum().sum() == 0
+    if not using_copy_on_write:
+        # smoketest for OP bug from GH#35731
+        assert df.isnull().sum().sum() == 0
 
 
 def test_nonconsolidated_item_cache_take():
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 7f030fc11a20b..16021facb3986 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -18,7 +18,6 @@
 import pytest
 import pytz
 
-from pandas.compat import np_version_under1p19
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import is_integer_dtype
@@ -53,6 +52,7 @@
     IntervalArray,
     PeriodArray,
     SparseArray,
+    TimedeltaArray,
 )
 from pandas.core.api import Int64Index
 
@@ -70,6 +70,14 @@
 
 
 class TestDataFrameConstructors:
+    def test_constructor_from_ndarray_with_str_dtype(self):
+        # If we don't ravel/reshape around ensure_str_array, we end up
+        #  with an array of strings each of which is e.g. "[0 1 2]"
+        arr = np.arange(12).reshape(4, 3)
+        df = DataFrame(arr, dtype=str)
+        expected = DataFrame(arr.astype(str))
+        tm.assert_frame_equal(df, expected)
+
     def test_constructor_from_2d_datetimearray(self, using_array_manager):
         dti = date_range("2016-01-01", periods=6, tz="US/Pacific")
         dta = dti._data.reshape(3, 2)
@@ -263,15 +271,22 @@ def test_constructor_dtype_copy(self):
         new_df["col1"] = 200.0
         assert orig_df["col1"][0] == 1.0
 
-    def test_constructor_dtype_nocast_view_dataframe(self):
+    def test_constructor_dtype_nocast_view_dataframe(self, using_copy_on_write):
         df = DataFrame([[1, 2]])
         should_be_view = DataFrame(df, dtype=df[0].dtype)
-        should_be_view[0][0] = 99
-        assert df.values[0, 0] == 99
+        if using_copy_on_write:
+            # INFO(CoW) doesn't mutate original
+            should_be_view.iloc[0, 0] = 99
+            assert df.values[0, 0] == 1
+        else:
+            should_be_view[0][0] = 99
+            assert df.values[0, 0] == 99
 
-    def test_constructor_dtype_nocast_view_2d_array(self, using_array_manager):
+    def test_constructor_dtype_nocast_view_2d_array(
+        self, using_array_manager, using_copy_on_write
+    ):
         df = DataFrame([[1, 2], [3, 4]], dtype="int64")
-        if not using_array_manager:
+        if not using_array_manager and not using_copy_on_write:
             should_be_view = DataFrame(df.values, dtype=df[0].dtype)
             should_be_view[0][0] = 97
             assert df.values[0, 0] == 97
@@ -300,7 +315,6 @@ def test_constructor_dtype_list_data(self):
         assert df.loc[1, 0] is None
         assert df.loc[0, 1] == "2"
 
-    @pytest.mark.skipif(np_version_under1p19, reason="NumPy change.")
     def test_constructor_list_of_2d_raises(self):
         # https://github.com/pandas-dev/pandas/issues/32289
         a = DataFrame()
@@ -315,43 +329,34 @@ def test_constructor_list_of_2d_raises(self):
         with pytest.raises(ValueError, match=r"shape=\(2, 2, 1\)"):
             DataFrame([a, a])
 
-    def test_constructor_mixed_dtypes(self):
-        def _make_mixed_dtypes_df(typ, ad=None):
-
-            if typ == "int":
-                dtypes = MIXED_INT_DTYPES
-                arrays = [np.array(np.random.rand(10), dtype=d) for d in dtypes]
-            elif typ == "float":
-                dtypes = MIXED_FLOAT_DTYPES
-                arrays = [
-                    np.array(np.random.randint(10, size=10), dtype=d) for d in dtypes
-                ]
-
-            for d, a in zip(dtypes, arrays):
-                assert a.dtype == d
-            if ad is None:
-                ad = {}
-            ad.update({d: a for d, a in zip(dtypes, arrays)})
-            return DataFrame(ad)
-
-        def _check_mixed_dtypes(df, dtypes=None):
-            if dtypes is None:
-                dtypes = MIXED_FLOAT_DTYPES + MIXED_INT_DTYPES
-            for d in dtypes:
-                if d in df:
-                    assert df.dtypes[d] == d
-
-        # mixed floating and integer coexist in the same frame
-        df = _make_mixed_dtypes_df("float")
-        _check_mixed_dtypes(df)
-
-        # add lots of types
-        df = _make_mixed_dtypes_df("float", {"A": 1, "B": "foo", "C": "bar"})
-        _check_mixed_dtypes(df)
-
-        # GH 622
-        df = _make_mixed_dtypes_df("int")
-        _check_mixed_dtypes(df)
+    @pytest.mark.parametrize(
+        "typ, ad",
+        [
+            # mixed floating and integer coexist in the same frame
+            ["float", {}],
+            # add lots of types
+            ["float", {"A": 1, "B": "foo", "C": "bar"}],
+            # GH 622
+            ["int", {}],
+        ],
+    )
+    def test_constructor_mixed_dtypes(self, typ, ad):
+        if typ == "int":
+            dtypes = MIXED_INT_DTYPES
+            arrays = [np.array(np.random.rand(10), dtype=d) for d in dtypes]
+        elif typ == "float":
+            dtypes = MIXED_FLOAT_DTYPES
+            arrays = [np.array(np.random.randint(10, size=10), dtype=d) for d in dtypes]
+
+        for d, a in zip(dtypes, arrays):
+            assert a.dtype == d
+        ad.update({d: a for d, a in zip(dtypes, arrays)})
+        df = DataFrame(ad)
+
+        dtypes = MIXED_FLOAT_DTYPES + MIXED_INT_DTYPES
+        for d in dtypes:
+            if d in df:
+                assert df.dtypes[d] == d
 
     def test_constructor_complex_dtypes(self):
         # GH10952
@@ -398,7 +403,7 @@ def test_constructor_bool(self):
 
     def test_constructor_overflow_int64(self):
         # see gh-14881
-        values = np.array([2 ** 64 - i for i in range(1, 10)], dtype=np.uint64)
+        values = np.array([2**64 - i for i in range(1, 10)], dtype=np.uint64)
 
         result = DataFrame({"a": values})
         assert result["a"].dtype == np.uint64
@@ -420,12 +425,12 @@ def test_constructor_overflow_int64(self):
     @pytest.mark.parametrize(
         "values",
         [
-            np.array([2 ** 64], dtype=object),
-            np.array([2 ** 65]),
-            [2 ** 64 + 1],
-            np.array([-(2 ** 63) - 4], dtype=object),
-            np.array([-(2 ** 64) - 1]),
-            [-(2 ** 65) - 2],
+            np.array([2**64], dtype=object),
+            np.array([2**65]),
+            [2**64 + 1],
+            np.array([-(2**63) - 4], dtype=object),
+            np.array([-(2**64) - 1]),
+            [-(2**65) - 2],
         ],
     )
     def test_constructor_int_overflow(self, values):
@@ -436,6 +441,25 @@ def test_constructor_int_overflow(self, values):
         assert result[0].dtype == object
         assert result[0][0] == value
 
+    @pytest.mark.parametrize(
+        "values",
+        [
+            np.array([1], dtype=np.uint16),
+            np.array([1], dtype=np.uint32),
+            np.array([1], dtype=np.uint64),
+            [np.uint16(1)],
+            [np.uint32(1)],
+            [np.uint64(1)],
+        ],
+    )
+    def test_constructor_numpy_uints(self, values):
+        # GH#47294
+        value = values[0]
+        result = DataFrame(values)
+
+        assert result[0].dtype == value.dtype
+        assert result[0][0] == value
+
     def test_constructor_ordereddict(self):
         import random
 
@@ -1285,8 +1309,7 @@ def test_constructor_empty_list(self):
 
         # Empty generator: list(empty_gen()) == []
         def empty_gen():
-            return
-            yield
+            yield from ()
 
         df = DataFrame(empty_gen(), columns=["A", "B"])
         tm.assert_frame_equal(df, expected)
@@ -1365,13 +1388,13 @@ def test_constructor_sequence_like(self):
         # collections.Sequence like
 
         class DummyContainer(abc.Sequence):
-            def __init__(self, lst):
+            def __init__(self, lst) -> None:
                 self._lst = lst
 
             def __getitem__(self, n):
                 return self._lst.__getitem__(n)
 
-            def __len__(self, n):
+            def __len__(self):
                 return self._lst.__len__()
 
         lst_containers = [DummyContainer([1, "a"]), DummyContainer([2, "b"])]
@@ -1531,7 +1554,7 @@ def test_constructor_mixed_dict_and_Series(self):
         data["B"] = Series([4, 3, 2, 1], index=["bar", "qux", "baz", "foo"])
 
         result = DataFrame(data)
-        assert result.index.is_monotonic
+        assert result.index.is_monotonic_increasing
 
         # ordering ambiguous, raise exception
         with pytest.raises(ValueError, match="ambiguous ordering"):
@@ -2082,7 +2105,7 @@ def test_constructor_for_list_with_dtypes(self):
         tm.assert_series_equal(result, expected)
 
         # overflow issue? (we always expected int64 upcasting here)
-        df = DataFrame({"a": [2 ** 31, 2 ** 31 + 1]})
+        df = DataFrame({"a": [2**31, 2**31 + 1]})
         assert df.dtypes.iloc[0] == np.dtype("int64")
 
         # GH #2751 (construction with no index specified), make sure we cast to
@@ -2158,8 +2181,6 @@ def test_constructor_ndarray_copy(self, float_frame, using_array_manager):
             arr[0, 0] = 1000
             assert df.iloc[0, 0] == 1000
 
-    # TODO(ArrayManager) keep view on Series?
-    @td.skip_array_manager_not_yet_implemented
     def test_constructor_series_copy(self, float_frame):
         series = float_frame._series
 
@@ -2506,15 +2527,18 @@ def test_constructor_list_str_na(self, string_dtype):
 
     @pytest.mark.parametrize("copy", [False, True])
     def test_dict_nocopy(
-        self, request, copy, any_numeric_ea_dtype, any_numpy_dtype, using_array_manager
+        self,
+        request,
+        copy,
+        any_numeric_ea_dtype,
+        any_numpy_dtype,
+        using_array_manager,
+        using_copy_on_write,
     ):
-        if using_array_manager and not (
-            (any_numpy_dtype in (tm.STRING_DTYPES + tm.BYTES_DTYPES))
-            or (
-                any_numpy_dtype
-                in (tm.DATETIME64_DTYPES + tm.TIMEDELTA64_DTYPES + tm.BOOL_DTYPES)
-                and copy
-            )
+        if (
+            using_array_manager
+            and not copy
+            and not (any_numpy_dtype in (tm.STRING_DTYPES + tm.BYTES_DTYPES))
         ):
             # TODO(ArrayManager) properly honor copy keyword for dict input
             td.mark_array_manager_not_yet_implemented(request)
@@ -2526,6 +2550,7 @@ def test_dict_nocopy(
             return
 
         c = pd.array([1, 2], dtype=any_numeric_ea_dtype)
+        c_orig = c.copy()
         df = DataFrame({"a": a, "b": b, "c": c}, copy=copy)
 
         def get_base(obj):
@@ -2537,9 +2562,19 @@ def get_base(obj):
             else:
                 raise TypeError
 
-        def check_views():
+        def check_views(c_only: bool = False):
             # written to work for either BlockManager or ArrayManager
+
+            # Check that the underlying data behind df["c"] is still `c`
+            #  after setting with iloc.  Since we don't know which entry in
+            #  df._mgr.arrays corresponds to df["c"], we just check that exactly
+            #  one of these arrays is `c`.  GH#38939
             assert sum(x is c for x in df._mgr.arrays) == 1
+            if c_only:
+                # If we ever stop consolidating in setitem_with_indexer,
+                #  this will become unnecessary.
+                return
+
             assert (
                 sum(
                     get_base(x) is a
@@ -2561,23 +2596,21 @@ def check_views():
             # constructor preserves views
             check_views()
 
+        # TODO: most of the rest of this test belongs in indexing tests
         df.iloc[0, 0] = 0
         df.iloc[0, 1] = 0
         if not copy:
-            # Check that the underlying data behind df["c"] is still `c`
-            #  after setting with iloc.  Since we don't know which entry in
-            #  df._mgr.arrays corresponds to df["c"], we just check that exactly
-            #  one of these arrays is `c`.  GH#38939
-            assert sum(x is c for x in df._mgr.arrays) == 1
-            # TODO: we can call check_views if we stop consolidating
-            #  in setitem_with_indexer
+            check_views(True)
 
         # FIXME(GH#35417): until GH#35417, iloc.setitem into EA values does not preserve
         #  view, so we have to check in the other direction
-        # df.iloc[0, 2] = 0
-        # if not copy:
-        #     check_views()
-        c[0] = 0
+        with tm.assert_produces_warning(
+            DeprecationWarning, match="will attempt to set"
+        ):
+            df.iloc[:, 2] = pd.array([45, 46], dtype=c.dtype)
+        assert df.dtypes.iloc[2] == c.dtype
+        if not copy and not using_copy_on_write:
+            check_views(True)
 
         if copy:
             if a.dtype.kind == "M":
@@ -2587,14 +2620,13 @@ def check_views():
                 assert a[0] == a.dtype.type(1)
                 assert b[0] == b.dtype.type(3)
             # FIXME(GH#35417): enable after GH#35417
-            # assert c[0] == 1
-            assert df.iloc[0, 2] == 1
-        else:
+            assert c[0] == c_orig[0]  # i.e. df.iloc[0, 2]=45 did *not* update c
+        elif not using_copy_on_write:
             # TODO: we can call check_views if we stop consolidating
             #  in setitem_with_indexer
-            # FIXME(GH#35417): enable after GH#35417
-            # assert b[0] == 0
-            assert df.iloc[0, 2] == 0
+            assert c[0] == 45  # i.e. df.iloc[0, 2]=45 *did* update c
+            # TODO: we can check b[0] == 0 if we stop consolidating in
+            #  setitem_with_indexer (except for datetimelike?)
 
     def test_from_series_with_name_with_columns(self):
         # GH 7893
@@ -2648,6 +2680,29 @@ def test_error_from_2darray(self, col_a, col_b):
         with pytest.raises(ValueError, match=msg):
             DataFrame({"a": col_a, "b": col_b})
 
+    def test_from_dict_with_missing_copy_false(self):
+        # GH#45369 filled columns should not be views of one another
+        df = DataFrame(index=[1, 2, 3], columns=["a", "b", "c"], copy=False)
+        assert not np.shares_memory(df["a"]._values, df["b"]._values)
+
+        df.iloc[0, 0] = 0
+        expected = DataFrame(
+            {
+                "a": [0, np.nan, np.nan],
+                "b": [np.nan, np.nan, np.nan],
+                "c": [np.nan, np.nan, np.nan],
+            },
+            index=[1, 2, 3],
+            dtype=object,
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_construction_empty_array_multi_column_raises(self):
+        # GH#46822
+        msg = "Empty data passed with indices specified."
+        with pytest.raises(ValueError, match=msg):
+            DataFrame(data=np.array([]), columns=["a", "b"])
+
 
 class TestDataFrameConstructorIndexInference:
     def test_frame_from_dict_of_series_overlapping_monthly_period_indexes(self):
@@ -2958,6 +3013,14 @@ def test_construction_from_ndarray_with_eadtype_mismatched_columns(self):
         with pytest.raises(ValueError, match=msg):
             DataFrame(arr2, columns=["foo", "bar"])
 
+    def test_columns_indexes_raise_on_sets(self):
+        # GH 47215
+        data = [[1, 2, 3], [4, 5, 6]]
+        with pytest.raises(ValueError, match="index cannot be a set"):
+            DataFrame(data, index={"a", "b"})
+        with pytest.raises(ValueError, match="columns cannot be a set"):
+            DataFrame(data, columns={"a", "b", "c"})
+
 
 def get1(obj):  # TODO: make a helper in tm?
     if isinstance(obj, Series):
@@ -3068,3 +3131,51 @@ def test_tzaware_data_tznaive_dtype(self, constructor):
 
         assert np.all(result.dtypes == "M8[ns]")
         assert np.all(result == ts_naive)
+
+
+# TODO: better location for this test?
+class TestAllowNonNano:
+    # Until 2.0, we do not preserve non-nano dt64/td64 when passed as ndarray,
+    #  but do preserve it when passed as DTA/TDA
+
+    @pytest.fixture(params=[True, False])
+    def as_td(self, request):
+        return request.param
+
+    @pytest.fixture
+    def arr(self, as_td):
+        values = np.arange(5).astype(np.int64).view("M8[s]")
+        if as_td:
+            values = values - values[0]
+            return TimedeltaArray._simple_new(values, dtype=values.dtype)
+        else:
+            return DatetimeArray._simple_new(values, dtype=values.dtype)
+
+    def test_index_allow_non_nano(self, arr):
+        idx = Index(arr)
+        assert idx.dtype == arr.dtype
+
+    def test_dti_tdi_allow_non_nano(self, arr, as_td):
+        if as_td:
+            idx = pd.TimedeltaIndex(arr)
+        else:
+            idx = DatetimeIndex(arr)
+        assert idx.dtype == arr.dtype
+
+    def test_series_allow_non_nano(self, arr):
+        ser = Series(arr)
+        assert ser.dtype == arr.dtype
+
+    def test_frame_allow_non_nano(self, arr):
+        df = DataFrame(arr)
+        assert df.dtypes[0] == arr.dtype
+
+    @pytest.mark.xfail(
+        # TODO(2.0): xfail should become unnecessary
+        strict=False,
+        reason="stack_arrays converts TDA to ndarray, then goes "
+        "through ensure_wrapped_if_datetimelike",
+    )
+    def test_frame_from_dict_allow_non_nano(self, arr):
+        df = DataFrame({0: arr})
+        assert df.dtypes[0] == arr.dtype
diff --git a/pandas/tests/frame/test_nonunique_indexes.py b/pandas/tests/frame/test_nonunique_indexes.py
index d010426bee53e..38861a2b04409 100644
--- a/pandas/tests/frame/test_nonunique_indexes.py
+++ b/pandas/tests/frame/test_nonunique_indexes.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas.compat import is_platform_windows
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -173,7 +175,7 @@ def test_column_dups_indexes(self):
             this_df = df.copy()
             expected_ser = Series(index.values, index=this_df.index)
             expected_df = DataFrame(
-                {"A": expected_ser, "B": this_df["B"], "A": expected_ser},
+                {"A": expected_ser, "B": this_df["B"]},
                 columns=["A", "B", "A"],
             )
             this_df["A"] = index
@@ -318,18 +320,27 @@ def test_dup_columns_across_dtype(self):
         xp.columns = ["A", "A", "B"]
         tm.assert_frame_equal(rs, xp)
 
-    def test_set_value_by_index(self):
+    def test_set_value_by_index(self, using_array_manager):
         # See gh-12344
+        warn = (
+            DeprecationWarning
+            if using_array_manager and not is_platform_windows()
+            else None
+        )
+        msg = "will attempt to set the values inplace"
+
         df = DataFrame(np.arange(9).reshape(3, 3).T)
         df.columns = list("AAA")
         expected = df.iloc[:, 2]
 
-        df.iloc[:, 0] = 3
+        with tm.assert_produces_warning(warn, match=msg):
+            df.iloc[:, 0] = 3
         tm.assert_series_equal(df.iloc[:, 2], expected)
 
         df = DataFrame(np.arange(9).reshape(3, 3).T)
         df.columns = [2, float(2), str(2)]
         expected = df.iloc[:, 1]
 
-        df.iloc[:, 0] = 3
+        with tm.assert_produces_warning(warn, match=msg):
+            df.iloc[:, 0] = 3
         tm.assert_series_equal(df.iloc[:, 1], expected)
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index 558ba0424e481..35335c54cd41e 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -3,6 +3,7 @@
 import numpy as np
 import pytest
 
+from pandas.errors import UndefinedVariableError
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -16,16 +17,15 @@
 import pandas._testing as tm
 from pandas.core.computation.check import NUMEXPR_INSTALLED
 
-PARSERS = "python", "pandas"
-ENGINES = "python", pytest.param("numexpr", marks=td.skip_if_no_ne)
 
-
-@pytest.fixture(params=PARSERS, ids=lambda x: x)
+@pytest.fixture(params=["python", "pandas"], ids=lambda x: x)
 def parser(request):
     return request.param
 
 
-@pytest.fixture(params=ENGINES, ids=lambda x: x)
+@pytest.fixture(
+    params=["python", pytest.param("numexpr", marks=td.skip_if_no_ne)], ids=lambda x: x
+)
 def engine(request):
     return request.param
 
@@ -36,7 +36,7 @@ def skip_if_no_pandas_parser(parser):
 
 
 class TestCompat:
-    def setup_method(self, method):
+    def setup_method(self):
         self.df = DataFrame({"A": [1, 2, 3]})
         self.expected1 = self.df[self.df.A > 0]
         self.expected2 = self.df.A + 1
@@ -496,8 +496,6 @@ def test_query_syntax_error(self):
             df.query("i - +", engine=engine, parser=parser)
 
     def test_query_scope(self):
-        from pandas.core.computation.ops import UndefinedVariableError
-
         engine, parser = self.engine, self.parser
         skip_if_no_pandas_parser(parser)
 
@@ -523,8 +521,6 @@ def test_query_scope(self):
             df.query("@a > b > c", engine=engine, parser=parser)
 
     def test_query_doesnt_pickup_local(self):
-        from pandas.core.computation.ops import UndefinedVariableError
-
         engine, parser = self.engine, self.parser
         n = m = 10
         df = DataFrame(np.random.randint(m, size=(n, 3)), columns=list("abc"))
@@ -534,7 +530,7 @@ def test_query_doesnt_pickup_local(self):
             df.query("sin > 5", engine=engine, parser=parser)
 
     def test_query_builtin(self):
-        from pandas.core.computation.engines import NumExprClobberingError
+        from pandas.errors import NumExprClobberingError
 
         engine, parser = self.engine, self.parser
 
@@ -619,8 +615,6 @@ def test_nested_scope(self):
         tm.assert_frame_equal(result, expected)
 
     def test_nested_raises_on_local_self_reference(self):
-        from pandas.core.computation.ops import UndefinedVariableError
-
         df = DataFrame(np.random.randn(5, 3))
 
         # can't reference ourself b/c we're a local so @ is necessary
@@ -679,8 +673,6 @@ def test_at_inside_string(self):
         tm.assert_frame_equal(result, expected)
 
     def test_query_undefined_local(self):
-        from pandas.core.computation.ops import UndefinedVariableError
-
         engine, parser = self.engine, self.parser
         skip_if_no_pandas_parser(parser)
 
@@ -715,16 +707,15 @@ def test_index_resolvers_come_after_columns_with_the_same_name(self):
         expected = df.loc[df.index[df.index > 5]]
         tm.assert_frame_equal(result, expected)
 
-    def test_inf(self):
+    @pytest.mark.parametrize("op, f", [["==", operator.eq], ["!=", operator.ne]])
+    def test_inf(self, op, f):
         n = 10
         df = DataFrame({"a": np.random.rand(n), "b": np.random.rand(n)})
         df.loc[::2, 0] = np.inf
-        d = {"==": operator.eq, "!=": operator.ne}
-        for op, f in d.items():
-            q = f"a {op} inf"
-            expected = df[f(df.a, np.inf)]
-            result = df.query(q, engine=self.engine, parser=self.parser)
-            tm.assert_frame_equal(result, expected)
+        q = f"a {op} inf"
+        expected = df[f(df.a, np.inf)]
+        result = df.query(q, engine=self.engine, parser=self.parser)
+        tm.assert_frame_equal(result, expected)
 
     def test_check_tz_aware_index_query(self, tz_aware_fixture):
         # https://github.com/pandas-dev/pandas/issues/29463
@@ -840,8 +831,6 @@ def test_date_index_query_with_NaT_duplicates(self):
             df.query("index < 20130101 < dates3", engine=engine, parser=parser)
 
     def test_nested_scope(self):
-        from pandas.core.computation.ops import UndefinedVariableError
-
         engine = self.engine
         parser = self.parser
         # smoke test
@@ -1054,18 +1043,24 @@ def test_query_with_nested_special_character(self, parser, engine):
         expec = df[df.a == "test & test"]
         tm.assert_frame_equal(res, expec)
 
-    def test_query_lex_compare_strings(self, parser, engine):
+    @pytest.mark.parametrize(
+        "op, func",
+        [
+            ["<", operator.lt],
+            [">", operator.gt],
+            ["<=", operator.le],
+            [">=", operator.ge],
+        ],
+    )
+    def test_query_lex_compare_strings(self, parser, engine, op, func):
 
         a = Series(np.random.choice(list("abcde"), 20))
         b = Series(np.arange(a.size))
         df = DataFrame({"X": a, "Y": b})
 
-        ops = {"<": operator.lt, ">": operator.gt, "<=": operator.le, ">=": operator.ge}
-
-        for op, func in ops.items():
-            res = df.query(f'X {op} "d"', engine=engine, parser=parser)
-            expected = df[func(df.X, "d")]
-            tm.assert_frame_equal(res, expected)
+        res = df.query(f'X {op} "d"', engine=engine, parser=parser)
+        expected = df[func(df.X, "d")]
+        tm.assert_frame_equal(res, expected)
 
     def test_query_single_element_booleans(self, parser, engine):
         columns = "bid", "bidsize", "ask", "asksize"
@@ -1090,20 +1085,18 @@ def test_query_string_scalar_variable(self, parser, engine):
 
 
 class TestDataFrameEvalWithFrame:
-    def setup_method(self, method):
-        self.frame = DataFrame(np.random.randn(10, 3), columns=list("abc"))
-
-    def teardown_method(self, method):
-        del self.frame
+    @pytest.fixture
+    def frame(self):
+        return DataFrame(np.random.randn(10, 3), columns=list("abc"))
 
-    def test_simple_expr(self, parser, engine):
-        res = self.frame.eval("a + b", engine=engine, parser=parser)
-        expect = self.frame.a + self.frame.b
+    def test_simple_expr(self, frame, parser, engine):
+        res = frame.eval("a + b", engine=engine, parser=parser)
+        expect = frame.a + frame.b
         tm.assert_series_equal(res, expect)
 
-    def test_bool_arith_expr(self, parser, engine):
-        res = self.frame.eval("a[a < 1] + b", engine=engine, parser=parser)
-        expect = self.frame.a[self.frame.a < 1] + self.frame.b
+    def test_bool_arith_expr(self, frame, parser, engine):
+        res = frame.eval("a[a < 1] + b", engine=engine, parser=parser)
+        expect = frame.a[frame.a < 1] + frame.b
         tm.assert_series_equal(res, expect)
 
     @pytest.mark.parametrize("op", ["+", "-", "*", "/"])
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 245e54d665745..b4d3d1ae548b5 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -1,11 +1,13 @@
 from datetime import timedelta
 from decimal import Decimal
+import inspect
 import re
 
 from dateutil.tz import tzlocal
 import numpy as np
 import pytest
 
+from pandas._libs import lib
 from pandas.compat import is_platform_windows
 import pandas.util._test_decorators as td
 
@@ -67,6 +69,7 @@ def assert_stat_op_calc(
     skipna_alternative : function, default None
         NaN-safe version of alternative
     """
+    warn = FutureWarning if opname == "mad" else None
     f = getattr(frame, opname)
 
     if check_dates:
@@ -88,8 +91,9 @@ def wrapper(x):
             return alternative(x.values)
 
         skipna_wrapper = tm._make_skipna_wrapper(alternative, skipna_alternative)
-        result0 = f(axis=0, skipna=False)
-        result1 = f(axis=1, skipna=False)
+        with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+            result0 = f(axis=0, skipna=False)
+            result1 = f(axis=1, skipna=False)
         tm.assert_series_equal(
             result0, frame.apply(wrapper), check_dtype=check_dtype, rtol=rtol, atol=atol
         )
@@ -102,8 +106,9 @@ def wrapper(x):
     else:
         skipna_wrapper = alternative
 
-    result0 = f(axis=0)
-    result1 = f(axis=1)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result0 = f(axis=0)
+        result1 = f(axis=1)
     tm.assert_series_equal(
         result0,
         frame.apply(skipna_wrapper),
@@ -125,14 +130,18 @@ def wrapper(x):
         assert lcd_dtype == result1.dtype
 
     # bad axis
-    with pytest.raises(ValueError, match="No axis named 2"):
-        f(axis=2)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        with pytest.raises(ValueError, match="No axis named 2"):
+            f(axis=2)
 
     # all NA case
     if has_skipna:
         all_na = frame * np.NaN
-        r0 = getattr(all_na, opname)(axis=0)
-        r1 = getattr(all_na, opname)(axis=1)
+        with tm.assert_produces_warning(
+            warn, match="The 'mad' method is deprecated", raise_on_extra_warnings=False
+        ):
+            r0 = getattr(all_na, opname)(axis=0)
+            r1 = getattr(all_na, opname)(axis=1)
         if opname in ["sum", "prod"]:
             unit = 1 if opname == "prod" else 0  # result for empty sum/prod
             expected = Series(unit, index=r0.index, dtype=r0.dtype)
@@ -141,155 +150,61 @@ def wrapper(x):
             tm.assert_series_equal(r1, expected)
 
 
-def assert_stat_op_api(opname, float_frame, float_string_frame, has_numeric_only=True):
-    """
-    Check that API for operator opname works as advertised on frame
-
-    Parameters
-    ----------
-    opname : str
-        Name of the operator to test on frame
-    float_frame : DataFrame
-        DataFrame with columns of type float
-    float_string_frame : DataFrame
-        DataFrame with both float and string columns
-    has_numeric_only : bool, default False
-        Whether the method "opname" has the kwarg "numeric_only"
-    """
-    # make sure works on mixed-type frame
-    getattr(float_string_frame, opname)(axis=0)
-    getattr(float_string_frame, opname)(axis=1)
-
-    if has_numeric_only:
-        getattr(float_string_frame, opname)(axis=0, numeric_only=True)
-        getattr(float_string_frame, opname)(axis=1, numeric_only=True)
-        getattr(float_frame, opname)(axis=0, numeric_only=False)
-        getattr(float_frame, opname)(axis=1, numeric_only=False)
-
-
-def assert_bool_op_calc(opname, alternative, frame, has_skipna=True):
-    """
-    Check that bool operator opname works as advertised on frame
-
-    Parameters
-    ----------
-    opname : str
-        Name of the operator to test on frame
-    alternative : function
-        Function that opname is tested against; i.e. "frame.opname()" should
-        equal "alternative(frame)".
-    frame : DataFrame
-        The object that the tests are executed on
-    has_skipna : bool, default True
-        Whether the method "opname" has the kwarg "skip_na"
-    """
-    f = getattr(frame, opname)
-
-    if has_skipna:
-
-        def skipna_wrapper(x):
-            nona = x.dropna().values
-            return alternative(nona)
-
-        def wrapper(x):
-            return alternative(x.values)
-
-        result0 = f(axis=0, skipna=False)
-        result1 = f(axis=1, skipna=False)
-
-        tm.assert_series_equal(result0, frame.apply(wrapper))
-        tm.assert_series_equal(result1, frame.apply(wrapper, axis=1))
-    else:
-        skipna_wrapper = alternative
-        wrapper = alternative
-
-    result0 = f(axis=0)
-    result1 = f(axis=1)
-
-    tm.assert_series_equal(result0, frame.apply(skipna_wrapper))
-    tm.assert_series_equal(
-        result1, frame.apply(skipna_wrapper, axis=1), check_dtype=False
-    )
-
-    # bad axis
-    with pytest.raises(ValueError, match="No axis named 2"):
-        f(axis=2)
-
-    # all NA case
-    if has_skipna:
-        all_na = frame * np.NaN
-        r0 = getattr(all_na, opname)(axis=0)
-        r1 = getattr(all_na, opname)(axis=1)
-        if opname == "any":
-            assert not r0.any()
-            assert not r1.any()
-        else:
-            assert r0.all()
-            assert r1.all()
-
-
-def assert_bool_op_api(
-    opname, bool_frame_with_na, float_string_frame, has_bool_only=False
-):
-    """
-    Check that API for boolean operator opname works as advertised on frame
-
-    Parameters
-    ----------
-    opname : str
-        Name of the operator to test on frame
-    float_frame : DataFrame
-        DataFrame with columns of type float
-    float_string_frame : DataFrame
-        DataFrame with both float and string columns
-    has_bool_only : bool, default False
-        Whether the method "opname" has the kwarg "bool_only"
-    """
-    # make sure op works on mixed-type frame
-    mixed = float_string_frame
-    mixed["_bool_"] = np.random.randn(len(mixed)) > 0.5
-
-    getattr(mixed, opname)(axis=0)
-    getattr(mixed, opname)(axis=1)
-
-    if has_bool_only:
-        getattr(mixed, opname)(axis=0, bool_only=True)
-        getattr(mixed, opname)(axis=1, bool_only=True)
-        getattr(bool_frame_with_na, opname)(axis=0, bool_only=False)
-        getattr(bool_frame_with_na, opname)(axis=1, bool_only=False)
-
-
 class TestDataFrameAnalytics:
 
     # ---------------------------------------------------------------------
     # Reductions
-
     @pytest.mark.filterwarnings("ignore:Dropping of nuisance:FutureWarning")
-    def test_stat_op_api(self, float_frame, float_string_frame):
-        assert_stat_op_api("count", float_frame, float_string_frame)
-        assert_stat_op_api("sum", float_frame, float_string_frame)
-
-        assert_stat_op_api(
-            "nunique", float_frame, float_string_frame, has_numeric_only=False
-        )
-        assert_stat_op_api("mean", float_frame, float_string_frame)
-        assert_stat_op_api("product", float_frame, float_string_frame)
-        assert_stat_op_api("median", float_frame, float_string_frame)
-        assert_stat_op_api("min", float_frame, float_string_frame)
-        assert_stat_op_api("max", float_frame, float_string_frame)
-        assert_stat_op_api(
-            "mad", float_frame, float_string_frame, has_numeric_only=False
-        )
-        assert_stat_op_api("var", float_frame, float_string_frame)
-        assert_stat_op_api("std", float_frame, float_string_frame)
-        assert_stat_op_api("sem", float_frame, float_string_frame)
-        assert_stat_op_api("median", float_frame, float_string_frame)
+    @pytest.mark.parametrize("axis", [0, 1])
+    @pytest.mark.parametrize(
+        "opname",
+        [
+            "count",
+            "sum",
+            "mean",
+            "product",
+            "median",
+            "min",
+            "max",
+            "nunique",
+            "mad",
+            "var",
+            "std",
+            "sem",
+            pytest.param("skew", marks=td.skip_if_no_scipy),
+            pytest.param("kurt", marks=td.skip_if_no_scipy),
+        ],
+    )
+    def test_stat_op_api_float_string_frame(self, float_string_frame, axis, opname):
+        warn = FutureWarning if opname == "mad" else None
+        with tm.assert_produces_warning(
+            warn, match="The 'mad' method is deprecated", raise_on_extra_warnings=False
+        ):
+            getattr(float_string_frame, opname)(axis=axis)
+            if opname not in ("nunique", "mad"):
+                getattr(float_string_frame, opname)(axis=axis, numeric_only=True)
 
     @pytest.mark.filterwarnings("ignore:Dropping of nuisance:FutureWarning")
-    @td.skip_if_no_scipy
-    def test_stat_op_api_skew_kurt(self, float_frame, float_string_frame):
-        assert_stat_op_api("skew", float_frame, float_string_frame)
-        assert_stat_op_api("kurt", float_frame, float_string_frame)
+    @pytest.mark.parametrize("axis", [0, 1])
+    @pytest.mark.parametrize(
+        "opname",
+        [
+            "count",
+            "sum",
+            "mean",
+            "product",
+            "median",
+            "min",
+            "max",
+            "var",
+            "std",
+            "sem",
+            pytest.param("skew", marks=td.skip_if_no_scipy),
+            pytest.param("kurt", marks=td.skip_if_no_scipy),
+        ],
+    )
+    def test_stat_op_api_float_frame(self, float_frame, axis, opname):
+        getattr(float_frame, opname)(axis=axis, numeric_only=False)
 
     def test_stat_op_calc(self, float_frame_with_na, mixed_float_frame):
         def count(s):
@@ -388,32 +303,37 @@ def wrapper(x):
     @pytest.mark.parametrize(
         "method", ["sum", "mean", "prod", "var", "std", "skew", "min", "max"]
     )
-    def test_stat_operators_attempt_obj_array(self, method):
+    @pytest.mark.parametrize(
+        "df",
+        [
+            DataFrame(
+                {
+                    "a": [
+                        -0.00049987540199591344,
+                        -0.0016467257772919831,
+                        0.00067695870775883013,
+                    ],
+                    "b": [-0, -0, 0.0],
+                    "c": [
+                        0.00031111847529610595,
+                        0.0014902627951905339,
+                        -0.00094099200035979691,
+                    ],
+                },
+                index=["foo", "bar", "baz"],
+                dtype="O",
+            ),
+            DataFrame({0: [np.nan, 2], 1: [np.nan, 3], 2: [np.nan, 4]}, dtype=object),
+        ],
+    )
+    def test_stat_operators_attempt_obj_array(self, method, df):
         # GH#676
-        data = {
-            "a": [
-                -0.00049987540199591344,
-                -0.0016467257772919831,
-                0.00067695870775883013,
-            ],
-            "b": [-0, -0, 0.0],
-            "c": [
-                0.00031111847529610595,
-                0.0014902627951905339,
-                -0.00094099200035979691,
-            ],
-        }
-        df1 = DataFrame(data, index=["foo", "bar", "baz"], dtype="O")
-
-        df2 = DataFrame({0: [np.nan, 2], 1: [np.nan, 3], 2: [np.nan, 4]}, dtype=object)
-
-        for df in [df1, df2]:
-            assert df.values.dtype == np.object_
-            result = getattr(df, method)(1)
-            expected = getattr(df.astype("f8"), method)(1)
+        assert df.values.dtype == np.object_
+        result = getattr(df, method)(1)
+        expected = getattr(df.astype("f8"), method)(1)
 
-            if method in ["sum", "prod"]:
-                tm.assert_series_equal(result, expected)
+        if method in ["sum", "prod"]:
+            tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("op", ["mean", "std", "var", "skew", "kurt", "sem"])
     def test_mixed_ops(self, op):
@@ -773,11 +693,7 @@ def test_operators_timedelta64(self):
     def test_std_timedelta64_skipna_false(self):
         # GH#37392
         tdi = pd.timedelta_range("1 Day", periods=10)
-        df = DataFrame({"A": tdi, "B": tdi})
-        # Copy is needed for ArrayManager case, otherwise setting df.iloc
-        #  below edits tdi, alterting both df['A'] and df['B']
-        #  FIXME: passing copy=True to constructor does not fix this
-        df = df.copy()
+        df = DataFrame({"A": tdi, "B": tdi}, copy=True)
         df.iloc[-2, -1] = pd.NaT
 
         result = df.std(skipna=False)
@@ -862,6 +778,40 @@ def test_sum_nanops_min_count(self):
         expected = Series([np.nan, np.nan], index=["x", "y"])
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize("float_type", ["float16", "float32", "float64"])
+    @pytest.mark.parametrize(
+        "kwargs, expected_result",
+        [
+            ({"axis": 1, "min_count": 2}, [3.2, 5.3, np.NaN]),
+            ({"axis": 1, "min_count": 3}, [np.NaN, np.NaN, np.NaN]),
+            ({"axis": 1, "skipna": False}, [3.2, 5.3, np.NaN]),
+        ],
+    )
+    def test_sum_nanops_dtype_min_count(self, float_type, kwargs, expected_result):
+        # GH#46947
+        df = DataFrame({"a": [1.0, 2.3, 4.4], "b": [2.2, 3, np.nan]}, dtype=float_type)
+        result = df.sum(**kwargs)
+        expected = Series(expected_result).astype(float_type)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("float_type", ["float16", "float32", "float64"])
+    @pytest.mark.parametrize(
+        "kwargs, expected_result",
+        [
+            ({"axis": 1, "min_count": 2}, [2.0, 4.0, np.NaN]),
+            ({"axis": 1, "min_count": 3}, [np.NaN, np.NaN, np.NaN]),
+            ({"axis": 1, "skipna": False}, [2.0, 4.0, np.NaN]),
+        ],
+    )
+    def test_prod_nanops_dtype_min_count(self, float_type, kwargs, expected_result):
+        # GH#46947
+        df = DataFrame(
+            {"a": [1.0, 2.0, 4.4], "b": [2.0, 2.0, np.nan]}, dtype=float_type
+        )
+        result = df.prod(**kwargs)
+        expected = Series(expected_result).astype(float_type)
+        tm.assert_series_equal(result, expected)
+
     def test_sum_object(self, float_frame):
         values = float_frame.values.astype(int)
         frame = DataFrame(values, index=float_frame.index, columns=float_frame.columns)
@@ -972,32 +922,58 @@ def test_sum_bools(self):
     # ----------------------------------------------------------------------
     # Index of max / min
 
-    def test_idxmin(self, float_frame, int_frame):
+    @pytest.mark.parametrize("skipna", [True, False])
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_idxmin(self, float_frame, int_frame, skipna, axis):
         frame = float_frame
         frame.iloc[5:10] = np.nan
         frame.iloc[15:20, -2:] = np.nan
-        for skipna in [True, False]:
-            for axis in [0, 1]:
-                for df in [frame, int_frame]:
-                    result = df.idxmin(axis=axis, skipna=skipna)
-                    expected = df.apply(Series.idxmin, axis=axis, skipna=skipna)
-                    tm.assert_series_equal(result, expected)
+        for df in [frame, int_frame]:
+            result = df.idxmin(axis=axis, skipna=skipna)
+            expected = df.apply(Series.idxmin, axis=axis, skipna=skipna)
+            tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_idxmin_numeric_only(self, numeric_only):
+        df = DataFrame({"a": [2, 3, 1], "b": [2, 1, 1], "c": list("xyx")})
+        if numeric_only:
+            result = df.idxmin(numeric_only=numeric_only)
+            expected = Series([2, 1], index=["a", "b"])
+            tm.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(TypeError, match="not allowed for this dtype"):
+                df.idxmin(numeric_only=numeric_only)
 
+    def test_idxmin_axis_2(self, float_frame):
+        frame = float_frame
         msg = "No axis named 2 for object type DataFrame"
         with pytest.raises(ValueError, match=msg):
             frame.idxmin(axis=2)
 
-    def test_idxmax(self, float_frame, int_frame):
+    @pytest.mark.parametrize("skipna", [True, False])
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_idxmax(self, float_frame, int_frame, skipna, axis):
         frame = float_frame
         frame.iloc[5:10] = np.nan
         frame.iloc[15:20, -2:] = np.nan
-        for skipna in [True, False]:
-            for axis in [0, 1]:
-                for df in [frame, int_frame]:
-                    result = df.idxmax(axis=axis, skipna=skipna)
-                    expected = df.apply(Series.idxmax, axis=axis, skipna=skipna)
-                    tm.assert_series_equal(result, expected)
+        for df in [frame, int_frame]:
+            result = df.idxmax(axis=axis, skipna=skipna)
+            expected = df.apply(Series.idxmax, axis=axis, skipna=skipna)
+            tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_idxmax_numeric_only(self, numeric_only):
+        df = DataFrame({"a": [2, 3, 1], "b": [2, 1, 1], "c": list("xyx")})
+        if numeric_only:
+            result = df.idxmax(numeric_only=numeric_only)
+            expected = Series([1, 0], index=["a", "b"])
+            tm.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(TypeError, match="not allowed for this dtype"):
+                df.idxmin(numeric_only=numeric_only)
 
+    def test_idxmax_axis_2(self, float_frame):
+        frame = float_frame
         msg = "No axis named 2 for object type DataFrame"
         with pytest.raises(ValueError, match=msg):
             frame.idxmax(axis=2)
@@ -1064,11 +1040,7 @@ def test_idxmax_idxmin_convert_dtypes(self, op, expected_value):
 
     def test_idxmax_dt64_multicolumn_axis1(self):
         dti = date_range("2016-01-01", periods=3)
-        df = DataFrame({3: dti, 4: dti[::-1]})
-        # FIXME: copy needed for ArrayManager, otherwise setting with iloc
-        #  below also sets df.iloc[-1, 1]; passing copy=True to DataFrame
-        #  does not solve this.
-        df = df.copy()
+        df = DataFrame({3: dti, 4: dti[::-1]}, copy=True)
         df.iloc[0, 0] = pd.NaT
 
         df._consolidate_inplace()
@@ -1085,17 +1057,63 @@ def test_idxmax_dt64_multicolumn_axis1(self):
     # Logical reductions
 
     @pytest.mark.parametrize("opname", ["any", "all"])
-    def test_any_all(self, opname, bool_frame_with_na, float_string_frame):
-        assert_bool_op_api(
-            opname, bool_frame_with_na, float_string_frame, has_bool_only=True
-        )
+    @pytest.mark.parametrize("axis", [0, 1])
+    @pytest.mark.parametrize("bool_only", [False, True])
+    def test_any_all_mixed_float(self, opname, axis, bool_only, float_string_frame):
+        # make sure op works on mixed-type frame
+        mixed = float_string_frame
+        mixed["_bool_"] = np.random.randn(len(mixed)) > 0.5
+
+        getattr(mixed, opname)(axis=axis, bool_only=bool_only)
+
+    @pytest.mark.parametrize("opname", ["any", "all"])
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_any_all_bool_with_na(self, opname, axis, bool_frame_with_na):
+        getattr(bool_frame_with_na, opname)(axis=axis, bool_only=False)
 
     @pytest.mark.parametrize("opname", ["any", "all"])
     def test_any_all_bool_frame(self, opname, bool_frame_with_na):
         # GH#12863: numpy gives back non-boolean data for object type
         # so fill NaNs to compare with pandas behavior
-        df = bool_frame_with_na.fillna(True)
-        assert_bool_op_calc(opname, getattr(np, opname), df, has_skipna=True)
+        frame = bool_frame_with_na.fillna(True)
+        alternative = getattr(np, opname)
+        f = getattr(frame, opname)
+
+        def skipna_wrapper(x):
+            nona = x.dropna().values
+            return alternative(nona)
+
+        def wrapper(x):
+            return alternative(x.values)
+
+        result0 = f(axis=0, skipna=False)
+        result1 = f(axis=1, skipna=False)
+
+        tm.assert_series_equal(result0, frame.apply(wrapper))
+        tm.assert_series_equal(result1, frame.apply(wrapper, axis=1))
+
+        result0 = f(axis=0)
+        result1 = f(axis=1)
+
+        tm.assert_series_equal(result0, frame.apply(skipna_wrapper))
+        tm.assert_series_equal(
+            result1, frame.apply(skipna_wrapper, axis=1), check_dtype=False
+        )
+
+        # bad axis
+        with pytest.raises(ValueError, match="No axis named 2"):
+            f(axis=2)
+
+        # all NA case
+        all_na = frame * np.NaN
+        r0 = getattr(all_na, opname)(axis=0)
+        r1 = getattr(all_na, opname)(axis=1)
+        if opname == "any":
+            assert not r0.any()
+            assert not r1.any()
+        else:
+            assert r0.all()
+            assert r1.all()
 
     def test_any_all_extra(self):
         df = DataFrame(
@@ -1106,11 +1124,11 @@ def test_any_all_extra(self):
             },
             index=["a", "b", "c"],
         )
-        result = df[["A", "B"]].any(1)
+        result = df[["A", "B"]].any(axis=1)
         expected = Series([True, True, False], index=["a", "b", "c"])
         tm.assert_series_equal(result, expected)
 
-        result = df[["A", "B"]].any(1, bool_only=True)
+        result = df[["A", "B"]].any(axis=1, bool_only=True)
         tm.assert_series_equal(result, expected)
 
         result = df.all(1)
@@ -1159,7 +1177,7 @@ def test_any_datetime(self):
         ]
         df = DataFrame({"A": float_data, "B": datetime_data})
 
-        result = df.any(1)
+        result = df.any(axis=1)
         expected = Series([True, True, True, False])
         tm.assert_series_equal(result, expected)
 
@@ -1270,6 +1288,8 @@ def test_any_all_object(self):
         assert result is False
 
     def test_any_all_object_bool_only(self):
+        msg = "object-dtype columns with all-bool values"
+
         df = DataFrame({"A": ["foo", 2], "B": [True, False]}).astype(object)
         df._consolidate_inplace()
         df["C"] = Series([True, True])
@@ -1279,29 +1299,36 @@ def test_any_all_object_bool_only(self):
 
         # The underlying bug is in DataFrame._get_bool_data, so we check
         #  that while we're here
-        res = df._get_bool_data()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df._get_bool_data()
         expected = df[["B", "C"]]
         tm.assert_frame_equal(res, expected)
 
-        res = df.all(bool_only=True, axis=0)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.all(bool_only=True, axis=0)
         expected = Series([False, True], index=["B", "C"])
         tm.assert_series_equal(res, expected)
 
         # operating on a subset of columns should not produce a _larger_ Series
-        res = df[["B", "C"]].all(bool_only=True, axis=0)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df[["B", "C"]].all(bool_only=True, axis=0)
         tm.assert_series_equal(res, expected)
 
-        assert not df.all(bool_only=True, axis=None)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert not df.all(bool_only=True, axis=None)
 
-        res = df.any(bool_only=True, axis=0)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.any(bool_only=True, axis=0)
         expected = Series([True, True], index=["B", "C"])
         tm.assert_series_equal(res, expected)
 
         # operating on a subset of columns should not produce a _larger_ Series
-        res = df[["B", "C"]].any(bool_only=True, axis=0)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df[["B", "C"]].any(bool_only=True, axis=0)
         tm.assert_series_equal(res, expected)
 
-        assert df.any(bool_only=True, axis=None)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert df.any(bool_only=True, axis=None)
 
     @pytest.mark.parametrize("method", ["any", "all"])
     def test_any_all_level_axis_none_raises(self, method):
@@ -1466,7 +1493,9 @@ def test_frame_any_with_timedelta(self):
     def test_reductions_deprecation_skipna_none(self, frame_or_series):
         # GH#44580
         obj = frame_or_series([1, 2, 3])
-        with tm.assert_produces_warning(FutureWarning, match="skipna"):
+        with tm.assert_produces_warning(
+            FutureWarning, match="skipna", raise_on_extra_warnings=False
+        ):
             obj.mad(skipna=None)
 
     def test_reductions_deprecation_level_argument(
@@ -1479,9 +1508,15 @@ def test_reductions_deprecation_level_argument(
         with tm.assert_produces_warning(FutureWarning, match="level"):
             getattr(obj, reduction_functions)(level=0)
 
-    def test_reductions_skipna_none_raises(self, frame_or_series, reduction_functions):
-        if reduction_functions in ["count", "mad"]:
-            pytest.skip("Count does not accept skipna. Mad needs a deprecation cycle.")
+    def test_reductions_skipna_none_raises(
+        self, request, frame_or_series, reduction_functions
+    ):
+        if reduction_functions == "count":
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Count does not accept skipna")
+            )
+        elif reduction_functions == "mad":
+            pytest.skip("Mad is deprecated: GH#11787")
         obj = frame_or_series([1, 2, 3])
         msg = 'For argument "skipna" expected type bool, received type NoneType.'
         with pytest.raises(ValueError, match=msg):
@@ -1680,25 +1715,37 @@ def test_mad_nullable_integer(any_signed_int_ea_dtype):
     df = DataFrame(np.random.randn(100, 4).astype(np.int64))
     df2 = df.astype(any_signed_int_ea_dtype)
 
-    result = df2.mad()
-    expected = df.mad()
+    with tm.assert_produces_warning(
+        FutureWarning, match="The 'mad' method is deprecated"
+    ):
+        result = df2.mad()
+        expected = df.mad()
     tm.assert_series_equal(result, expected)
 
-    result = df2.mad(axis=1)
-    expected = df.mad(axis=1)
+    with tm.assert_produces_warning(
+        FutureWarning, match="The 'mad' method is deprecated"
+    ):
+        result = df2.mad(axis=1)
+        expected = df.mad(axis=1)
     tm.assert_series_equal(result, expected)
 
     # case with NAs present
     df2.iloc[::2, 1] = pd.NA
 
-    result = df2.mad()
-    expected = df.mad()
-    expected[1] = df.iloc[1::2, 1].mad()
+    with tm.assert_produces_warning(
+        FutureWarning, match="The 'mad' method is deprecated"
+    ):
+        result = df2.mad()
+        expected = df.mad()
+        expected[1] = df.iloc[1::2, 1].mad()
     tm.assert_series_equal(result, expected)
 
-    result = df2.mad(axis=1)
-    expected = df.mad(axis=1)
-    expected[::2] = df.T.loc[[0, 2, 3], ::2].mad()
+    with tm.assert_produces_warning(
+        FutureWarning, match="The 'mad' method is deprecated"
+    ):
+        result = df2.mad(axis=1)
+        expected = df.mad(axis=1)
+        expected[::2] = df.T.loc[[0, 2, 3], ::2].mad()
     tm.assert_series_equal(result, expected)
 
 
@@ -1709,11 +1756,19 @@ def test_mad_nullable_integer_all_na(any_signed_int_ea_dtype):
     df2 = df.astype(any_signed_int_ea_dtype)
 
     # case with all-NA row/column
-    df2.iloc[:, 1] = pd.NA  # FIXME(GH#44199): this doesn't operate in-place
-    df2.iloc[:, 1] = pd.array([pd.NA] * len(df2), dtype=any_signed_int_ea_dtype)
-    result = df2.mad()
-    expected = df.mad()
+    msg = "will attempt to set the values inplace instead"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df2.iloc[:, 1] = pd.NA  # FIXME(GH#44199): this doesn't operate in-place
+        df2.iloc[:, 1] = pd.array([pd.NA] * len(df2), dtype=any_signed_int_ea_dtype)
+
+    with tm.assert_produces_warning(
+        FutureWarning, match="The 'mad' method is deprecated"
+    ):
+        result = df2.mad()
+        expected = df.mad()
+
     expected[1] = pd.NA
+    expected = expected.astype("Float64")
     tm.assert_series_equal(result, expected)
 
 
@@ -1737,7 +1792,9 @@ def test_groupby_regular_arithmetic_equivalent(meth):
 def test_frame_mixed_numeric_object_with_timestamp(ts_value):
     # GH 13912
     df = DataFrame({"a": [1], "b": [1.1], "c": ["foo"], "d": [ts_value]})
-    with tm.assert_produces_warning(FutureWarning, match="Dropping of nuisance"):
+    with tm.assert_produces_warning(
+        FutureWarning, match="The default value of numeric_only"
+    ):
         result = df.sum()
     expected = Series([1, 1.1, "foo"], index=list("abc"))
     tm.assert_series_equal(result, expected)
@@ -1771,3 +1828,60 @@ def test_reduction_axis_none_deprecation(method):
         expected = meth()
     tm.assert_series_equal(res, expected)
     tm.assert_series_equal(res, meth(axis=0))
+
+
+@pytest.mark.parametrize(
+    "kernel",
+    [
+        "corr",
+        "corrwith",
+        "count",
+        "cov",
+        "idxmax",
+        "idxmin",
+        "kurt",
+        "kurt",
+        "max",
+        "mean",
+        "median",
+        "min",
+        "mode",
+        "prod",
+        "prod",
+        "quantile",
+        "sem",
+        "skew",
+        "std",
+        "sum",
+        "var",
+    ],
+)
+def test_numeric_only_deprecation(kernel):
+    # GH#46852
+    df = DataFrame({"a": [1, 2, 3], "b": object})
+    args = (df,) if kernel == "corrwith" else ()
+    signature = inspect.signature(getattr(DataFrame, kernel))
+    default = signature.parameters["numeric_only"].default
+    assert default is not True
+
+    if kernel in ("idxmax", "idxmin"):
+        # kernels that default to numeric_only=False and fail on nuisance columns
+        assert default is False
+        with pytest.raises(TypeError, match="not allowed for this dtype"):
+            getattr(df, kernel)(*args)
+    else:
+        if default is None or default is lib.no_default:
+            expected = getattr(df[["a"]], kernel)(*args)
+            warn = FutureWarning
+        else:
+            # default must be False and works on any nuisance columns
+            expected = getattr(df, kernel)(*args)
+            if kernel == "mode":
+                assert "b" in expected.columns
+            else:
+                assert "b" in expected.index
+            warn = None
+        msg = f"The default value of numeric_only in DataFrame.{kernel}"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = getattr(df, kernel)(*args)
+        tm.assert_equal(result, expected)
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index e71f625a6ead6..86c8e36cb7bd4 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -9,6 +9,7 @@
 import pytest
 
 from pandas import (
+    NA,
     Categorical,
     DataFrame,
     MultiIndex,
@@ -62,12 +63,33 @@ def test_assign_index_sequences(self):
         df.index = index
         repr(df)
 
-    def test_repr_with_mi_nat(self, float_string_frame):
+    def test_repr_with_mi_nat(self):
         df = DataFrame({"X": [1, 2]}, index=[[NaT, Timestamp("20130101")], ["a", "b"]])
         result = repr(df)
         expected = "              X\nNaT        a  1\n2013-01-01 b  2"
         assert result == expected
 
+    def test_repr_with_different_nulls(self):
+        # GH45263
+        df = DataFrame([1, 2, 3, 4], [True, None, np.nan, NaT])
+        result = repr(df)
+        expected = """      0
+True  1
+None  2
+NaN   3
+NaT   4"""
+        assert result == expected
+
+    def test_repr_with_different_nulls_cols(self):
+        # GH45263
+        d = {np.nan: [1, 2], None: [3, 4], NaT: [6, 7], True: [8, 9]}
+        df = DataFrame(data=d)
+        result = repr(df)
+        expected = """   NaN  None  NaT  True
+0    1     3    6     8
+1    2     4    7     9"""
+        assert result == expected
+
     def test_multiindex_na_repr(self):
         # only an issue with long columns
         df3 = DataFrame(
@@ -198,7 +220,7 @@ def test_repr_unsortable(self, float_frame):
         )
         repr(unsortable)
 
-        fmt.set_option("display.precision", 3, "display.column_space", 10)
+        fmt.set_option("display.precision", 3)
         repr(float_frame)
 
         fmt.set_option("display.max_rows", 10, "display.max_columns", 2)
@@ -321,6 +343,19 @@ def test_frame_to_string_with_periodindex(self):
         # it works!
         frame.to_string()
 
+    def test_to_string_ea_na_in_multiindex(self):
+        # GH#47986
+        df = DataFrame(
+            {"a": [1, 2]},
+            index=MultiIndex.from_arrays([Series([NA, 1], dtype="Int64")]),
+        )
+
+        result = df.to_string()
+        expected = """      a
+<NA>  1
+1     2"""
+        assert result == expected
+
     def test_datetime64tz_slice_non_truncate(self):
         # GH 30263
         df = DataFrame({"x": date_range("2019", periods=10, tz="UTC")})
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index 005d2600b2bae..e22559802cbec 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -22,9 +22,13 @@
 
 
 class TestDataFrameReshape:
-    def test_stack_unstack(self, float_frame):
+    def test_stack_unstack(self, float_frame, using_array_manager):
+        warn = DeprecationWarning if using_array_manager else None
+        msg = "will attempt to set the values inplace"
+
         df = float_frame.copy()
-        df[:] = np.arange(np.prod(df.shape)).reshape(df.shape)
+        with tm.assert_produces_warning(warn, match=msg):
+            df[:] = np.arange(np.prod(df.shape)).reshape(df.shape)
 
         stacked = df.stack()
         stacked_df = DataFrame({"foo": stacked, "bar": stacked})
@@ -601,32 +605,35 @@ def test_unstack_dtypes(self):
         )
         tm.assert_series_equal(result, expected)
 
-        # GH7405
-        for c, d in (
+    @pytest.mark.parametrize(
+        "c, d",
+        (
             (np.zeros(5), np.zeros(5)),
             (np.arange(5, dtype="f8"), np.arange(5, 10, dtype="f8")),
-        ):
-
-            df = DataFrame(
-                {
-                    "A": ["a"] * 5,
-                    "C": c,
-                    "D": d,
-                    "B": date_range("2012-01-01", periods=5),
-                }
-            )
+        ),
+    )
+    def test_unstack_dtypes_mixed_date(self, c, d):
+        # GH7405
+        df = DataFrame(
+            {
+                "A": ["a"] * 5,
+                "C": c,
+                "D": d,
+                "B": date_range("2012-01-01", periods=5),
+            }
+        )
 
-            right = df.iloc[:3].copy(deep=True)
+        right = df.iloc[:3].copy(deep=True)
 
-            df = df.set_index(["A", "B"])
-            df["D"] = df["D"].astype("int64")
+        df = df.set_index(["A", "B"])
+        df["D"] = df["D"].astype("int64")
 
-            left = df.iloc[:3].unstack(0)
-            right = right.set_index(["A", "B"]).unstack(0)
-            right[("D", "a")] = right[("D", "a")].astype("int64")
+        left = df.iloc[:3].unstack(0)
+        right = right.set_index(["A", "B"]).unstack(0)
+        right[("D", "a")] = right[("D", "a")].astype("int64")
 
-            assert left.shape == (3, 2)
-            tm.assert_frame_equal(left, right)
+        assert left.shape == (3, 2)
+        tm.assert_frame_equal(left, right)
 
     def test_unstack_non_unique_index_names(self):
         idx = MultiIndex.from_tuples([("a", "b"), ("c", "d")], names=["c1", "c1"])
@@ -662,6 +669,16 @@ def test_unstack_unused_levels(self):
         tm.assert_frame_equal(result, expected)
         assert (result.columns.levels[1] == idx.levels[1]).all()
 
+    @pytest.mark.parametrize(
+        "level, idces, col_level, idx_level",
+        (
+            (0, [13, 16, 6, 9, 2, 5, 8, 11], [np.nan, "a", 2], [np.nan, 5, 1]),
+            (1, [8, 11, 1, 4, 12, 15, 13, 16], [np.nan, 5, 1], [np.nan, "a", 2]),
+        ),
+    )
+    def test_unstack_unused_levels_mixed_with_nan(
+        self, level, idces, col_level, idx_level
+    ):
         # With mixed dtype and NaN
         levels = [["a", 2, "c"], [1, 3, 5, 7]]
         codes = [[0, -1, 1, 1], [0, 2, -1, 2]]
@@ -669,17 +686,12 @@ def test_unstack_unused_levels(self):
         data = np.arange(8)
         df = DataFrame(data.reshape(4, 2), index=idx)
 
-        cases = (
-            (0, [13, 16, 6, 9, 2, 5, 8, 11], [np.nan, "a", 2], [np.nan, 5, 1]),
-            (1, [8, 11, 1, 4, 12, 15, 13, 16], [np.nan, 5, 1], [np.nan, "a", 2]),
-        )
-        for level, idces, col_level, idx_level in cases:
-            result = df.unstack(level=level)
-            exp_data = np.zeros(18) * np.nan
-            exp_data[idces] = data
-            cols = MultiIndex.from_product([[0, 1], col_level])
-            expected = DataFrame(exp_data.reshape(3, 6), index=idx_level, columns=cols)
-            tm.assert_frame_equal(result, expected)
+        result = df.unstack(level=level)
+        exp_data = np.zeros(18) * np.nan
+        exp_data[idces] = data
+        cols = MultiIndex.from_product([[0, 1], col_level])
+        expected = DataFrame(exp_data.reshape(3, 6), index=idx_level, columns=cols)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("cols", [["A", "C"], slice(None)])
     def test_unstack_unused_level(self, cols):
@@ -992,40 +1004,9 @@ def test_stack_datetime_column_multiIndex(self):
         expected = DataFrame([1, 2, 3, 4], index=eidx, columns=ecols)
         tm.assert_frame_equal(result, expected)
 
-    def test_stack_partial_multiIndex(self):
-        # GH 8844
-        def _test_stack_with_multiindex(multiindex):
-            df = DataFrame(
-                np.arange(3 * len(multiindex)).reshape(3, len(multiindex)),
-                columns=multiindex,
-            )
-            for level in (-1, 0, 1, [0, 1], [1, 0]):
-                result = df.stack(level=level, dropna=False)
-
-                if isinstance(level, int):
-                    # Stacking a single level should not make any all-NaN rows,
-                    # so df.stack(level=level, dropna=False) should be the same
-                    # as df.stack(level=level, dropna=True).
-                    expected = df.stack(level=level, dropna=True)
-                    if isinstance(expected, Series):
-                        tm.assert_series_equal(result, expected)
-                    else:
-                        tm.assert_frame_equal(result, expected)
-
-                df.columns = MultiIndex.from_tuples(
-                    df.columns.to_numpy(), names=df.columns.names
-                )
-                expected = df.stack(level=level, dropna=False)
-                if isinstance(expected, Series):
-                    tm.assert_series_equal(result, expected)
-                else:
-                    tm.assert_frame_equal(result, expected)
-
-        full_multiindex = MultiIndex.from_tuples(
-            [("B", "x"), ("B", "z"), ("A", "y"), ("C", "x"), ("C", "u")],
-            names=["Upper", "Lower"],
-        )
-        for multiindex_columns in (
+    @pytest.mark.parametrize(
+        "multiindex_columns",
+        [
             [0, 1, 2, 3, 4],
             [0, 1, 2, 3],
             [0, 1, 2, 4],
@@ -1038,12 +1019,56 @@ def _test_stack_with_multiindex(multiindex):
             [0],
             [2],
             [4],
-        ):
-            _test_stack_with_multiindex(full_multiindex[multiindex_columns])
-            if len(multiindex_columns) > 1:
-                multiindex_columns.reverse()
-                _test_stack_with_multiindex(full_multiindex[multiindex_columns])
+            [4, 3, 2, 1, 0],
+            [3, 2, 1, 0],
+            [4, 2, 1, 0],
+            [2, 1, 0],
+            [3, 2, 1],
+            [4, 3, 2],
+            [1, 0],
+            [2, 0],
+            [3, 0],
+        ],
+    )
+    @pytest.mark.parametrize("level", (-1, 0, 1, [0, 1], [1, 0]))
+    def test_stack_partial_multiIndex(self, multiindex_columns, level):
+        # GH 8844
+        full_multiindex = MultiIndex.from_tuples(
+            [("B", "x"), ("B", "z"), ("A", "y"), ("C", "x"), ("C", "u")],
+            names=["Upper", "Lower"],
+        )
+        multiindex = full_multiindex[multiindex_columns]
+        df = DataFrame(
+            np.arange(3 * len(multiindex)).reshape(3, len(multiindex)),
+            columns=multiindex,
+        )
+        result = df.stack(level=level, dropna=False)
+
+        if isinstance(level, int):
+            # Stacking a single level should not make any all-NaN rows,
+            # so df.stack(level=level, dropna=False) should be the same
+            # as df.stack(level=level, dropna=True).
+            expected = df.stack(level=level, dropna=True)
+            if isinstance(expected, Series):
+                tm.assert_series_equal(result, expected)
+            else:
+                tm.assert_frame_equal(result, expected)
+
+        df.columns = MultiIndex.from_tuples(
+            df.columns.to_numpy(), names=df.columns.names
+        )
+        expected = df.stack(level=level, dropna=False)
+        if isinstance(expected, Series):
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_frame_equal(result, expected)
 
+    def test_stack_full_multiIndex(self):
+        # GH 8844
+        full_multiindex = MultiIndex.from_tuples(
+            [("B", "x"), ("B", "z"), ("A", "y"), ("C", "x"), ("C", "u")],
+            names=["Upper", "Lower"],
+        )
         df = DataFrame(np.arange(6).reshape(2, 3), columns=full_multiindex[[0, 1, 3]])
         result = df.stack(dropna=False)
         expected = DataFrame(
@@ -1764,7 +1789,9 @@ def test_stack_multiple_bug(self):
         multi = df.set_index(["DATE", "ID"])
         multi.columns.name = "Params"
         unst = multi.unstack("ID")
-        down = unst.resample("W-THU").mean()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            down = unst.resample("W-THU").mean()
 
         rs = down.stack("ID")
         xp = unst.loc[:, ["VAR1"]].resample("W-THU").mean().stack("ID")
@@ -1840,7 +1867,7 @@ def test_unstack_number_of_levels_larger_than_int32(self, monkeypatch):
         # GH 26314: Change ValueError to PerformanceWarning
 
         class MockUnstacker(reshape_lib._Unstacker):
-            def __init__(self, *args, **kwargs):
+            def __init__(self, *args, **kwargs) -> None:
                 # __init__ will raise the warning
                 super().__init__(*args, **kwargs)
                 raise Exception("Don't compute final result.")
@@ -1848,36 +1875,37 @@ def __init__(self, *args, **kwargs):
         with monkeypatch.context() as m:
             m.setattr(reshape_lib, "_Unstacker", MockUnstacker)
             df = DataFrame(
-                np.random.randn(2 ** 16, 2),
-                index=[np.arange(2 ** 16), np.arange(2 ** 16)],
+                np.random.randn(2**16, 2),
+                index=[np.arange(2**16), np.arange(2**16)],
             )
             msg = "The following operation may generate"
             with tm.assert_produces_warning(PerformanceWarning, match=msg):
                 with pytest.raises(Exception, match="Don't compute final result."):
                     df.unstack()
 
-    def test_stack_order_with_unsorted_levels(self):
+    @pytest.mark.parametrize(
+        "levels",
+        itertools.chain.from_iterable(
+            itertools.product(itertools.permutations([0, 1, 2], width), repeat=2)
+            for width in [2, 3]
+        ),
+    )
+    @pytest.mark.parametrize("stack_lev", range(2))
+    def test_stack_order_with_unsorted_levels(self, levels, stack_lev):
         # GH#16323
-
-        def manual_compare_stacked(df, df_stacked, lev0, lev1):
-            assert all(
-                df.loc[row, col] == df_stacked.loc[(row, col[lev0]), col[lev1]]
-                for row in df.index
-                for col in df.columns
-            )
-
         # deep check for 1-row case
-        for width in [2, 3]:
-            levels_poss = itertools.product(
-                itertools.permutations([0, 1, 2], width), repeat=2
-            )
+        columns = MultiIndex(levels=levels, codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
+        df = DataFrame(columns=columns, data=[range(4)])
+        df_stacked = df.stack(stack_lev)
+        assert all(
+            df.loc[row, col]
+            == df_stacked.loc[(row, col[stack_lev]), col[1 - stack_lev]]
+            for row in df.index
+            for col in df.columns
+        )
 
-            for levels in levels_poss:
-                columns = MultiIndex(levels=levels, codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
-                df = DataFrame(columns=columns, data=[range(4)])
-                for stack_lev in range(2):
-                    df_stacked = df.stack(stack_lev)
-                    manual_compare_stacked(df, df_stacked, stack_lev, 1 - stack_lev)
+    def test_stack_order_with_unsorted_levels_multi_row(self):
+        # GH#16323
 
         # check multi-row case
         mi = MultiIndex(
@@ -1887,7 +1915,11 @@ def manual_compare_stacked(df, df_stacked, lev0, lev1):
         df = DataFrame(
             columns=mi, index=range(5), data=np.arange(5 * len(mi)).reshape(5, -1)
         )
-        manual_compare_stacked(df, df.stack(0), 0, 1)
+        assert all(
+            df.loc[row, col] == df.stack(0).loc[(row, col[0]), col[1]]
+            for row in df.index
+            for col in df.columns
+        )
 
     def test_stack_unstack_unordered_multiindex(self):
         # GH# 18265
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index 8d9957b24300f..d5331b1060b23 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -42,7 +42,7 @@ class CustomDataFrame(DataFrame):
             custom plotting functions.
             """
 
-            def __init__(self, *args, **kw):
+            def __init__(self, *args, **kw) -> None:
                 super().__init__(*args, **kw)
 
             @property
@@ -723,6 +723,13 @@ def test_convert_dtypes_preserves_subclass(self, gpd_style_subclass_df):
         result = gpd_style_subclass_df.convert_dtypes()
         assert isinstance(result, type(gpd_style_subclass_df))
 
+    def test_astype_preserves_subclass(self):
+        # GH#40810
+        df = tm.SubclassedDataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
+
+        result = df.astype({"A": np.int64, "B": np.int32, "C": np.float64})
+        assert isinstance(result, tm.SubclassedDataFrame)
+
     def test_equals_subclass(self):
         # https://github.com/pandas-dev/pandas/pull/34402
         # allow subclass in both directions
@@ -730,3 +737,11 @@ def test_equals_subclass(self):
         df2 = tm.SubclassedDataFrame({"a": [1, 2, 3]})
         assert df1.equals(df2)
         assert df2.equals(df1)
+
+    def test_replace_list_method(self):
+        # https://github.com/pandas-dev/pandas/pull/46018
+        df = tm.SubclassedDataFrame({"A": [0, 1, 2]})
+        result = df.replace([1, 2], method="ffill")
+        expected = tm.SubclassedDataFrame({"A": [0, 0, 0]})
+        assert isinstance(result, tm.SubclassedDataFrame)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_ufunc.py b/pandas/tests/frame/test_ufunc.py
index 90b4afd657131..b884224315a61 100644
--- a/pandas/tests/frame/test_ufunc.py
+++ b/pandas/tests/frame/test_ufunc.py
@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat.numpy import np_version_is1p22
+from pandas.compat.numpy import np_version_gte1p22
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -81,7 +81,7 @@ def test_binary_input_dispatch_binop(dtype):
         ),
     ],
 )
-def test_ufunc_passes_args(func, arg, expected, request):
+def test_ufunc_passes_args(func, arg, expected):
     # GH#40662
     arr = np.array([[1, 2], [3, 4]])
     df = pd.DataFrame(arr)
@@ -262,10 +262,9 @@ def test_alignment_deprecation_many_inputs(request):
         vectorize,
     )
 
-    if np_version_is1p22:
-        mark = pytest.mark.xfail(
-            reason="ufunc 'my_ufunc' did not contain a loop with signature matching "
-            "types",
+    if np_version_gte1p22:
+        mark = pytest.mark.filterwarnings(
+            "ignore:`np.MachAr` is deprecated.*:DeprecationWarning"
         )
         request.node.add_marker(mark)
 
diff --git a/pandas/tests/frame/test_unary.py b/pandas/tests/frame/test_unary.py
index a69ca0fef7f8b..9caadd0998a26 100644
--- a/pandas/tests/frame/test_unary.py
+++ b/pandas/tests/frame/test_unary.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas.compat import is_numpy_dev
+
 import pandas as pd
 import pandas._testing as tm
 
@@ -98,11 +100,6 @@ def test_pos_numeric(self, df):
     @pytest.mark.parametrize(
         "df",
         [
-            # numpy changing behavior in the future
-            pytest.param(
-                pd.DataFrame({"a": ["a", "b"]}),
-                marks=[pytest.mark.filterwarnings("ignore")],
-            ),
             pd.DataFrame({"a": np.array([-1, 2], dtype=object)}),
             pd.DataFrame({"a": [Decimal("-1.0"), Decimal("2.0")]}),
         ],
@@ -112,6 +109,25 @@ def test_pos_object(self, df):
         tm.assert_frame_equal(+df, df)
         tm.assert_series_equal(+df["a"], df["a"])
 
+    @pytest.mark.parametrize(
+        "df",
+        [
+            pytest.param(
+                pd.DataFrame({"a": ["a", "b"]}),
+                marks=[pytest.mark.filterwarnings("ignore")],
+            ),
+        ],
+    )
+    def test_pos_object_raises(self, df):
+        # GH#21380
+        if is_numpy_dev:
+            with pytest.raises(
+                TypeError, match=r"^bad operand type for unary \+: \'str\'$"
+            ):
+                tm.assert_frame_equal(+df, df)
+        else:
+            tm.assert_series_equal(+df["a"], df["a"])
+
     @pytest.mark.parametrize(
         "df", [pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])})]
     )
diff --git a/pandas/tests/generic/test_duplicate_labels.py b/pandas/tests/generic/test_duplicate_labels.py
index 43cd3039870d0..0546534d91399 100644
--- a/pandas/tests/generic/test_duplicate_labels.py
+++ b/pandas/tests/generic/test_duplicate_labels.py
@@ -63,10 +63,9 @@ def test_preserved_frame(self):
         assert df.loc[["a"]].flags.allows_duplicate_labels is False
         assert df.loc[:, ["A", "B"]].flags.allows_duplicate_labels is False
 
-    @not_implemented
     def test_to_frame(self):
-        s = pd.Series(dtype=float).set_flags(allows_duplicate_labels=False)
-        assert s.to_frame().flags.allows_duplicate_labels is False
+        ser = pd.Series(dtype=float).set_flags(allows_duplicate_labels=False)
+        assert ser.to_frame().flags.allows_duplicate_labels is False
 
     @pytest.mark.parametrize("func", ["add", "sub"])
     @pytest.mark.parametrize(
@@ -85,7 +84,6 @@ def test_binops(self, func, other, frame):
         assert df.flags.allows_duplicate_labels is False
         assert func(df).flags.allows_duplicate_labels is False
 
-    @not_implemented
     def test_preserve_getitem(self):
         df = pd.DataFrame({"A": [1, 2]}).set_flags(allows_duplicate_labels=False)
         assert df[["A"]].flags.allows_duplicate_labels is False
@@ -307,15 +305,11 @@ def test_series_raises(self):
             (operator.itemgetter(["A", "A"]), None),
             # loc
             (operator.itemgetter(["a", "a"]), "loc"),
-            pytest.param(
-                operator.itemgetter(("a", ["A", "A"])), "loc", marks=not_implemented
-            ),
+            pytest.param(operator.itemgetter(("a", ["A", "A"])), "loc"),
             (operator.itemgetter((["a", "a"], "A")), "loc"),
             # iloc
             (operator.itemgetter([0, 0]), "iloc"),
-            pytest.param(
-                operator.itemgetter((0, [0, 0])), "iloc", marks=not_implemented
-            ),
+            pytest.param(operator.itemgetter((0, [0, 0])), "iloc"),
             pytest.param(operator.itemgetter(([0, 0], 0)), "iloc"),
         ],
     )
@@ -435,11 +429,19 @@ def test_inplace_raises(method, frame_only):
     s.flags.allows_duplicate_labels = False
     msg = "Cannot specify"
 
+    warn_msg = "Series.set_axis 'inplace' keyword"
+    if "set_axis" in str(method):
+        warn = FutureWarning
+    else:
+        warn = None
+
     with pytest.raises(ValueError, match=msg):
-        method(df)
+        with tm.assert_produces_warning(warn, match=warn_msg):
+            method(df)
     if not frame_only:
         with pytest.raises(ValueError, match=msg):
-            method(s)
+            with tm.assert_produces_warning(warn, match=warn_msg):
+                method(s)
 
 
 def test_pickle():
diff --git a/pandas/tests/generic/test_finalize.py b/pandas/tests/generic/test_finalize.py
index ba9cb22ed27a5..dddab05af7341 100644
--- a/pandas/tests/generic/test_finalize.py
+++ b/pandas/tests/generic/test_finalize.py
@@ -38,14 +38,9 @@
     (pd.Series, ([0],), operator.methodcaller("take", [])),
     (pd.Series, ([0],), operator.methodcaller("__getitem__", [True])),
     (pd.Series, ([0],), operator.methodcaller("repeat", 2)),
-    pytest.param(
-        (pd.Series, ([0],), operator.methodcaller("reset_index")),
-        marks=pytest.mark.xfail,
-    ),
+    (pd.Series, ([0],), operator.methodcaller("reset_index")),
     (pd.Series, ([0],), operator.methodcaller("reset_index", drop=True)),
-    pytest.param(
-        (pd.Series, ([0],), operator.methodcaller("to_frame")), marks=pytest.mark.xfail
-    ),
+    (pd.Series, ([0],), operator.methodcaller("to_frame")),
     (pd.Series, ([0, 0],), operator.methodcaller("drop_duplicates")),
     (pd.Series, ([0, 0],), operator.methodcaller("duplicated")),
     (pd.Series, ([0, 0],), operator.methodcaller("round")),
@@ -159,18 +154,12 @@
         operator.methodcaller("pivot_table", columns="A", aggfunc=["mean", "sum"]),
     ),
     (pd.DataFrame, frame_data, operator.methodcaller("stack")),
-    pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("explode", "A")),
-        marks=not_implemented_mark,
-    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("explode", "A")),
     (pd.DataFrame, frame_mi_data, operator.methodcaller("unstack")),
-    pytest.param(
-        (
-            pd.DataFrame,
-            ({"A": ["a", "b", "c"], "B": [1, 3, 5], "C": [2, 4, 6]},),
-            operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
-        ),
-        marks=not_implemented_mark,
+    (
+        pd.DataFrame,
+        ({"A": ["a", "b", "c"], "B": [1, 3, 5], "C": [2, 4, 6]},),
+        operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
     ),
     pytest.param(
         (pd.DataFrame, frame_data, operator.methodcaller("applymap", lambda x: x))
@@ -205,7 +194,6 @@
     ),
     pytest.param(
         (pd.DataFrame, frame_data, operator.methodcaller("round", 2)),
-        marks=not_implemented_mark,
     ),
     pytest.param(
         (pd.DataFrame, frame_data, operator.methodcaller("corr")),
@@ -228,44 +216,50 @@
     ),
     pytest.param(
         (pd.DataFrame, frame_data, operator.methodcaller("count")),
-        marks=not_implemented_mark,
     ),
     pytest.param(
         (pd.DataFrame, frame_mi_data, operator.methodcaller("count", level="A")),
         marks=[
-            not_implemented_mark,
             pytest.mark.filterwarnings("ignore:Using the level keyword:FutureWarning"),
         ],
     ),
     pytest.param(
         (pd.DataFrame, frame_data, operator.methodcaller("nunique")),
     ),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmin")),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmax")),
+    (pd.DataFrame, frame_data, operator.methodcaller("mode")),
     pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("idxmin")),
-        marks=not_implemented_mark,
-    ),
-    pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("idxmax")),
+        (pd.Series, [0], operator.methodcaller("mode")),
         marks=not_implemented_mark,
     ),
     pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("mode")),
-    ),
-    pytest.param(
-        (pd.Series, [0], operator.methodcaller("mode")),
-        marks=not_implemented_mark,
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("quantile", numeric_only=True),
+        ),
     ),
     pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("quantile")),
-        marks=not_implemented_mark,
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("quantile", q=[0.25, 0.75], numeric_only=True),
+        ),
     ),
     pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("quantile", q=[0.25, 0.75])),
-        marks=not_implemented_mark,
+        (
+            pd.DataFrame,
+            ({"A": [pd.Timedelta(days=1), pd.Timedelta(days=2)]},),
+            operator.methodcaller("quantile", numeric_only=False),
+        ),
     ),
     pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("quantile")),
-        marks=not_implemented_mark,
+        (
+            pd.DataFrame,
+            ({"A": [np.datetime64("2022-01-01"), np.datetime64("2022-01-02")]},),
+            operator.methodcaller("quantile", numeric_only=True),
+        ),
     ),
     (
         pd.DataFrame,
@@ -279,11 +273,9 @@
     ),
     pytest.param(
         (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", [1])),
-        marks=not_implemented_mark,
     ),
     pytest.param(
         (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", pd.Series([1]))),
-        marks=not_implemented_mark,
     ),
     pytest.param(
         (
@@ -291,7 +283,6 @@
             frame_mi_data,
             operator.methodcaller("isin", pd.DataFrame({"A": [1]})),
         ),
-        marks=not_implemented_mark,
     ),
     (pd.DataFrame, frame_data, operator.methodcaller("swapaxes", 0, 1)),
     (pd.DataFrame, frame_mi_data, operator.methodcaller("droplevel", "A")),
@@ -300,10 +291,7 @@
         (pd.DataFrame, frame_data, operator.methodcaller("squeeze")),
         marks=not_implemented_mark,
     ),
-    pytest.param(
-        (pd.Series, ([1, 2],), operator.methodcaller("squeeze"))
-        # marks=not_implemented_mark,
-    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("squeeze")),
     (pd.Series, ([1, 2],), operator.methodcaller("rename_axis", index="a")),
     (pd.DataFrame, frame_data, operator.methodcaller("rename_axis", columns="a")),
     # Unary ops
@@ -315,7 +303,7 @@
     (pd.Series, [1], operator.inv),
     (pd.DataFrame, frame_data, abs),
     (pd.Series, [1], abs),
-    pytest.param((pd.DataFrame, frame_data, round), marks=not_implemented_mark),
+    pytest.param((pd.DataFrame, frame_data, round)),
     (pd.Series, [1], round),
     (pd.DataFrame, frame_data, operator.methodcaller("take", [0, 0])),
     (pd.DataFrame, frame_mi_data, operator.methodcaller("xs", "a")),
@@ -461,10 +449,7 @@
         marks=not_implemented_mark,
     ),
     (pd.Series, ([1, 2],), operator.methodcaller("pct_change")),
-    pytest.param(
-        (pd.DataFrame, frame_data, operator.methodcaller("pct_change")),
-        marks=not_implemented_mark,
-    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("pct_change")),
     (pd.Series, ([1],), operator.methodcaller("transform", lambda x: x - x.min())),
     pytest.param(
         (
@@ -746,6 +731,7 @@ def test_categorical_accessor(method):
     "method",
     [
         operator.methodcaller("sum"),
+        lambda x: x.apply(lambda y: y),
         lambda x: x.agg("sum"),
         lambda x: x.agg("mean"),
         lambda x: x.agg("median"),
@@ -753,7 +739,7 @@ def test_categorical_accessor(method):
 )
 def test_groupby_finalize(obj, method):
     obj.attrs = {"a": 1}
-    result = method(obj.groupby([0, 0]))
+    result = method(obj.groupby([0, 0], group_keys=False))
     assert result.attrs == {"a": 1}
 
 
@@ -764,7 +750,6 @@ def test_groupby_finalize(obj, method):
     "method",
     [
         lambda x: x.agg(["sum", "count"]),
-        lambda x: x.apply(lambda y: y),
         lambda x: x.agg("std"),
         lambda x: x.agg("var"),
         lambda x: x.agg("sem"),
diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index 2b248afb42057..b4a3a60e72139 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -71,7 +71,9 @@ def test_metadata_propagation_indiv_groupby(self):
                 "D": np.random.randn(8),
             }
         )
-        result = df.groupby("A").sum()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.groupby("A").sum()
         tm.assert_metadata_equivalent(df, result)
 
     def test_metadata_propagation_indiv_resample(self):
diff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py
index 5c1eb28ed6099..80d9bde784018 100644
--- a/pandas/tests/generic/test_generic.py
+++ b/pandas/tests/generic/test_generic.py
@@ -309,23 +309,31 @@ def test_copy_and_deepcopy(self, frame_or_series, shape, func):
 class TestNDFrame:
     # tests that don't fit elsewhere
 
-    def test_squeeze(self):
+    @pytest.mark.parametrize(
+        "ser", [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]
+    )
+    def test_squeeze_series_noop(self, ser):
+        # noop
+        tm.assert_series_equal(ser.squeeze(), ser)
+
+    def test_squeeze_frame_noop(self):
         # noop
-        for s in [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]:
-            tm.assert_series_equal(s.squeeze(), s)
-        for df in [tm.makeTimeDataFrame()]:
-            tm.assert_frame_equal(df.squeeze(), df)
+        df = tm.makeTimeDataFrame()
+        tm.assert_frame_equal(df.squeeze(), df)
 
+    def test_squeeze_frame_reindex(self):
         # squeezing
         df = tm.makeTimeDataFrame().reindex(columns=["A"])
         tm.assert_series_equal(df.squeeze(), df["A"])
 
+    def test_squeeze_0_len_dim(self):
         # don't fail with 0 length dimensions GH11229 & GH8999
         empty_series = Series([], name="five", dtype=np.float64)
         empty_frame = DataFrame([empty_series])
         tm.assert_series_equal(empty_series, empty_series.squeeze())
         tm.assert_series_equal(empty_series, empty_frame.squeeze())
 
+    def test_squeeze_axis(self):
         # axis argument
         df = tm.makeTimeDataFrame(nper=1).iloc[:, :1]
         assert df.shape == (1, 1)
@@ -341,6 +349,7 @@ def test_squeeze(self):
         with pytest.raises(ValueError, match=msg):
             df.squeeze(axis="x")
 
+    def test_squeeze_axis_len_3(self):
         df = tm.makeTimeDataFrame(3)
         tm.assert_frame_equal(df.squeeze(axis=0), df)
 
@@ -351,12 +360,16 @@ def test_numpy_squeeze(self):
         df = tm.makeTimeDataFrame().reindex(columns=["A"])
         tm.assert_series_equal(np.squeeze(df), df["A"])
 
-    def test_transpose(self):
-        for s in [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]:
-            # calls implementation in pandas/core/base.py
-            tm.assert_series_equal(s.transpose(), s)
-        for df in [tm.makeTimeDataFrame()]:
-            tm.assert_frame_equal(df.transpose().transpose(), df)
+    @pytest.mark.parametrize(
+        "ser", [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]
+    )
+    def test_transpose_series(self, ser):
+        # calls implementation in pandas/core/base.py
+        tm.assert_series_equal(ser.transpose(), ser)
+
+    def test_transpose_frame(self):
+        df = tm.makeTimeDataFrame()
+        tm.assert_frame_equal(df.transpose().transpose(), df)
 
     def test_numpy_transpose(self, frame_or_series):
 
@@ -374,22 +387,29 @@ def test_numpy_transpose(self, frame_or_series):
         with pytest.raises(ValueError, match=msg):
             np.transpose(obj, axes=1)
 
-    def test_take(self):
+    @pytest.mark.parametrize(
+        "ser", [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]
+    )
+    def test_take_series(self, ser):
+        indices = [1, 5, -2, 6, 3, -1]
+        out = ser.take(indices)
+        expected = Series(
+            data=ser.values.take(indices),
+            index=ser.index.take(indices),
+            dtype=ser.dtype,
+        )
+        tm.assert_series_equal(out, expected)
+
+    def test_take_frame(self):
         indices = [1, 5, -2, 6, 3, -1]
-        for s in [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]:
-            out = s.take(indices)
-            expected = Series(
-                data=s.values.take(indices), index=s.index.take(indices), dtype=s.dtype
-            )
-            tm.assert_series_equal(out, expected)
-        for df in [tm.makeTimeDataFrame()]:
-            out = df.take(indices)
-            expected = DataFrame(
-                data=df.values.take(indices, axis=0),
-                index=df.index.take(indices),
-                columns=df.columns,
-            )
-            tm.assert_frame_equal(out, expected)
+        df = tm.makeTimeDataFrame()
+        out = df.take(indices)
+        expected = DataFrame(
+            data=df.values.take(indices, axis=0),
+            index=df.index.take(indices),
+            columns=df.columns,
+        )
+        tm.assert_frame_equal(out, expected)
 
     def test_take_invalid_kwargs(self, frame_or_series):
         indices = [-3, 2, 0, 1]
diff --git a/pandas/tests/groupby/__init__.py b/pandas/tests/groupby/__init__.py
index e69de29bb2d1d..c63aa568a15dc 100644
--- a/pandas/tests/groupby/__init__.py
+++ b/pandas/tests/groupby/__init__.py
@@ -0,0 +1,27 @@
+def get_groupby_method_args(name, obj):
+    """
+    Get required arguments for a groupby method.
+
+    When parametrizing a test over groupby methods (e.g. "sum", "mean", "fillna"),
+    it is often the case that arguments are required for certain methods.
+
+    Parameters
+    ----------
+    name: str
+        Name of the method.
+    obj: Series or DataFrame
+        pandas object that is being grouped.
+
+    Returns
+    -------
+    A tuple of required arguments for the method.
+    """
+    if name in ("nth", "fillna", "take"):
+        return (0,)
+    if name == "quantile":
+        return (0.5,)
+    if name == "corrwith":
+        return (obj,)
+    if name == "tshift":
+        return (0, 0)
+    return ()
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 2ab553434873c..4e8cc2cb3869d 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -9,6 +9,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SpecificationError
+
 from pandas.core.dtypes.common import is_integer_dtype
 
 import pandas as pd
@@ -21,7 +23,6 @@
     to_datetime,
 )
 import pandas._testing as tm
-from pandas.core.base import SpecificationError
 from pandas.core.groupby.grouper import Grouping
 
 
@@ -133,7 +134,7 @@ def test_groupby_aggregation_multi_level_column():
 
 def test_agg_apply_corner(ts, tsframe):
     # nothing to group, all NA
-    grouped = ts.groupby(ts * np.nan)
+    grouped = ts.groupby(ts * np.nan, group_keys=False)
     assert ts.dtype == np.float64
 
     # groupby float64 values results in Float64Index
@@ -143,7 +144,7 @@ def test_agg_apply_corner(ts, tsframe):
     tm.assert_series_equal(grouped.apply(np.sum), exp, check_index_type=False)
 
     # DataFrame
-    grouped = tsframe.groupby(tsframe["A"] * np.nan)
+    grouped = tsframe.groupby(tsframe["A"] * np.nan, group_keys=False)
     exp_df = DataFrame(
         columns=tsframe.columns,
         dtype=float,
@@ -225,10 +226,10 @@ def test_agg_str_with_kwarg_axis_1_raises(df, reduction_func):
     "func, expected, dtype, result_dtype_dict",
     [
         ("sum", [5, 7, 9], "int64", {}),
-        ("std", [4.5 ** 0.5] * 3, int, {"i": float, "j": float, "k": float}),
+        ("std", [4.5**0.5] * 3, int, {"i": float, "j": float, "k": float}),
         ("var", [4.5] * 3, int, {"i": float, "j": float, "k": float}),
         ("sum", [5, 7, 9], "Int64", {"j": "int64"}),
-        ("std", [4.5 ** 0.5] * 3, "Int64", {"i": float, "j": float, "k": float}),
+        ("std", [4.5**0.5] * 3, "Int64", {"i": float, "j": float, "k": float}),
         ("var", [4.5] * 3, "Int64", {"i": "float64", "j": "float64", "k": "float64"}),
     ],
 )
@@ -238,7 +239,10 @@ def test_multiindex_groupby_mixed_cols_axis1(func, expected, dtype, result_dtype
         [[1, 2, 3, 4, 5, 6]] * 3,
         columns=MultiIndex.from_product([["a", "b"], ["i", "j", "k"]]),
     ).astype({("a", "j"): dtype, ("b", "j"): dtype})
-    result = df.groupby(level=1, axis=1).agg(func)
+    warn = FutureWarning if func == "std" else None
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = df.groupby(level=1, axis=1).agg(func)
     expected = DataFrame([expected] * 3, columns=["i", "j", "k"]).astype(
         result_dtype_dict
     )
@@ -250,7 +254,7 @@ def test_multiindex_groupby_mixed_cols_axis1(func, expected, dtype, result_dtype
     [
         ("sum", [[2, 4], [10, 12], [18, 20]], {10: "int64", 20: "int64"}),
         # std should ideally return Int64 / Float64 #43330
-        ("std", [[2 ** 0.5] * 2] * 3, "float64"),
+        ("std", [[2**0.5] * 2] * 3, "float64"),
         ("var", [[2] * 2] * 3, {10: "float64", 20: "float64"}),
     ],
 )
@@ -262,7 +266,10 @@ def test_groupby_mixed_cols_axis1(func, expected_data, result_dtype_dict):
         columns=Index([10, 20, 10, 20], name="x"),
         dtype="int64",
     ).astype({10: "Int64"})
-    result = df.groupby("x", axis=1).agg(func)
+    warn = FutureWarning if func == "std" else None
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = df.groupby("x", axis=1).agg(func)
     expected = DataFrame(
         data=expected_data,
         index=Index([0, 1, 0], name="y"),
@@ -557,6 +564,22 @@ def test_order_aggregate_multiple_funcs():
     tm.assert_index_equal(result, expected)
 
 
+def test_ohlc_ea_dtypes(any_numeric_ea_dtype):
+    # GH#37493
+    df = DataFrame(
+        {"a": [1, 1, 2, 3, 4, 4], "b": [22, 11, pd.NA, 10, 20, pd.NA]},
+        dtype=any_numeric_ea_dtype,
+    )
+    result = df.groupby("a").ohlc()
+    expected = DataFrame(
+        [[22, 22, 11, 11], [pd.NA] * 4, [10] * 4, [20] * 4],
+        columns=MultiIndex.from_product([["b"], ["open", "high", "low", "close"]]),
+        index=Index([1, 2, 3, 4], dtype=any_numeric_ea_dtype, name="a"),
+        dtype=any_numeric_ea_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
 @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
 @pytest.mark.parametrize("how", ["first", "last", "min", "max", "mean", "median"])
 def test_uint64_type_handling(dtype, how):
@@ -914,7 +937,7 @@ def test_groupby_aggregate_empty_key_empty_return():
 def test_groupby_aggregate_empty_with_multiindex_frame():
     # GH 39178
     df = DataFrame(columns=["a", "b", "c"])
-    result = df.groupby(["a", "b"]).agg(d=("c", list))
+    result = df.groupby(["a", "b"], group_keys=False).agg(d=("c", list))
     expected = DataFrame(
         columns=["d"], index=MultiIndex([[], []], [[], []], names=["a", "b"])
     )
@@ -1097,7 +1120,7 @@ def test_agg_with_one_lambda(self):
         # check pd.NameAgg case
         result1 = df.groupby(by="kind").agg(
             height_sqr_min=pd.NamedAgg(
-                column="height", aggfunc=lambda x: np.min(x ** 2)
+                column="height", aggfunc=lambda x: np.min(x**2)
             ),
             height_max=pd.NamedAgg(column="height", aggfunc="max"),
             weight_max=pd.NamedAgg(column="weight", aggfunc="max"),
@@ -1106,7 +1129,7 @@ def test_agg_with_one_lambda(self):
 
         # check agg(key=(col, aggfunc)) case
         result2 = df.groupby(by="kind").agg(
-            height_sqr_min=("height", lambda x: np.min(x ** 2)),
+            height_sqr_min=("height", lambda x: np.min(x**2)),
             height_max=("height", "max"),
             weight_max=("weight", "max"),
         )
@@ -1143,7 +1166,7 @@ def test_agg_multiple_lambda(self):
 
         # check agg(key=(col, aggfunc)) case
         result1 = df.groupby(by="kind").agg(
-            height_sqr_min=("height", lambda x: np.min(x ** 2)),
+            height_sqr_min=("height", lambda x: np.min(x**2)),
             height_max=("height", "max"),
             weight_max=("weight", "max"),
             height_max_2=("height", lambda x: np.max(x)),
@@ -1154,7 +1177,7 @@ def test_agg_multiple_lambda(self):
         # check pd.NamedAgg case
         result2 = df.groupby(by="kind").agg(
             height_sqr_min=pd.NamedAgg(
-                column="height", aggfunc=lambda x: np.min(x ** 2)
+                column="height", aggfunc=lambda x: np.min(x**2)
             ),
             height_max=pd.NamedAgg(column="height", aggfunc="max"),
             weight_max=pd.NamedAgg(column="weight", aggfunc="max"),
@@ -1325,11 +1348,13 @@ def test_groupby_aggregate_directory(reduction_func):
     # GH#32793
     if reduction_func in ["corrwith", "nth"]:
         return None
+    warn = FutureWarning if reduction_func == "mad" else None
 
     obj = DataFrame([[0, 1], [0, np.nan]])
 
-    result_reduced_series = obj.groupby(0).agg(reduction_func)
-    result_reduced_frame = obj.groupby(0).agg({1: reduction_func})
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result_reduced_series = obj.groupby(0).agg(reduction_func)
+        result_reduced_frame = obj.groupby(0).agg({1: reduction_func})
 
     if reduction_func in ["size", "ngroup"]:
         # names are different: None / 1
@@ -1393,3 +1418,51 @@ def test_groupby_complex_raises(func):
     msg = "No matching signature found"
     with pytest.raises(TypeError, match=msg):
         data.groupby(data.index % 2).agg(func)
+
+
+@pytest.mark.parametrize(
+    "func", [["min"], ["mean", "max"], {"b": "sum"}, {"b": "prod", "c": "median"}]
+)
+def test_multi_axis_1_raises(func):
+    # GH#46995
+    df = DataFrame({"a": [1, 1, 2], "b": [3, 4, 5], "c": [6, 7, 8]})
+    gb = df.groupby("a", axis=1)
+    with pytest.raises(NotImplementedError, match="axis other than 0 is not supported"):
+        gb.agg(func)
+
+
+@pytest.mark.parametrize(
+    "test, constant",
+    [
+        ([[20, "A"], [20, "B"], [10, "C"]], {0: [10, 20], 1: ["C", ["A", "B"]]}),
+        ([[20, "A"], [20, "B"], [30, "C"]], {0: [20, 30], 1: [["A", "B"], "C"]}),
+        ([["a", 1], ["a", 1], ["b", 2], ["b", 3]], {0: ["a", "b"], 1: [1, [2, 3]]}),
+        pytest.param(
+            [["a", 1], ["a", 2], ["b", 3], ["b", 3]],
+            {0: ["a", "b"], 1: [[1, 2], 3]},
+            marks=pytest.mark.xfail,
+        ),
+    ],
+)
+def test_agg_of_mode_list(test, constant):
+    # GH#25581
+    df1 = DataFrame(test)
+    result = df1.groupby(0).agg(Series.mode)
+    # Mode usually only returns 1 value, but can return a list in the case of a tie.
+
+    expected = DataFrame(constant)
+    expected = expected.set_index(0)
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_numeric_only_warning_numpy():
+    # GH#50538
+    df = DataFrame({"a": [1, 1, 2], "b": list("xyz"), "c": [3, 4, 5]})
+    gb = df.groupby("a")
+    msg = "The operation <function mean.*failed"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        gb.agg(np.mean)
+    # Ensure users can't pass numeric_only
+    with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+        gb.agg(np.mean, numeric_only=True)
diff --git a/pandas/tests/groupby/aggregate/test_cython.py b/pandas/tests/groupby/aggregate/test_cython.py
index d9372ba5cbb50..0a3845617b32d 100644
--- a/pandas/tests/groupby/aggregate/test_cython.py
+++ b/pandas/tests/groupby/aggregate/test_cython.py
@@ -5,7 +5,10 @@
 import numpy as np
 import pytest
 
-from pandas.core.dtypes.common import is_float_dtype
+from pandas.core.dtypes.common import (
+    is_float_dtype,
+    is_integer_dtype,
+)
 
 import pandas as pd
 from pandas import (
@@ -89,8 +92,9 @@ def test_cython_agg_boolean():
 def test_cython_agg_nothing_to_agg():
     frame = DataFrame({"a": np.random.randint(0, 5, 50), "b": ["foo", "bar"] * 25})
 
-    with pytest.raises(NotImplementedError, match="does not implement"):
-        frame.groupby("a")["b"].mean(numeric_only=True)
+    with tm.assert_produces_warning(FutureWarning, match="This will raise a TypeError"):
+        with pytest.raises(NotImplementedError, match="does not implement"):
+            frame.groupby("a")["b"].mean(numeric_only=True)
 
     with pytest.raises(TypeError, match="Could not convert (foo|bar)*"):
         frame.groupby("a")["b"].mean()
@@ -111,8 +115,9 @@ def test_cython_agg_nothing_to_agg_with_dates():
             "dates": pd.date_range("now", periods=50, freq="T"),
         }
     )
-    with pytest.raises(NotImplementedError, match="does not implement"):
-        frame.groupby("b").dates.mean(numeric_only=True)
+    with tm.assert_produces_warning(FutureWarning, match="This will raise a TypeError"):
+        with pytest.raises(NotImplementedError, match="does not implement"):
+            frame.groupby("b").dates.mean(numeric_only=True)
 
 
 def test_cython_agg_frame_columns():
@@ -161,7 +166,7 @@ def test_cython_fail_agg():
         ("mean", np.mean),
         ("median", np.median),
         ("var", np.var),
-        ("add", np.sum),
+        ("sum", np.sum),
         ("prod", np.prod),
         ("min", np.min),
         ("max", np.max),
@@ -209,7 +214,7 @@ def test_cython_agg_empty_buckets_nanops(observed):
     grps = range(0, 25, 5)
     # add / sum
     result = df.groupby(pd.cut(df["a"], grps), observed=observed)._cython_agg_general(
-        "add", alt=None, numeric_only=True
+        "sum", alt=None, numeric_only=True
     )
     intervals = pd.interval_range(0, 20, freq=5)
     expected = DataFrame(
@@ -369,6 +374,9 @@ def test_cython_agg_EA_known_dtypes(data, op_name, action, with_na):
         # for any int/bool use Int64, for float preserve dtype
         if is_float_dtype(data.dtype):
             expected_dtype = data.dtype
+        elif is_integer_dtype(data.dtype):
+            # match the numpy dtype we'd get with the non-nullable analogue
+            expected_dtype = data.dtype
         else:
             expected_dtype = pd.Int64Dtype()
     elif action == "always_float":
diff --git a/pandas/tests/groupby/aggregate/test_numba.py b/pandas/tests/groupby/aggregate/test_numba.py
index e7fa2e0690066..0b2fb56a02006 100644
--- a/pandas/tests/groupby/aggregate/test_numba.py
+++ b/pandas/tests/groupby/aggregate/test_numba.py
@@ -12,7 +12,6 @@
     option_context,
 )
 import pandas._testing as tm
-from pandas.core.util.numba_ import NUMBA_FUNC_CACHE
 
 
 @td.skip_if_no("numba")
@@ -33,8 +32,8 @@ def incorrect_function(x):
 
 @td.skip_if_no("numba")
 def test_check_nopython_kwargs():
-    def incorrect_function(x, **kwargs):
-        return sum(x) * 2.7
+    def incorrect_function(values, index):
+        return sum(values) * 2.7
 
     data = DataFrame(
         {"key": ["a", "a", "b", "b", "a"], "data": [1.0, 2.0, 3.0, 4.0, 5.0]},
@@ -48,7 +47,7 @@ def incorrect_function(x, **kwargs):
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 @pytest.mark.parametrize("jit", [True, False])
 @pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
@@ -77,7 +76,7 @@ def func_numba(values, index):
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 @pytest.mark.parametrize("jit", [True, False])
 @pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
@@ -106,14 +105,11 @@ def func_2(values, index):
     result = grouped.agg(func_1, engine="numba", engine_kwargs=engine_kwargs)
     expected = grouped.agg(lambda x: np.mean(x) - 3.4, engine="cython")
     tm.assert_equal(result, expected)
-    # func_1 should be in the cache now
-    assert (func_1, "groupby_agg") in NUMBA_FUNC_CACHE
 
     # Add func_2 to the cache
     result = grouped.agg(func_2, engine="numba", engine_kwargs=engine_kwargs)
     expected = grouped.agg(lambda x: np.mean(x) * 2.7, engine="cython")
     tm.assert_equal(result, expected)
-    assert (func_2, "groupby_agg") in NUMBA_FUNC_CACHE
 
     # Retest func_1 which should use the cache
     result = grouped.agg(func_1, engine="numba", engine_kwargs=engine_kwargs)
@@ -187,3 +183,59 @@ def f(values, index):
         [-1.5, -3.0], columns=["v"], index=Index(["A", "B"], name="group")
     )
     tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_engine_kwargs_not_cached():
+    # If the user passes a different set of engine_kwargs don't return the same
+    # jitted function
+    nogil = True
+    parallel = False
+    nopython = True
+
+    def func_kwargs(values, index):
+        return nogil + parallel + nopython
+
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    df = DataFrame({"value": [0, 0, 0]})
+    result = df.groupby(level=0).aggregate(
+        func_kwargs, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame({"value": [2.0, 2.0, 2.0]})
+    tm.assert_frame_equal(result, expected)
+
+    nogil = False
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    result = df.groupby(level=0).aggregate(
+        func_kwargs, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame({"value": [1.0, 1.0, 1.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+@pytest.mark.filterwarnings("ignore")
+def test_multiindex_one_key(nogil, parallel, nopython):
+    def numba_func(values, index):
+        return 1
+
+    df = DataFrame([{"A": 1, "B": 2, "C": 3}]).set_index(["A", "B"])
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    result = df.groupby("A").agg(
+        numba_func, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame([1.0], index=Index([1], name="A"), columns=["C"])
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_multiindex_multi_key_not_supported(nogil, parallel, nopython):
+    def numba_func(values, index):
+        return 1
+
+    df = DataFrame([{"A": 1, "B": 2, "C": 3}]).set_index(["A", "B"])
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    with pytest.raises(NotImplementedError, match="More than 1 grouping labels"):
+        df.groupby(["A", "B"]).agg(
+            numba_func, engine="numba", engine_kwargs=engine_kwargs
+        )
diff --git a/pandas/tests/groupby/aggregate/test_other.py b/pandas/tests/groupby/aggregate/test_other.py
index 06044ddd3f4b8..f84abecea37da 100644
--- a/pandas/tests/groupby/aggregate/test_other.py
+++ b/pandas/tests/groupby/aggregate/test_other.py
@@ -8,6 +8,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SpecificationError
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -19,7 +21,6 @@
     period_range,
 )
 import pandas._testing as tm
-from pandas.core.base import SpecificationError
 
 from pandas.io.formats.printing import pprint_thing
 
diff --git a/pandas/tests/groupby/conftest.py b/pandas/tests/groupby/conftest.py
index 2be680d7a4ccd..7e7b97d9273dc 100644
--- a/pandas/tests/groupby/conftest.py
+++ b/pandas/tests/groupby/conftest.py
@@ -19,6 +19,16 @@ def as_index(request):
     return request.param
 
 
+@pytest.fixture(params=[True, False])
+def dropna(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def observed(request):
+    return request.param
+
+
 @pytest.fixture
 def mframe(multiindex_dataframe_random_data):
     return multiindex_dataframe_random_data
@@ -184,7 +194,10 @@ def nopython(request):
         ("std", {"ddof": 1}),
         ("std", {"ddof": 0}),
         ("sum", {}),
-    ]
+        ("min", {}),
+        ("max", {}),
+    ],
+    ids=["mean", "var_1", "var_0", "std_1", "std_0", "sum", "min", "max"],
 )
 def numba_supported_reductions(request):
     """reductions supported with engine='numba'"""
diff --git a/pandas/tests/groupby/test_allowlist.py b/pandas/tests/groupby/test_allowlist.py
index 44778aafdf75f..e541abb368a02 100644
--- a/pandas/tests/groupby/test_allowlist.py
+++ b/pandas/tests/groupby/test_allowlist.py
@@ -178,6 +178,7 @@ def test_regression_allowlist_methods(raw_frame, op, level, axis, skipna, sort):
     # GH6944
     # GH 17537
     # explicitly test the allowlist methods
+    warn = FutureWarning if op == "mad" else None
 
     if axis == 0:
         frame = raw_frame
@@ -186,7 +187,10 @@ def test_regression_allowlist_methods(raw_frame, op, level, axis, skipna, sort):
 
     if op in AGG_FUNCTIONS_WITH_SKIPNA:
         grouped = frame.groupby(level=level, axis=axis, sort=sort)
-        result = getattr(grouped, op)(skipna=skipna)
+        with tm.assert_produces_warning(
+            warn, match="The 'mad' method is deprecated", raise_on_extra_warnings=False
+        ):
+            result = getattr(grouped, op)(skipna=skipna)
         with tm.assert_produces_warning(FutureWarning):
             expected = getattr(frame, op)(level=level, axis=axis, skipna=skipna)
         if sort:
@@ -194,8 +198,8 @@ def test_regression_allowlist_methods(raw_frame, op, level, axis, skipna, sort):
         tm.assert_frame_equal(result, expected)
     else:
         grouped = frame.groupby(level=level, axis=axis, sort=sort)
-        result = getattr(grouped, op)()
         with tm.assert_produces_warning(FutureWarning):
+            result = getattr(grouped, op)()
             expected = getattr(frame, op)(level=level, axis=axis)
         if sort:
             expected = expected.sort_index(axis=axis, level=level)
@@ -419,7 +423,7 @@ def test_all_methods_categorized(mframe):
     # new public method?
     if new_names:
         msg = f"""
-There are uncatgeorized methods defined on the Grouper class:
+There are uncategorized methods defined on the Grouper class:
 {new_names}.
 
 Was a new method recently added?
diff --git a/pandas/tests/groupby/test_any_all.py b/pandas/tests/groupby/test_any_all.py
index 13232d454a48c..3f61a4ece66c0 100644
--- a/pandas/tests/groupby/test_any_all.py
+++ b/pandas/tests/groupby/test_any_all.py
@@ -178,3 +178,13 @@ def test_object_NA_raises_with_skipna_false(bool_agg_func):
     ser = Series([pd.NA], dtype=object)
     with pytest.raises(TypeError, match="boolean value of NA is ambiguous"):
         ser.groupby([1]).agg(bool_agg_func, skipna=False)
+
+
+@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
+def test_empty(frame_or_series, bool_agg_func):
+    # GH 45231
+    kwargs = {"columns": ["a"]} if frame_or_series is DataFrame else {"name": "a"}
+    obj = frame_or_series(**kwargs, dtype=object)
+    result = getattr(obj.groupby(obj.index), bool_agg_func)()
+    expected = frame_or_series(**kwargs, dtype=bool)
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index 22a4ce327c150..b6c16c0dee827 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -17,6 +17,7 @@
 )
 import pandas._testing as tm
 from pandas.core.api import Int64Index
+from pandas.tests.groupby import get_groupby_method_args
 
 
 def test_apply_issues():
@@ -54,7 +55,9 @@ def test_apply_issues():
         ["2011.05.16", "2011.05.17", "2011.05.18"], dtype=object, name="date"
     )
     expected = Series(["00:00", "02:00", "02:00"], index=exp_idx)
-    result = df.groupby("date").apply(lambda x: x["time"][x["value"].idxmax()])
+    result = df.groupby("date", group_keys=False).apply(
+        lambda x: x["time"][x["value"].idxmax()]
+    )
     tm.assert_series_equal(result, expected)
 
 
@@ -80,7 +83,9 @@ def test_apply_trivial_fail():
         columns=["key", "data"],
     )
     expected = pd.concat([df, df], axis=1, keys=["float64", "object"])
-    result = df.groupby([str(x) for x in df.dtypes], axis=1).apply(lambda x: df)
+    result = df.groupby([str(x) for x in df.dtypes], axis=1, group_keys=True).apply(
+        lambda x: df
+    )
 
     tm.assert_frame_equal(result, expected)
 
@@ -156,7 +161,7 @@ def f_constant_df(group):
     for func in [f_copy, f_nocopy, f_scalar, f_none, f_constant_df]:
         del names[:]
 
-        df.groupby("a").apply(func)
+        df.groupby("a", group_keys=False).apply(func)
         assert names == group_names
 
 
@@ -174,7 +179,9 @@ def test_group_apply_once_per_group2(capsys):
         index=["0", "2", "4", "6", "8", "10", "12", "14"],
     )
 
-    df.groupby("group_by_column").apply(lambda df: print("function_called"))
+    df.groupby("group_by_column", group_keys=False).apply(
+        lambda df: print("function_called")
+    )
 
     result = capsys.readouterr().out.count("function_called")
     # If `groupby` behaves unexpectedly, this test will break
@@ -194,8 +201,8 @@ def slow(group):
     def fast(group):
         return group.copy()
 
-    fast_df = df.groupby("A").apply(fast)
-    slow_df = df.groupby("A").apply(slow)
+    fast_df = df.groupby("A", group_keys=False).apply(fast)
+    slow_df = df.groupby("A", group_keys=False).apply(slow)
 
     tm.assert_frame_equal(fast_df, slow_df)
 
@@ -217,7 +224,7 @@ def test_groupby_apply_identity_maybecopy_index_identical(func):
 
     df = DataFrame({"g": [1, 2, 2, 2], "a": [1, 2, 3, 4], "b": [5, 6, 7, 8]})
 
-    result = df.groupby("g").apply(func)
+    result = df.groupby("g", group_keys=False).apply(func)
     tm.assert_frame_equal(result, df)
 
 
@@ -241,7 +248,7 @@ def test_apply_with_mixed_dtype():
     tm.assert_series_equal(result1, result2)
 
 
-def test_groupby_as_index_apply(df):
+def test_groupby_as_index_apply():
     # GH #4648 and #3417
     df = DataFrame(
         {
@@ -274,7 +281,7 @@ def test_groupby_as_index_apply(df):
 
     ind = Index(list("abcde"))
     df = DataFrame([[1, 2], [2, 3], [1, 4], [1, 5], [2, 6]], index=ind)
-    res = df.groupby(0, as_index=False).apply(lambda x: x).index
+    res = df.groupby(0, as_index=False, group_keys=False).apply(lambda x: x).index
     tm.assert_index_equal(res, ind)
 
 
@@ -324,10 +331,11 @@ def f(piece):
     dr = bdate_range("1/1/2000", periods=100)
     ts = Series(np.random.randn(100), index=dr)
 
-    grouped = ts.groupby(lambda x: x.month)
+    grouped = ts.groupby(lambda x: x.month, group_keys=False)
     result = grouped.apply(f)
 
     assert isinstance(result, DataFrame)
+    assert not hasattr(result, "name")  # GH49907
     tm.assert_index_equal(result.index, ts.index)
 
 
@@ -367,11 +375,11 @@ def test_apply_frame_not_as_index_column_name(df):
 
 def test_apply_frame_concat_series():
     def trans(group):
-        return group.groupby("B")["C"].sum().sort_values()[:2]
+        return group.groupby("B")["C"].sum().sort_values().iloc[:2]
 
     def trans2(group):
         grouped = group.groupby(df.reindex(group.index)["B"])
-        return grouped.sum().sort_values()[:2]
+        return grouped.sum().sort_values().iloc[:2]
 
     df = DataFrame(
         {
@@ -388,7 +396,7 @@ def trans2(group):
 
 
 def test_apply_transform(ts):
-    grouped = ts.groupby(lambda x: x.month)
+    grouped = ts.groupby(lambda x: x.month, group_keys=False)
     result = grouped.apply(lambda x: x * 2)
     expected = grouped.transform(lambda x: x * 2)
     tm.assert_series_equal(result, expected)
@@ -405,12 +413,18 @@ def f(group):
         tm.assert_frame_equal(result.loc[key], f(group))
 
 
-def test_apply_chunk_view():
+@pytest.mark.parametrize("group_keys", [True, False])
+def test_apply_chunk_view(group_keys):
     # Low level tinkering could be unsafe, make sure not
     df = DataFrame({"key": [1, 1, 1, 2, 2, 2, 3, 3, 3], "value": range(9)})
 
-    result = df.groupby("key", group_keys=False).apply(lambda x: x[:2])
+    result = df.groupby("key", group_keys=group_keys).apply(lambda x: x.iloc[:2])
     expected = df.take([0, 1, 3, 4, 6, 7])
+    if group_keys:
+        expected.index = MultiIndex.from_arrays(
+            [[1, 1, 2, 2, 3, 3], expected.index], names=["key", None]
+        )
+
     tm.assert_frame_equal(result, expected)
 
 
@@ -442,7 +456,7 @@ def f(group):
         group["v2"] = (v - v.min()) / (v.max() - v.min())
         return group
 
-    result = df.groupby("d").apply(f)
+    result = df.groupby("d", group_keys=False).apply(f)
 
     expected = df.copy()
     expected["v2"] = np.tile([0.0, 0.5, 1], 2)
@@ -466,7 +480,7 @@ def f(group):
         group["v2"] = (v - v.min()) / (v.max() - v.min())
         return group
 
-    result = df.groupby("d").apply(f)
+    result = df.groupby("d", group_keys=False).apply(f)
 
     expected = df.copy()
     expected["v2"] = np.tile([0.0, 0.5, 1], 2)
@@ -475,7 +489,7 @@ def f(group):
 
 
 def test_apply_corner(tsframe):
-    result = tsframe.groupby(lambda x: x.year).apply(lambda x: x * 2)
+    result = tsframe.groupby(lambda x: x.year, group_keys=False).apply(lambda x: x * 2)
     expected = tsframe * 2
     tm.assert_frame_equal(result, expected)
 
@@ -517,14 +531,14 @@ def test_apply_with_duplicated_non_sorted_axis(test_series):
     )
     if test_series:
         ser = df.set_index("Y")["X"]
-        result = ser.groupby(level=0).apply(lambda x: x)
+        result = ser.groupby(level=0, group_keys=False).apply(lambda x: x)
 
         # not expecting the order to remain the same for duplicated axis
         result = result.sort_index()
         expected = ser.sort_index()
         tm.assert_series_equal(result, expected)
     else:
-        result = df.groupby("Y").apply(lambda x: x)
+        result = df.groupby("Y", group_keys=False).apply(lambda x: x)
 
         # not expecting the order to remain the same for duplicated axis
         result = result.sort_values("Y")
@@ -546,7 +560,7 @@ def reindex_helper(x):
         return x.reindex(np.arange(x.index.min(), x.index.max() + 1))
 
     # the following group by raised a ValueError
-    result = df.groupby("group").value.apply(reindex_helper)
+    result = df.groupby("group", group_keys=False).value.apply(reindex_helper)
     tm.assert_series_equal(expected, result)
 
 
@@ -563,7 +577,7 @@ def test_apply_corner_cases():
         }
     )
 
-    grouped = df.groupby("key")
+    grouped = df.groupby("key", group_keys=False)
 
     def f(g):
         g["value3"] = g["value1"] * 2
@@ -774,7 +788,7 @@ def test_groupby_apply_return_empty_chunk():
 def test_apply_with_mixed_types():
     # gh-20949
     df = DataFrame({"A": "a a b".split(), "B": [1, 2, 3], "C": [4, 6, 5]})
-    g = df.groupby("A")
+    g = df.groupby("A", group_keys=False)
 
     result = g.transform(lambda x: x / x.sum())
     expected = DataFrame({"B": [1 / 3.0, 2 / 3.0, 1], "C": [0.4, 0.6, 1.0]})
@@ -843,7 +857,7 @@ def test_apply_series_return_dataframe_groups():
     )
 
     def most_common_values(df):
-        return Series({c: s.value_counts().index[0] for c, s in df.iteritems()})
+        return Series({c: s.value_counts().index[0] for c, s in df.items()})
 
     result = tdf.groupby("day").apply(most_common_values)["userId"]
     expected = Series(
@@ -901,7 +915,7 @@ def test_groupby_apply_datetime_result_dtypes():
 def test_apply_index_has_complex_internals(index):
     # GH 31248
     df = DataFrame({"group": [1, 1, 2], "value": [0, 1, 0]}, index=index)
-    result = df.groupby("group").apply(lambda x: x)
+    result = df.groupby("group", group_keys=False).apply(lambda x: x)
     tm.assert_frame_equal(result, df)
 
 
@@ -969,6 +983,55 @@ def test_apply_function_with_indexing_return_column():
     tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize(
+    "udf",
+    [(lambda x: x.copy()), (lambda x: x.copy().rename(lambda y: y + 1))],
+)
+@pytest.mark.parametrize("group_keys", [True, False])
+def test_apply_result_type(group_keys, udf):
+    # https://github.com/pandas-dev/pandas/issues/34809
+    # We'd like to control whether the group keys end up in the index
+    # regardless of whether the UDF happens to be a transform.
+    df = DataFrame({"A": ["a", "b"], "B": [1, 2]})
+    df_result = df.groupby("A", group_keys=group_keys).apply(udf)
+    series_result = df.B.groupby(df.A, group_keys=group_keys).apply(udf)
+
+    if group_keys:
+        assert df_result.index.nlevels == 2
+        assert series_result.index.nlevels == 2
+    else:
+        assert df_result.index.nlevels == 1
+        assert series_result.index.nlevels == 1
+
+
+def test_result_order_group_keys_false():
+    # GH 34998
+    # apply result order should not depend on whether index is the same or just equal
+    df = DataFrame({"A": [2, 1, 2], "B": [1, 2, 3]})
+    result = df.groupby("A", group_keys=False).apply(lambda x: x)
+    expected = df.groupby("A", group_keys=False).apply(lambda x: x.copy())
+    tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_apply_group_keys_warns():
+    df = DataFrame({"A": [0, 1, 1], "B": [1, 2, 3]})
+    msg = "Not prepending group keys to the result index"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby("A").apply(lambda x: x)
+
+    tm.assert_frame_equal(result, df)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby("A")["B"].apply(lambda x: x)
+
+    tm.assert_series_equal(result, df["B"])
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df["B"].groupby(df["A"]).apply(lambda x: x)
+
+    tm.assert_series_equal(result, df["B"])
+
+
 def test_apply_with_timezones_aware():
     # GH: 27212
     dates = ["2001-01-01"] * 2 + ["2001-01-02"] * 2 + ["2001-01-03"] * 2
@@ -986,6 +1049,8 @@ def test_apply_with_timezones_aware():
 def test_apply_is_unchanged_when_other_methods_are_called_first(reduction_func):
     # GH #34656
     # GH #34271
+    warn = FutureWarning if reduction_func == "mad" else None
+
     df = DataFrame(
         {
             "a": [99, 99, 99, 88, 88, 88],
@@ -1006,8 +1071,9 @@ def test_apply_is_unchanged_when_other_methods_are_called_first(reduction_func):
 
     # Check output when another method is called before .apply()
     grp = df.groupby(by="a")
-    args = {"nth": [0], "corrwith": [df]}.get(reduction_func, [])
-    _ = getattr(grp, reduction_func)(*args)
+    args = get_groupby_method_args(reduction_func, df)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        _ = getattr(grp, reduction_func)(*args)
     result = grp.apply(sum)
     tm.assert_frame_equal(result, expected)
 
@@ -1073,7 +1139,7 @@ def test_apply_dropna_with_indexed_same(dropna):
         },
         index=list("xxyxz"),
     )
-    result = df.groupby("group", dropna=dropna).apply(lambda x: x)
+    result = df.groupby("group", dropna=dropna, group_keys=False).apply(lambda x: x)
     expected = df.dropna() if dropna else df.iloc[[0, 3, 1, 2, 4]]
     tm.assert_frame_equal(result, expected)
 
@@ -1128,9 +1194,9 @@ def test_positional_slice_groups_datetimelike():
             "let": list("abcde"),
         }
     )
-    result = expected.groupby([expected.let, expected.date.dt.date]).apply(
-        lambda x: x.iloc[0:]
-    )
+    result = expected.groupby(
+        [expected.let, expected.date.dt.date], group_keys=False
+    ).apply(lambda x: x.iloc[0:])
     tm.assert_frame_equal(result, expected)
 
 
@@ -1245,5 +1311,62 @@ def test_apply_index_key_error_bug(index_values):
 def test_apply_nonmonotonic_float_index(arg, idx):
     # GH 34455
     expected = DataFrame({"col": arg}, index=idx)
-    result = expected.groupby("col").apply(lambda x: x)
+    result = expected.groupby("col", group_keys=False).apply(lambda x: x)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("args, kwargs", [([True], {}), ([], {"numeric_only": True})])
+def test_apply_str_with_args(df, args, kwargs):
+    # GH#46479
+    gb = df.groupby("A")
+    result = gb.apply("sum", *args, **kwargs)
+    expected = gb.sum(numeric_only=True)
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("name", ["some_name", None])
+def test_result_name_when_one_group(name):
+    # GH 46369
+    ser = Series([1, 2], name=name)
+    result = ser.groupby(["a", "a"], group_keys=False).apply(lambda x: x)
+    expected = Series([1, 2], name=name)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method, op",
+    [
+        ("apply", lambda gb: gb.values[-1]),
+        ("apply", lambda gb: gb["b"].iloc[0]),
+        ("agg", "mad"),
+        ("agg", "skew"),
+        ("agg", "prod"),
+        ("agg", "sum"),
+    ],
+)
+def test_empty_df(method, op):
+    # GH 47985
+    empty_df = DataFrame({"a": [], "b": []})
+    gb = empty_df.groupby("a", group_keys=True)
+    group = getattr(gb, "b")
+
+    result = getattr(group, method)(op)
+    expected = Series(
+        [], name="b", dtype="float64", index=Index([], dtype="float64", name="a")
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_numeric_only_warning_numpy():
+    # GH#50538
+    df = DataFrame({"a": [1, 1, 2], "b": list("xyz"), "c": [3, 4, 5]})
+    gb = df.groupby("a")
+    msg = "The operation <function mean.*failed"
+    # Warning is raised from within NumPy
+    with tm.assert_produces_warning(FutureWarning, match=msg, check_stacklevel=False):
+        gb.apply(np.mean)
+    # Ensure users can't pass numeric_only
+    with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+        gb.apply(np.mean, numeric_only=True)
diff --git a/pandas/tests/groupby/test_apply_mutate.py b/pandas/tests/groupby/test_apply_mutate.py
index 05c1f5b716f40..d1f25aabe31a2 100644
--- a/pandas/tests/groupby/test_apply_mutate.py
+++ b/pandas/tests/groupby/test_apply_mutate.py
@@ -4,6 +4,22 @@
 import pandas._testing as tm
 
 
+def test_group_by_copy():
+    # GH#44803
+    df = pd.DataFrame(
+        {
+            "name": ["Alice", "Bob", "Carl"],
+            "age": [20, 21, 20],
+        }
+    ).set_index("name")
+
+    grp_by_same_value = df.groupby(["age"], group_keys=False).apply(lambda group: group)
+    grp_by_copy = df.groupby(["age"], group_keys=False).apply(
+        lambda group: group.copy()
+    )
+    tm.assert_frame_equal(grp_by_same_value, grp_by_copy)
+
+
 def test_mutate_groups():
 
     # GH3380
@@ -56,7 +72,7 @@ def test_apply_function_with_indexing():
     )
 
     def fn(x):
-        x.col2[x.index[-1]] = 0
+        x.loc[x.index[-1], "col2"] = 0
         return x.col2
 
     result = df.groupby(["col1"], as_index=False).apply(fn)
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 3d5016b058c07..e99d1325a7e4f 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -14,6 +14,7 @@
     qcut,
 )
 import pandas._testing as tm
+from pandas.tests.groupby import get_groupby_method_args
 
 
 def cartesian_product_for_groupers(result, args, names, fill_value=np.NaN):
@@ -103,7 +104,9 @@ def test_basic():  # TODO: split this test
     gb = df.groupby("A", observed=False)
     exp_idx = CategoricalIndex(["a", "b", "z"], name="A", ordered=True)
     expected = DataFrame({"values": Series([3, 7, 0], index=exp_idx)})
-    result = gb.sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = gb.sum()
     tm.assert_frame_equal(result, expected)
 
     # GH 8623
@@ -271,7 +274,7 @@ def test_sorting_with_different_categoricals():
     index = ["low", "med", "high", "low", "med", "high"]
     index = Categorical(index, categories=["low", "med", "high"], ordered=True)
     index = [["A", "A", "A", "B", "B", "B"], CategoricalIndex(index)]
-    index = MultiIndex.from_arrays(index, names=["group", None])
+    index = MultiIndex.from_arrays(index, names=["group", "dose"])
     expected = Series([2] * 6, index=index, name="dose")
     tm.assert_series_equal(result, expected)
 
@@ -314,6 +317,7 @@ def test_apply(ordered):
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.filterwarnings("ignore:.*value of numeric_only.*:FutureWarning")
 def test_observed(observed):
     # multiple groupers, don't re-expand the output space
     # of the grouper
@@ -807,8 +811,12 @@ def test_preserve_categorical_dtype():
         }
     )
     for col in ["C1", "C2"]:
-        result1 = df.groupby(by=col, as_index=False, observed=False).mean()
-        result2 = df.groupby(by=col, as_index=True, observed=False).mean().reset_index()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result1 = df.groupby(by=col, as_index=False, observed=False).mean()
+            result2 = (
+                df.groupby(by=col, as_index=True, observed=False).mean().reset_index()
+            )
         expected = exp_full.reindex(columns=result1.columns)
         tm.assert_frame_equal(result1, expected)
         tm.assert_frame_equal(result2, expected)
@@ -1357,6 +1365,7 @@ def test_series_groupby_on_2_categoricals_unobserved(reduction_func, observed, r
             reason="TODO: implemented SeriesGroupBy.corrwith. See GH 32293"
         )
         request.node.add_marker(mark)
+    warn = FutureWarning if reduction_func == "mad" else None
 
     df = DataFrame(
         {
@@ -1365,13 +1374,14 @@ def test_series_groupby_on_2_categoricals_unobserved(reduction_func, observed, r
             "value": [0.1] * 4,
         }
     )
-    args = {"nth": [0]}.get(reduction_func, [])
+    args = get_groupby_method_args(reduction_func, df)
 
     expected_length = 4 if observed else 16
 
     series_groupby = df.groupby(["cat_1", "cat_2"], observed=observed)["value"]
     agg = getattr(series_groupby, reduction_func)
-    result = agg(*args)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = agg(*args)
 
     assert len(result) == expected_length
 
@@ -1390,6 +1400,7 @@ def test_series_groupby_on_2_categoricals_unobserved_zeroes_or_nans(
             reason="TODO: implemented SeriesGroupBy.corrwith. See GH 32293"
         )
         request.node.add_marker(mark)
+    warn = FutureWarning if reduction_func == "mad" else None
 
     df = DataFrame(
         {
@@ -1399,11 +1410,12 @@ def test_series_groupby_on_2_categoricals_unobserved_zeroes_or_nans(
         }
     )
     unobserved = [tuple("AC"), tuple("BC"), tuple("CA"), tuple("CB"), tuple("CC")]
-    args = {"nth": [0]}.get(reduction_func, [])
+    args = get_groupby_method_args(reduction_func, df)
 
     series_groupby = df.groupby(["cat_1", "cat_2"], observed=False)["value"]
     agg = getattr(series_groupby, reduction_func)
-    result = agg(*args)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = agg(*args)
 
     zero_or_nan = _results_for_groupbys_with_missing_categories[reduction_func]
 
@@ -1426,6 +1438,7 @@ def test_dataframe_groupby_on_2_categoricals_when_observed_is_true(reduction_fun
     # does not return the categories that are not in df when observed=True
     if reduction_func == "ngroup":
         pytest.skip("ngroup does not return the Categories on the index")
+    warn = FutureWarning if reduction_func == "mad" else None
 
     df = DataFrame(
         {
@@ -1438,8 +1451,9 @@ def test_dataframe_groupby_on_2_categoricals_when_observed_is_true(reduction_fun
 
     df_grp = df.groupby(["cat_1", "cat_2"], observed=True)
 
-    args = {"nth": [0], "corrwith": [df]}.get(reduction_func, [])
-    res = getattr(df_grp, reduction_func)(*args)
+    args = get_groupby_method_args(reduction_func, df)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        res = getattr(df_grp, reduction_func)(*args)
 
     for cat in unobserved_cats:
         assert cat not in res.index
@@ -1447,7 +1461,7 @@ def test_dataframe_groupby_on_2_categoricals_when_observed_is_true(reduction_fun
 
 @pytest.mark.parametrize("observed", [False, None])
 def test_dataframe_groupby_on_2_categoricals_when_observed_is_false(
-    reduction_func, observed, request
+    reduction_func, observed
 ):
     # GH 23865
     # GH 27075
@@ -1456,6 +1470,7 @@ def test_dataframe_groupby_on_2_categoricals_when_observed_is_false(
 
     if reduction_func == "ngroup":
         pytest.skip("ngroup does not return the Categories on the index")
+    warn = FutureWarning if reduction_func == "mad" else None
 
     df = DataFrame(
         {
@@ -1468,8 +1483,9 @@ def test_dataframe_groupby_on_2_categoricals_when_observed_is_false(
 
     df_grp = df.groupby(["cat_1", "cat_2"], observed=observed)
 
-    args = {"nth": [0], "corrwith": [df]}.get(reduction_func, [])
-    res = getattr(df_grp, reduction_func)(*args)
+    args = get_groupby_method_args(reduction_func, df)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        res = getattr(df_grp, reduction_func)(*args)
 
     expected = _results_for_groupbys_with_missing_categories[reduction_func]
 
@@ -1524,7 +1540,7 @@ def test_groupby_agg_non_numeric():
 
 
 @pytest.mark.parametrize("func", ["first", "last"])
-def test_groupy_first_returned_categorical_instead_of_dataframe(func):
+def test_groupby_first_returned_categorical_instead_of_dataframe(func):
     # GH 28641: groupby drops index, when grouping over categorical column with
     # first/last. Renamed Categorical instead of DataFrame previously.
     df = DataFrame({"A": [1997], "B": Series(["b"], dtype="category").cat.as_ordered()})
@@ -1794,3 +1810,38 @@ def test_groupby_categorical_observed_nunique():
         name="c",
     )
     tm.assert_series_equal(result, expected)
+
+
+def test_groupby_categorical_aggregate_functions():
+    # GH#37275
+    dtype = pd.CategoricalDtype(categories=["small", "big"], ordered=True)
+    df = DataFrame(
+        [[1, "small"], [1, "big"], [2, "small"]], columns=["grp", "description"]
+    ).astype({"description": dtype})
+
+    result = df.groupby("grp")["description"].max()
+    expected = Series(
+        ["big", "small"],
+        index=Index([1, 2], name="grp"),
+        name="description",
+        dtype=pd.CategoricalDtype(categories=["small", "big"], ordered=True),
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_groupby_categorical_dropna(observed, dropna):
+    # GH#48645 - dropna should have no impact on the result when there are no NA values
+    cat = Categorical([1, 2], categories=[1, 2, 3])
+    df = DataFrame({"x": Categorical([1, 2], categories=[1, 2, 3]), "y": [3, 4]})
+    gb = df.groupby("x", observed=observed, dropna=dropna)
+    result = gb.sum()
+
+    if observed:
+        expected = DataFrame({"y": [3, 4]}, index=cat)
+    else:
+        index = CategoricalIndex([1, 2, 3], [1, 2, 3])
+        expected = DataFrame({"y": [3, 4, 0]}, index=index)
+    expected.index.name = "x"
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 73b2d8ac2c1f5..7e7f1a628da6e 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -188,21 +188,20 @@ def test_ngroup_cumcount_pair(self):
             tm.assert_series_equal(g.ngroup(), Series(ngroupd))
             tm.assert_series_equal(g.cumcount(), Series(cumcounted))
 
-    def test_ngroup_respects_groupby_order(self):
+    def test_ngroup_respects_groupby_order(self, sort):
         np.random.seed(0)
         df = DataFrame({"a": np.random.choice(list("abcdef"), 100)})
-        for sort_flag in (False, True):
-            g = df.groupby(["a"], sort=sort_flag)
-            df["group_id"] = -1
-            df["group_index"] = -1
+        g = df.groupby("a", sort=sort)
+        df["group_id"] = -1
+        df["group_index"] = -1
 
-            for i, (_, group) in enumerate(g):
-                df.loc[group.index, "group_id"] = i
-                for j, ind in enumerate(group.index):
-                    df.loc[ind, "group_index"] = j
+        for i, (_, group) in enumerate(g):
+            df.loc[group.index, "group_id"] = i
+            for j, ind in enumerate(group.index):
+                df.loc[ind, "group_index"] = j
 
-            tm.assert_series_equal(Series(df["group_id"].values), g.ngroup())
-            tm.assert_series_equal(Series(df["group_index"].values), g.cumcount())
+        tm.assert_series_equal(Series(df["group_id"].values), g.ngroup())
+        tm.assert_series_equal(Series(df["group_index"].values), g.cumcount())
 
     @pytest.mark.parametrize(
         "datetimelike",
@@ -364,7 +363,7 @@ class RaisingObjectException(Exception):
         pass
 
     class RaisingObject:
-        def __init__(self, msg="I will raise inside Cython"):
+        def __init__(self, msg="I will raise inside Cython") -> None:
             super().__init__()
             self.msg = msg
 
diff --git a/pandas/tests/groupby/test_frame_value_counts.py b/pandas/tests/groupby/test_frame_value_counts.py
index 79ef46db8e95e..8255fbab40dce 100644
--- a/pandas/tests/groupby/test_frame_value_counts.py
+++ b/pandas/tests/groupby/test_frame_value_counts.py
@@ -309,34 +309,244 @@ def test_data_frame_value_counts_dropna(
 
 
 @pytest.mark.parametrize("as_index", [False, True])
+@pytest.mark.parametrize("observed", [False, True])
+@pytest.mark.parametrize(
+    "normalize, expected_data",
+    [
+        (False, np.array([2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0], dtype=np.int64)),
+        (
+            True,
+            np.array([0.5, 0.25, 0.25, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0]),
+        ),
+    ],
+)
+def test_categorical_single_grouper_with_only_observed_categories(
+    education_df, as_index, observed, normalize, expected_data
+):
+
+    # Test single categorical grouper with only observed grouping categories
+    # when non-groupers are also categorical
+
+    gp = education_df.astype("category").groupby(
+        "country", as_index=as_index, observed=observed
+    )
+    result = gp.value_counts(normalize=normalize)
+
+    expected_index = MultiIndex.from_tuples(
+        [
+            ("FR", "male", "low"),
+            ("FR", "female", "high"),
+            ("FR", "male", "medium"),
+            ("FR", "female", "low"),
+            ("FR", "female", "medium"),
+            ("FR", "male", "high"),
+            ("US", "female", "high"),
+            ("US", "male", "low"),
+            ("US", "female", "low"),
+            ("US", "female", "medium"),
+            ("US", "male", "high"),
+            ("US", "male", "medium"),
+        ],
+        names=["country", "gender", "education"],
+    )
+
+    expected_series = Series(
+        data=expected_data,
+        index=expected_index,
+    )
+    for i in range(3):
+        expected_series.index = expected_series.index.set_levels(
+            CategoricalIndex(expected_series.index.levels[i]), level=i
+        )
+
+    if as_index:
+        tm.assert_series_equal(result, expected_series)
+    else:
+        expected = expected_series.reset_index(
+            name="proportion" if normalize else "count"
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+def assert_categorical_single_grouper(
+    education_df, as_index, observed, expected_index, normalize, expected_data
+):
+    # Test single categorical grouper when non-groupers are also categorical
+    education_df = education_df.copy().astype("category")
+
+    # Add non-observed grouping categories
+    education_df["country"] = education_df["country"].cat.add_categories(["ASIA"])
+
+    gp = education_df.groupby("country", as_index=as_index, observed=observed)
+    result = gp.value_counts(normalize=normalize)
+
+    expected_series = Series(
+        data=expected_data,
+        index=MultiIndex.from_tuples(
+            expected_index,
+            names=["country", "gender", "education"],
+        ),
+    )
+    for i in range(3):
+        index_level = CategoricalIndex(expected_series.index.levels[i])
+        if i == 0:
+            index_level = index_level.set_categories(
+                education_df["country"].cat.categories
+            )
+        expected_series.index = expected_series.index.set_levels(index_level, level=i)
+
+    if as_index:
+        tm.assert_series_equal(result, expected_series)
+    else:
+        expected = expected_series.reset_index(
+            name="proportion" if normalize else "count"
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("as_index", [True, False])
+@pytest.mark.parametrize(
+    "normalize, expected_data",
+    [
+        (False, np.array([2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0], dtype=np.int64)),
+        (
+            True,
+            np.array([0.5, 0.25, 0.25, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0]),
+        ),
+    ],
+)
+def test_categorical_single_grouper_observed_true(
+    education_df, as_index, normalize, expected_data
+):
+    # GH#46357
+
+    expected_index = [
+        ("FR", "male", "low"),
+        ("FR", "female", "high"),
+        ("FR", "male", "medium"),
+        ("FR", "female", "low"),
+        ("FR", "female", "medium"),
+        ("FR", "male", "high"),
+        ("US", "female", "high"),
+        ("US", "male", "low"),
+        ("US", "female", "low"),
+        ("US", "female", "medium"),
+        ("US", "male", "high"),
+        ("US", "male", "medium"),
+    ]
+
+    assert_categorical_single_grouper(
+        education_df=education_df,
+        as_index=as_index,
+        observed=True,
+        expected_index=expected_index,
+        normalize=normalize,
+        expected_data=expected_data,
+    )
+
+
+@pytest.mark.parametrize("as_index", [True, False])
+@pytest.mark.parametrize(
+    "normalize, expected_data",
+    [
+        (
+            False,
+            np.array(
+                [2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.int64
+            ),
+        ),
+        (
+            True,
+            np.array(
+                [
+                    0.5,
+                    0.25,
+                    0.25,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.5,
+                    0.5,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                ]
+            ),
+        ),
+    ],
+)
+def test_categorical_single_grouper_observed_false(
+    education_df, as_index, normalize, expected_data
+):
+    # GH#46357
+
+    expected_index = [
+        ("FR", "male", "low"),
+        ("FR", "female", "high"),
+        ("FR", "male", "medium"),
+        ("FR", "female", "low"),
+        ("FR", "male", "high"),
+        ("FR", "female", "medium"),
+        ("US", "female", "high"),
+        ("US", "male", "low"),
+        ("US", "male", "medium"),
+        ("US", "male", "high"),
+        ("US", "female", "medium"),
+        ("US", "female", "low"),
+        ("ASIA", "male", "low"),
+        ("ASIA", "male", "high"),
+        ("ASIA", "female", "medium"),
+        ("ASIA", "female", "low"),
+        ("ASIA", "female", "high"),
+        ("ASIA", "male", "medium"),
+    ]
+
+    assert_categorical_single_grouper(
+        education_df=education_df,
+        as_index=as_index,
+        observed=False,
+        expected_index=expected_index,
+        normalize=normalize,
+        expected_data=expected_data,
+    )
+
+
+@pytest.mark.parametrize("as_index", [True, False])
 @pytest.mark.parametrize(
     "observed, expected_index",
     [
         (
             False,
             [
-                ("FR", "male", "low"),
-                ("FR", "female", "high"),
-                ("FR", "male", "medium"),
-                ("FR", "female", "low"),
-                ("FR", "female", "medium"),
-                ("FR", "male", "high"),
-                ("US", "female", "high"),
-                ("US", "male", "low"),
-                ("US", "female", "low"),
-                ("US", "female", "medium"),
-                ("US", "male", "high"),
-                ("US", "male", "medium"),
+                ("FR", "high", "female"),
+                ("FR", "high", "male"),
+                ("FR", "low", "male"),
+                ("FR", "low", "female"),
+                ("FR", "medium", "male"),
+                ("FR", "medium", "female"),
+                ("US", "high", "female"),
+                ("US", "high", "male"),
+                ("US", "low", "male"),
+                ("US", "low", "female"),
+                ("US", "medium", "female"),
+                ("US", "medium", "male"),
             ],
         ),
         (
             True,
             [
-                ("FR", "male", "low"),
-                ("FR", "female", "high"),
-                ("FR", "male", "medium"),
-                ("US", "female", "high"),
-                ("US", "male", "low"),
+                ("FR", "high", "female"),
+                ("FR", "low", "male"),
+                ("FR", "medium", "male"),
+                ("US", "high", "female"),
+                ("US", "low", "male"),
             ],
         ),
     ],
@@ -344,30 +554,97 @@ def test_data_frame_value_counts_dropna(
 @pytest.mark.parametrize(
     "normalize, expected_data",
     [
-        (False, np.array([2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0], dtype=np.int64)),
+        (False, np.array([1, 0, 2, 0, 1, 0, 1, 0, 1, 0, 0, 0], dtype=np.int64)),
         (
             True,
-            np.array([0.5, 0.25, 0.25, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0]),
+            # NaN values corresponds to non-observed groups
+            np.array([1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]),
         ),
     ],
 )
-def test_categorical(
+def test_categorical_multiple_groupers(
     education_df, as_index, observed, expected_index, normalize, expected_data
 ):
-    # Test categorical data whether or not observed
-    gp = education_df.astype("category").groupby(
-        "country", as_index=as_index, observed=observed
+    # GH#46357
+
+    # Test multiple categorical groupers when non-groupers are non-categorical
+    education_df = education_df.copy()
+    education_df["country"] = education_df["country"].astype("category")
+    education_df["education"] = education_df["education"].astype("category")
+
+    gp = education_df.groupby(
+        ["country", "education"], as_index=as_index, observed=observed
     )
     result = gp.value_counts(normalize=normalize)
 
     expected_series = Series(
         data=expected_data[expected_data > 0.0] if observed else expected_data,
+        index=MultiIndex.from_tuples(
+            expected_index,
+            names=["country", "education", "gender"],
+        ),
+    )
+    for i in range(2):
+        expected_series.index = expected_series.index.set_levels(
+            CategoricalIndex(expected_series.index.levels[i]), level=i
+        )
+
+    if as_index:
+        tm.assert_series_equal(result, expected_series)
+    else:
+        expected = expected_series.reset_index(
+            name="proportion" if normalize else "count"
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("as_index", [False, True])
+@pytest.mark.parametrize("observed", [False, True])
+@pytest.mark.parametrize(
+    "normalize, expected_data",
+    [
+        (False, np.array([2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0], dtype=np.int64)),
+        (
+            True,
+            # NaN values corresponds to non-observed groups
+            np.array([0.5, 0.25, 0.25, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0]),
+        ),
+    ],
+)
+def test_categorical_non_groupers(
+    education_df, as_index, observed, normalize, expected_data
+):
+    # GH#46357 Test non-observed categories are included in the result,
+    # regardless of `observed`
+    education_df = education_df.copy()
+    education_df["gender"] = education_df["gender"].astype("category")
+    education_df["education"] = education_df["education"].astype("category")
+
+    gp = education_df.groupby("country", as_index=as_index, observed=observed)
+    result = gp.value_counts(normalize=normalize)
+
+    expected_index = [
+        ("FR", "male", "low"),
+        ("FR", "female", "high"),
+        ("FR", "male", "medium"),
+        ("FR", "female", "low"),
+        ("FR", "female", "medium"),
+        ("FR", "male", "high"),
+        ("US", "female", "high"),
+        ("US", "male", "low"),
+        ("US", "female", "low"),
+        ("US", "female", "medium"),
+        ("US", "male", "high"),
+        ("US", "male", "medium"),
+    ]
+    expected_series = Series(
+        data=expected_data,
         index=MultiIndex.from_tuples(
             expected_index,
             names=["country", "gender", "education"],
         ),
     )
-    for i in range(3):
+    for i in range(1, 3):
         expected_series.index = expected_series.index.set_levels(
             CategoricalIndex(expected_series.index.levels[i]), level=i
         )
@@ -406,33 +683,52 @@ def test_mixed_groupings(normalize, expected_label, expected_values):
 
 
 @pytest.mark.parametrize(
-    "test, expected_names",
+    "test, columns, expected_names",
     [
-        ("repeat", ["a", None, "d", "b", "b", "e"]),
-        ("level", ["a", None, "d", "b", "c", "level_1"]),
+        ("repeat", list("abbde"), ["a", None, "d", "b", "b", "e"]),
+        ("level", list("abcd") + ["level_1"], ["a", None, "d", "b", "c", "level_1"]),
     ],
 )
 @pytest.mark.parametrize("as_index", [False, True])
-def test_column_name_clashes(test, expected_names, as_index):
-    df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6], "d": [7, 8], "e": [9, 10]})
-    if test == "repeat":
-        df.columns = list("abbde")
-    else:
-        df.columns = list("abcd") + ["level_1"]
-
+def test_column_label_duplicates(test, columns, expected_names, as_index):
+    # GH 44992
+    # Test for duplicate input column labels and generated duplicate labels
+    df = DataFrame([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]], columns=columns)
+    expected_data = [(1, 0, 7, 3, 5, 9), (2, 1, 8, 4, 6, 10)]
+    result = df.groupby(["a", [0, 1], "d"], as_index=as_index).value_counts()
     if as_index:
-        result = df.groupby(["a", [0, 1], "d"], as_index=as_index).value_counts()
         expected = Series(
             data=(1, 1),
             index=MultiIndex.from_tuples(
-                [(1, 0, 7, 3, 5, 9), (2, 1, 8, 4, 6, 10)],
+                expected_data,
                 names=expected_names,
             ),
         )
         tm.assert_series_equal(result, expected)
     else:
-        with pytest.raises(ValueError, match="cannot insert"):
-            df.groupby(["a", [0, 1], "d"], as_index=as_index).value_counts()
+        expected_data = [list(row) + [1] for row in expected_data]
+        expected_columns = list(expected_names)
+        expected_columns[1] = "level_1"
+        expected_columns.append("count")
+        expected = DataFrame(expected_data, columns=expected_columns)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "normalize, expected_label",
+    [
+        (False, "count"),
+        (True, "proportion"),
+    ],
+)
+def test_result_label_duplicates(normalize, expected_label):
+    # Test for result column label duplicating an input column label
+    gb = DataFrame([[1, 2, 3]], columns=["a", "b", expected_label]).groupby(
+        "a", as_index=False
+    )
+    msg = f"Column label '{expected_label}' is duplicate of result column"
+    with pytest.raises(ValueError, match=msg):
+        gb.value_counts(normalize=normalize)
 
 
 def test_ambiguous_grouping():
@@ -442,3 +738,46 @@ def test_ambiguous_grouping():
     result = gb.value_counts()
     expected = Series([2], index=MultiIndex.from_tuples([[1, 1]], names=[None, "a"]))
     tm.assert_series_equal(result, expected)
+
+
+def test_subset_overlaps_gb_key_raises():
+    # GH 46383
+    df = DataFrame({"c1": ["a", "b", "c"], "c2": ["x", "y", "y"]}, index=[0, 1, 1])
+    msg = "Keys {'c1'} in subset cannot be in the groupby column keys."
+    with pytest.raises(ValueError, match=msg):
+        df.groupby("c1").value_counts(subset=["c1"])
+
+
+def test_subset_doesnt_exist_in_frame():
+    # GH 46383
+    df = DataFrame({"c1": ["a", "b", "c"], "c2": ["x", "y", "y"]}, index=[0, 1, 1])
+    msg = "Keys {'c3'} in subset do not exist in the DataFrame."
+    with pytest.raises(ValueError, match=msg):
+        df.groupby("c1").value_counts(subset=["c3"])
+
+
+def test_subset():
+    # GH 46383
+    df = DataFrame({"c1": ["a", "b", "c"], "c2": ["x", "y", "y"]}, index=[0, 1, 1])
+    result = df.groupby(level=0).value_counts(subset=["c2"])
+    expected = Series(
+        [1, 2], index=MultiIndex.from_arrays([[0, 1], ["x", "y"]], names=[None, "c2"])
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_subset_duplicate_columns():
+    # GH 46383
+    df = DataFrame(
+        [["a", "x", "x"], ["b", "y", "y"], ["b", "y", "y"]],
+        index=[0, 1, 1],
+        columns=["c1", "c2", "c2"],
+    )
+    result = df.groupby(level=0).value_counts(subset=["c2"])
+    expected = Series(
+        [1, 2],
+        index=MultiIndex.from_arrays(
+            [[0, 1], ["x", "y"], ["x", "y"]], names=[None, "c2", "c2"]
+        ),
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py
index dbc38497d3bee..d813a2848a5dc 100644
--- a/pandas/tests/groupby/test_function.py
+++ b/pandas/tests/groupby/test_function.py
@@ -4,6 +4,7 @@
 import numpy as np
 import pytest
 
+from pandas._libs import lib
 from pandas.errors import UnsupportedFunctionCall
 
 import pandas as pd
@@ -17,6 +18,7 @@
 )
 import pandas._testing as tm
 import pandas.core.nanops as nanops
+from pandas.tests.groupby import get_groupby_method_args
 from pandas.util import _test_decorators as td
 
 
@@ -259,7 +261,9 @@ def _check(self, df, method, expected_columns, expected_columns_numeric):
             # these have numeric_only kwarg, but default to False
             warn = FutureWarning
 
-        with tm.assert_produces_warning(warn, match="Dropping invalid columns"):
+        with tm.assert_produces_warning(
+            warn, match="Dropping invalid columns", raise_on_extra_warnings=False
+        ):
             result = getattr(gb, method)()
 
         tm.assert_index_equal(result.columns, expected_columns_numeric)
@@ -297,35 +301,43 @@ def gni(self, df):
         return gni
 
     # TODO: non-unique columns, as_index=False
-    @pytest.mark.filterwarnings("ignore:.*Select only valid:FutureWarning")
     def test_idxmax(self, gb):
         # object dtype so idxmax goes through _aggregate_item_by_item
         # GH#5610
         # non-cython calls should not include the grouper
         expected = DataFrame([[0.0], [np.nan]], columns=["B"], index=[1, 3])
         expected.index.name = "A"
-        result = gb.idxmax()
+        msg = "The default value of numeric_only in DataFrameGroupBy.idxmax"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = gb.idxmax()
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.filterwarnings("ignore:.*Select only valid:FutureWarning")
     def test_idxmin(self, gb):
         # object dtype so idxmax goes through _aggregate_item_by_item
         # GH#5610
         # non-cython calls should not include the grouper
         expected = DataFrame([[0.0], [np.nan]], columns=["B"], index=[1, 3])
         expected.index.name = "A"
-        result = gb.idxmin()
+        msg = "The default value of numeric_only in DataFrameGroupBy.idxmin"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = gb.idxmin()
         tm.assert_frame_equal(result, expected)
 
     def test_mad(self, gb, gni):
         # mad
         expected = DataFrame([[0], [np.nan]], columns=["B"], index=[1, 3])
         expected.index.name = "A"
-        result = gb.mad()
+        with tm.assert_produces_warning(
+            FutureWarning, match="The 'mad' method is deprecated"
+        ):
+            result = gb.mad()
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame([[1, 0.0], [3, np.nan]], columns=["A", "B"], index=[0, 1])
-        result = gni.mad()
+        with tm.assert_produces_warning(
+            FutureWarning, match="The 'mad' method is deprecated"
+        ):
+            result = gni.mad()
         tm.assert_frame_equal(result, expected)
 
     def test_describe(self, df, gb, gni):
@@ -489,8 +501,9 @@ def test_groupby_non_arithmetic_agg_int_like_precision(i):
         ("idxmax", {"c_int": [1, 3], "c_float": [0, 2], "c_date": [0, 3]}),
     ],
 )
+@pytest.mark.parametrize("numeric_only", [True, False])
 @pytest.mark.filterwarnings("ignore:.*Select only valid:FutureWarning")
-def test_idxmin_idxmax_returns_int_types(func, values):
+def test_idxmin_idxmax_returns_int_types(func, values, numeric_only):
     # GH 25444
     df = DataFrame(
         {
@@ -507,12 +520,15 @@ def test_idxmin_idxmax_returns_int_types(func, values):
     df["c_Integer"] = df["c_int"].astype("Int64")
     df["c_Floating"] = df["c_float"].astype("Float64")
 
-    result = getattr(df.groupby("name"), func)()
+    result = getattr(df.groupby("name"), func)(numeric_only=numeric_only)
 
     expected = DataFrame(values, index=Index(["A", "B"], name="name"))
-    expected["c_date_tz"] = expected["c_date"]
-    expected["c_timedelta"] = expected["c_date"]
-    expected["c_period"] = expected["c_date"]
+    if numeric_only:
+        expected = expected.drop(columns=["c_date"])
+    else:
+        expected["c_date_tz"] = expected["c_date"]
+        expected["c_timedelta"] = expected["c_date"]
+        expected["c_period"] = expected["c_date"]
     expected["c_Integer"] = expected["c_int"]
     expected["c_Floating"] = expected["c_float"]
 
@@ -540,12 +556,87 @@ def test_idxmin_idxmax_axis1():
         gb2.idxmax(axis=1)
 
 
+@pytest.mark.parametrize("numeric_only", [True, False, None])
+def test_axis1_numeric_only(request, groupby_func, numeric_only):
+    if groupby_func in ("idxmax", "idxmin"):
+        pytest.skip("idxmax and idx_min tested in test_idxmin_idxmax_axis1")
+    if groupby_func in ("mad", "tshift"):
+        pytest.skip("mad and tshift are deprecated")
+    if groupby_func in ("corrwith", "skew"):
+        msg = "GH#47723 groupby.corrwith and skew do not correctly implement axis=1"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+
+    df = DataFrame(np.random.randn(10, 4), columns=["A", "B", "C", "D"])
+    df["E"] = "x"
+    groups = [1, 2, 3, 1, 2, 3, 1, 2, 3, 4]
+    gb = df.groupby(groups)
+    method = getattr(gb, groupby_func)
+    args = get_groupby_method_args(groupby_func, df)
+    kwargs = {"axis": 1}
+    if numeric_only is not None:
+        # when numeric_only is None we don't pass any argument
+        kwargs["numeric_only"] = numeric_only
+
+    # Functions without numeric_only and axis args
+    no_args = ("cumprod", "cumsum", "diff", "fillna", "pct_change", "rank", "shift")
+    # Functions with axis args
+    has_axis = (
+        "cumprod",
+        "cumsum",
+        "diff",
+        "pct_change",
+        "rank",
+        "shift",
+        "cummax",
+        "cummin",
+        "idxmin",
+        "idxmax",
+        "fillna",
+    )
+    if numeric_only is not None and groupby_func in no_args:
+        msg = "got an unexpected keyword argument 'numeric_only'"
+        with pytest.raises(TypeError, match=msg):
+            method(*args, **kwargs)
+    elif groupby_func not in has_axis:
+        msg = "got an unexpected keyword argument 'axis'"
+        warn = FutureWarning if groupby_func == "skew" and not numeric_only else None
+        with tm.assert_produces_warning(warn, match="Dropping of nuisance columns"):
+            with pytest.raises(TypeError, match=msg):
+                method(*args, **kwargs)
+    # fillna and shift are successful even on object dtypes
+    elif (numeric_only is None or not numeric_only) and groupby_func not in (
+        "fillna",
+        "shift",
+    ):
+        msgs = (
+            # cummax, cummin, rank
+            "not supported between instances of",
+            # cumprod
+            "can't multiply sequence by non-int of type 'float'",
+            # cumsum, diff, pct_change
+            "unsupported operand type",
+        )
+        with pytest.raises(TypeError, match=f"({'|'.join(msgs)})"):
+            method(*args, **kwargs)
+    else:
+        result = method(*args, **kwargs)
+
+        df_expected = df.drop(columns="E").T if numeric_only else df.T
+        expected = getattr(df_expected, groupby_func)(*args).T
+        if groupby_func == "shift" and not numeric_only:
+            # shift with axis=1 leaves the leftmost column as numeric
+            # but transposing for expected gives us object dtype
+            expected = expected.astype(float)
+
+        tm.assert_equal(result, expected)
+
+
 def test_groupby_cumprod():
     # GH 4095
     df = DataFrame({"key": ["b"] * 10, "value": 2})
 
     actual = df.groupby("key")["value"].cumprod()
-    expected = df.groupby("key")["value"].apply(lambda x: x.cumprod())
+    expected = df.groupby("key", group_keys=False)["value"].apply(lambda x: x.cumprod())
     expected.name = "value"
     tm.assert_series_equal(actual, expected)
 
@@ -554,11 +645,25 @@ def test_groupby_cumprod():
     # if overflows, groupby product casts to float
     # while numpy passes back invalid values
     df["value"] = df["value"].astype(float)
-    expected = df.groupby("key")["value"].apply(lambda x: x.cumprod())
+    expected = df.groupby("key", group_keys=False)["value"].apply(lambda x: x.cumprod())
     expected.name = "value"
     tm.assert_series_equal(actual, expected)
 
 
+def test_groupby_cumprod_nan_influences_other_columns():
+    # GH#48064
+    df = DataFrame(
+        {
+            "a": 1,
+            "b": [1, np.nan, 2],
+            "c": [1, 2, 3.0],
+        }
+    )
+    result = df.groupby("a").cumprod(numeric_only=True, skipna=False)
+    expected = DataFrame({"b": [1, np.nan, np.nan], "c": [1, 2, 6.0]})
+    tm.assert_frame_equal(result, expected)
+
+
 def scipy_sem(*args, **kwargs):
     from scipy.stats import sem
 
@@ -734,7 +839,7 @@ def test_cummin(dtypes_for_minmax):
     expected = DataFrame({"B": expected_mins}).astype(dtype)
     result = df.groupby("A").cummin()
     tm.assert_frame_equal(result, expected)
-    result = df.groupby("A").B.apply(lambda x: x.cummin()).to_frame()
+    result = df.groupby("A", group_keys=False).B.apply(lambda x: x.cummin()).to_frame()
     tm.assert_frame_equal(result, expected)
 
     # Test w/ min value for dtype
@@ -744,7 +849,9 @@ def test_cummin(dtypes_for_minmax):
     expected.loc[[1, 5], "B"] = min_val + 1  # should not be rounded to min_val
     result = df.groupby("A").cummin()
     tm.assert_frame_equal(result, expected, check_exact=True)
-    expected = df.groupby("A").B.apply(lambda x: x.cummin()).to_frame()
+    expected = (
+        df.groupby("A", group_keys=False).B.apply(lambda x: x.cummin()).to_frame()
+    )
     tm.assert_frame_equal(result, expected, check_exact=True)
 
     # Test nan in some values
@@ -752,7 +859,9 @@ def test_cummin(dtypes_for_minmax):
     expected = DataFrame({"B": [np.nan, 4, np.nan, 2, np.nan, 3, np.nan, 1]})
     result = base_df.groupby("A").cummin()
     tm.assert_frame_equal(result, expected)
-    expected = base_df.groupby("A").B.apply(lambda x: x.cummin()).to_frame()
+    expected = (
+        base_df.groupby("A", group_keys=False).B.apply(lambda x: x.cummin()).to_frame()
+    )
     tm.assert_frame_equal(result, expected)
 
     # GH 15561
@@ -797,7 +906,7 @@ def test_cummax(dtypes_for_minmax):
     expected = DataFrame({"B": expected_maxs}).astype(dtype)
     result = df.groupby("A").cummax()
     tm.assert_frame_equal(result, expected)
-    result = df.groupby("A").B.apply(lambda x: x.cummax()).to_frame()
+    result = df.groupby("A", group_keys=False).B.apply(lambda x: x.cummax()).to_frame()
     tm.assert_frame_equal(result, expected)
 
     # Test w/ max value for dtype
@@ -805,7 +914,9 @@ def test_cummax(dtypes_for_minmax):
     expected.loc[[2, 3, 6, 7], "B"] = max_val
     result = df.groupby("A").cummax()
     tm.assert_frame_equal(result, expected)
-    expected = df.groupby("A").B.apply(lambda x: x.cummax()).to_frame()
+    expected = (
+        df.groupby("A", group_keys=False).B.apply(lambda x: x.cummax()).to_frame()
+    )
     tm.assert_frame_equal(result, expected)
 
     # Test nan in some values
@@ -813,7 +924,9 @@ def test_cummax(dtypes_for_minmax):
     expected = DataFrame({"B": [np.nan, 4, np.nan, 4, np.nan, 3, np.nan, 3]})
     result = base_df.groupby("A").cummax()
     tm.assert_frame_equal(result, expected)
-    expected = base_df.groupby("A").B.apply(lambda x: x.cummax()).to_frame()
+    expected = (
+        base_df.groupby("A", group_keys=False).B.apply(lambda x: x.cummax()).to_frame()
+    )
     tm.assert_frame_equal(result, expected)
 
     # GH 15561
@@ -830,6 +943,18 @@ def test_cummax(dtypes_for_minmax):
     tm.assert_series_equal(result, expected)
 
 
+def test_cummax_i8_at_implementation_bound():
+    # the minimum value used to be treated as NPY_NAT+1 instead of NPY_NAT
+    #  for int64 dtype GH#46382
+    ser = Series([pd.NaT.value + n for n in range(5)])
+    df = DataFrame({"A": 1, "B": ser, "C": ser.view("M8[ns]")})
+    gb = df.groupby("A")
+
+    res = gb.cummax()
+    exp = df[["B", "C"]]
+    tm.assert_frame_equal(res, exp)
+
+
 @pytest.mark.parametrize("method", ["cummin", "cummax"])
 @pytest.mark.parametrize("dtype", ["float", "Int64", "Float64"])
 @pytest.mark.parametrize(
@@ -843,11 +968,15 @@ def test_cummax(dtypes_for_minmax):
 def test_cummin_max_skipna(method, dtype, groups, expected_data):
     # GH-34047
     df = DataFrame({"a": Series([1, None, 2], dtype=dtype)})
+    orig = df.copy()
     gb = df.groupby(groups)["a"]
 
     result = getattr(gb, method)(skipna=False)
     expected = Series(expected_data, dtype=dtype, name="a")
 
+    # check we didn't accidentally alter df
+    tm.assert_frame_equal(df, orig)
+
     tm.assert_series_equal(result, expected)
 
 
@@ -866,7 +995,7 @@ def test_cummin_max_skipna_multiple_cols(method):
 @td.skip_if_32bit
 @pytest.mark.parametrize("method", ["cummin", "cummax"])
 @pytest.mark.parametrize(
-    "dtype,val", [("UInt64", np.iinfo("uint64").max), ("Int64", 2 ** 53 + 1)]
+    "dtype,val", [("UInt64", np.iinfo("uint64").max), ("Int64", 2**53 + 1)]
 )
 def test_nullable_int_not_cast_as_float(method, dtype, val):
     data = [val, pd.NA]
@@ -999,6 +1128,11 @@ def test_frame_describe_multikey(tsframe):
     groupedT = tsframe.groupby({"A": 0, "B": 0, "C": 1, "D": 1}, axis=1)
     result = groupedT.describe()
     expected = tsframe.describe().T
+    # reverting the change from https://github.com/pandas-dev/pandas/pull/35441/
+    expected.index = MultiIndex(
+        levels=[[0, 1], expected.index],
+        codes=[[0, 0, 1, 1], range(len(expected.index))],
+    )
     tm.assert_frame_equal(result, expected)
 
 
@@ -1199,3 +1333,271 @@ def test_groupby_sum_timedelta_with_nat():
     res = gb["b"].sum(min_count=2)
     expected = Series([td3, pd.NaT], dtype="m8[ns]", name="b", index=expected.index)
     tm.assert_series_equal(res, expected)
+
+
+@pytest.mark.parametrize(
+    "kernel, numeric_only_default, drops_nuisance, has_arg",
+    [
+        ("all", False, False, False),
+        ("any", False, False, False),
+        ("bfill", False, False, False),
+        ("corr", True, False, True),
+        ("corrwith", True, False, True),
+        ("cov", True, False, True),
+        ("cummax", False, True, True),
+        ("cummin", False, True, True),
+        ("cumprod", True, True, True),
+        ("cumsum", True, True, True),
+        ("diff", False, False, False),
+        ("ffill", False, False, False),
+        ("fillna", False, False, False),
+        ("first", False, False, True),
+        ("idxmax", True, False, True),
+        ("idxmin", True, False, True),
+        ("last", False, False, True),
+        ("max", False, True, True),
+        ("mean", True, True, True),
+        ("median", True, True, True),
+        ("min", False, True, True),
+        ("nth", False, False, False),
+        ("nunique", False, False, False),
+        ("pct_change", False, False, False),
+        ("prod", True, True, True),
+        ("quantile", True, False, True),
+        ("sem", True, True, True),
+        ("skew", True, False, True),
+        ("std", True, True, True),
+        ("sum", True, True, True),
+        ("var", True, False, True),
+    ],
+)
+@pytest.mark.parametrize("numeric_only", [True, False, lib.no_default])
+@pytest.mark.parametrize("keys", [["a1"], ["a1", "a2"]])
+def test_deprecate_numeric_only(
+    kernel, numeric_only_default, drops_nuisance, has_arg, numeric_only, keys
+):
+    # GH#46072
+    # drops_nuisance: Whether the op drops nuisance columns even when numeric_only=False
+    # has_arg: Whether the op has a numeric_only arg
+    df = DataFrame({"a1": [1, 1], "a2": [2, 2], "a3": [5, 6], "b": 2 * [object]})
+
+    args = get_groupby_method_args(kernel, df)
+    kwargs = {} if numeric_only is lib.no_default else {"numeric_only": numeric_only}
+
+    gb = df.groupby(keys)
+    method = getattr(gb, kernel)
+    if has_arg and (
+        # Cases where b does not appear in the result
+        numeric_only is True
+        or (numeric_only is lib.no_default and numeric_only_default)
+        or drops_nuisance
+    ):
+        if numeric_only is True or (not numeric_only_default and not drops_nuisance):
+            warn = None
+        else:
+            warn = FutureWarning
+        if numeric_only is lib.no_default and numeric_only_default:
+            msg = f"The default value of numeric_only in DataFrameGroupBy.{kernel}"
+        else:
+            msg = f"Dropping invalid columns in DataFrameGroupBy.{kernel}"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = method(*args, **kwargs)
+
+        assert "b" not in result.columns
+    elif (
+        # kernels that work on any dtype and have numeric_only arg
+        kernel in ("first", "last")
+        or (
+            # kernels that work on any dtype and don't have numeric_only arg
+            kernel in ("any", "all", "bfill", "ffill", "fillna", "nth", "nunique")
+            and numeric_only is lib.no_default
+        )
+    ):
+        result = method(*args, **kwargs)
+        assert "b" in result.columns
+    elif has_arg:
+        assert numeric_only is not True
+        assert numeric_only is not lib.no_default or numeric_only_default is False
+        assert not drops_nuisance
+        # kernels that are successful on any dtype were above; this will fail
+        msg = (
+            "(not allowed for this dtype"
+            "|must be a string or a number"
+            "|cannot be performed against 'object' dtypes"
+            "|must be a string or a real number"
+            "|unsupported operand type)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            method(*args, **kwargs)
+    elif not has_arg and numeric_only is not lib.no_default:
+        with pytest.raises(
+            TypeError, match="got an unexpected keyword argument 'numeric_only'"
+        ):
+            method(*args, **kwargs)
+    else:
+        assert kernel in ("diff", "pct_change")
+        assert numeric_only is lib.no_default
+        # Doesn't have numeric_only argument and fails on nuisance columns
+        with pytest.raises(TypeError, match=r"unsupported operand type"):
+            method(*args, **kwargs)
+
+
+@pytest.mark.parametrize("dtype", [bool, int, float, object])
+def test_deprecate_numeric_only_series(dtype, groupby_func, request):
+    # GH#46560
+    if groupby_func in ("backfill", "mad", "pad", "tshift"):
+        pytest.skip("method is deprecated")
+    elif groupby_func == "corrwith":
+        msg = "corrwith is not implemented on SeriesGroupBy"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+
+    grouper = [0, 0, 1]
+
+    ser = Series([1, 0, 0], dtype=dtype)
+    gb = ser.groupby(grouper)
+    method = getattr(gb, groupby_func)
+
+    expected_ser = Series([1, 0, 0])
+    expected_gb = expected_ser.groupby(grouper)
+    expected_method = getattr(expected_gb, groupby_func)
+
+    args = get_groupby_method_args(groupby_func, ser)
+
+    fails_on_numeric_object = (
+        "corr",
+        "cov",
+        "cummax",
+        "cummin",
+        "cumprod",
+        "cumsum",
+        "idxmax",
+        "idxmin",
+        "quantile",
+    )
+    # ops that give an object result on object input
+    obj_result = (
+        "first",
+        "last",
+        "nth",
+        "bfill",
+        "ffill",
+        "shift",
+        "sum",
+        "diff",
+        "pct_change",
+    )
+
+    # Test default behavior; kernels that fail may be enabled in the future but kernels
+    # that succeed should not be allowed to fail (without deprecation, at least)
+    if groupby_func in fails_on_numeric_object and dtype is object:
+        if groupby_func in ("idxmax", "idxmin"):
+            msg = "not allowed for this dtype"
+        elif groupby_func == "quantile":
+            msg = "cannot be performed against 'object' dtypes"
+        else:
+            msg = "is not supported for object dtype"
+        with pytest.raises(TypeError, match=msg):
+            method(*args)
+    elif dtype is object:
+        result = method(*args)
+        expected = expected_method(*args)
+        if groupby_func in obj_result:
+            expected = expected.astype(object)
+        tm.assert_series_equal(result, expected)
+
+    has_numeric_only = (
+        "first",
+        "last",
+        "max",
+        "mean",
+        "median",
+        "min",
+        "prod",
+        "quantile",
+        "sem",
+        "skew",
+        "std",
+        "sum",
+        "var",
+        "cummax",
+        "cummin",
+        "cumprod",
+        "cumsum",
+    )
+    if groupby_func not in has_numeric_only:
+        msg = "got an unexpected keyword argument 'numeric_only'"
+        with pytest.raises(TypeError, match=msg):
+            method(*args, numeric_only=True)
+    elif dtype is object:
+        err_category = NotImplementedError
+        err_msg = f"{groupby_func} does not implement numeric_only"
+        if groupby_func.startswith("cum"):
+            # cum ops already exhibit future behavior
+            warn_category = None
+            warn_msg = ""
+            err_category = TypeError
+            err_msg = f"{groupby_func} is not supported for object dtype"
+        elif groupby_func == "skew":
+            warn_category = FutureWarning
+            warn_msg = "will raise a TypeError in the future"
+        else:
+            warn_category = FutureWarning
+            warn_msg = "This will raise a TypeError"
+
+        with tm.assert_produces_warning(warn_category, match=warn_msg):
+            with pytest.raises(err_category, match=err_msg):
+                method(*args, numeric_only=True)
+    else:
+        result = method(*args, numeric_only=True)
+        expected = method(*args, numeric_only=False)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, float, object])
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"percentiles": [0.10, 0.20, 0.30], "include": "all", "exclude": None},
+        {"percentiles": [0.10, 0.20, 0.30], "include": None, "exclude": ["int"]},
+        {"percentiles": [0.10, 0.20, 0.30], "include": ["int"], "exclude": None},
+    ],
+)
+def test_groupby_empty_dataset(dtype, kwargs):
+    # GH#41575
+    df = DataFrame([[1, 2, 3]], columns=["A", "B", "C"], dtype=dtype)
+    df["B"] = df["B"].astype(int)
+    df["C"] = df["C"].astype(float)
+
+    result = df.iloc[:0].groupby("A").describe(**kwargs)
+    expected = df.groupby("A").describe(**kwargs).reset_index(drop=True).iloc[:0]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.iloc[:0].groupby("A").B.describe(**kwargs)
+    expected = df.groupby("A").B.describe(**kwargs).reset_index(drop=True).iloc[:0]
+    expected.index = Index([])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_corrwith_with_1_axis():
+    # GH 47723
+    df = DataFrame({"a": [1, 1, 2], "b": [3, 7, 4]})
+    result = df.groupby("a").corrwith(df, axis=1)
+    index = Index(
+        data=[(1, 0), (1, 1), (1, 2), (2, 2), (2, 0), (2, 1)],
+        name=("a", None),
+    )
+    expected = Series([np.nan] * 6, index=index)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore:.* is deprecated:FutureWarning")
+def test_multiindex_group_all_columns_when_empty(groupby_func):
+    # GH 32464
+    df = DataFrame({"a": [], "b": [], "c": []}).set_index(["a", "b", "c"])
+    gb = df.groupby(["a", "b", "c"], group_keys=False)
+    method = getattr(gb, groupby_func)
+    args = get_groupby_method_args(groupby_func, df)
+
+    result = method(*args).index
+    expected = df.index
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index fb2b9f0632f0d..f6bbb9eda133d 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -4,8 +4,12 @@
 import numpy as np
 import pytest
 
+from pandas._libs import lib
 from pandas.compat import IS64
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    PerformanceWarning,
+    SpecificationError,
+)
 
 import pandas as pd
 from pandas import (
@@ -22,20 +26,16 @@
     to_datetime,
 )
 import pandas._testing as tm
-from pandas.core.arrays import (
-    BooleanArray,
-    FloatingArray,
-    IntegerArray,
-)
-from pandas.core.base import SpecificationError
+from pandas.core.arrays import BooleanArray
 import pandas.core.common as com
 from pandas.core.groupby.base import maybe_normalize_deprecated_kernels
+from pandas.tests.groupby import get_groupby_method_args
 
 
 def test_repr():
     # GH18203
     result = repr(Grouper(key="A", level="B"))
-    expected = "Grouper(key='A', level='B', axis=0, sort=False)"
+    expected = "Grouper(key='A', level='B', axis=0, sort=False, dropna=True)"
     assert result == expected
 
 
@@ -48,7 +48,7 @@ def test_basic(dtype):
     np.random.shuffle(index)
     data = data.reindex(index)
 
-    grouped = data.groupby(lambda x: x // 3)
+    grouped = data.groupby(lambda x: x // 3, group_keys=False)
 
     for k, v in grouped:
         assert len(v) == 3
@@ -477,14 +477,23 @@ def test_frame_groupby_columns(tsframe):
 def test_frame_set_name_single(df):
     grouped = df.groupby("A")
 
-    result = grouped.mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.mean()
     assert result.index.name == "A"
 
-    result = df.groupby("A", as_index=False).mean()
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby("A", as_index=False).mean()
     assert result.index.name != "A"
 
-    result = grouped.agg(np.mean)
+    # GH#50538
+    msg = "The operation <function mean.*failed"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.agg(np.mean)
     assert result.index.name == "A"
+    # Ensure users can't pass numeric_only
+    with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+        grouped.agg(np.mean, numeric_only=True)
 
     result = grouped.agg({"C": np.mean, "D": np.std})
     assert result.index.name == "A"
@@ -506,8 +515,10 @@ def test_multi_func(df):
     col2 = df["B"]
 
     grouped = df.groupby([col1.get, col2.get])
-    agged = grouped.mean()
-    expected = df.groupby(["A", "B"]).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        agged = grouped.mean()
+        expected = df.groupby(["A", "B"]).mean()
 
     # TODO groupby get drops names
     tm.assert_frame_equal(
@@ -641,7 +652,9 @@ def test_as_index_select_column():
     expected = Series([2, 4], name="B")
     tm.assert_series_equal(result, expected)
 
-    result = df.groupby("A", as_index=False)["B"].apply(lambda x: x.cumsum())
+    result = df.groupby("A", as_index=False, group_keys=True)["B"].apply(
+        lambda x: x.cumsum()
+    )
     expected = Series(
         [2, 6, 6], name="B", index=MultiIndex.from_tuples([(0, 0), (0, 1), (1, 2)])
     )
@@ -662,13 +675,16 @@ def test_groupby_as_index_agg(df):
 
     # single-key
 
-    result = grouped.agg(np.mean)
-    expected = grouped.mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.agg(np.mean)
+        expected = grouped.mean()
     tm.assert_frame_equal(result, expected)
 
     result2 = grouped.agg({"C": np.mean, "D": np.sum})
-    expected2 = grouped.mean()
-    expected2["D"] = grouped.sum()["D"]
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected2 = grouped.mean()
+        expected2["D"] = grouped.sum()["D"]
     tm.assert_frame_equal(result2, expected2)
 
     grouped = df.groupby("A", as_index=True)
@@ -717,14 +733,13 @@ def test_ops_not_as_index(reduction_func):
     # GH 10355, 21090
     # Using as_index=False should not modify grouped column
 
-    if reduction_func in ("corrwith",):
-        pytest.skip("Test not applicable")
-
-    if reduction_func in ("nth", "ngroup"):
-        pytest.skip("Skip until behavior is determined (GH #5755)")
+    if reduction_func in ("corrwith", "nth", "ngroup"):
+        pytest.skip(f"GH 5755: Test not applicable for {reduction_func}")
+    warn = FutureWarning if reduction_func == "mad" else None
 
     df = DataFrame(np.random.randint(0, 5, size=(100, 2)), columns=["a", "b"])
-    expected = getattr(df.groupby("a"), reduction_func)()
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        expected = getattr(df.groupby("a"), reduction_func)()
     if reduction_func == "size":
         expected = expected.rename("size")
     expected = expected.reset_index()
@@ -735,16 +750,20 @@ def test_ops_not_as_index(reduction_func):
 
     g = df.groupby("a", as_index=False)
 
-    result = getattr(g, reduction_func)()
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = getattr(g, reduction_func)()
     tm.assert_frame_equal(result, expected)
 
-    result = g.agg(reduction_func)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = g.agg(reduction_func)
     tm.assert_frame_equal(result, expected)
 
-    result = getattr(g["b"], reduction_func)()
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = getattr(g["b"], reduction_func)()
     tm.assert_frame_equal(result, expected)
 
-    result = g["b"].agg(reduction_func)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = g["b"].agg(reduction_func)
     tm.assert_frame_equal(result, expected)
 
 
@@ -752,10 +771,16 @@ def test_as_index_series_return_frame(df):
     grouped = df.groupby("A", as_index=False)
     grouped2 = df.groupby(["A", "B"], as_index=False)
 
-    result = grouped["C"].agg(np.sum)
-    expected = grouped.agg(np.sum).loc[:, ["A", "C"]]
+    # GH#50538
+    msg = "The operation <function sum.*failed"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped["C"].agg(np.sum)
+        expected = grouped.agg(np.sum).loc[:, ["A", "C"]]
     assert isinstance(result, DataFrame)
     tm.assert_frame_equal(result, expected)
+    # Ensure users can't pass numeric_only
+    with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+        grouped.agg(np.mean, numeric_only=True)
 
     result2 = grouped2["C"].agg(np.sum)
     expected2 = grouped2.agg(np.sum).loc[:, ["A", "B", "C"]]
@@ -763,7 +788,9 @@ def test_as_index_series_return_frame(df):
     tm.assert_frame_equal(result2, expected2)
 
     result = grouped["C"].sum()
-    expected = grouped.sum().loc[:, ["A", "C"]]
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = grouped.sum().loc[:, ["A", "C"]]
     assert isinstance(result, DataFrame)
     tm.assert_frame_equal(result, expected)
 
@@ -787,8 +814,10 @@ def test_groupby_as_index_cython(df):
 
     # single-key
     grouped = data.groupby("A", as_index=False)
-    result = grouped.mean()
-    expected = data.groupby(["A"]).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.mean()
+        expected = data.groupby(["A"]).mean()
     expected.insert(0, "A", expected.index)
     expected.index = np.arange(len(expected))
     tm.assert_frame_equal(result, expected)
@@ -825,7 +854,7 @@ def test_groupby_as_index_corner(df, ts):
         df.groupby(lambda x: x.lower(), as_index=False, axis=1)
 
 
-def test_groupby_multiple_key(df):
+def test_groupby_multiple_key():
     df = tm.makeTimeDataFrame()
     grouped = df.groupby([lambda x: x.year, lambda x: x.month, lambda x: x.day])
     agged = grouped.sum()
@@ -857,15 +886,18 @@ def test_groupby_multi_corner(df):
 
 def test_omit_nuisance(df):
     grouped = df.groupby("A")
-    agged = grouped.agg(np.mean)
-    exp = grouped.mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        agged = grouped.agg(np.mean)
+        exp = grouped.mean()
     tm.assert_frame_equal(agged, exp)
 
     df = df.loc[:, ["A", "C", "D"]]
     df["E"] = datetime.now()
     grouped = df.groupby("A")
-    result = grouped.agg(np.sum)
-    expected = grouped.sum()
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.agg(np.sum)
+        expected = grouped.sum()
     tm.assert_frame_equal(result, expected)
 
     # won't work with axis = 1
@@ -891,14 +923,55 @@ def test_keep_nuisance_agg(df, agg_function):
 
 @pytest.mark.parametrize(
     "agg_function",
-    ["sum", "mean", "prod", "std", "var", "median"],
+    ["sum", "mean", "prod", "std", "var", "sem", "median"],
 )
-def test_omit_nuisance_agg(df, agg_function):
+@pytest.mark.parametrize("numeric_only", [lib.no_default, True, False])
+def test_omit_nuisance_agg(df, agg_function, numeric_only):
     # GH 38774, GH 38815
+    if numeric_only is lib.no_default or (not numeric_only and agg_function != "sum"):
+        # sum doesn't drop strings
+        warn = FutureWarning
+    else:
+        warn = None
+
     grouped = df.groupby("A")
-    result = getattr(grouped, agg_function)()
-    expected = getattr(df.loc[:, ["A", "C", "D"]].groupby("A"), agg_function)()
-    tm.assert_frame_equal(result, expected)
+
+    if agg_function in ("var", "std", "sem") and numeric_only is False:
+        # Added numeric_only as part of GH#46560; these do not drop nuisance
+        # columns when numeric_only is False
+        klass = TypeError if agg_function == "var" else ValueError
+        with pytest.raises(klass, match="could not convert string to float"):
+            getattr(grouped, agg_function)(numeric_only=numeric_only)
+    else:
+        if numeric_only is lib.no_default:
+            msg = (
+                f"The default value of numeric_only in DataFrameGroupBy.{agg_function}"
+            )
+        else:
+            msg = "Dropping invalid columns"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = getattr(grouped, agg_function)(numeric_only=numeric_only)
+        if (
+            (numeric_only is lib.no_default or not numeric_only)
+            # These methods drop non-numeric columns even when numeric_only is False
+            and agg_function not in ("mean", "prod", "median")
+        ):
+            columns = ["A", "B", "C", "D"]
+        else:
+            columns = ["A", "C", "D"]
+        if agg_function == "sum" and numeric_only is False:
+            # sum doesn't drop nuisance string columns
+            warn = None
+        elif agg_function in ("sum", "std", "var", "sem") and numeric_only is not True:
+            warn = FutureWarning
+        else:
+            warn = None
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(warn, match=msg):
+            expected = getattr(df.loc[:, columns].groupby("A"), agg_function)(
+                numeric_only=numeric_only
+            )
+        tm.assert_frame_equal(result, expected)
 
 
 def test_omit_nuisance_warnings(df):
@@ -913,8 +986,10 @@ def test_omit_nuisance_warnings(df):
 def test_omit_nuisance_python_multiple(three_group):
     grouped = three_group.groupby(["A", "B"])
 
-    agged = grouped.agg(np.mean)
-    exp = grouped.mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        agged = grouped.agg(np.mean)
+        exp = grouped.mean()
     tm.assert_frame_equal(agged, exp)
 
 
@@ -931,8 +1006,10 @@ def test_empty_groups_corner(mframe):
     )
 
     grouped = df.groupby(["k1", "k2"])
-    result = grouped.agg(np.mean)
-    expected = grouped.mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.agg(np.mean)
+        expected = grouped.mean()
     tm.assert_frame_equal(result, expected)
 
     grouped = mframe[3:5].groupby(level=0)
@@ -954,8 +1031,14 @@ def test_wrap_aggregated_output_multindex(mframe):
     df["baz", "two"] = "peekaboo"
 
     keys = [np.array([0, 0, 1]), np.array([0, 0, 1])]
-    agged = df.groupby(keys).agg(np.mean)
+    # GH#50538
+    msg = "The operation <function mean.*failed"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        agged = df.groupby(keys).agg(np.mean)
     assert isinstance(agged.columns, MultiIndex)
+    # Ensure users can't pass numeric_only
+    with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+        df.groupby(keys).agg(np.mean, numeric_only=True)
 
     def aggfun(ser):
         if ser.name == ("foo", "one"):
@@ -1054,15 +1137,14 @@ def test_groupby_complex_numbers():
     )
     expected = DataFrame(
         np.array([1, 1, 1], dtype=np.int64),
-        index=Index([(1 + 1j), (1 + 2j), (1 + 0j)], dtype="object", name="b"),
+        index=Index([(1 + 1j), (1 + 2j), (1 + 0j)], name="b"),
         columns=Index(["a"], dtype="object"),
     )
     result = df.groupby("b", sort=False).count()
     tm.assert_frame_equal(result, expected)
 
     # Sorted by the magnitude of the complex numbers
-    # Complex Index dtype is cast to object
-    expected.index = Index([(1 + 0j), (1 + 1j), (1 + 2j)], dtype="object", name="b")
+    expected.index = Index([(1 + 0j), (1 + 1j), (1 + 2j)], name="b")
     result = df.groupby("b", sort=True).count()
     tm.assert_frame_equal(result, expected)
 
@@ -1116,15 +1198,19 @@ def test_groupby_with_hier_columns():
     # add a nuisance column
     sorted_columns, _ = columns.sortlevel(0)
     df["A", "foo"] = "bar"
-    result = df.groupby(level=0).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby(level=0).mean()
     tm.assert_index_equal(result.columns, df.columns[:-1])
 
 
 def test_grouping_ndarray(df):
     grouped = df.groupby(df["A"].values)
 
-    result = grouped.sum()
-    expected = df.groupby("A").sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = grouped.sum()
+        expected = df.groupby("A").sum()
     tm.assert_frame_equal(
         result, expected, check_names=False
     )  # Note: no names when grouping by value
@@ -1152,8 +1238,10 @@ def test_groupby_wrong_multi_labels():
 
 
 def test_groupby_series_with_name(df):
-    result = df.groupby(df["A"]).mean()
-    result2 = df.groupby(df["A"], as_index=False).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby(df["A"]).mean()
+        result2 = df.groupby(df["A"], as_index=False).mean()
     assert result.index.name == "A"
     assert "A" in result2
 
@@ -1304,8 +1392,10 @@ def test_groupby_unit64_float_conversion():
 
 
 def test_groupby_list_infer_array_like(df):
-    result = df.groupby(list(df["A"])).mean()
-    expected = df.groupby(df["A"]).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby(list(df["A"])).mean()
+        expected = df.groupby(df["A"]).mean()
     tm.assert_frame_equal(result, expected, check_names=False)
 
     with pytest.raises(KeyError, match=r"^'foo'$"):
@@ -1418,7 +1508,9 @@ def test_groupby_2d_malformed():
     d["zeros"] = [0, 0]
     d["ones"] = [1, 1]
     d["label"] = ["l1", "l2"]
-    tmp = d.groupby(["group"]).mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        tmp = d.groupby(["group"]).mean()
     res_values = np.array([[0.0, 1.0], [0.0, 1.0]])
     tm.assert_index_equal(tmp.columns, Index(["zeros", "ones"]))
     tm.assert_numpy_array_equal(tmp.values, res_values)
@@ -1480,7 +1572,7 @@ def test_dont_clobber_name_column():
         {"key": ["a", "a", "a", "b", "b", "b"], "name": ["foo", "bar", "baz"] * 2}
     )
 
-    result = df.groupby("key").apply(lambda x: x)
+    result = df.groupby("key", group_keys=False).apply(lambda x: x)
     tm.assert_frame_equal(result, df)
 
 
@@ -1552,7 +1644,7 @@ def freduce(group):
     def foo(x):
         return freduce(x)
 
-    grouped = df.groupby(grouper)
+    grouped = df.groupby(grouper, group_keys=False)
 
     # make sure all these work
     grouped.apply(f)
@@ -1584,10 +1676,13 @@ def f(group):
 
 def test_no_dummy_key_names(df):
     # see gh-1291
-    result = df.groupby(df["A"].values).sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby(df["A"].values).sum()
     assert result.index.name is None
 
-    result = df.groupby([df["A"].values, df["B"].values]).sum()
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby([df["A"].values, df["B"].values]).sum()
     assert result.index.names == (None, None)
 
 
@@ -1698,13 +1793,15 @@ def test_groupby_multiindex_not_lexsorted():
 
     for level in [0, 1, [0, 1]]:
         for sort in [False, True]:
-            result = df.groupby(level=level, sort=sort).apply(DataFrame.drop_duplicates)
+            result = df.groupby(level=level, sort=sort, group_keys=False).apply(
+                DataFrame.drop_duplicates
+            )
             expected = df
             tm.assert_frame_equal(expected, result)
 
             result = (
                 df.sort_index()
-                .groupby(level=level, sort=sort)
+                .groupby(level=level, sort=sort, group_keys=False)
                 .apply(DataFrame.drop_duplicates)
             )
             expected = df.sort_index()
@@ -1821,6 +1918,18 @@ def test_pivot_table_values_key_error():
         pd.array([0], dtype="Float64"),
         pd.array([False], dtype="boolean"),
     ],
+    ids=[
+        "bool",
+        "int",
+        "float",
+        "str",
+        "cat",
+        "dt64",
+        "dt64tz",
+        "Int64",
+        "Float64",
+        "boolean",
+    ],
 )
 @pytest.mark.parametrize("method", ["attr", "agg", "apply"])
 @pytest.mark.parametrize(
@@ -1877,15 +1986,6 @@ def test_empty_groupby(columns, keys, values, method, op, request, using_array_m
             raises=AssertionError, match="(DataFrame|Series) are different"
         )
         request.node.add_marker(mark)
-    elif (
-        isinstance(values, (IntegerArray, FloatingArray))
-        and op == "mad"
-        and isinstance(columns, list)
-    ):
-        mark = pytest.mark.xfail(
-            raises=TypeError, match="can only perform ops with numeric values"
-        )
-        request.node.add_marker(mark)
 
     elif (
         op == "mad"
@@ -1916,13 +2016,17 @@ def test_empty_groupby(columns, keys, values, method, op, request, using_array_m
 
     df = df.iloc[:0]
 
-    gb = df.groupby(keys)[columns]
+    gb = df.groupby(keys, group_keys=False)[columns]
 
     def get_result():
-        if method == "attr":
-            return getattr(gb, op)()
-        else:
-            return getattr(gb, method)(op)
+        warn = FutureWarning if op == "mad" else None
+        with tm.assert_produces_warning(
+            warn, match="The 'mad' method is deprecated", raise_on_extra_warnings=False
+        ):
+            if method == "attr":
+                return getattr(gb, op)()
+            else:
+                return getattr(gb, method)(op)
 
     if columns == "C":
         # i.e. SeriesGroupBy
@@ -2037,7 +2141,7 @@ def test_empty_groupby_apply_nonunique_columns():
     df = DataFrame(np.random.randn(0, 4))
     df[3] = df[3].astype(np.int64)
     df.columns = [0, 1, 2, 0]
-    gb = df.groupby(df[1])
+    gb = df.groupby(df[1], group_keys=False)
     res = gb.apply(lambda x: x)
     assert (res.dtypes == df.dtypes).all()
 
@@ -2259,6 +2363,43 @@ def test_groupby_duplicate_index():
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.filterwarnings("ignore:.*is deprecated.*:FutureWarning")
+def test_group_on_empty_multiindex(transformation_func, request):
+    # GH 47787
+    # With one row, those are transforms so the schema should be the same
+    if transformation_func == "tshift":
+        mark = pytest.mark.xfail(raises=NotImplementedError)
+        request.node.add_marker(mark)
+    df = DataFrame(
+        data=[[1, Timestamp("today"), 3, 4]],
+        columns=["col_1", "col_2", "col_3", "col_4"],
+    )
+    df["col_3"] = df["col_3"].astype(int)
+    df["col_4"] = df["col_4"].astype(int)
+    df = df.set_index(["col_1", "col_2"])
+    if transformation_func == "fillna":
+        args = ("ffill",)
+    elif transformation_func == "tshift":
+        args = (1, "D")
+    else:
+        args = ()
+    result = df.iloc[:0].groupby(["col_1"]).transform(transformation_func, *args)
+    expected = df.groupby(["col_1"]).transform(transformation_func, *args).iloc[:0]
+    if transformation_func in ("diff", "shift"):
+        expected = expected.astype(int)
+    tm.assert_equal(result, expected)
+
+    result = (
+        df["col_3"].iloc[:0].groupby(["col_1"]).transform(transformation_func, *args)
+    )
+    expected = (
+        df["col_3"].groupby(["col_1"]).transform(transformation_func, *args).iloc[:0]
+    )
+    if transformation_func in ("diff", "shift"):
+        expected = expected.astype(int)
+    tm.assert_equal(result, expected)
+
+
 @pytest.mark.parametrize(
     "idx",
     [
@@ -2269,22 +2410,21 @@ def test_groupby_duplicate_index():
 @pytest.mark.filterwarnings("ignore:tshift is deprecated:FutureWarning")
 def test_dup_labels_output_shape(groupby_func, idx):
     if groupby_func in {"size", "ngroup", "cumcount"}:
-        pytest.skip("Not applicable")
+        pytest.skip(f"Not applicable for {groupby_func}")
     # TODO(2.0) Remove after pad/backfill deprecation enforced
     groupby_func = maybe_normalize_deprecated_kernels(groupby_func)
+    warn = FutureWarning if groupby_func in ("mad", "tshift") else None
+
     df = DataFrame([[1, 1]], columns=idx)
     grp_by = df.groupby([0])
 
-    args = []
-    if groupby_func in {"fillna", "nth"}:
-        args.append(0)
-    elif groupby_func == "corrwith":
-        args.append(df)
-    elif groupby_func == "tshift":
+    if groupby_func == "tshift":
         df.index = [Timestamp("today")]
-        args.extend([1, "D"])
+        # args.extend([1, "D"])
+    args = get_groupby_method_args(groupby_func, df)
 
-    result = getattr(grp_by, groupby_func)(*args)
+    with tm.assert_produces_warning(warn, match="is deprecated"):
+        result = getattr(grp_by, groupby_func)(*args)
 
     assert result.shape == (1, 2)
     tm.assert_index_equal(result.columns, idx)
@@ -2473,6 +2613,40 @@ def test_groupby_numerical_stability_cumsum():
     tm.assert_frame_equal(result, expected, check_exact=True)
 
 
+def test_groupby_cumsum_skipna_false():
+    # GH#46216 don't propagate np.nan above the diagonal
+    arr = np.random.randn(5, 5)
+    df = DataFrame(arr)
+    for i in range(5):
+        df.iloc[i, i] = np.nan
+
+    df["A"] = 1
+    gb = df.groupby("A")
+
+    res = gb.cumsum(skipna=False)
+
+    expected = df[[0, 1, 2, 3, 4]].cumsum(skipna=False)
+    tm.assert_frame_equal(res, expected)
+
+
+def test_groupby_cumsum_timedelta64():
+    # GH#46216 don't ignore is_datetimelike in libgroupby.group_cumsum
+    dti = date_range("2016-01-01", periods=5)
+    ser = Series(dti) - dti[0]
+    ser[2] = pd.NaT
+
+    df = DataFrame({"A": 1, "B": ser})
+    gb = df.groupby("A")
+
+    res = gb.cumsum(numeric_only=False, skipna=True)
+    exp = DataFrame({"B": [ser[0], ser[1], pd.NaT, ser[4], ser[4] * 2]})
+    tm.assert_frame_equal(res, exp)
+
+    res = gb.cumsum(numeric_only=False, skipna=False)
+    exp = DataFrame({"B": [ser[0], ser[1], pd.NaT, pd.NaT, pd.NaT]})
+    tm.assert_frame_equal(res, exp)
+
+
 def test_groupby_mean_duplicate_index(rand_series_with_duplicate_datetimeindex):
     dups = rand_series_with_duplicate_datetimeindex
     result = dups.groupby(level=0).mean()
@@ -2561,7 +2735,9 @@ def test_groupby_aggregation_numeric_with_non_numeric_dtype():
     )
 
     gb = df.groupby(by=["x"])
-    result = gb.sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = gb.sum()
     tm.assert_frame_equal(result, expected)
 
 
@@ -2625,3 +2801,123 @@ def test_pad_backfill_deprecation():
         s.groupby(level=0).backfill()
     with tm.assert_produces_warning(FutureWarning, match="pad"):
         s.groupby(level=0).pad()
+
+
+def test_by_column_values_with_same_starting_value():
+    # GH29635
+    df = DataFrame(
+        {
+            "Name": ["Thomas", "Thomas", "Thomas John"],
+            "Credit": [1200, 1300, 900],
+            "Mood": ["sad", "happy", "happy"],
+        }
+    )
+    aggregate_details = {"Mood": Series.mode, "Credit": "sum"}
+
+    result = df.groupby(["Name"]).agg(aggregate_details)
+    expected_result = DataFrame(
+        {
+            "Mood": [["happy", "sad"], "happy"],
+            "Credit": [2500, 900],
+            "Name": ["Thomas", "Thomas John"],
+        }
+    ).set_index("Name")
+
+    tm.assert_frame_equal(result, expected_result)
+
+
+def test_groupby_none_in_first_mi_level():
+    # GH#47348
+    arr = [[None, 1, 0, 1], [2, 3, 2, 3]]
+    ser = Series(1, index=MultiIndex.from_arrays(arr, names=["a", "b"]))
+    result = ser.groupby(level=[0, 1]).sum()
+    expected = Series(
+        [1, 2], MultiIndex.from_tuples([(0.0, 2), (1.0, 3)], names=["a", "b"])
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_groupby_none_column_name():
+    # GH#47348
+    df = DataFrame({None: [1, 1, 2, 2], "b": [1, 1, 2, 3], "c": [4, 5, 6, 7]})
+    result = df.groupby(by=[None]).sum()
+    expected = DataFrame({"b": [2, 5], "c": [9, 13]}, index=Index([1, 2], name=None))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_single_element_list_grouping():
+    # GH 42795
+    df = DataFrame(
+        {"a": [np.nan, 1], "b": [np.nan, 5], "c": [np.nan, 2]}, index=["x", "y"]
+    )
+    msg = (
+        "In a future version of pandas, a length 1 "
+        "tuple will be returned when iterating over "
+        "a groupby with a grouper equal to a list of "
+        "length 1. Don't supply a list with a single grouper "
+        "to avoid this warning."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        values, _ = next(iter(df.groupby(["a"])))
+
+
+@pytest.mark.parametrize("func", ["sum", "cumsum", "prod"])
+def test_groupby_avoid_casting_to_float(func):
+    # GH#37493
+    val = 922337203685477580
+    df = DataFrame({"a": 1, "b": [val]})
+    result = getattr(df.groupby("a"), func)() - val
+    expected = DataFrame({"b": [0]}, index=Index([1], name="a"))
+    if func == "cumsum":
+        expected = expected.reset_index(drop=True)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("func, val", [("sum", 3), ("prod", 2)])
+def test_groupby_sum_support_mask(any_numeric_ea_dtype, func, val):
+    # GH#37493
+    df = DataFrame({"a": 1, "b": [1, 2, pd.NA]}, dtype=any_numeric_ea_dtype)
+    result = getattr(df.groupby("a"), func)()
+    expected = DataFrame(
+        {"b": [val]},
+        index=Index([1], name="a", dtype=any_numeric_ea_dtype),
+        dtype=any_numeric_ea_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("val, dtype", [(111, "int"), (222, "uint")])
+def test_groupby_overflow(val, dtype):
+    # GH#37493
+    df = DataFrame({"a": 1, "b": [val, val]}, dtype=f"{dtype}8")
+    result = df.groupby("a").sum()
+    expected = DataFrame(
+        {"b": [val * 2]},
+        index=Index([1], name="a", dtype=f"{dtype}64"),
+        dtype=f"{dtype}64",
+    )
+    tm.assert_frame_equal(result, expected)
+
+    result = df.groupby("a").cumsum()
+    expected = DataFrame({"b": [val, val * 2]}, dtype=f"{dtype}64")
+    tm.assert_frame_equal(result, expected)
+
+    result = df.groupby("a").prod()
+    expected = DataFrame(
+        {"b": [val * val]},
+        index=Index([1], name="a", dtype=f"{dtype}64"),
+        dtype=f"{dtype}64",
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("skipna, val", [(True, 3), (False, pd.NA)])
+def test_groupby_cumsum_mask(any_numeric_ea_dtype, skipna, val):
+    # GH#37493
+    df = DataFrame({"a": 1, "b": [1, pd.NA, 2]}, dtype=any_numeric_ea_dtype)
+    result = df.groupby("a").cumsum(skipna=skipna)
+    expected = DataFrame(
+        {"b": [1, pd.NA, val]},
+        dtype=any_numeric_ea_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_groupby_dropna.py b/pandas/tests/groupby/test_groupby_dropna.py
index ab568e24ff029..ee660dd073ce9 100644
--- a/pandas/tests/groupby/test_groupby_dropna.py
+++ b/pandas/tests/groupby/test_groupby_dropna.py
@@ -1,6 +1,10 @@
 import numpy as np
 import pytest
 
+from pandas.compat.pyarrow import pa_version_under1p01
+
+from pandas.core.dtypes.missing import na_value_for_dtype
+
 import pandas as pd
 import pandas._testing as tm
 
@@ -171,52 +175,30 @@ def test_grouper_dropna_propagation(dropna):
 
 
 @pytest.mark.parametrize(
-    "dropna,input_index,expected_data,expected_index",
+    "index",
     [
-        (True, pd.RangeIndex(0, 4), {"B": [2, 2, 1]}, pd.RangeIndex(0, 3)),
-        (True, list("abcd"), {"B": [2, 2, 1]}, list("abc")),
-        (
-            True,
-            pd.MultiIndex.from_tuples(
-                [(1, "R"), (1, "B"), (2, "R"), (2, "B")], names=["num", "col"]
-            ),
-            {"B": [2, 2, 1]},
-            pd.MultiIndex.from_tuples(
-                [(1, "R"), (1, "B"), (2, "R")], names=["num", "col"]
-            ),
-        ),
-        (False, pd.RangeIndex(0, 4), {"B": [2, 2, 1, 1]}, pd.RangeIndex(0, 4)),
-        (False, list("abcd"), {"B": [2, 2, 1, 1]}, list("abcd")),
-        (
-            False,
-            pd.MultiIndex.from_tuples(
-                [(1, "R"), (1, "B"), (2, "R"), (2, "B")], names=["num", "col"]
-            ),
-            {"B": [2, 2, 1, 1]},
-            pd.MultiIndex.from_tuples(
-                [(1, "R"), (1, "B"), (2, "R"), (2, "B")], names=["num", "col"]
-            ),
-        ),
+        pd.RangeIndex(0, 4),
+        list("abcd"),
+        pd.MultiIndex.from_product([(1, 2), ("R", "B")], names=["num", "col"]),
     ],
 )
-def test_groupby_dataframe_slice_then_transform(
-    dropna, input_index, expected_data, expected_index
-):
+def test_groupby_dataframe_slice_then_transform(dropna, index):
     # GH35014 & GH35612
+    expected_data = {"B": [2, 2, 1, np.nan if dropna else 1]}
 
-    df = pd.DataFrame({"A": [0, 0, 1, None], "B": [1, 2, 3, None]}, index=input_index)
+    df = pd.DataFrame({"A": [0, 0, 1, None], "B": [1, 2, 3, None]}, index=index)
     gb = df.groupby("A", dropna=dropna)
 
     result = gb.transform(len)
-    expected = pd.DataFrame(expected_data, index=expected_index)
+    expected = pd.DataFrame(expected_data, index=index)
     tm.assert_frame_equal(result, expected)
 
     result = gb[["B"]].transform(len)
-    expected = pd.DataFrame(expected_data, index=expected_index)
+    expected = pd.DataFrame(expected_data, index=index)
     tm.assert_frame_equal(result, expected)
 
     result = gb["B"].transform(len)
-    expected = pd.Series(expected_data["B"], index=expected_index, name="B")
+    expected = pd.Series(expected_data["B"], index=index, name="B")
     tm.assert_series_equal(result, expected)
 
 
@@ -354,6 +336,36 @@ def test_groupby_apply_with_dropna_for_multi_index(dropna, data, selected_data,
     tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize("input_index", [None, ["a"], ["a", "b"]])
+@pytest.mark.parametrize("keys", [["a"], ["a", "b"]])
+@pytest.mark.parametrize("series", [True, False])
+def test_groupby_dropna_with_multiindex_input(input_index, keys, series):
+    # GH#46783
+    obj = pd.DataFrame(
+        {
+            "a": [1, np.nan],
+            "b": [1, 1],
+            "c": [2, 3],
+        }
+    )
+
+    expected = obj.set_index(keys)
+    if series:
+        expected = expected["c"]
+    elif input_index == ["a", "b"] and keys == ["a"]:
+        # Column b should not be aggregated
+        expected = expected[["c"]]
+
+    if input_index is not None:
+        obj = obj.set_index(input_index)
+    gb = obj.groupby(keys, dropna=False)
+    if series:
+        gb = gb["c"]
+    result = gb.sum()
+
+    tm.assert_equal(result, expected)
+
+
 def test_groupby_nan_included():
     # GH 35646
     data = {"group": ["g1", np.nan, "g1", "g2", np.nan], "B": [0, 1, 2, 3, 4]}
@@ -370,3 +382,119 @@ def test_groupby_nan_included():
         tm.assert_numpy_array_equal(result_values, expected_values)
     assert np.isnan(list(result.keys())[2])
     assert list(result.keys())[0:2] == ["g1", "g2"]
+
+
+def test_groupby_drop_nan_with_multi_index():
+    # GH 39895
+    df = pd.DataFrame([[np.nan, 0, 1]], columns=["a", "b", "c"])
+    df = df.set_index(["a", "b"])
+    result = df.groupby(["a", "b"], dropna=False).first()
+    expected = df
+    tm.assert_frame_equal(result, expected)
+
+
+# sequence_index enumerates all strings made up of x, y, z of length 4
+@pytest.mark.parametrize("sequence_index", range(3**4))
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        None,
+        "UInt8",
+        "Int8",
+        "UInt16",
+        "Int16",
+        "UInt32",
+        "Int32",
+        "UInt64",
+        "Int64",
+        "Float32",
+        "Int64",
+        "Float64",
+        "category",
+        "string",
+        pytest.param(
+            "string[pyarrow]",
+            marks=pytest.mark.skipif(
+                pa_version_under1p01, reason="pyarrow is not installed"
+            ),
+        ),
+        "datetime64[ns]",
+        "period[d]",
+        "Sparse[float]",
+    ],
+)
+@pytest.mark.parametrize("test_series", [True, False])
+def test_no_sort_keep_na(request, sequence_index, dtype, test_series):
+    # GH#46584, GH#48794
+
+    # Convert sequence_index into a string sequence, e.g. 5 becomes "xxyz"
+    # This sequence is used for the grouper.
+    sequence = "".join(
+        [{0: "x", 1: "y", 2: "z"}[sequence_index // (3**k) % 3] for k in range(4)]
+    )
+
+    if dtype == "category" and "z" in sequence:
+        # Only xfail when nulls are present
+        msg = "dropna=False not correct for categorical, GH#48645"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+
+    # Unique values to use for grouper, depends on dtype
+    if dtype in ("string", "string[pyarrow]"):
+        uniques = {"x": "x", "y": "y", "z": pd.NA}
+    elif dtype in ("datetime64[ns]", "period[d]"):
+        uniques = {"x": "2016-01-01", "y": "2017-01-01", "z": pd.NA}
+    else:
+        uniques = {"x": 1, "y": 2, "z": np.nan}
+
+    df = pd.DataFrame(
+        {
+            "key": pd.Series([uniques[label] for label in sequence], dtype=dtype),
+            "a": [0, 1, 2, 3],
+        }
+    )
+    gb = df.groupby("key", dropna=False, sort=False)
+    if test_series:
+        gb = gb["a"]
+    result = gb.sum()
+
+    # Manually compute the groupby sum, use the labels "x", "y", and "z" to avoid
+    # issues with hashing np.nan
+    summed = {}
+    for idx, label in enumerate(sequence):
+        summed[label] = summed.get(label, 0) + idx
+    if dtype == "category":
+        index = pd.CategoricalIndex(
+            [uniques[e] for e in summed],
+            list({uniques[k]: 0 for k in sequence if not pd.isnull(uniques[k])}),
+            name="key",
+        )
+    elif isinstance(dtype, str) and dtype.startswith("Sparse"):
+        index = pd.Index(
+            pd.array([uniques[label] for label in summed], dtype=dtype), name="key"
+        )
+    else:
+        index = pd.Index([uniques[label] for label in summed], dtype=dtype, name="key")
+    expected = pd.Series(summed.values(), index=index, name="a", dtype=None)
+    if not test_series:
+        expected = expected.to_frame()
+
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("test_series", [True, False])
+@pytest.mark.parametrize("dtype", [object, None])
+def test_null_is_null_for_dtype(
+    sort, dtype, nulls_fixture, nulls_fixture2, test_series
+):
+    # GH#48506 - groups should always result in using the null for the dtype
+    df = pd.DataFrame({"a": [1, 2]})
+    groups = pd.Series([nulls_fixture, nulls_fixture2], dtype=dtype)
+    obj = df["a"] if test_series else df
+    gb = obj.groupby(groups, dropna=False, sort=sort)
+    result = gb.sum()
+    index = pd.Index([na_value_for_dtype(groups.dtype)])
+    expected = pd.DataFrame({"a": [3]}, index=index)
+    if test_series:
+        tm.assert_series_equal(result, expected["a"])
+    else:
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_groupby_shift_diff.py b/pandas/tests/groupby/test_groupby_shift_diff.py
index c989c0e0c94cd..7ffee412e3cdf 100644
--- a/pandas/tests/groupby/test_groupby_shift_diff.py
+++ b/pandas/tests/groupby/test_groupby_shift_diff.py
@@ -69,7 +69,7 @@ def test_group_shift_lose_timezone():
     tm.assert_series_equal(result, expected)
 
 
-def test_group_diff_real(any_real_numpy_dtype):
+def test_group_diff_real_series(any_real_numpy_dtype):
     df = DataFrame(
         {"a": [1, 2, 3, 3, 2], "b": [1, 2, 3, 4, 5]},
         dtype=any_real_numpy_dtype,
@@ -82,6 +82,29 @@ def test_group_diff_real(any_real_numpy_dtype):
     tm.assert_series_equal(result, expected)
 
 
+def test_group_diff_real_frame(any_real_numpy_dtype):
+    df = DataFrame(
+        {
+            "a": [1, 2, 3, 3, 2],
+            "b": [1, 2, 3, 4, 5],
+            "c": [1, 2, 3, 4, 6],
+        },
+        dtype=any_real_numpy_dtype,
+    )
+    result = df.groupby("a").diff()
+    exp_dtype = "float"
+    if any_real_numpy_dtype in ["int8", "int16", "float32"]:
+        exp_dtype = "float32"
+    expected = DataFrame(
+        {
+            "b": [np.nan, np.nan, np.nan, 1.0, 3.0],
+            "c": [np.nan, np.nan, np.nan, 1.0, 4.0],
+        },
+        dtype=exp_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
 @pytest.mark.parametrize(
     "data",
     [
diff --git a/pandas/tests/groupby/test_groupby_subclass.py b/pandas/tests/groupby/test_groupby_subclass.py
index cc8d4176ca054..fddf0c86d0ab1 100644
--- a/pandas/tests/groupby/test_groupby_subclass.py
+++ b/pandas/tests/groupby/test_groupby_subclass.py
@@ -5,10 +5,12 @@
 
 from pandas import (
     DataFrame,
+    Index,
     Series,
 )
 import pandas._testing as tm
 from pandas.core.groupby.base import maybe_normalize_deprecated_kernels
+from pandas.tests.groupby import get_groupby_method_args
 
 
 @pytest.mark.parametrize(
@@ -23,29 +25,26 @@ def test_groupby_preserves_subclass(obj, groupby_func):
     # GH28330 -- preserve subclass through groupby operations
 
     if isinstance(obj, Series) and groupby_func in {"corrwith"}:
-        pytest.skip("Not applicable")
+        pytest.skip(f"Not applicable for Series and {groupby_func}")
     # TODO(2.0) Remove after pad/backfill deprecation enforced
     groupby_func = maybe_normalize_deprecated_kernels(groupby_func)
+    warn = FutureWarning if groupby_func in ("mad", "tshift") else None
+
     grouped = obj.groupby(np.arange(0, 10))
 
     # Groups should preserve subclass type
     assert isinstance(grouped.get_group(0), type(obj))
 
-    args = []
-    if groupby_func in {"fillna", "nth"}:
-        args.append(0)
-    elif groupby_func == "corrwith":
-        args.append(obj)
-    elif groupby_func == "tshift":
-        args.extend([0, 0])
+    args = get_groupby_method_args(groupby_func, obj)
 
-    result1 = getattr(grouped, groupby_func)(*args)
-    result2 = grouped.agg(groupby_func, *args)
+    with tm.assert_produces_warning(warn, match="is deprecated"):
+        result1 = getattr(grouped, groupby_func)(*args)
+        result2 = grouped.agg(groupby_func, *args)
 
     # Reduction or transformation kernels should preserve type
     slices = {"ngroup", "cumcount", "size"}
     if isinstance(obj, DataFrame) and groupby_func in slices:
-        assert isinstance(result1, obj._constructor_sliced)
+        assert isinstance(result1, tm.SubclassedSeries)
     else:
         assert isinstance(result1, type(obj))
 
@@ -64,6 +63,28 @@ def test_groupby_preserves_metadata():
     for _, group_df in custom_df.groupby("c"):
         assert group_df.testattr == "hello"
 
+    # GH-45314
+    def func(group):
+        assert isinstance(group, tm.SubclassedDataFrame)
+        assert hasattr(group, "testattr")
+        return group.testattr
+
+    result = custom_df.groupby("c").apply(func)
+    expected = tm.SubclassedSeries(["hello"] * 3, index=Index([7, 8, 9], name="c"))
+    tm.assert_series_equal(result, expected)
+
+    def func2(group):
+        assert isinstance(group, tm.SubclassedSeries)
+        assert hasattr(group, "testattr")
+        return group.testattr
+
+    custom_series = tm.SubclassedSeries([1, 2, 3])
+    custom_series.testattr = "hello"
+    result = custom_series.groupby(custom_df["c"]).apply(func2)
+    tm.assert_series_equal(result, expected)
+    result = custom_series.groupby(custom_df["c"]).agg(func2)
+    tm.assert_series_equal(result, expected)
+
 
 @pytest.mark.parametrize("obj", [DataFrame, tm.SubclassedDataFrame])
 def test_groupby_resample_preserves_subclass(obj):
@@ -86,5 +107,7 @@ def test_groupby_resample_preserves_subclass(obj):
     df = df.set_index("Date")
 
     # Confirm groupby.resample() preserves dataframe type
-    result = df.groupby("Buyer").resample("5D").sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.groupby("Buyer").resample("5D").sum()
     assert isinstance(result, obj)
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index efb0b82f58e97..728575a80f32f 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -59,8 +59,10 @@ def test_column_select_via_attr(self, df):
         tm.assert_series_equal(result, expected)
 
         df["mean"] = 1.5
-        result = df.groupby("A").mean()
-        expected = df.groupby("A").agg(np.mean)
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.groupby("A").mean()
+            expected = df.groupby("A").agg(np.mean)
         tm.assert_frame_equal(result, expected)
 
     def test_getitem_list_of_columns(self):
@@ -148,24 +150,26 @@ def test_indices_grouped_by_tuple_with_lambda(self):
 
 
 class TestGrouping:
-    def test_grouper_index_types(self):
-        # related GH5375
-        # groupby misbehaving when using a Floatlike index
-        df = DataFrame(np.arange(10).reshape(5, 2), columns=list("AB"))
-        for index in [
+    @pytest.mark.parametrize(
+        "index",
+        [
             tm.makeFloatIndex,
             tm.makeStringIndex,
-            tm.makeUnicodeIndex,
             tm.makeIntIndex,
             tm.makeDateIndex,
             tm.makePeriodIndex,
-        ]:
+        ],
+    )
+    def test_grouper_index_types(self, index):
+        # related GH5375
+        # groupby misbehaving when using a Floatlike index
+        df = DataFrame(np.arange(10).reshape(5, 2), columns=list("AB"))
 
-            df.index = index(len(df))
-            df.groupby(list("abcde")).apply(lambda x: x)
+        df.index = index(len(df))
+        df.groupby(list("abcde"), group_keys=False).apply(lambda x: x)
 
-            df.index = list(reversed(df.index.tolist()))
-            df.groupby(list("abcde")).apply(lambda x: x)
+        df.index = list(reversed(df.index.tolist()))
+        df.groupby(list("abcde"), group_keys=False).apply(lambda x: x)
 
     def test_grouper_multilevel_freq(self):
 
@@ -284,25 +288,30 @@ def test_grouper_column_and_index(self):
             {"A": np.arange(6), "B": ["one", "one", "two", "two", "one", "one"]},
             index=idx,
         )
-        result = df_multi.groupby(["B", pd.Grouper(level="inner")]).mean()
-        expected = df_multi.reset_index().groupby(["B", "inner"]).mean()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df_multi.groupby(["B", pd.Grouper(level="inner")]).mean()
+            expected = df_multi.reset_index().groupby(["B", "inner"]).mean()
         tm.assert_frame_equal(result, expected)
 
         # Test the reverse grouping order
-        result = df_multi.groupby([pd.Grouper(level="inner"), "B"]).mean()
-        expected = df_multi.reset_index().groupby(["inner", "B"]).mean()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df_multi.groupby([pd.Grouper(level="inner"), "B"]).mean()
+            expected = df_multi.reset_index().groupby(["inner", "B"]).mean()
         tm.assert_frame_equal(result, expected)
 
         # Grouping a single-index frame by a column and the index should
         # be equivalent to resetting the index and grouping by two columns
         df_single = df_multi.reset_index("outer")
-        result = df_single.groupby(["B", pd.Grouper(level="inner")]).mean()
-        expected = df_single.reset_index().groupby(["B", "inner"]).mean()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df_single.groupby(["B", pd.Grouper(level="inner")]).mean()
+            expected = df_single.reset_index().groupby(["B", "inner"]).mean()
         tm.assert_frame_equal(result, expected)
 
         # Test the reverse grouping order
-        result = df_single.groupby([pd.Grouper(level="inner"), "B"]).mean()
-        expected = df_single.reset_index().groupby(["inner", "B"]).mean()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df_single.groupby([pd.Grouper(level="inner"), "B"]).mean()
+            expected = df_single.reset_index().groupby(["inner", "B"]).mean()
         tm.assert_frame_equal(result, expected)
 
     def test_groupby_levels_and_columns(self):
@@ -376,8 +385,10 @@ def test_empty_groups(self, df):
     def test_groupby_grouper(self, df):
         grouped = df.groupby("A")
 
-        result = df.groupby(grouped.grouper).mean()
-        expected = grouped.mean()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.groupby(grouped.grouper).mean()
+            expected = grouped.mean()
         tm.assert_frame_equal(result, expected)
 
     def test_groupby_dict_mapping(self):
@@ -460,7 +471,7 @@ def test_multiindex_negative_level(self, mframe):
         tm.assert_frame_equal(result, expected)
 
         result = mframe.groupby(level=[-2, -1]).sum()
-        expected = mframe
+        expected = mframe.sort_index()
         tm.assert_frame_equal(result, expected)
 
         result = mframe.groupby(level=[-1, "first"]).sum()
@@ -669,7 +680,7 @@ def test_evaluate_with_empty_groups(self, func, expected):
         # (not testing other agg fns, because they return
         # different index objects.
         df = DataFrame({1: [], 2: []})
-        g = df.groupby(1)
+        g = df.groupby(1, group_keys=False)
         result = getattr(g[2], func)(lambda x: x)
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 971a447b84cae..501a21981a148 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -47,8 +47,11 @@ def series():
     ],
 )
 def test_grouper_index_level_as_string(frame, key_strs, groupers):
-    result = frame.groupby(key_strs).mean()
-    expected = frame.groupby(groupers).mean()
+    warn = FutureWarning if "B" not in key_strs or "outer" in frame.columns else None
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = frame.groupby(key_strs).mean()
+        expected = frame.groupby(groupers).mean()
     tm.assert_frame_equal(result, expected)
 
 
diff --git a/pandas/tests/groupby/test_indexing.py b/pandas/tests/groupby/test_indexing.py
index 0caa17f387a94..06b77c8f21e30 100644
--- a/pandas/tests/groupby/test_indexing.py
+++ b/pandas/tests/groupby/test_indexing.py
@@ -221,7 +221,7 @@ def test_against_head_and_tail(arg, method, simulated):
 @pytest.mark.parametrize("stop", [None, 0, 1, 10, -1, -10])
 @pytest.mark.parametrize("step", [None, 1, 5])
 def test_against_df_iloc(start, stop, step):
-    # Test that a single group gives the same results as DataFame.iloc
+    # Test that a single group gives the same results as DataFrame.iloc
     n_rows = 30
 
     data = {
@@ -314,3 +314,19 @@ def test_groupby_duplicated_columns(func):
         [[1.5, 3.0, 1.5]], columns=["A", "B", "A"], index=pd.Index(["G"], name="C")
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_get_nonexisting_groups():
+    # GH#32492
+    df = pd.DataFrame(
+        data={
+            "A": ["a1", "a2", None],
+            "B": ["b1", "b2", "b1"],
+            "val": [1, 2, 3],
+        }
+    )
+    grps = df.groupby(by=["A", "B"])
+
+    msg = "('a2', 'b1')"
+    with pytest.raises(KeyError, match=msg):
+        grps.get_group(("a2", "b1"))
diff --git a/pandas/tests/groupby/test_libgroupby.py b/pandas/tests/groupby/test_libgroupby.py
index 2a24448d24ce2..24abbd0f65795 100644
--- a/pandas/tests/groupby/test_libgroupby.py
+++ b/pandas/tests/groupby/test_libgroupby.py
@@ -112,13 +112,13 @@ def test_group_var_large_inputs(self):
 
         out = np.array([[np.nan]], dtype=self.dtype)
         counts = np.array([0], dtype="int64")
-        values = (prng.rand(10 ** 6) + 10 ** 12).astype(self.dtype)
-        values.shape = (10 ** 6, 1)
-        labels = np.zeros(10 ** 6, dtype="intp")
+        values = (prng.rand(10**6) + 10**12).astype(self.dtype)
+        values.shape = (10**6, 1)
+        labels = np.zeros(10**6, dtype="intp")
 
         self.algo(out, counts, values, labels)
 
-        assert counts[0] == 10 ** 6
+        assert counts[0] == 10**6
         tm.assert_almost_equal(out[0, 0], 1.0 / 12, rtol=0.5e-3)
 
 
@@ -183,9 +183,10 @@ def _check_cython_group_transform_cumulative(pd_op, np_op, dtype):
     tm.assert_numpy_array_equal(np_op(data), answer[:, 0], check_dtype=False)
 
 
-def test_cython_group_transform_cumsum(any_real_numpy_dtype):
+@pytest.mark.parametrize("np_dtype", ["int64", "uint64", "float32", "float64"])
+def test_cython_group_transform_cumsum(np_dtype):
     # see gh-4095
-    dtype = np.dtype(any_real_numpy_dtype).type
+    dtype = np.dtype(np_dtype).type
     pd_op, np_op = group_cumsum, np.cumsum
     _check_cython_group_transform_cumulative(pd_op, np_op, dtype)
 
diff --git a/pandas/tests/groupby/test_min_max.py b/pandas/tests/groupby/test_min_max.py
index 767ef2915d66e..b26ee057d2041 100644
--- a/pandas/tests/groupby/test_min_max.py
+++ b/pandas/tests/groupby/test_min_max.py
@@ -225,3 +225,20 @@ def test_groupby_min_max_nullable(dtype):
 
     res_max4 = gb2.max(min_count=100)
     tm.assert_frame_equal(res_max4, expected2)
+
+
+def test_min_max_nullable_uint64_empty_group():
+    # don't raise NotImplementedError from libgroupby
+    cat = pd.Categorical([0] * 10, categories=[0, 1])
+    df = DataFrame({"A": cat, "B": pd.array(np.arange(10, dtype=np.uint64))})
+    gb = df.groupby("A")
+
+    res = gb.min()
+
+    idx = pd.CategoricalIndex([0, 1], dtype=cat.dtype, name="A")
+    expected = DataFrame({"B": pd.array([0, pd.NA], dtype="UInt64")}, index=idx)
+    tm.assert_frame_equal(res, expected)
+
+    res = gb.max()
+    expected.iloc[0, 0] = 9
+    tm.assert_frame_equal(res, expected)
diff --git a/pandas/tests/groupby/test_nth.py b/pandas/tests/groupby/test_nth.py
index 185b0b8ea8a71..187c80075f36b 100644
--- a/pandas/tests/groupby/test_nth.py
+++ b/pandas/tests/groupby/test_nth.py
@@ -665,7 +665,7 @@ def test_first_categorical_and_datetime_data_nat():
     tm.assert_frame_equal(result, expected)
 
 
-def test_first_multi_key_groupbby_categorical():
+def test_first_multi_key_groupby_categorical():
     # GH 22512
     df = DataFrame(
         {
diff --git a/pandas/tests/groupby/test_numba.py b/pandas/tests/groupby/test_numba.py
index 6554993c140a1..4eb7b6a7b5bea 100644
--- a/pandas/tests/groupby/test_numba.py
+++ b/pandas/tests/groupby/test_numba.py
@@ -10,7 +10,7 @@
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 class TestEngine:
     def test_cython_vs_numba_frame(
@@ -25,7 +25,7 @@ def test_cython_vs_numba_frame(
         )
         expected = getattr(gb, func)(**kwargs)
         # check_dtype can be removed if GH 44952 is addressed
-        check_dtype = func != "sum"
+        check_dtype = func not in ("sum", "min", "max")
         tm.assert_frame_equal(result, expected, check_dtype=check_dtype)
 
     def test_cython_vs_numba_getitem(
@@ -40,7 +40,7 @@ def test_cython_vs_numba_getitem(
         )
         expected = getattr(gb, func)(**kwargs)
         # check_dtype can be removed if GH 44952 is addressed
-        check_dtype = func != "sum"
+        check_dtype = func not in ("sum", "min", "max")
         tm.assert_series_equal(result, expected, check_dtype=check_dtype)
 
     def test_cython_vs_numba_series(
@@ -55,7 +55,7 @@ def test_cython_vs_numba_series(
         )
         expected = getattr(gb, func)(**kwargs)
         # check_dtype can be removed if GH 44952 is addressed
-        check_dtype = func != "sum"
+        check_dtype = func not in ("sum", "min", "max")
         tm.assert_series_equal(result, expected, check_dtype=check_dtype)
 
     def test_as_index_false_unsupported(self, numba_supported_reductions):
diff --git a/pandas/tests/groupby/test_pipe.py b/pandas/tests/groupby/test_pipe.py
index 42bd6a84e05f6..4f58bcb5ee763 100644
--- a/pandas/tests/groupby/test_pipe.py
+++ b/pandas/tests/groupby/test_pipe.py
@@ -27,7 +27,7 @@ def f(dfgb):
         return dfgb.B.max() - dfgb.C.min().min()
 
     def square(srs):
-        return srs ** 2
+        return srs**2
 
     # Note that the transformations are
     # GroupBy -> Series
@@ -60,7 +60,9 @@ def f(dfgb, arg1):
         )
 
     def g(dfgb, arg2):
-        return dfgb.sum() / dfgb.sum().sum() + arg2
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            return dfgb.sum() / dfgb.sum().sum() + arg2
 
     def h(df, arg3):
         return df.x + df.y - arg3
diff --git a/pandas/tests/groupby/test_quantile.py b/pandas/tests/groupby/test_quantile.py
index 1badc4aa7995a..2b7e71d9619a4 100644
--- a/pandas/tests/groupby/test_quantile.py
+++ b/pandas/tests/groupby/test_quantile.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs import lib
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -34,10 +36,13 @@
     ],
 )
 @pytest.mark.parametrize("q", [0, 0.25, 0.5, 0.75, 1])
-def test_quantile(interpolation, a_vals, b_vals, q):
+def test_quantile(interpolation, a_vals, b_vals, q, request):
     if interpolation == "nearest" and q == 0.5 and b_vals == [4, 3, 2, 1]:
-        pytest.skip(
-            "Unclear numpy expectation for nearest result with equidistant data"
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Unclear numpy expectation for nearest "
+                "result with equidistant data"
+            )
         )
 
     a_expected = pd.Series(a_vals).quantile(q, interpolation=interpolation)
@@ -237,14 +242,23 @@ def test_groupby_quantile_nullable_array(values, q):
 
 
 @pytest.mark.parametrize("q", [0.5, [0.0, 0.5, 1.0]])
-def test_groupby_quantile_skips_invalid_dtype(q):
+@pytest.mark.parametrize("numeric_only", [lib.no_default, True, False])
+def test_groupby_quantile_skips_invalid_dtype(q, numeric_only):
     df = DataFrame({"a": [1], "b": [2.0], "c": ["x"]})
 
-    with tm.assert_produces_warning(FutureWarning, match="Dropping invalid columns"):
-        result = df.groupby("a").quantile(q)
+    if numeric_only is lib.no_default or numeric_only:
+        warn = FutureWarning if numeric_only is lib.no_default else None
+        msg = "The default value of numeric_only in DataFrameGroupBy.quantile"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = df.groupby("a").quantile(q, numeric_only=numeric_only)
 
-    expected = df.groupby("a")[["b"]].quantile(q)
-    tm.assert_frame_equal(result, expected)
+        expected = df.groupby("a")[["b"]].quantile(q)
+        tm.assert_frame_equal(result, expected)
+    else:
+        with pytest.raises(
+            TypeError, match="'quantile' cannot be performed against 'object' dtypes!"
+        ):
+            df.groupby("a").quantile(q, numeric_only=numeric_only)
 
 
 def test_groupby_quantile_NA_float(any_float_dtype):
@@ -329,3 +343,38 @@ def test_columns_groupby_quantile():
     )
 
     tm.assert_frame_equal(result, expected)
+
+
+def test_timestamp_groupby_quantile():
+    # GH 33168
+    df = DataFrame(
+        {
+            "timestamp": pd.date_range(
+                start="2020-04-19 00:00:00", freq="1T", periods=100, tz="UTC"
+            ).floor("1H"),
+            "category": list(range(1, 101)),
+            "value": list(range(101, 201)),
+        }
+    )
+
+    result = df.groupby("timestamp").quantile([0.2, 0.8])
+
+    expected = DataFrame(
+        [
+            {"category": 12.8, "value": 112.8},
+            {"category": 48.2, "value": 148.2},
+            {"category": 68.8, "value": 168.8},
+            {"category": 92.2, "value": 192.2},
+        ],
+        index=pd.MultiIndex.from_tuples(
+            [
+                (pd.Timestamp("2020-04-19 00:00:00+00:00"), 0.2),
+                (pd.Timestamp("2020-04-19 00:00:00+00:00"), 0.8),
+                (pd.Timestamp("2020-04-19 01:00:00+00:00"), 0.2),
+                (pd.Timestamp("2020-04-19 01:00:00+00:00"), 0.8),
+            ],
+            names=("timestamp", None),
+        ),
+    )
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_rank.py b/pandas/tests/groupby/test_rank.py
index 83b8d5c29bbf0..8bbe38d3379ac 100644
--- a/pandas/tests/groupby/test_rank.py
+++ b/pandas/tests/groupby/test_rank.py
@@ -458,6 +458,8 @@ def test_rank_avg_even_vals(dtype, upper):
 
     result = df.groupby("key").rank()
     exp_df = DataFrame([2.5, 2.5, 2.5, 2.5], columns=["val"])
+    if upper:
+        exp_df = exp_df.astype("Float64")
     tm.assert_frame_equal(result, exp_df)
 
 
@@ -658,6 +660,22 @@ def test_non_unique_index():
     )
     result = df.groupby([df.index, "A"]).value.rank(ascending=True, pct=True)
     expected = Series(
-        [1.0] * 4, index=[pd.Timestamp("20170101", tz="US/Eastern")] * 4, name="value"
+        [1.0, 1.0, 1.0, np.nan],
+        index=[pd.Timestamp("20170101", tz="US/Eastern")] * 4,
+        name="value",
     )
     tm.assert_series_equal(result, expected)
+
+
+def test_rank_categorical():
+    cat = pd.Categorical(["a", "a", "b", np.nan, "c", "b"], ordered=True)
+    cat2 = pd.Categorical([1, 2, 3, np.nan, 4, 5], ordered=True)
+
+    df = DataFrame({"col1": [0, 1, 0, 1, 0, 1], "col2": cat, "col3": cat2})
+
+    gb = df.groupby("col1")
+
+    res = gb.rank()
+
+    expected = df.astype(object).groupby("col1").rank()
+    tm.assert_frame_equal(res, expected)
diff --git a/pandas/tests/groupby/test_size.py b/pandas/tests/groupby/test_size.py
index f87e4117f57fd..92012436f6b47 100644
--- a/pandas/tests/groupby/test_size.py
+++ b/pandas/tests/groupby/test_size.py
@@ -18,9 +18,32 @@ def test_size(df, by):
         assert result[key] == len(group)
 
 
+@pytest.mark.parametrize(
+    "by",
+    [
+        [0, 0, 0, 0],
+        [0, 1, 1, 1],
+        [1, 0, 1, 1],
+        [0, None, None, None],
+        pytest.param([None, None, None, None], marks=pytest.mark.xfail),
+    ],
+)
+def test_size_axis_1(df, axis_1, by, sort, dropna):
+    # GH#45715
+    counts = {key: sum(value == key for value in by) for key in dict.fromkeys(by)}
+    if dropna:
+        counts = {key: value for key, value in counts.items() if key is not None}
+    expected = Series(counts)
+    if sort:
+        expected = expected.sort_index()
+    grouped = df.groupby(by=by, axis=axis_1, sort=sort, dropna=dropna)
+    result = grouped.size()
+    tm.assert_series_equal(result, expected)
+
+
 @pytest.mark.parametrize("by", ["A", "B", ["A", "B"]])
 @pytest.mark.parametrize("sort", [True, False])
-def test_size_sort(df, sort, by):
+def test_size_sort(sort, by):
     df = DataFrame(np.random.choice(20, (1000, 3)), columns=list("ABC"))
     left = df.groupby(by=by, sort=sort).size()
     right = df.groupby(by=by, sort=sort)["C"].apply(lambda a: a.shape[0])
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index d4b21633309db..ae725cbb2b588 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -105,14 +105,18 @@ def test_groupby_with_timegrouper(self):
             )
             expected.iloc[[0, 6, 18], 0] = np.array([24, 6, 9], dtype="int64")
 
-            result1 = df.resample("5D").sum()
+            msg = "The default value of numeric_only"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result1 = df.resample("5D").sum()
             tm.assert_frame_equal(result1, expected)
 
             df_sorted = df.sort_index()
-            result2 = df_sorted.groupby(Grouper(freq="5D")).sum()
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result2 = df_sorted.groupby(Grouper(freq="5D")).sum()
             tm.assert_frame_equal(result2, expected)
 
-            result3 = df.groupby(Grouper(freq="5D")).sum()
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result3 = df.groupby(Grouper(freq="5D")).sum()
             tm.assert_frame_equal(result3, expected)
 
     @pytest.mark.parametrize("should_sort", [True, False])
@@ -186,7 +190,9 @@ def test_timegrouper_with_reg_groups(self):
                 }
             ).set_index(["Date", "Buyer"])
 
-            result = df.groupby([Grouper(freq="A"), "Buyer"]).sum()
+            msg = "The default value of numeric_only"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result = df.groupby([Grouper(freq="A"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             expected = DataFrame(
@@ -201,7 +207,8 @@ def test_timegrouper_with_reg_groups(self):
                     ],
                 }
             ).set_index(["Date", "Buyer"])
-            result = df.groupby([Grouper(freq="6MS"), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result = df.groupby([Grouper(freq="6MS"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
         df_original = DataFrame(
@@ -239,10 +246,13 @@ def test_timegrouper_with_reg_groups(self):
                 }
             ).set_index(["Date", "Buyer"])
 
-            result = df.groupby([Grouper(freq="1D"), "Buyer"]).sum()
+            warn_msg = "The default value of numeric_only"
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1D"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([Grouper(freq="1M"), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M"), "Buyer"]).sum()
             expected = DataFrame(
                 {
                     "Buyer": "Carl Joe Mark".split(),
@@ -258,7 +268,8 @@ def test_timegrouper_with_reg_groups(self):
 
             # passing the name
             df = df.reset_index()
-            result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             with pytest.raises(KeyError, match="'The grouper name foo is not found'"):
@@ -266,9 +277,11 @@ def test_timegrouper_with_reg_groups(self):
 
             # passing the level
             df = df.set_index("Date")
-            result = df.groupby([Grouper(freq="1M", level="Date"), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M", level="Date"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
-            result = df.groupby([Grouper(freq="1M", level=0), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M", level=0), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             with pytest.raises(ValueError, match="The level foo is not valid"):
@@ -277,7 +290,8 @@ def test_timegrouper_with_reg_groups(self):
             # multi names
             df = df.copy()
             df["Date"] = df.index + offsets.MonthEnd(2)
-            result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
             expected = DataFrame(
                 {
                     "Buyer": "Carl Joe Mark".split(),
@@ -306,18 +320,22 @@ def test_timegrouper_with_reg_groups(self):
                     [datetime(2013, 10, 31, 0, 0)], freq=offsets.MonthEnd(), name="Date"
                 ),
             )
-            result = df.groupby(Grouper(freq="1M")).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby(Grouper(freq="1M")).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([Grouper(freq="1M")]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M")]).sum()
             tm.assert_frame_equal(result, expected)
 
             expected.index = expected.index.shift(1)
             assert expected.index.freq == offsets.MonthEnd()
-            result = df.groupby(Grouper(freq="1M", key="Date")).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby(Grouper(freq="1M", key="Date")).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([Grouper(freq="1M", key="Date")]).sum()
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                result = df.groupby([Grouper(freq="1M", key="Date")]).sum()
             tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("freq", ["D", "M", "A", "Q-APR"])
@@ -593,7 +611,7 @@ def test_groupby_multi_timezone(self):
 4,2000-01-01 16:50:00,America/New_York"""
 
         df = pd.read_csv(StringIO(data), header=None, names=["value", "date", "tz"])
-        result = df.groupby("tz").date.apply(
+        result = df.groupby("tz", group_keys=False).date.apply(
             lambda x: pd.to_datetime(x).dt.tz_localize(x.name)
         )
 
diff --git a/pandas/tests/groupby/test_value_counts.py b/pandas/tests/groupby/test_value_counts.py
index 54f672cb69800..577a72d3f5090 100644
--- a/pandas/tests/groupby/test_value_counts.py
+++ b/pandas/tests/groupby/test_value_counts.py
@@ -22,6 +22,26 @@
 import pandas._testing as tm
 
 
+def tests_value_counts_index_names_category_column():
+    # GH44324 Missing name of index category column
+    df = DataFrame(
+        {
+            "gender": ["female"],
+            "country": ["US"],
+        }
+    )
+    df["gender"] = df["gender"].astype("category")
+    result = df.groupby("country")["gender"].value_counts()
+
+    # Construct expected, very specific multiindex
+    df_mi_expected = DataFrame([["US", "female"]], columns=["country", "gender"])
+    df_mi_expected["gender"] = df_mi_expected["gender"].astype("category")
+    mi_expected = MultiIndex.from_frame(df_mi_expected)
+    expected = Series([1], index=mi_expected, name="gender")
+
+    tm.assert_series_equal(result, expected)
+
+
 # our starting frame
 def seed_df(seed_nans, n, m):
     np.random.seed(1234)
@@ -163,12 +183,11 @@ def test_series_groupby_value_counts_on_categorical():
                 ),
             ]
         ),
-        name=0,
     )
 
     # Expected:
     # 0  a    1
     #    b    0
-    # Name: 0, dtype: int64
+    # dtype: int64
 
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/transform/test_numba.py b/pandas/tests/groupby/transform/test_numba.py
index 4e1b777296d5b..2b70d7325a209 100644
--- a/pandas/tests/groupby/transform/test_numba.py
+++ b/pandas/tests/groupby/transform/test_numba.py
@@ -9,7 +9,6 @@
     option_context,
 )
 import pandas._testing as tm
-from pandas.core.util.numba_ import NUMBA_FUNC_CACHE
 
 
 @td.skip_if_no("numba")
@@ -30,8 +29,8 @@ def incorrect_function(x):
 
 @td.skip_if_no("numba")
 def test_check_nopython_kwargs():
-    def incorrect_function(x, **kwargs):
-        return x + 1
+    def incorrect_function(values, index):
+        return values + 1
 
     data = DataFrame(
         {"key": ["a", "a", "b", "b", "a"], "data": [1.0, 2.0, 3.0, 4.0, 5.0]},
@@ -45,7 +44,7 @@ def incorrect_function(x, **kwargs):
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 @pytest.mark.parametrize("jit", [True, False])
 @pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
@@ -74,7 +73,7 @@ def func(values, index):
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 @pytest.mark.parametrize("jit", [True, False])
 @pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
@@ -103,14 +102,10 @@ def func_2(values, index):
     result = grouped.transform(func_1, engine="numba", engine_kwargs=engine_kwargs)
     expected = grouped.transform(lambda x: x + 1, engine="cython")
     tm.assert_equal(result, expected)
-    # func_1 should be in the cache now
-    assert (func_1, "groupby_transform") in NUMBA_FUNC_CACHE
 
-    # Add func_2 to the cache
     result = grouped.transform(func_2, engine="numba", engine_kwargs=engine_kwargs)
     expected = grouped.transform(lambda x: x * 5, engine="cython")
     tm.assert_equal(result, expected)
-    assert (func_2, "groupby_transform") in NUMBA_FUNC_CACHE
 
     # Retest func_1 which should use the cache
     result = grouped.transform(func_1, engine="numba", engine_kwargs=engine_kwargs)
@@ -176,3 +171,59 @@ def f(values, index):
     result = df.groupby("group").transform(f, engine="numba")
     expected = DataFrame([-4.0, -3.0, -2.0], columns=["v"], index=[-1, -2, -3])
     tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_engine_kwargs_not_cached():
+    # If the user passes a different set of engine_kwargs don't return the same
+    # jitted function
+    nogil = True
+    parallel = False
+    nopython = True
+
+    def func_kwargs(values, index):
+        return nogil + parallel + nopython
+
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    df = DataFrame({"value": [0, 0, 0]})
+    result = df.groupby(level=0).transform(
+        func_kwargs, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame({"value": [2.0, 2.0, 2.0]})
+    tm.assert_frame_equal(result, expected)
+
+    nogil = False
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    result = df.groupby(level=0).transform(
+        func_kwargs, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame({"value": [1.0, 1.0, 1.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+@pytest.mark.filterwarnings("ignore")
+def test_multiindex_one_key(nogil, parallel, nopython):
+    def numba_func(values, index):
+        return 1
+
+    df = DataFrame([{"A": 1, "B": 2, "C": 3}]).set_index(["A", "B"])
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    result = df.groupby("A").transform(
+        numba_func, engine="numba", engine_kwargs=engine_kwargs
+    )
+    expected = DataFrame([{"A": 1, "B": 2, "C": 1.0}]).set_index(["A", "B"])
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_multiindex_multi_key_not_supported(nogil, parallel, nopython):
+    def numba_func(values, index):
+        return 1
+
+    df = DataFrame([{"A": 1, "B": 2, "C": 3}]).set_index(["A", "B"])
+    engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+    with pytest.raises(NotImplementedError, match="More than 1 grouping labels"):
+        df.groupby(["A", "B"]).transform(
+            numba_func, engine="numba", engine_kwargs=engine_kwargs
+        )
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 12a25a1e61211..5b5b28be4a501 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -21,10 +21,8 @@
 )
 import pandas._testing as tm
 from pandas.core.groupby.base import maybe_normalize_deprecated_kernels
-from pandas.core.groupby.generic import (
-    DataFrameGroupBy,
-    SeriesGroupBy,
-)
+from pandas.core.groupby.generic import DataFrameGroupBy
+from pandas.tests.groupby import get_groupby_method_args
 
 
 def assert_fp_equal(a, b):
@@ -70,7 +68,7 @@ def demean(arr):
     )
     key = ["one", "two", "one", "two", "one"]
     result = people.groupby(key).transform(demean).groupby(key).mean()
-    expected = people.groupby(key).apply(demean).groupby(key).mean()
+    expected = people.groupby(key, group_keys=False).apply(demean).groupby(key).mean()
     tm.assert_frame_equal(result, expected)
 
     # GH 8430
@@ -165,24 +163,20 @@ def test_transform_broadcast(tsframe, ts):
             assert_fp_equal(res.xs(idx), agged[idx])
 
 
-def test_transform_axis_1(request, transformation_func, using_array_manager):
+def test_transform_axis_1(request, transformation_func):
     # GH 36308
-    if using_array_manager and transformation_func == "pct_change":
-        # TODO(ArrayManager) column-wise shift
-        request.node.add_marker(
-            pytest.mark.xfail(reason="ArrayManager: shift axis=1 not yet implemented")
-        )
+
     # TODO(2.0) Remove after pad/backfill deprecation enforced
     transformation_func = maybe_normalize_deprecated_kernels(transformation_func)
 
-    warn = None
-    if transformation_func == "tshift":
-        warn = FutureWarning
+    if transformation_func == "ngroup":
+        msg = "ngroup fails with axis=1: #45986"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
 
-        request.node.add_marker(pytest.mark.xfail(reason="tshift is deprecated"))
-    args = ("ffill",) if transformation_func == "fillna" else ()
+    warn = FutureWarning if transformation_func == "tshift" else None
 
     df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]}, index=["x", "y"])
+    args = get_groupby_method_args(transformation_func, df)
     with tm.assert_produces_warning(warn):
         result = df.groupby([0, 0, 1], axis=1).transform(transformation_func, *args)
         expected = df.T.groupby([0, 0, 1]).transform(transformation_func, *args).T
@@ -195,6 +189,36 @@ def test_transform_axis_1(request, transformation_func, using_array_manager):
     tm.assert_equal(result, expected)
 
 
+def test_transform_axis_1_reducer(request, reduction_func):
+    # GH#45715
+    if reduction_func in (
+        "corrwith",
+        "idxmax",
+        "idxmin",
+        "ngroup",
+        "nth",
+    ):
+        marker = pytest.mark.xfail(reason="transform incorrectly fails - GH#45986")
+        request.node.add_marker(marker)
+    if reduction_func == "mad":
+        warn = FutureWarning
+        msg = "The 'mad' method is deprecated"
+    elif reduction_func in ("sem", "std"):
+        warn = FutureWarning
+        msg = "The default value of numeric_only"
+    else:
+        warn = None
+        msg = ""
+
+    df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]}, index=["x", "y"])
+    with tm.assert_produces_warning(warn, match=msg):
+        result = df.groupby([0, 0, 1], axis=1).transform(reduction_func)
+    warn = FutureWarning if reduction_func == "mad" else None
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        expected = df.T.groupby([0, 0, 1]).transform(reduction_func).T
+    tm.assert_equal(result, expected)
+
+
 def test_transform_axis_ts(tsframe):
 
     # make sure that we are setting the axes
@@ -210,26 +234,26 @@ def test_transform_axis_ts(tsframe):
     )
     # monotonic
     ts = tso
-    grouped = ts.groupby(lambda x: x.weekday())
+    grouped = ts.groupby(lambda x: x.weekday(), group_keys=False)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: x - x.mean())
     tm.assert_frame_equal(result, expected)
 
     ts = ts.T
-    grouped = ts.groupby(lambda x: x.weekday(), axis=1)
+    grouped = ts.groupby(lambda x: x.weekday(), axis=1, group_keys=False)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: (x.T - x.mean(1)).T)
     tm.assert_frame_equal(result, expected)
 
     # non-monotonic
     ts = tso.iloc[[1, 0] + list(range(2, len(base)))]
-    grouped = ts.groupby(lambda x: x.weekday())
+    grouped = ts.groupby(lambda x: x.weekday(), group_keys=False)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: x - x.mean())
     tm.assert_frame_equal(result, expected)
 
     ts = ts.T
-    grouped = ts.groupby(lambda x: x.weekday(), axis=1)
+    grouped = ts.groupby(lambda x: x.weekday(), axis=1, group_keys=False)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: (x.T - x.mean(1)).T)
     tm.assert_frame_equal(result, expected)
@@ -369,6 +393,15 @@ def test_transform_transformation_func(request, transformation_func):
     elif transformation_func == "fillna":
         test_op = lambda x: x.transform("fillna", value=0)
         mock_op = lambda x: x.fillna(value=0)
+    elif transformation_func == "ngroup":
+        test_op = lambda x: x.transform("ngroup")
+        counter = -1
+
+        def mock_op(x):
+            nonlocal counter
+            counter += 1
+            return Series(counter, index=x.index)
+
     elif transformation_func == "tshift":
         msg = (
             "Current behavior of groupby.tshift is inconsistent with other "
@@ -380,10 +413,14 @@ def test_transform_transformation_func(request, transformation_func):
         mock_op = lambda x: getattr(x, transformation_func)()
 
     result = test_op(df.groupby("A"))
-    groups = [df[["B"]].iloc[:4], df[["B"]].iloc[4:6], df[["B"]].iloc[6:]]
-    expected = concat([mock_op(g) for g in groups])
-
-    if transformation_func == "cumcount":
+    # pass the group in same order as iterating `for ... in df.groupby(...)`
+    # but reorder to match df's index since this is a transform
+    groups = [df[["B"]].iloc[4:6], df[["B"]].iloc[6:], df[["B"]].iloc[:4]]
+    expected = concat([mock_op(g) for g in groups]).sort_index()
+    # sort_index does not preserve the freq
+    expected = expected.set_axis(df.index)
+
+    if transformation_func in ("cumcount", "ngroup"):
         tm.assert_series_equal(result, expected)
     else:
         tm.assert_frame_equal(result, expected)
@@ -399,43 +436,36 @@ def test_transform_select_columns(df):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize("duplicates", [True, False])
-def test_transform_exclude_nuisance(df, duplicates):
+def test_transform_exclude_nuisance(df):
     # case that goes through _transform_item_by_item
 
-    if duplicates:
-        # make sure we work with duplicate columns GH#41427
-        df.columns = ["A", "C", "C", "D"]
+    df.columns = ["A", "B", "B", "D"]
 
     # this also tests orderings in transform between
     # series/frame to make sure it's consistent
     expected = {}
     grouped = df.groupby("A")
 
-    gbc = grouped["C"]
-    warn = FutureWarning if duplicates else None
-    with tm.assert_produces_warning(warn, match="Dropping invalid columns"):
-        expected["C"] = gbc.transform(np.mean)
-    if duplicates:
-        # squeeze 1-column DataFrame down to Series
-        expected["C"] = expected["C"]["C"]
+    gbc = grouped["B"]
+    with tm.assert_produces_warning(FutureWarning, match="Dropping invalid columns"):
+        expected["B"] = gbc.transform(lambda x: np.mean(x))
+    # squeeze 1-column DataFrame down to Series
+    expected["B"] = expected["B"]["B"]
 
-        assert isinstance(gbc.obj, DataFrame)
-        assert isinstance(gbc, DataFrameGroupBy)
-    else:
-        assert isinstance(gbc, SeriesGroupBy)
-        assert isinstance(gbc.obj, Series)
+    assert isinstance(gbc.obj, DataFrame)
+    assert isinstance(gbc, DataFrameGroupBy)
 
     expected["D"] = grouped["D"].transform(np.mean)
     expected = DataFrame(expected)
     with tm.assert_produces_warning(FutureWarning, match="Dropping invalid columns"):
-        result = df.groupby("A").transform(np.mean)
+        result = df.groupby("A").transform(lambda x: np.mean(x))
 
     tm.assert_frame_equal(result, expected)
 
 
 def test_transform_function_aliases(df):
-    with tm.assert_produces_warning(FutureWarning, match="Dropping invalid columns"):
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
         result = df.groupby("A").transform("mean")
         expected = df.groupby("A").transform(np.mean)
     tm.assert_frame_equal(result, expected)
@@ -484,7 +514,7 @@ def test_transform_coercion():
     # 14457
     # when we are transforming be sure to not coerce
     # via assignment
-    df = DataFrame({"A": ["a", "a"], "B": [0, 1]})
+    df = DataFrame({"A": ["a", "a", "b", "b"], "B": [0, 1, 3, 4]})
     g = df.groupby("A")
 
     expected = g.transform(np.mean)
@@ -731,7 +761,7 @@ def test_cython_transform_frame(op, args, targop):
         ]:  # {"by": 'string_missing'}]:
             # {"by": ['int','string']}]:
 
-            gb = df.groupby(**gb_target)
+            gb = df.groupby(group_keys=False, **gb_target)
             # allowlisted methods set the selection before applying
             # bit a of hack to make sure the cythonized shift
             # is equivalent to pre 0.17.1 behavior
@@ -748,8 +778,15 @@ def test_cython_transform_frame(op, args, targop):
                 expected = gb.apply(targop)
 
             expected = expected.sort_index(axis=1)
-            tm.assert_frame_equal(expected, gb.transform(op, *args).sort_index(axis=1))
-            tm.assert_frame_equal(expected, getattr(gb, op)(*args).sort_index(axis=1))
+
+            warn = None if op == "shift" else FutureWarning
+            msg = "The default value of numeric_only"
+            with tm.assert_produces_warning(warn, match=msg):
+                result = gb.transform(op, *args).sort_index(axis=1)
+            tm.assert_frame_equal(result, expected)
+            with tm.assert_produces_warning(warn, match=msg):
+                result = getattr(gb, op)(*args).sort_index(axis=1)
+            tm.assert_frame_equal(result, expected)
             # individual columns
             for c in df:
                 if (
@@ -803,39 +840,29 @@ def test_transform_with_non_scalar_group():
 
 
 @pytest.mark.parametrize(
-    "cols,exp,comp_func",
+    "cols,expected",
     [
-        ("a", Series([1, 1, 1], name="a"), tm.assert_series_equal),
+        ("a", Series([1, 1, 1], name="a")),
         (
             ["a", "c"],
             DataFrame({"a": [1, 1, 1], "c": [1, 1, 1]}),
-            tm.assert_frame_equal,
         ),
     ],
 )
 @pytest.mark.parametrize("agg_func", ["count", "rank", "size"])
-def test_transform_numeric_ret(cols, exp, comp_func, agg_func, request):
-    if agg_func == "size" and isinstance(cols, list):
-        # https://github.com/pytest-dev/pytest/issues/6300
-        # workaround to xfail fixture/param permutations
-        reason = "'size' transformation not supported with NDFrameGroupy"
-        request.node.add_marker(pytest.mark.xfail(reason=reason))
-
-    # GH 19200
+def test_transform_numeric_ret(cols, expected, agg_func):
+    # GH#19200 and GH#27469
     df = DataFrame(
         {"a": date_range("2018-01-01", periods=3), "b": range(3), "c": range(7, 10)}
     )
-
-    warn = FutureWarning
-    if isinstance(exp, Series) or agg_func != "size":
-        warn = None
-    with tm.assert_produces_warning(warn, match="Dropping invalid columns"):
-        result = df.groupby("b")[cols].transform(agg_func)
+    result = df.groupby("b")[cols].transform(agg_func)
 
     if agg_func == "rank":
-        exp = exp.astype("float")
-
-    comp_func(result, exp)
+        expected = expected.astype("float")
+    elif agg_func == "size" and cols == ["a", "c"]:
+        # transform("size") returns a Series
+        expected = expected["a"].rename(None)
+    tm.assert_equal(result, expected)
 
 
 def test_transform_ffill():
@@ -1027,7 +1054,7 @@ def demean_rename(x):
         if isinstance(x, Series):
             return result
 
-        result = result.rename(columns={c: "{c}_demeaned" for c in result.columns})
+        result = result.rename(columns={c: f"{c}_demeaned" for c in result.columns})
 
         return result
 
@@ -1125,33 +1152,24 @@ def test_transform_invalid_name_raises():
 )
 def test_transform_agg_by_name(request, reduction_func, obj):
     func = reduction_func
+    warn = FutureWarning if func == "mad" else None
+
     g = obj.groupby(np.repeat([0, 1], 3))
 
-    if func == "ngroup":  # GH#27468
-        request.node.add_marker(
-            pytest.mark.xfail(reason="TODO: g.transform('ngroup') doesn't work")
-        )
-    if func == "size" and obj.ndim == 2:  # GH#27469
-        request.node.add_marker(
-            pytest.mark.xfail(reason="TODO: g.transform('size') doesn't work")
-        )
     if func == "corrwith" and isinstance(obj, Series):  # GH#32293
         request.node.add_marker(
             pytest.mark.xfail(reason="TODO: implement SeriesGroupBy.corrwith")
         )
 
-    args = {"nth": [0], "quantile": [0.5], "corrwith": [obj]}.get(func, [])
-
-    warn = None
-    if isinstance(obj, DataFrame) and func == "size":
-        warn = FutureWarning
-
-    with tm.assert_produces_warning(warn, match="Dropping invalid columns"):
+    args = get_groupby_method_args(reduction_func, obj)
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
         result = g.transform(func, *args)
 
     # this is the *definition* of a transformation
     tm.assert_index_equal(result.index, obj.index)
-    if hasattr(obj, "columns"):
+
+    if func not in ("ngroup", "size") and obj.ndim == 2:
+        # size/ngroup return a Series, unlike other transforms
         tm.assert_index_equal(result.columns, obj.columns)
 
     # verify that values were broadcasted across each group
@@ -1303,9 +1321,260 @@ def test_transform_cumcount():
     tm.assert_series_equal(result, expected)
 
 
-def test_null_group_lambda_self():
+@pytest.mark.parametrize("keys", [["A1"], ["A1", "A2"]])
+def test_null_group_lambda_self(sort, dropna, keys):
+    # GH 17093
+    size = 50
+    nulls1 = np.random.choice([False, True], size)
+    nulls2 = np.random.choice([False, True], size)
+    # Whether a group contains a null value or not
+    nulls_grouper = nulls1 if len(keys) == 1 else nulls1 | nulls2
+
+    a1 = np.random.randint(0, 5, size=size).astype(float)
+    a1[nulls1] = np.nan
+    a2 = np.random.randint(0, 5, size=size).astype(float)
+    a2[nulls2] = np.nan
+    values = np.random.randint(0, 5, size=a1.shape)
+    df = DataFrame({"A1": a1, "A2": a2, "B": values})
+
+    expected_values = values
+    if dropna and nulls_grouper.any():
+        expected_values = expected_values.astype(float)
+        expected_values[nulls_grouper] = np.nan
+    expected = DataFrame(expected_values, columns=["B"])
+
+    gb = df.groupby(keys, dropna=dropna, sort=sort)
+    result = gb[["B"]].transform(lambda x: x)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_null_group_str_reducer(request, dropna, reduction_func):
+    # GH 17093
+    if reduction_func == "corrwith":
+        msg = "incorrectly raises"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+    warn = FutureWarning if reduction_func == "mad" else None
+
+    index = [1, 2, 3, 4]  # test transform preserves non-standard index
+    df = DataFrame({"A": [1, 1, np.nan, np.nan], "B": [1, 2, 2, 3]}, index=index)
+    gb = df.groupby("A", dropna=dropna)
+
+    args = get_groupby_method_args(reduction_func, df)
+
+    # Manually handle reducers that don't fit the generic pattern
+    # Set expected with dropna=False, then replace if necessary
+    if reduction_func == "first":
+        expected = DataFrame({"B": [1, 1, 2, 2]}, index=index)
+    elif reduction_func == "last":
+        expected = DataFrame({"B": [2, 2, 3, 3]}, index=index)
+    elif reduction_func == "nth":
+        expected = DataFrame({"B": [1, 1, 2, 2]}, index=index)
+    elif reduction_func == "size":
+        expected = Series([2, 2, 2, 2], index=index)
+    elif reduction_func == "corrwith":
+        expected = DataFrame({"B": [1.0, 1.0, 1.0, 1.0]}, index=index)
+    else:
+        expected_gb = df.groupby("A", dropna=False)
+        buffer = []
+        for idx, group in expected_gb:
+            with tm.assert_produces_warning(
+                warn, match="The 'mad' method is deprecated"
+            ):
+                res = getattr(group["B"], reduction_func)()
+            buffer.append(Series(res, index=group.index))
+        expected = concat(buffer).to_frame("B")
+    if dropna:
+        dtype = object if reduction_func in ("any", "all") else float
+        expected = expected.astype(dtype)
+        if expected.ndim == 2:
+            expected.iloc[[2, 3], 0] = np.nan
+        else:
+            expected.iloc[[2, 3]] = np.nan
+
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = gb.transform(reduction_func, *args)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore:tshift is deprecated:FutureWarning")
+def test_null_group_str_transformer(request, dropna, transformation_func):
+    # GH 17093
+    if transformation_func == "tshift":
+        msg = "tshift requires timeseries"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+    df = DataFrame({"A": [1, 1, np.nan], "B": [1, 2, 2]}, index=[1, 2, 3])
+    args = get_groupby_method_args(transformation_func, df)
+    gb = df.groupby("A", dropna=dropna)
+
+    buffer = []
+    for k, (idx, group) in enumerate(gb):
+        if transformation_func == "cumcount":
+            # DataFrame has no cumcount method
+            res = DataFrame({"B": range(len(group))}, index=group.index)
+        elif transformation_func == "ngroup":
+            res = DataFrame(len(group) * [k], index=group.index, columns=["B"])
+        else:
+            res = getattr(group[["B"]], transformation_func)(*args)
+        buffer.append(res)
+    if dropna:
+        dtype = object if transformation_func in ("any", "all") else None
+        buffer.append(DataFrame([[np.nan]], index=[3], dtype=dtype, columns=["B"]))
+    expected = concat(buffer)
+
+    if transformation_func in ("cumcount", "ngroup"):
+        # ngroup/cumcount always returns a Series as it counts the groups, not values
+        expected = expected["B"].rename(None)
+
+    warn = FutureWarning if transformation_func in ("backfill", "pad") else None
+    msg = f"{transformation_func} is deprecated"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = gb.transform(transformation_func, *args)
+
+    tm.assert_equal(result, expected)
+
+
+def test_null_group_str_reducer_series(request, dropna, reduction_func):
+    # GH 17093
+    if reduction_func == "corrwith":
+        msg = "corrwith not implemented for SeriesGroupBy"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+    warn = FutureWarning if reduction_func == "mad" else None
+
+    # GH 17093
+    index = [1, 2, 3, 4]  # test transform preserves non-standard index
+    ser = Series([1, 2, 2, 3], index=index)
+    gb = ser.groupby([1, 1, np.nan, np.nan], dropna=dropna)
+
+    args = get_groupby_method_args(reduction_func, ser)
+
+    # Manually handle reducers that don't fit the generic pattern
+    # Set expected with dropna=False, then replace if necessary
+    if reduction_func == "first":
+        expected = Series([1, 1, 2, 2], index=index)
+    elif reduction_func == "last":
+        expected = Series([2, 2, 3, 3], index=index)
+    elif reduction_func == "nth":
+        expected = Series([1, 1, 2, 2], index=index)
+    elif reduction_func == "size":
+        expected = Series([2, 2, 2, 2], index=index)
+    elif reduction_func == "corrwith":
+        expected = Series([1, 1, 2, 2], index=index)
+    else:
+        expected_gb = ser.groupby([1, 1, np.nan, np.nan], dropna=False)
+        buffer = []
+        for idx, group in expected_gb:
+            with tm.assert_produces_warning(
+                warn, match="The 'mad' method is deprecated"
+            ):
+                res = getattr(group, reduction_func)()
+            buffer.append(Series(res, index=group.index))
+        expected = concat(buffer)
+    if dropna:
+        dtype = object if reduction_func in ("any", "all") else float
+        expected = expected.astype(dtype)
+        expected.iloc[[2, 3]] = np.nan
+
+    with tm.assert_produces_warning(warn, match="The 'mad' method is deprecated"):
+        result = gb.transform(reduction_func, *args)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore:tshift is deprecated:FutureWarning")
+def test_null_group_str_transformer_series(request, dropna, transformation_func):
     # GH 17093
-    df = DataFrame({"A": [1, np.nan], "B": [1, 1]})
-    result = df.groupby("A").transform(lambda x: x)
-    expected = DataFrame([1], columns=["B"])
+    if transformation_func == "tshift":
+        msg = "tshift requires timeseries"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+    ser = Series([1, 2, 2], index=[1, 2, 3])
+    args = get_groupby_method_args(transformation_func, ser)
+    gb = ser.groupby([1, 1, np.nan], dropna=dropna)
+
+    buffer = []
+    for k, (idx, group) in enumerate(gb):
+        if transformation_func == "cumcount":
+            # Series has no cumcount method
+            res = Series(range(len(group)), index=group.index)
+        elif transformation_func == "ngroup":
+            res = Series(k, index=group.index)
+        else:
+            res = getattr(group, transformation_func)(*args)
+        buffer.append(res)
+    if dropna:
+        dtype = object if transformation_func in ("any", "all") else None
+        buffer.append(Series([np.nan], index=[3], dtype=dtype))
+    expected = concat(buffer)
+
+    warn = FutureWarning if transformation_func in ("backfill", "pad") else None
+    msg = f"{transformation_func} is deprecated"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = gb.transform(transformation_func, *args)
+
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func, series, expected_values",
+    [
+        (Series.sort_values, False, [4, 5, 3, 1, 2]),
+        (lambda x: x.head(1), False, ValueError),
+        # SeriesGroupBy already has correct behavior
+        (Series.sort_values, True, [5, 4, 3, 2, 1]),
+        (lambda x: x.head(1), True, [5.0, np.nan, 3.0, 2.0, np.nan]),
+    ],
+)
+@pytest.mark.parametrize("keys", [["a1"], ["a1", "a2"]])
+@pytest.mark.parametrize("keys_in_index", [True, False])
+def test_transform_aligns_depr(func, series, expected_values, keys, keys_in_index):
+    # GH#45648 - transform should align with the input's index
+    df = DataFrame({"a1": [1, 1, 3, 2, 2], "b": [5, 4, 3, 2, 1]})
+    if "a2" in keys:
+        df["a2"] = df["a1"]
+    if keys_in_index:
+        df = df.set_index(keys, append=True)
+
+    gb = df.groupby(keys)
+    if series:
+        gb = gb["b"]
+
+    warn = None if series else FutureWarning
+    msg = "returning a DataFrame in groupby.transform will align"
+    if expected_values is ValueError:
+        with tm.assert_produces_warning(warn, match=msg):
+            with pytest.raises(ValueError, match="Length mismatch"):
+                gb.transform(func)
+    else:
+        with tm.assert_produces_warning(warn, match=msg):
+            result = gb.transform(func)
+        expected = DataFrame({"b": expected_values}, index=df.index)
+        if series:
+            expected = expected["b"]
+        tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("keys", ["A", ["A", "B"]])
+def test_as_index_no_change(keys, df, groupby_func):
+    # GH#49834 - as_index should have no impact on DataFrameGroupBy.transform
+    if keys == "A":
+        # Column B is string dtype; will fail on some ops
+        df = df.drop(columns="B")
+    args = get_groupby_method_args(groupby_func, df)
+    gb_as_index_true = df.groupby(keys, as_index=True)
+    gb_as_index_false = df.groupby(keys, as_index=False)
+    result = gb_as_index_true.transform(groupby_func, *args)
+    expected = gb_as_index_false.transform(groupby_func, *args)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", [np.mean, np.cumprod])
+def test_numeric_only_warning_numpy(func):
+    # GH#50538
+    df = DataFrame({"a": [1, 1, 2], "b": list("xyz"), "c": [3, 4, 5]})
+    gb = df.groupby("a")
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        gb.transform(func)
+    # Ensure users can pass numeric_only
+    result = gb.transform(func, numeric_only=True)
+    values = [3.5, 3.5, 5.0] if func == np.mean else [3, 12, 5]
+    expected = DataFrame({"c": values})
     tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexes/base_class/test_constructors.py b/pandas/tests/indexes/base_class/test_constructors.py
index bc894579340ab..df04502a01f99 100644
--- a/pandas/tests/indexes/base_class/test_constructors.py
+++ b/pandas/tests/indexes/base_class/test_constructors.py
@@ -40,3 +40,11 @@ def test_constructor_cast(self):
         msg = "could not convert string to float"
         with pytest.raises(ValueError, match=msg):
             Index(["a", "b", "c"], dtype=float)
+
+    @pytest.mark.parametrize("tuple_list", [[()], [(), ()]])
+    def test_construct_empty_tuples(self, tuple_list):
+        # GH #45608
+        result = Index(tuple_list)
+        expected = MultiIndex.from_tuples(tuple_list)
+
+        tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/base_class/test_indexing.py b/pandas/tests/indexes/base_class/test_indexing.py
index 9cd582925ff79..770fa3f6e5dc1 100644
--- a/pandas/tests/indexes/base_class/test_indexing.py
+++ b/pandas/tests/indexes/base_class/test_indexing.py
@@ -51,7 +51,7 @@ def test_get_loc_tuple_monotonic_above_size_cutoff(self):
         lev = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
         dti = pd.date_range("2016-01-01", periods=100)
 
-        mi = pd.MultiIndex.from_product([lev, range(10 ** 3), dti])
+        mi = pd.MultiIndex.from_product([lev, range(10**3), dti])
         oidx = mi.to_flat_index()
 
         loc = len(oidx) // 2
@@ -76,3 +76,11 @@ def test_get_loc_nan_object_dtype_nonmonotonic_nonunique(self):
         # we don't match at all on mismatched NA
         with pytest.raises(KeyError, match="NaT"):
             idx.get_loc(NaT)
+
+
+def test_getitem_boolean_ea_indexer():
+    # GH#45806
+    ser = pd.Series([True, False, pd.NA], dtype="boolean")
+    result = ser.index[ser]
+    expected = Index([0])
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 2ae6ce99b4ee8..06c00123566ba 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -25,7 +25,7 @@ def simple_index(self) -> CategoricalIndex:
         return self._index_cls(list("aabbca"), categories=list("cab"), ordered=False)
 
     @pytest.fixture
-    def index(self, request):
+    def index(self):
         return tm.makeCategoricalIndex(100)
 
     def create_index(self, *, categories=None, ordered=False):
@@ -290,6 +290,24 @@ def test_map_str(self):
 class TestCategoricalIndex2:
     # Tests that are not overriding a test in Base
 
+    def test_view_i8(self):
+        # GH#25464
+        ci = tm.makeCategoricalIndex(100)
+        msg = "When changing to a larger dtype, its size must be a divisor"
+        with pytest.raises(ValueError, match=msg):
+            ci.view("i8")
+        with pytest.raises(ValueError, match=msg):
+            ci._data.view("i8")
+
+        ci = ci[:-4]  # length divisible by 8
+
+        res = ci.view("i8")
+        expected = ci._data.codes.view("i8")
+        tm.assert_numpy_array_equal(res, expected)
+
+        cat = ci._data
+        tm.assert_numpy_array_equal(cat.view("i8"), expected)
+
     @pytest.mark.parametrize(
         "dtype, engine_type",
         [
diff --git a/pandas/tests/indexes/categorical/test_formats.py b/pandas/tests/indexes/categorical/test_formats.py
index 044b03579d535..d7812888556ea 100644
--- a/pandas/tests/indexes/categorical/test_formats.py
+++ b/pandas/tests/indexes/categorical/test_formats.py
@@ -24,7 +24,7 @@ def test_string_categorical_index_repr(self):
         expected = """CategoricalIndex(['a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a',
                   'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb',
                   'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc'],
-                 categories=['a', 'bb', 'ccc'], ordered=False, dtype='category')"""
+                 categories=['a', 'bb', 'ccc'], ordered=False, dtype='category')"""  # noqa:E501
 
         assert repr(idx) == expected
 
@@ -41,7 +41,7 @@ def test_string_categorical_index_repr(self):
         idx = CategoricalIndex(list("abcdefghijklmmo"))
         expected = """CategoricalIndex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
                   'm', 'm', 'o'],
-                 categories=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', ...], ordered=False, dtype='category')"""  # noqa:E501
+                 categories=['a', 'b', 'c', 'd', ..., 'k', 'l', 'm', 'o'], ordered=False, dtype='category')"""  # noqa:E501
 
         assert repr(idx) == expected
 
@@ -55,7 +55,7 @@ def test_string_categorical_index_repr(self):
         expected = """CategoricalIndex(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ',
                   'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',
                   'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう'],
-                 categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')"""
+                 categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')"""  # noqa:E501
 
         assert repr(idx) == expected
 
@@ -72,7 +72,7 @@ def test_string_categorical_index_repr(self):
         idx = CategoricalIndex(list("あいうえおかきくけこさしすせそ"))
         expected = """CategoricalIndex(['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ', 'さ', 'し',
                   'す', 'せ', 'そ'],
-                 categories=['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', ...], ordered=False, dtype='category')"""  # noqa:E501
+                 categories=['あ', 'い', 'う', 'え', ..., 'し', 'す', 'せ', 'そ'], ordered=False, dtype='category')"""  # noqa:E501
 
         assert repr(idx) == expected
 
@@ -90,7 +90,7 @@ def test_string_categorical_index_repr(self):
                   'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう',
                   'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',
                   'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう'],
-                 categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')"""
+                 categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')"""  # noqa:E501
 
             assert repr(idx) == expected
 
@@ -109,6 +109,6 @@ def test_string_categorical_index_repr(self):
             idx = CategoricalIndex(list("あいうえおかきくけこさしすせそ"))
             expected = """CategoricalIndex(['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ',
                   'さ', 'し', 'す', 'せ', 'そ'],
-                 categories=['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', ...], ordered=False, dtype='category')"""  # noqa:E501
+                 categories=['あ', 'い', 'う', 'え', ..., 'し', 'す', 'せ', 'そ'], ordered=False, dtype='category')"""  # noqa:E501
 
             assert repr(idx) == expected
diff --git a/pandas/tests/indexes/categorical/test_indexing.py b/pandas/tests/indexes/categorical/test_indexing.py
index 2297f8cf87209..588486452fc20 100644
--- a/pandas/tests/indexes/categorical/test_indexing.py
+++ b/pandas/tests/indexes/categorical/test_indexing.py
@@ -298,6 +298,18 @@ def test_get_indexer_same_categories_different_order(self):
         expected = np.array([1, 1], dtype="intp")
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_get_indexer_nans_in_index_and_target(self):
+        # GH 45361
+        ci = CategoricalIndex([1, 2, np.nan, 3])
+        other1 = [2, 3, 4, np.nan]
+        res1 = ci.get_indexer(other1)
+        expected1 = np.array([1, 3, -1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res1, expected1)
+        other2 = [1, 4, 2, 3]
+        res2 = ci.get_indexer(other2)
+        expected2 = np.array([0, -1, 1, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(res2, expected2)
+
 
 class TestWhere:
     def test_where(self, listlike_box):
diff --git a/pandas/tests/indexes/categorical/test_reindex.py b/pandas/tests/indexes/categorical/test_reindex.py
index 5a0b2672e397c..1337eff1f1c2f 100644
--- a/pandas/tests/indexes/categorical/test_reindex.py
+++ b/pandas/tests/indexes/categorical/test_reindex.py
@@ -19,7 +19,7 @@ def test_reindex_list_non_unique(self):
         tm.assert_index_equal(res, Index(["a", "a", "c"]), exact=True)
         tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
 
-    def test_reindex_categorcal_non_unique(self):
+    def test_reindex_categorical_non_unique(self):
         ci = CategoricalIndex(["a", "b", "c", "a"])
         with tm.assert_produces_warning(FutureWarning, match="non-unique"):
             res, indexer = ci.reindex(Categorical(["a", "c"]))
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index ef528f59a1e4e..3f8c679c6162f 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -216,6 +216,8 @@ def test_ensure_copied_data(self, index):
             # RangeIndex cannot be initialized from data
             # MultiIndex and CategoricalIndex are tested separately
             return
+        elif index.dtype == object and index.inferred_type == "boolean":
+            init_kwargs["dtype"] = index.dtype
 
         index_type = type(index)
         result = index_type(index.values, copy=True, **init_kwargs)
@@ -422,9 +424,11 @@ def test_equals(self, index):
             #  fails for IntervalIndex
             return
 
+        is_ea_idx = type(index) is Index and not isinstance(index.dtype, np.dtype)
+
         assert index.equals(index)
         assert index.equals(index.copy())
-        if not (type(index) is Index and not isinstance(index.dtype, np.dtype)):
+        if not is_ea_idx:
             # doesn't hold for e.g. IntegerDtype
             assert index.equals(index.astype(object))
 
@@ -432,7 +436,7 @@ def test_equals(self, index):
         assert not index.equals(np.array(index))
 
         # Cannot pass in non-int64 dtype to RangeIndex
-        if not isinstance(index, RangeIndex):
+        if not isinstance(index, RangeIndex) and not is_ea_idx:
             same_values = Index(index, dtype=object)
             assert index.equals(same_values)
             assert same_values.equals(index)
@@ -520,6 +524,9 @@ def test_fillna(self, index):
         # GH 11343
         if len(index) == 0:
             return
+        elif index.dtype == bool:
+            # can't hold NAs
+            return
         elif isinstance(index, NumericIndex) and is_integer_dtype(index.dtype):
             return
         elif isinstance(index, MultiIndex):
@@ -890,6 +897,6 @@ def test_arithmetic_explicit_conversions(self):
     def test_invalid_dtype(self, invalid_dtype):
         # GH 29539
         dtype = invalid_dtype
-        msg = fr"Incorrect `dtype` passed: expected \w+(?: \w+)?, received {dtype}"
+        msg = rf"Incorrect `dtype` passed: expected \w+(?: \w+)?, received {dtype}"
         with pytest.raises(ValueError, match=msg):
             self._index_cls([1, 2, 3], dtype=dtype)
diff --git a/pandas/tests/indexes/datetimelike_/test_equals.py b/pandas/tests/indexes/datetimelike_/test_equals.py
index cc90e8f6d9bec..39e8270b1c4f5 100644
--- a/pandas/tests/indexes/datetimelike_/test_equals.py
+++ b/pandas/tests/indexes/datetimelike_/test_equals.py
@@ -167,7 +167,7 @@ def test_equals2(self):
 
         # Check that we dont raise OverflowError on comparisons outside the
         #  implementation range GH#28532
-        oob = Index([timedelta(days=10 ** 6)] * 3, dtype=object)
+        oob = Index([timedelta(days=10**6)] * 3, dtype=object)
         assert not idx.equals(oob)
         assert not idx2.equals(oob)
 
diff --git a/pandas/tests/indexes/datetimelike_/test_indexing.py b/pandas/tests/indexes/datetimelike_/test_indexing.py
index eb37c2c4ad2a3..b64d5421a2067 100644
--- a/pandas/tests/indexes/datetimelike_/test_indexing.py
+++ b/pandas/tests/indexes/datetimelike_/test_indexing.py
@@ -20,7 +20,7 @@
 @pytest.mark.parametrize("rdtype", dtlike_dtypes)
 def test_get_indexer_non_unique_wrong_dtype(ldtype, rdtype):
 
-    vals = np.tile(3600 * 10 ** 9 * np.arange(3), 2)
+    vals = np.tile(3600 * 10**9 * np.arange(3), 2)
 
     def construct(dtype):
         if dtype is dtlike_dtypes[-1]:
diff --git a/pandas/tests/indexes/datetimelike_/test_is_monotonic.py b/pandas/tests/indexes/datetimelike_/test_is_monotonic.py
index 22247c982edbc..088ccc406cb81 100644
--- a/pandas/tests/indexes/datetimelike_/test_is_monotonic.py
+++ b/pandas/tests/indexes/datetimelike_/test_is_monotonic.py
@@ -7,7 +7,7 @@
 
 def test_is_monotonic_with_nat():
     # GH#31437
-    # PeriodIndex.is_monotonic should behave analogously to DatetimeIndex,
+    # PeriodIndex.is_monotonic_increasing should behave analogously to DatetimeIndex,
     #  in particular never be monotonic when we have NaT
     dti = date_range("2016-01-01", periods=3)
     pi = dti.to_period("D")
@@ -16,7 +16,7 @@ def test_is_monotonic_with_nat():
     for obj in [pi, pi._engine, dti, dti._engine, tdi, tdi._engine]:
         if isinstance(obj, Index):
             # i.e. not Engines
-            assert obj.is_monotonic
+            assert obj.is_monotonic_increasing
         assert obj.is_monotonic_increasing
         assert not obj.is_monotonic_decreasing
         assert obj.is_unique
@@ -28,7 +28,7 @@ def test_is_monotonic_with_nat():
     for obj in [pi1, pi1._engine, dti1, dti1._engine, tdi1, tdi1._engine]:
         if isinstance(obj, Index):
             # i.e. not Engines
-            assert not obj.is_monotonic
+            assert not obj.is_monotonic_increasing
         assert not obj.is_monotonic_increasing
         assert not obj.is_monotonic_decreasing
         assert obj.is_unique
@@ -40,7 +40,7 @@ def test_is_monotonic_with_nat():
     for obj in [pi2, pi2._engine, dti2, dti2._engine, tdi2, tdi2._engine]:
         if isinstance(obj, Index):
             # i.e. not Engines
-            assert not obj.is_monotonic
+            assert not obj.is_monotonic_increasing
         assert not obj.is_monotonic_increasing
         assert not obj.is_monotonic_decreasing
         assert obj.is_unique
diff --git a/pandas/tests/indexes/datetimelike_/test_sort_values.py b/pandas/tests/indexes/datetimelike_/test_sort_values.py
index 9a91cc26c1430..6b7ad79e8f76d 100644
--- a/pandas/tests/indexes/datetimelike_/test_sort_values.py
+++ b/pandas/tests/indexes/datetimelike_/test_sort_values.py
@@ -59,17 +59,16 @@ def test_argmin_argmax(self, non_monotonic_idx):
     def test_sort_values(self, non_monotonic_idx):
         idx = non_monotonic_idx
         ordered = idx.sort_values()
-        assert ordered.is_monotonic
-
+        assert ordered.is_monotonic_increasing
         ordered = idx.sort_values(ascending=False)
-        assert ordered[::-1].is_monotonic
+        assert ordered[::-1].is_monotonic_increasing
 
         ordered, dexer = idx.sort_values(return_indexer=True)
-        assert ordered.is_monotonic
+        assert ordered.is_monotonic_increasing
         tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0], dtype=np.intp))
 
         ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
-        assert ordered[::-1].is_monotonic
+        assert ordered[::-1].is_monotonic_increasing
         tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1], dtype=np.intp))
 
     def check_sort_values_with_freq(self, idx):
diff --git a/pandas/tests/indexes/datetimes/methods/test_astype.py b/pandas/tests/indexes/datetimes/methods/test_astype.py
index 64b57767b155b..e7823f0c90b1a 100644
--- a/pandas/tests/indexes/datetimes/methods/test_astype.py
+++ b/pandas/tests/indexes/datetimes/methods/test_astype.py
@@ -32,8 +32,7 @@ def test_astype(self):
         )
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            result = idx.astype(int)
+        result = idx.astype(int)
         expected = Int64Index(
             [1463356800000000000] + [-9223372036854775808] * 3,
             dtype=np.int64,
@@ -42,8 +41,7 @@ def test_astype(self):
         tm.assert_index_equal(result, expected)
 
         rng = date_range("1/1/2000", periods=10, name="idx")
-        with tm.assert_produces_warning(FutureWarning):
-            result = rng.astype("i8")
+        result = rng.astype("i8")
         tm.assert_index_equal(result, Index(rng.asi8, name="idx"))
         tm.assert_numpy_array_equal(result.values, rng.asi8)
 
@@ -53,9 +51,12 @@ def test_astype_uint(self):
             np.array([946684800000000000, 946771200000000000], dtype="uint64"),
             name="idx",
         )
-        with tm.assert_produces_warning(FutureWarning):
-            tm.assert_index_equal(arr.astype("uint64"), expected)
-            tm.assert_index_equal(arr.astype("uint32"), expected)
+        tm.assert_index_equal(arr.astype("uint64"), expected)
+
+        msg = "will return exactly the specified dtype instead of uint64"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = arr.astype("uint32")
+        tm.assert_index_equal(res, expected)
 
     def test_astype_with_tz(self):
 
diff --git a/pandas/tests/indexes/datetimes/methods/test_snap.py b/pandas/tests/indexes/datetimes/methods/test_snap.py
index e591441c4f148..a94d00d919082 100644
--- a/pandas/tests/indexes/datetimes/methods/test_snap.py
+++ b/pandas/tests/indexes/datetimes/methods/test_snap.py
@@ -7,10 +7,30 @@
 import pandas._testing as tm
 
 
+def astype_non_nano(dti_nano, unit):
+    # TODO(2.0): remove once DTI/DTA.astype supports non-nano
+    if unit == "ns":
+        return dti_nano
+
+    dta_nano = dti_nano._data
+    arr_nano = dta_nano._ndarray
+
+    arr = arr_nano.astype(f"M8[{unit}]")
+    if dti_nano.tz is None:
+        dtype = arr.dtype
+    else:
+        dtype = type(dti_nano.dtype)(tz=dti_nano.tz, unit=unit)
+    dta = type(dta_nano)._simple_new(arr, dtype=dtype)
+    dti = DatetimeIndex(dta, name=dti_nano.name)
+    assert dti.dtype == dtype
+    return dti
+
+
 @pytest.mark.filterwarnings("ignore::DeprecationWarning")
 @pytest.mark.parametrize("tz", [None, "Asia/Shanghai", "Europe/Berlin"])
 @pytest.mark.parametrize("name", [None, "my_dti"])
-def test_dti_snap(name, tz):
+@pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+def test_dti_snap(name, tz, unit):
     dti = DatetimeIndex(
         [
             "1/1/2002",
@@ -25,10 +45,12 @@ def test_dti_snap(name, tz):
         tz=tz,
         freq="D",
     )
+    dti = astype_non_nano(dti, unit)
 
     result = dti.snap(freq="W-MON")
     expected = date_range("12/31/2001", "1/7/2002", name=name, tz=tz, freq="w-mon")
     expected = expected.repeat([3, 4])
+    expected = astype_non_nano(expected, unit)
     tm.assert_index_equal(result, expected)
     assert result.tz == expected.tz
     assert result.freq is None
@@ -38,6 +60,7 @@ def test_dti_snap(name, tz):
 
     expected = date_range("1/1/2002", "1/7/2002", name=name, tz=tz, freq="b")
     expected = expected.repeat([1, 1, 1, 2, 2])
+    expected = astype_non_nano(expected, unit)
     tm.assert_index_equal(result, expected)
     assert result.tz == expected.tz
     assert result.freq is None
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_frame.py b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
index 80e8284abe031..fa5cca1c3e78b 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_frame.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
@@ -17,10 +17,15 @@ def test_to_frame_datetime_tz(self):
     def test_to_frame_respects_none_name(self):
         # GH#44212 if we explicitly pass name=None, then that should be respected,
         #  not changed to 0
+        # GH-45448 this is first deprecated to only change in the future
         idx = date_range(start="2019-01-01", end="2019-01-30", freq="D", tz="UTC")
-        result = idx.to_frame(name=None)
-        exp_idx = Index([None], dtype=object)
+        with tm.assert_produces_warning(FutureWarning):
+            result = idx.to_frame(name=None)
+        # exp_idx = Index([None], dtype=object)
+        exp_idx = Index([0])
         tm.assert_index_equal(exp_idx, result.columns)
 
-        result = idx.rename("foo").to_frame(name=None)
+        with tm.assert_produces_warning(FutureWarning):
+            result = idx.rename("foo").to_frame(name=None)
+        exp_idx = Index(["foo"], dtype=object)
         tm.assert_index_equal(exp_idx, result.columns)
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index b1e764ceb7009..1d161630b1356 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -13,8 +13,9 @@
 
 from pandas._libs.tslibs import (
     OutOfBoundsDatetime,
-    conversion,
+    astype_overflowsafe,
 )
+from pandas.compat import PY39
 
 import pandas as pd
 from pandas import (
@@ -31,6 +32,9 @@
     period_array,
 )
 
+if PY39:
+    import zoneinfo
+
 
 class TestDatetimeIndex:
     @pytest.mark.parametrize(
@@ -517,7 +521,7 @@ def test_construction_outofbounds(self):
         # coerces to object
         tm.assert_index_equal(Index(dates), exp)
 
-        msg = "Out of bounds nanosecond timestamp"
+        msg = "Out of bounds .* present at position 0"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             # can't create DatetimeIndex
             DatetimeIndex(dates)
@@ -921,6 +925,9 @@ def test_explicit_none_freq(self):
         result = DatetimeIndex(rng._data, freq=None)
         assert result.freq is None
 
+        dta = DatetimeArray(rng, freq=None)
+        assert dta.freq is None
+
     def test_dti_constructor_years_only(self, tz_naive_fixture):
         tz = tz_naive_fixture
         # GH 6961
@@ -971,7 +978,7 @@ def test_index_cast_datetime64_other_units(self):
         arr = np.arange(0, 100, 10, dtype=np.int64).view("M8[D]")
         idx = Index(arr)
 
-        assert (idx.values == conversion.ensure_datetime64ns(arr)).all()
+        assert (idx.values == astype_overflowsafe(arr, dtype=np.dtype("M8[ns]"))).all()
 
     def test_constructor_int64_nocopy(self):
         # GH#1624
@@ -1128,7 +1135,15 @@ def test_timestamp_constructor_retain_fold(tz, fold):
     assert result == expected
 
 
-@pytest.mark.parametrize("tz", ["dateutil/Europe/London"])
+_tzs = ["dateutil/Europe/London"]
+if PY39:
+    try:
+        _tzs = ["dateutil/Europe/London", zoneinfo.ZoneInfo("Europe/London")]
+    except zoneinfo.ZoneInfoNotFoundError:
+        pass
+
+
+@pytest.mark.parametrize("tz", _tzs)
 @pytest.mark.parametrize(
     "ts_input,fold_out",
     [
@@ -1148,6 +1163,7 @@ def test_timestamp_constructor_infer_fold_from_value(tz, ts_input, fold_out):
     result = ts.fold
     expected = fold_out
     assert result == expected
+    # TODO: belongs in Timestamp tests?
 
 
 @pytest.mark.parametrize("tz", ["dateutil/Europe/London"])
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 377974a918ad9..07f57d3f9c3f4 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -1126,6 +1126,24 @@ def test_range_with_millisecond_resolution(self, start_end):
         expected = DatetimeIndex([start])
         tm.assert_index_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "start,period,expected",
+        [
+            ("2022-07-23 00:00:00+02:00", 1, ["2022-07-25 00:00:00+02:00"]),
+            ("2022-07-22 00:00:00+02:00", 1, ["2022-07-22 00:00:00+02:00"]),
+            (
+                "2022-07-22 00:00:00+02:00",
+                2,
+                ["2022-07-22 00:00:00+02:00", "2022-07-25 00:00:00+02:00"],
+            ),
+        ],
+    )
+    def test_range_with_timezone_and_custombusinessday(self, start, period, expected):
+        # GH49441
+        result = date_range(start=start, periods=period, freq="C")
+        expected = DatetimeIndex(expected)
+        tm.assert_index_equal(result, expected)
+
 
 def test_date_range_with_custom_holidays():
     # GH 30593
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index b8f72a8c1f988..a203fee5b3a61 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -777,3 +777,32 @@ def test_indexer_between_time(self):
         msg = r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\] to a time"
         with pytest.raises(ValueError, match=msg):
             rng.indexer_between_time(datetime(2010, 1, 2, 1), datetime(2010, 1, 2, 5))
+
+    @pytest.mark.parametrize("unit", ["us", "ms", "s"])
+    def test_indexer_between_time_non_nano(self, unit):
+        # For simple cases like this, the non-nano indexer_between_time
+        #  should match the nano result
+
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        arr_nano = rng._data._ndarray
+
+        arr = arr_nano.astype(f"M8[{unit}]")
+
+        dta = type(rng._data)._simple_new(arr, dtype=arr.dtype)
+        dti = DatetimeIndex(dta)
+        assert dti.dtype == arr.dtype
+
+        tic = time(1, 25)
+        toc = time(2, 29)
+
+        result = dti.indexer_between_time(tic, toc)
+        expected = rng.indexer_between_time(tic, toc)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # case with non-zero micros in arguments
+        tic = time(1, 25, 0, 45678)
+        toc = time(2, 29, 0, 1234)
+
+        result = dti.indexer_between_time(tic, toc)
+        expected = rng.indexer_between_time(tic, toc)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/indexes/datetimes/test_join.py b/pandas/tests/indexes/datetimes/test_join.py
index 8b633e8db8836..9afeb7ce924df 100644
--- a/pandas/tests/indexes/datetimes/test_join.py
+++ b/pandas/tests/indexes/datetimes/test_join.py
@@ -89,7 +89,7 @@ def test_join_nonunique(self):
         idx1 = to_datetime(["2012-11-06 16:00:11.477563", "2012-11-06 16:00:11.477563"])
         idx2 = to_datetime(["2012-11-06 15:11:09.006507", "2012-11-06 15:11:09.006507"])
         rs = idx1.join(idx2, how="outer")
-        assert rs.is_monotonic
+        assert rs.is_monotonic_increasing
 
     @pytest.mark.parametrize("freq", ["B", "C"])
     def test_outer_join(self, freq):
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 2f32f9e18311d..8ddcd6a453080 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -281,7 +281,7 @@ def test_partial_slicing_dataframe(self):
                 result = df["a"][ts_string]
                 assert isinstance(result, np.int64)
                 assert result == expected
-                msg = fr"^'{ts_string}'$"
+                msg = rf"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df[ts_string]
 
@@ -311,7 +311,7 @@ def test_partial_slicing_dataframe(self):
                 result = df["a"][ts_string]
                 assert isinstance(result, np.int64)
                 assert result == 2
-                msg = fr"^'{ts_string}'$"
+                msg = rf"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df[ts_string]
 
@@ -320,7 +320,7 @@ def test_partial_slicing_dataframe(self):
             for fmt, res in list(zip(formats, resolutions))[rnum + 1 :]:
                 ts = index[1] + Timedelta("1 " + res)
                 ts_string = ts.strftime(fmt)
-                msg = fr"^'{ts_string}'$"
+                msg = rf"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df["a"][ts_string]
                 with pytest.raises(KeyError, match=msg):
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index c60e56875bfcd..890590094094a 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -38,7 +38,7 @@ def test_dti_date(self):
     @pytest.mark.parametrize("data", [["1400-01-01"], [datetime(1400, 1, 1)]])
     def test_dti_date_out_of_range(self, data):
         # GH#1475
-        msg = "Out of bounds nanosecond timestamp: 1400-01-01 00:00:00"
+        msg = "Out of bounds .* present at position 0"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             DatetimeIndex(data)
 
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 7c2b3b7f4482d..be8d70c127e8b 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pytest
+import pytz
 
 import pandas.util._test_decorators as td
 
@@ -417,27 +418,25 @@ def test_intersection_non_tick_no_fastpath(self):
 
 
 class TestBusinessDatetimeIndex:
-    def setup_method(self, method):
-        self.rng = bdate_range(START, END)
-
     def test_union(self, sort):
+        rng = bdate_range(START, END)
         # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
+        left = rng[:10]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
         # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
+        left = rng[:5]
+        right = rng[10:]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, Index)
 
         # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
+        left = rng[:5]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
@@ -452,7 +451,7 @@ def test_union(self, sort):
         # overlapping, but different offset
         rng = date_range(START, END, freq=BMonthEnd())
 
-        the_union = self.rng.union(rng, sort=sort)
+        the_union = rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
     def test_union_not_cacheable(self, sort):
@@ -555,27 +554,25 @@ def test_intersection_duplicates(self, sort):
 
 
 class TestCustomDatetimeIndex:
-    def setup_method(self, method):
-        self.rng = bdate_range(START, END, freq="C")
-
     def test_union(self, sort):
         # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
+        rng = bdate_range(START, END, freq="C")
+        left = rng[:10]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
         # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
+        left = rng[:5]
+        right = rng[10:]
 
         the_union = left.union(right, sort)
         assert isinstance(the_union, Index)
 
         # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
+        left = rng[:5]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
@@ -587,7 +584,7 @@ def test_union(self, sort):
         # overlapping, but different offset
         rng = date_range(START, END, freq=BMonthEnd())
 
-        the_union = self.rng.union(rng, sort=sort)
+        the_union = rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
     def test_intersection_bug(self):
@@ -597,3 +594,14 @@ def test_intersection_bug(self):
         result = a.intersection(b)
         tm.assert_index_equal(result, b)
         assert result.freq == b.freq
+
+    @pytest.mark.parametrize(
+        "tz", [None, "UTC", "Europe/Berlin", pytz.FixedOffset(-60)]
+    )
+    def test_intersection_dst_transition(self, tz):
+        # GH 46702: Europe/Berlin has DST transition
+        idx1 = date_range("2020-03-27", periods=5, freq="D", tz=tz)
+        idx2 = date_range("2020-03-30", periods=5, freq="D", tz=tz)
+        result = idx1.intersection(idx2)
+        expected = date_range("2020-03-30", periods=2, freq="D", tz=tz)
+        tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index a12f4c9676d9b..a07f21f785828 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -40,7 +40,7 @@
 class FixedOffset(tzinfo):
     """Fixed offset in minutes east from UTC."""
 
-    def __init__(self, offset, name):
+    def __init__(self, offset, name) -> None:
         self.__offset = timedelta(minutes=offset)
         self.__name = name
 
@@ -327,6 +327,17 @@ def test_tz_convert_unsorted(self, tzstr):
     # -------------------------------------------------------------
     # DatetimeIndex.tz_localize
 
+    def test_tz_localize_utc_copies(self, utc_fixture):
+        # GH#46460
+        times = ["2015-03-08 01:00", "2015-03-08 02:00", "2015-03-08 03:00"]
+        index = DatetimeIndex(times)
+
+        res = index.tz_localize(utc_fixture)
+        assert not tm.shares_memory(res, index)
+
+        res2 = index._data.tz_localize(utc_fixture)
+        assert not tm.shares_memory(index._data, res2)
+
     def test_dti_tz_localize_nonexistent_raise_coerce(self):
         # GH#13057
         times = ["2015-03-08 01:00", "2015-03-08 02:00", "2015-03-08 03:00"]
@@ -1140,7 +1151,9 @@ def test_dti_convert_tz_aware_datetime_datetime(self, tz):
         tm.assert_numpy_array_equal(converted.asi8, ex_vals)
         assert converted.tz is pytz.utc
 
-    def test_dti_union_aware(self):
+    # Note: not difference, as there is no symmetry requirement there
+    @pytest.mark.parametrize("setop", ["union", "intersection", "symmetric_difference"])
+    def test_dti_setop_aware(self, setop):
         # non-overlapping
         rng = date_range("2012-11-15 00:00:00", periods=6, freq="H", tz="US/Central")
 
@@ -1148,12 +1161,13 @@ def test_dti_union_aware(self):
 
         with tm.assert_produces_warning(FutureWarning):
             # # GH#39328 will cast both to UTC
-            result = rng.union(rng2)
+            result = getattr(rng, setop)(rng2)
 
-        expected = rng.astype("O").union(rng2.astype("O"))
+        expected = getattr(rng.astype("O"), setop)(rng2.astype("O"))
         tm.assert_index_equal(result, expected)
-        assert result[0].tz.zone == "US/Central"
-        assert result[-1].tz.zone == "US/Eastern"
+        if len(result):
+            assert result[0].tz.zone == "US/Central"
+            assert result[-1].tz.zone == "US/Eastern"
 
     def test_dti_union_mixed(self):
         # GH 21671
diff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py
index bdb9c3f97e798..c253a745ef5a2 100644
--- a/pandas/tests/indexes/interval/test_astype.py
+++ b/pandas/tests/indexes/interval/test_astype.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import is_platform_arm
-
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
     IntervalDtype,
@@ -170,7 +168,6 @@ def test_subtype_integer_with_non_integer_borders(self, subtype):
         )
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.xfail(is_platform_arm(), reason="GH 41740")
     def test_subtype_integer_errors(self):
         # float64 -> uint64 fails with negative values
         index = interval_range(-10.0, 10.0)
@@ -208,13 +205,18 @@ def index(self, request):
     @pytest.mark.parametrize("subtype", ["int64", "uint64"])
     def test_subtype_integer(self, index, subtype):
         dtype = IntervalDtype(subtype, "right")
-        with tm.assert_produces_warning(FutureWarning):
+
+        warn = None
+        if index.isna().any() and subtype == "uint64":
+            warn = FutureWarning
+        msg = "In a future version, this astype will raise if the conversion overflows"
+
+        with tm.assert_produces_warning(warn, match=msg):
             result = index.astype(dtype)
-            expected = IntervalIndex.from_arrays(
-                index.left.astype(subtype),
-                index.right.astype(subtype),
-                closed=index.closed,
-            )
+            new_left = index.left.astype(subtype)
+            new_right = index.right.astype(subtype)
+
+        expected = IntervalIndex.from_arrays(new_left, new_right, closed=index.closed)
         tm.assert_index_equal(result, expected)
 
     def test_subtype_float(self, index):
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 2ada97c0965f6..a71a8f9e34ea9 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -74,21 +74,13 @@ def test_constructor(self, constructor, breaks, closed, name):
     )
     def test_constructor_dtype(self, constructor, breaks, subtype):
         # GH 19262: conversion via dtype parameter
-        warn = None
-        if subtype == "int64" and breaks.dtype.kind in ["M", "m"]:
-            # astype(int64) deprecated
-            warn = FutureWarning
-
-        with tm.assert_produces_warning(warn):
-            expected_kwargs = self.get_kwargs_from_breaks(breaks.astype(subtype))
+        expected_kwargs = self.get_kwargs_from_breaks(breaks.astype(subtype))
         expected = constructor(**expected_kwargs)
 
         result_kwargs = self.get_kwargs_from_breaks(breaks)
         iv_dtype = IntervalDtype(subtype, "right")
         for dtype in (iv_dtype, str(iv_dtype)):
-            with tm.assert_produces_warning(warn):
-
-                result = constructor(dtype=dtype, **result_kwargs)
+            result = constructor(dtype=dtype, **result_kwargs)
             tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/interval/test_indexing.py b/pandas/tests/indexes/interval/test_indexing.py
index 7c00b23dc9ac4..4653981a1285d 100644
--- a/pandas/tests/indexes/interval/test_indexing.py
+++ b/pandas/tests/indexes/interval/test_indexing.py
@@ -8,6 +8,7 @@
 from pandas import (
     NA,
     CategoricalIndex,
+    DatetimeIndex,
     Index,
     Interval,
     IntervalIndex,
@@ -15,7 +16,11 @@
     NaT,
     Series,
     Timedelta,
+    Timestamp,
+    array,
     date_range,
+    interval_range,
+    period_range,
     timedelta_range,
 )
 import pandas._testing as tm
@@ -298,6 +303,20 @@ def test_get_indexer_categorical_with_nans(self):
         expected = np.array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_get_indexer_datetime(self):
+        ii = IntervalIndex.from_breaks(date_range("2018-01-01", periods=4))
+        result = ii.get_indexer(DatetimeIndex(["2018-01-02"]))
+        expected = np.array([0], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ii.get_indexer(DatetimeIndex(["2018-01-02"]).astype(str))
+        tm.assert_numpy_array_equal(result, expected)
+
+        # TODO this should probably be deprecated?
+        # https://github.com/pandas-dev/pandas/issues/47772
+        result = ii.get_indexer(DatetimeIndex(["2018-01-02"]).asi8)
+        tm.assert_numpy_array_equal(result, expected)
+
     @pytest.mark.parametrize(
         "tuples, closed",
         [
@@ -401,6 +420,16 @@ def test_get_indexer_multiindex_with_intervals(self):
         expected = np.array([1, 4, 7], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize("box", [IntervalIndex, array, list])
+    def test_get_indexer_interval_index(self, box):
+        # GH#30178
+        rng = period_range("2022-07-01", freq="D", periods=3)
+        idx = box(interval_range(Timestamp("2022-07-01"), freq="3D", periods=3))
+
+        actual = rng.get_indexer(idx)
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(actual, expected)
+
 
 class TestSliceLocs:
     def test_slice_locs_with_interval(self):
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 843885832690f..37c13c37d070b 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -259,70 +259,70 @@ def test_is_unique_interval(self, closed):
     def test_monotonic(self, closed):
         # increasing non-overlapping
         idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)], closed=closed)
-        assert idx.is_monotonic is True
+        assert idx.is_monotonic_increasing is True
         assert idx._is_strictly_monotonic_increasing is True
         assert idx.is_monotonic_decreasing is False
         assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing non-overlapping
         idx = IntervalIndex.from_tuples([(4, 5), (2, 3), (1, 2)], closed=closed)
-        assert idx.is_monotonic is False
+        assert idx.is_monotonic_increasing is False
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is True
 
         # unordered non-overlapping
         idx = IntervalIndex.from_tuples([(0, 1), (4, 5), (2, 3)], closed=closed)
-        assert idx.is_monotonic is False
+        assert idx.is_monotonic_increasing is False
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is False
         assert idx._is_strictly_monotonic_decreasing is False
 
         # increasing overlapping
         idx = IntervalIndex.from_tuples([(0, 2), (0.5, 2.5), (1, 3)], closed=closed)
-        assert idx.is_monotonic is True
+        assert idx.is_monotonic_increasing is True
         assert idx._is_strictly_monotonic_increasing is True
         assert idx.is_monotonic_decreasing is False
         assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing overlapping
         idx = IntervalIndex.from_tuples([(1, 3), (0.5, 2.5), (0, 2)], closed=closed)
-        assert idx.is_monotonic is False
+        assert idx.is_monotonic_increasing is False
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is True
 
         # unordered overlapping
         idx = IntervalIndex.from_tuples([(0.5, 2.5), (0, 2), (1, 3)], closed=closed)
-        assert idx.is_monotonic is False
+        assert idx.is_monotonic_increasing is False
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is False
         assert idx._is_strictly_monotonic_decreasing is False
 
         # increasing overlapping shared endpoints
         idx = IntervalIndex.from_tuples([(1, 2), (1, 3), (2, 3)], closed=closed)
-        assert idx.is_monotonic is True
+        assert idx.is_monotonic_increasing is True
         assert idx._is_strictly_monotonic_increasing is True
         assert idx.is_monotonic_decreasing is False
         assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing overlapping shared endpoints
         idx = IntervalIndex.from_tuples([(2, 3), (1, 3), (1, 2)], closed=closed)
-        assert idx.is_monotonic is False
+        assert idx.is_monotonic_increasing is False
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is True
 
         # stationary
         idx = IntervalIndex.from_tuples([(0, 1), (0, 1)], closed=closed)
-        assert idx.is_monotonic is True
+        assert idx.is_monotonic_increasing is True
         assert idx._is_strictly_monotonic_increasing is False
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is False
 
         # empty
         idx = IntervalIndex([], closed=closed)
-        assert idx.is_monotonic is True
+        assert idx.is_monotonic_increasing is True
         assert idx._is_strictly_monotonic_increasing is True
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is True
@@ -331,7 +331,7 @@ def test_is_monotonic_with_nans(self):
         # GH#41831
         index = IntervalIndex([np.nan, np.nan])
 
-        assert not index.is_monotonic
+        assert not index.is_monotonic_increasing
         assert not index._is_strictly_monotonic_increasing
         assert not index.is_monotonic_increasing
         assert not index._is_strictly_monotonic_decreasing
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index ab6eac482211d..3b9de8d9e45d9 100644
--- a/pandas/tests/indexes/interval/test_interval_tree.py
+++ b/pandas/tests/indexes/interval/test_interval_tree.py
@@ -58,7 +58,7 @@ def test_get_indexer(self, tree):
 
     @pytest.mark.parametrize(
         "dtype, target_value, target_dtype",
-        [("int64", 2 ** 63 + 1, "uint64"), ("uint64", -1, "int64")],
+        [("int64", 2**63 + 1, "uint64"), ("uint64", -1, "int64")],
     )
     def test_get_indexer_overflow(self, dtype, target_value, target_dtype):
         left, right = np.array([0, 1], dtype=dtype), np.array([1, 2], dtype=dtype)
@@ -89,7 +89,7 @@ def test_get_indexer_non_unique(self, tree):
 
     @pytest.mark.parametrize(
         "dtype, target_value, target_dtype",
-        [("int64", 2 ** 63 + 1, "uint64"), ("uint64", -1, "int64")],
+        [("int64", 2**63 + 1, "uint64"), ("uint64", -1, "int64")],
     )
     def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype):
         left, right = np.array([0, 2], dtype=dtype), np.array([1, 3], dtype=dtype)
@@ -189,3 +189,21 @@ def test_construction_overflow(self):
         result = tree.root.pivot
         expected = (50 + np.iinfo(np.int64).max) / 2
         assert result == expected
+
+    @pytest.mark.xfail(not IS64, reason="GH 23440")
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            ([-np.inf, 1.0], [1.0, 2.0], 0.0),
+            ([-np.inf, -2.0], [-2.0, -1.0], -2.0),
+            ([-2.0, -1.0], [-1.0, np.inf], 0.0),
+            ([1.0, 2.0], [2.0, np.inf], 2.0),
+        ],
+    )
+    def test_inf_bound_infinite_recursion(self, left, right, expected):
+        # GH 46658
+
+        tree = IntervalTree(left * 101, right * 101)
+
+        result = tree.root.pivot
+        assert result == expected
diff --git a/pandas/tests/indexes/interval/test_join.py b/pandas/tests/indexes/interval/test_join.py
new file mode 100644
index 0000000000000..2f42c530a6686
--- /dev/null
+++ b/pandas/tests/indexes/interval/test_join.py
@@ -0,0 +1,44 @@
+import pytest
+
+from pandas import (
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def range_index():
+    return RangeIndex(3, name="range_index")
+
+
+@pytest.fixture
+def interval_index():
+    return IntervalIndex.from_tuples(
+        [(0.0, 1.0), (1.0, 2.0), (1.5, 2.5)], name="interval_index"
+    )
+
+
+def test_join_overlapping_in_mi_to_same_intervalindex(range_index, interval_index):
+    #  GH-45661
+    multi_index = MultiIndex.from_product([interval_index, range_index])
+    result = multi_index.join(interval_index)
+
+    tm.assert_index_equal(result, multi_index)
+
+
+def test_join_overlapping_to_multiindex_with_same_interval(range_index, interval_index):
+    #  GH-45661
+    multi_index = MultiIndex.from_product([interval_index, range_index])
+    result = interval_index.join(multi_index)
+
+    tm.assert_index_equal(result, multi_index)
+
+
+def test_join_overlapping_interval_to_another_intervalindex(interval_index):
+    #  GH-45661
+    flipped_interval_index = interval_index[::-1]
+    result = interval_index.join(flipped_interval_index)
+
+    tm.assert_index_equal(result, interval_index)
diff --git a/pandas/tests/indexes/multi/conftest.py b/pandas/tests/indexes/multi/conftest.py
index 9d0a2fa81b53b..3cc4fa4713831 100644
--- a/pandas/tests/indexes/multi/conftest.py
+++ b/pandas/tests/indexes/multi/conftest.py
@@ -8,7 +8,7 @@
 )
 
 
-# Note: identical the the "multi" entry in the top-level "index" fixture
+# Note: identical the "multi" entry in the top-level "index" fixture
 @pytest.fixture
 def idx():
     # a MultiIndex used to test the general functionality of the
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 63b0bd235e57c..7fad59fc6654c 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -827,3 +827,13 @@ def test_multiindex_inference_consistency():
     mi = MultiIndex.from_tuples([(x,) for x in arr])
     lev = mi.levels[0]
     assert lev.dtype == object
+
+
+def test_dtype_representation():
+    # GH#46900
+    pmidx = MultiIndex.from_arrays([[1], ["a"]], names=[("a", "b"), ("c", "d")])
+    result = pmidx.dtypes
+    expected = Series(
+        ["int64", "object"], index=MultiIndex.from_tuples([("a", "b"), ("c", "d")])
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_conversion.py b/pandas/tests/indexes/multi/test_conversion.py
index 072055e4824a7..3c2ca045d6f99 100644
--- a/pandas/tests/indexes/multi/test_conversion.py
+++ b/pandas/tests/indexes/multi/test_conversion.py
@@ -126,6 +126,28 @@ def test_to_frame_resulting_column_order():
     assert result == expected
 
 
+def test_to_frame_duplicate_labels():
+    # GH 45245
+    data = [(1, 2), (3, 4)]
+    names = ["a", "a"]
+    index = MultiIndex.from_tuples(data, names=names)
+    with pytest.raises(ValueError, match="Cannot create duplicate column labels"):
+        index.to_frame()
+
+    result = index.to_frame(allow_duplicates=True)
+    expected = DataFrame(data, index=index, columns=names)
+    tm.assert_frame_equal(result, expected)
+
+    names = [None, 0]
+    index = MultiIndex.from_tuples(data, names=names)
+    with pytest.raises(ValueError, match="Cannot create duplicate column labels"):
+        index.to_frame()
+
+    result = index.to_frame(allow_duplicates=True)
+    expected = DataFrame(data, index=index, columns=[0, 0])
+    tm.assert_frame_equal(result, expected)
+
+
 def test_to_flat_index(idx):
     expected = pd.Index(
         (
diff --git a/pandas/tests/indexes/multi/test_copy.py b/pandas/tests/indexes/multi/test_copy.py
index 9a0e4bc0996be..2b64845c919cf 100644
--- a/pandas/tests/indexes/multi/test_copy.py
+++ b/pandas/tests/indexes/multi/test_copy.py
@@ -104,3 +104,15 @@ def test_copy_deprecated_parameters(deep, param_name, param_value):
         idx_copy = idx.copy(deep=deep, **{param_name: param_value})
 
     assert [list(i) for i in getattr(idx_copy, param_name)] == param_value
+
+
+def test_copy_deep_false_retains_id():
+    # GH#47878
+    idx = MultiIndex(
+        levels=[["foo", "bar"], ["fizz", "buzz"]],
+        codes=[[0, 0, 0, 1], [0, 0, 1, 1]],
+        names=["first", "second"],
+    )
+
+    res = idx.copy(deep=False)
+    assert res._id is idx._id
diff --git a/pandas/tests/indexes/multi/test_equivalence.py b/pandas/tests/indexes/multi/test_equivalence.py
index 3854aca9430a8..c6567b86f0da2 100644
--- a/pandas/tests/indexes/multi/test_equivalence.py
+++ b/pandas/tests/indexes/multi/test_equivalence.py
@@ -288,3 +288,11 @@ def test_multiindex_compare():
     expected = Series([False, False])
     result = Series(midx > midx)
     tm.assert_series_equal(result, expected)
+
+
+def test_equals_ea_int_regular_int():
+    # GH#46026
+    mi1 = MultiIndex.from_arrays([Index([1, 2], dtype="Int64"), [3, 4]])
+    mi2 = MultiIndex.from_arrays([[1, 2], [3, 4]])
+    assert not mi1.equals(mi2)
+    assert not mi2.equals(mi1)
diff --git a/pandas/tests/indexes/multi/test_formats.py b/pandas/tests/indexes/multi/test_formats.py
index a6dadd42f7bf0..238a3e78169a8 100644
--- a/pandas/tests/indexes/multi/test_formats.py
+++ b/pandas/tests/indexes/multi/test_formats.py
@@ -8,7 +8,6 @@
     Index,
     MultiIndex,
 )
-import pandas._testing as tm
 
 
 def test_format(idx):
@@ -27,13 +26,10 @@ def test_format_sparse_config(idx):
     warn_filters = warnings.filters
     warnings.filterwarnings("ignore", category=FutureWarning, module=".*format")
     # GH1538
-    pd.set_option("display.multi_sparse", False)
-
-    result = idx.format()
+    with pd.option_context("display.multi_sparse", False):
+        result = idx.format()
     assert result[1] == "foo  two"
 
-    tm.reset_display_options()
-
     warnings.filters = warn_filters
 
 
@@ -188,7 +184,7 @@ def test_tuple_width(self, wide_multi_index):
         mi = wide_multi_index
         result = mi[:1].__repr__()
         expected = """MultiIndex([('a', 9, '2000-01-01 00:00:00', '2000-01-01 00:00:00', ...)],
-           names=['a', 'b', 'dti_1', 'dti_2', 'dti_3'])"""
+           names=['a', 'b', 'dti_1', 'dti_2', 'dti_3'])"""  # noqa:E501
         assert result == expected
 
         result = mi[:10].__repr__()
diff --git a/pandas/tests/indexes/multi/test_get_level_values.py b/pandas/tests/indexes/multi/test_get_level_values.py
index 25b4501a03adb..bab6481fe107f 100644
--- a/pandas/tests/indexes/multi/test_get_level_values.py
+++ b/pandas/tests/indexes/multi/test_get_level_values.py
@@ -111,4 +111,15 @@ def test_get_level_values_when_periods():
     idx2 = MultiIndex.from_arrays(
         [idx._get_level_values(level) for level in range(idx.nlevels)]
     )
-    assert all(x.is_monotonic for x in idx2.levels)
+    assert all(x.is_monotonic_increasing for x in idx2.levels)
+
+
+def test_values_loses_freq_of_underlying_index():
+    # GH#49054
+    idx = pd.DatetimeIndex(date_range("20200101", periods=3, freq="BM"))
+    expected = idx.copy(deep=True)
+    idx2 = Index([1, 2, 3])
+    midx = MultiIndex(levels=[idx, idx2], codes=[[0, 1, 2], [0, 1, 2]])
+    midx.values
+    assert idx.freq is not None
+    tm.assert_index_equal(idx, expected)
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index aa0e91cecd4fc..42cf0168f6599 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas.compat import PY311
+
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
@@ -139,9 +141,15 @@ def test_set_levels_codes_directly(idx):
     minor_codes = [(x + 1) % 1 for x in minor_codes]
     new_codes = [major_codes, minor_codes]
 
-    msg = "[Cc]an't set attribute"
+    msg = "Can't set attribute"
     with pytest.raises(AttributeError, match=msg):
         idx.levels = new_levels
+
+    msg = (
+        "property 'codes' of 'MultiIndex' object has no setter"
+        if PY311
+        else "can't set attribute"
+    )
     with pytest.raises(AttributeError, match=msg):
         idx.codes = new_codes
 
diff --git a/pandas/tests/indexes/multi/test_indexing.py b/pandas/tests/indexes/multi/test_indexing.py
index 9cb65128e7068..9626352ac7e36 100644
--- a/pandas/tests/indexes/multi/test_indexing.py
+++ b/pandas/tests/indexes/multi/test_indexing.py
@@ -353,9 +353,9 @@ def test_get_indexer_three_or_more_levels(self):
             ]
         )
         # sanity check
-        assert mult_idx_1.is_monotonic
+        assert mult_idx_1.is_monotonic_increasing
         assert mult_idx_1.is_unique
-        assert mult_idx_2.is_monotonic
+        assert mult_idx_2.is_monotonic_increasing
         assert mult_idx_2.is_unique
 
         # show the relationships between the two
@@ -621,13 +621,22 @@ def test_get_loc_implicit_cast(self, level, dtypes):
         idx = MultiIndex.from_product(levels)
         assert idx.get_loc(tuple(key)) == 3
 
-    def test_get_loc_cast_bool(self):
-        # GH 19086 : int is casted to bool, but not vice-versa
-        levels = [[False, True], np.arange(2, dtype="int64")]
+    @pytest.mark.parametrize("dtype", [bool, object])
+    def test_get_loc_cast_bool(self, dtype):
+        # GH 19086 : int is casted to bool, but not vice-versa (for object dtype)
+        #  With bool dtype, we don't cast in either direction.
+        levels = [Index([False, True], dtype=dtype), np.arange(2, dtype="int64")]
         idx = MultiIndex.from_product(levels)
 
-        assert idx.get_loc((0, 1)) == 1
-        assert idx.get_loc((1, 0)) == 2
+        if dtype is bool:
+            with pytest.raises(KeyError, match=r"^\(0, 1\)$"):
+                assert idx.get_loc((0, 1)) == 1
+            with pytest.raises(KeyError, match=r"^\(1, 0\)$"):
+                assert idx.get_loc((1, 0)) == 2
+        else:
+            # We use python object comparisons, which treat 0 == False and 1 == True
+            assert idx.get_loc((0, 1)) == 1
+            assert idx.get_loc((1, 0)) == 2
 
         with pytest.raises(KeyError, match=r"^\(False, True\)$"):
             idx.get_loc((False, True))
@@ -790,8 +799,8 @@ def test_contains_td64_level(self):
     @pytest.mark.slow
     def test_large_mi_contains(self):
         # GH#10645
-        result = MultiIndex.from_arrays([range(10 ** 6), range(10 ** 6)])
-        assert not (10 ** 6, 0) in result
+        result = MultiIndex.from_arrays([range(10**6), range(10**6)])
+        assert not (10**6, 0) in result
 
 
 def test_timestamp_multiindex_indexer():
diff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py
index e1c2134b5b1f8..c35871745938b 100644
--- a/pandas/tests/indexes/multi/test_integrity.py
+++ b/pandas/tests/indexes/multi/test_integrity.py
@@ -52,7 +52,7 @@ def test_values_boxed():
 
 def test_values_multiindex_datetimeindex():
     # Test to ensure we hit the boxing / nobox part of MI.values
-    ints = np.arange(10 ** 18, 10 ** 18 + 5)
+    ints = np.arange(10**18, 10**18 + 5)
     naive = pd.DatetimeIndex(ints)
 
     aware = pd.DatetimeIndex(ints, tz="US/Central")
@@ -225,11 +225,11 @@ def test_metadata_immutable(idx):
 
 def test_level_setting_resets_attributes():
     ind = MultiIndex.from_arrays([["A", "A", "B", "B", "B"], [1, 2, 1, 2, 3]])
-    assert ind.is_monotonic
+    assert ind.is_monotonic_increasing
     with tm.assert_produces_warning(FutureWarning):
         ind.set_levels([["A", "B"], [1, 3, 2]], inplace=True)
     # if this fails, probably didn't reset the cache correctly.
-    assert not ind.is_monotonic
+    assert not ind.is_monotonic_increasing
 
 
 def test_rangeindex_fallback_coercion_bug():
diff --git a/pandas/tests/indexes/multi/test_join.py b/pandas/tests/indexes/multi/test_join.py
index e6bec97aedb38..7000724a6b271 100644
--- a/pandas/tests/indexes/multi/test_join.py
+++ b/pandas/tests/indexes/multi/test_join.py
@@ -5,6 +5,8 @@
     Index,
     Interval,
     MultiIndex,
+    Series,
+    StringDtype,
 )
 import pandas._testing as tm
 
@@ -158,3 +160,49 @@ def test_join_overlapping_interval_level():
     result = idx_1.join(idx_2, how="outer")
 
     tm.assert_index_equal(result, expected)
+
+
+def test_join_midx_ea():
+    # GH#49277
+    midx = MultiIndex.from_arrays(
+        [Series([1, 1, 3], dtype="Int64"), Series([1, 2, 3], dtype="Int64")],
+        names=["a", "b"],
+    )
+    midx2 = MultiIndex.from_arrays(
+        [Series([1], dtype="Int64"), Series([3], dtype="Int64")], names=["a", "c"]
+    )
+    result = midx.join(midx2, how="inner")
+    expected = MultiIndex.from_arrays(
+        [
+            Series([1, 1], dtype="Int64"),
+            Series([1, 2], dtype="Int64"),
+            Series([3, 3], dtype="Int64"),
+        ],
+        names=["a", "b", "c"],
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_join_midx_string():
+    # GH#49277
+    midx = MultiIndex.from_arrays(
+        [
+            Series(["a", "a", "c"], dtype=StringDtype()),
+            Series(["a", "b", "c"], dtype=StringDtype()),
+        ],
+        names=["a", "b"],
+    )
+    midx2 = MultiIndex.from_arrays(
+        [Series(["a"], dtype=StringDtype()), Series(["c"], dtype=StringDtype())],
+        names=["a", "c"],
+    )
+    result = midx.join(midx2, how="inner")
+    expected = MultiIndex.from_arrays(
+        [
+            Series(["a", "a"], dtype=StringDtype()),
+            Series(["a", "b"], dtype=StringDtype()),
+            Series(["c", "c"], dtype=StringDtype()),
+        ],
+        names=["a", "b", "c"],
+    )
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_lexsort.py b/pandas/tests/indexes/multi/test_lexsort.py
index c37172ad7a980..0aadbdb5c32da 100644
--- a/pandas/tests/indexes/multi/test_lexsort.py
+++ b/pandas/tests/indexes/multi/test_lexsort.py
@@ -24,7 +24,10 @@ def test_is_lexsorted(self):
 
     def test_is_lexsorted_deprecation(self):
         # GH 32259
-        with tm.assert_produces_warning():
+        with tm.assert_produces_warning(
+            FutureWarning,
+            match="MultiIndex.is_lexsorted is deprecated as a public function",
+        ):
             MultiIndex.from_arrays([["a", "b", "c"], ["d", "f", "e"]]).is_lexsorted()
 
 
@@ -53,5 +56,8 @@ def test_lexsort_depth(self):
 
     def test_lexsort_depth_deprecation(self):
         # GH 32259
-        with tm.assert_produces_warning():
+        with tm.assert_produces_warning(
+            FutureWarning,
+            match="MultiIndex.lexsort_depth is deprecated as a public function",
+        ):
             MultiIndex.from_arrays([["a", "b", "c"], ["d", "f", "e"]]).lexsort_depth
diff --git a/pandas/tests/indexes/multi/test_monotonic.py b/pandas/tests/indexes/multi/test_monotonic.py
index 74be9f829cb68..2b0b3f7cb36d7 100644
--- a/pandas/tests/indexes/multi/test_monotonic.py
+++ b/pandas/tests/indexes/multi/test_monotonic.py
@@ -10,39 +10,39 @@
 def test_is_monotonic_increasing_lexsorted(lexsorted_two_level_string_multiindex):
     # string ordering
     mi = lexsorted_two_level_string_multiindex
-    assert mi.is_monotonic is False
-    assert Index(mi.values).is_monotonic is False
+    assert mi.is_monotonic_increasing is False
+    assert Index(mi.values).is_monotonic_increasing is False
     assert mi._is_strictly_monotonic_increasing is False
     assert Index(mi.values)._is_strictly_monotonic_increasing is False
 
 
 def test_is_monotonic_increasing():
     i = MultiIndex.from_product([np.arange(10), np.arange(10)], names=["one", "two"])
-    assert i.is_monotonic is True
+    assert i.is_monotonic_increasing is True
     assert i._is_strictly_monotonic_increasing is True
-    assert Index(i.values).is_monotonic is True
+    assert Index(i.values).is_monotonic_increasing is True
     assert i._is_strictly_monotonic_increasing is True
 
     i = MultiIndex.from_product(
         [np.arange(10, 0, -1), np.arange(10)], names=["one", "two"]
     )
-    assert i.is_monotonic is False
+    assert i.is_monotonic_increasing is False
     assert i._is_strictly_monotonic_increasing is False
-    assert Index(i.values).is_monotonic is False
+    assert Index(i.values).is_monotonic_increasing is False
     assert Index(i.values)._is_strictly_monotonic_increasing is False
 
     i = MultiIndex.from_product(
         [np.arange(10), np.arange(10, 0, -1)], names=["one", "two"]
     )
-    assert i.is_monotonic is False
+    assert i.is_monotonic_increasing is False
     assert i._is_strictly_monotonic_increasing is False
-    assert Index(i.values).is_monotonic is False
+    assert Index(i.values).is_monotonic_increasing is False
     assert Index(i.values)._is_strictly_monotonic_increasing is False
 
     i = MultiIndex.from_product([[1.0, np.nan, 2.0], ["a", "b", "c"]])
-    assert i.is_monotonic is False
+    assert i.is_monotonic_increasing is False
     assert i._is_strictly_monotonic_increasing is False
-    assert Index(i.values).is_monotonic is False
+    assert Index(i.values).is_monotonic_increasing is False
     assert Index(i.values)._is_strictly_monotonic_increasing is False
 
     i = MultiIndex(
@@ -50,8 +50,8 @@ def test_is_monotonic_increasing():
         codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
         names=["first", "second"],
     )
-    assert i.is_monotonic is True
-    assert Index(i.values).is_monotonic is True
+    assert i.is_monotonic_increasing is True
+    assert Index(i.values).is_monotonic_increasing is True
     assert i._is_strictly_monotonic_increasing is True
     assert Index(i.values)._is_strictly_monotonic_increasing is True
 
@@ -71,13 +71,13 @@ def test_is_monotonic_increasing():
         names=["household_id", "asset_id"],
     )
 
-    assert i.is_monotonic is False
+    assert i.is_monotonic_increasing is False
     assert i._is_strictly_monotonic_increasing is False
 
     # empty
     i = MultiIndex.from_arrays([[], []])
-    assert i.is_monotonic is True
-    assert Index(i.values).is_monotonic is True
+    assert i.is_monotonic_increasing is True
+    assert Index(i.values).is_monotonic_increasing is True
     assert i._is_strictly_monotonic_increasing is True
     assert Index(i.values)._is_strictly_monotonic_increasing is True
 
diff --git a/pandas/tests/indexes/multi/test_reindex.py b/pandas/tests/indexes/multi/test_reindex.py
index 8136169aa26f6..5d124c19cd865 100644
--- a/pandas/tests/indexes/multi/test_reindex.py
+++ b/pandas/tests/indexes/multi/test_reindex.py
@@ -42,9 +42,6 @@ def test_reindex_level(idx):
     with pytest.raises(TypeError, match="Fill method not supported"):
         idx.reindex(idx, method="pad", level="second")
 
-    with pytest.raises(TypeError, match="Fill method not supported"):
-        index.reindex(index, method="bfill", level="first")
-
 
 def test_reindex_preserves_names_when_target_is_list_or_ndarray(idx):
     # GH6552
diff --git a/pandas/tests/indexes/multi/test_setops.py b/pandas/tests/indexes/multi/test_setops.py
index 9f12d62155692..d29abc1bc6a9f 100644
--- a/pandas/tests/indexes/multi/test_setops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -368,7 +368,7 @@ def test_union_sort_other_empty(slice_):
 
 
 @pytest.mark.xfail(reason="Not implemented.")
-def test_union_sort_other_empty_sort(slice_):
+def test_union_sort_other_empty_sort():
     # TODO(GH#25151): decide on True behaviour
     # # sort=True
     idx = MultiIndex.from_product([[1, 0], ["a", "b"]])
@@ -525,16 +525,52 @@ def test_union_nan_got_duplicated():
     tm.assert_index_equal(result, mi2)
 
 
-def test_union_duplicates(index):
+def test_union_duplicates(index, request):
     # GH#38977
     if index.empty or isinstance(index, (IntervalIndex, CategoricalIndex)):
         # No duplicates in empty indexes
         return
+    if index.dtype.kind == "c":
+        mark = pytest.mark.xfail(
+            reason="sort_values() call raises bc complex objects are not comparable"
+        )
+        request.node.add_marker(mark)
+
     values = index.unique().values.tolist()
     mi1 = MultiIndex.from_arrays([values, [1] * len(values)])
     mi2 = MultiIndex.from_arrays([[values[0]] + values, [1] * (len(values) + 1)])
     result = mi1.union(mi2)
-    tm.assert_index_equal(result, mi2.sort_values())
+    expected = mi2.sort_values()
+    if mi2.levels[0].dtype == np.uint64 and (mi2.get_level_values(0) < 2**63).all():
+        # GH#47294 - union uses lib.fast_zip, converting data to Python integers
+        # and loses type information. Result is then unsigned only when values are
+        # sufficiently large to require unsigned dtype.
+        expected = expected.set_levels(
+            [expected.levels[0].astype(int), expected.levels[1]]
+        )
+    tm.assert_index_equal(result, expected)
 
     result = mi2.union(mi1)
-    tm.assert_index_equal(result, mi2.sort_values())
+    tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "levels1, levels2, codes1, codes2, names",
+    [
+        (
+            [["a", "b", "c"], [0, ""]],
+            [["c", "d", "b"], [""]],
+            [[0, 1, 2], [1, 1, 1]],
+            [[0, 1, 2], [0, 0, 0]],
+            ["name1", "name2"],
+        ),
+    ],
+)
+def test_intersection_lexsort_depth(levels1, levels2, codes1, codes2, names):
+    # GH#25169
+    mi1 = MultiIndex(levels=levels1, codes=codes1, names=names)
+    mi2 = MultiIndex(levels=levels2, codes=codes2, names=names)
+    mi_int = mi1.intersection(mi2)
+
+    with tm.assert_produces_warning(FutureWarning, match="MultiIndex.lexsort_depth"):
+        assert mi_int.lexsort_depth == 0
diff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py
index 63d3fe53f9db5..6fd1781beeda4 100644
--- a/pandas/tests/indexes/multi/test_sorting.py
+++ b/pandas/tests/indexes/multi/test_sorting.py
@@ -157,10 +157,9 @@ def test_reconstruct_sort():
 
     # starts off lexsorted & monotonic
     mi = MultiIndex.from_arrays([["A", "A", "B", "B", "B"], [1, 2, 1, 2, 3]])
-    assert mi.is_monotonic
-
+    assert mi.is_monotonic_increasing
     recons = mi._sort_levels_monotonic()
-    assert recons.is_monotonic
+    assert recons.is_monotonic_increasing
     assert mi is recons
 
     assert mi.equals(recons)
@@ -171,11 +170,9 @@ def test_reconstruct_sort():
         [("z", "a"), ("x", "a"), ("y", "b"), ("x", "b"), ("y", "a"), ("z", "b")],
         names=["one", "two"],
     )
-    assert not mi.is_monotonic
-
+    assert not mi.is_monotonic_increasing
     recons = mi._sort_levels_monotonic()
-    assert not recons.is_monotonic
-
+    assert not recons.is_monotonic_increasing
     assert mi.equals(recons)
     assert Index(mi.values).equals(Index(recons.values))
 
@@ -185,11 +182,9 @@ def test_reconstruct_sort():
         codes=[[0, 1, 0, 2], [2, 0, 0, 1]],
         names=["col1", "col2"],
     )
-    assert not mi.is_monotonic
-
+    assert not mi.is_monotonic_increasing
     recons = mi._sort_levels_monotonic()
-    assert not recons.is_monotonic
-
+    assert not recons.is_monotonic_increasing
     assert mi.equals(recons)
     assert Index(mi.values).equals(Index(recons.values))
 
diff --git a/pandas/tests/indexes/numeric/test_astype.py b/pandas/tests/indexes/numeric/test_astype.py
index 89f26e953400d..ee75f56eac7ce 100644
--- a/pandas/tests/indexes/numeric/test_astype.py
+++ b/pandas/tests/indexes/numeric/test_astype.py
@@ -10,10 +10,22 @@
 from pandas.core.indexes.api import (
     Float64Index,
     Int64Index,
+    UInt64Index,
 )
 
 
 class TestAstype:
+    def test_astype_float64_to_uint64(self):
+        # GH#45309 used to incorrectly return Int64Index
+        idx = Float64Index([0.0, 5.0, 10.0, 15.0, 20.0])
+        result = idx.astype("u8")
+        expected = UInt64Index([0, 5, 10, 15, 20])
+        tm.assert_index_equal(result, expected)
+
+        idx_with_negatives = idx - 10
+        with pytest.raises(ValueError, match="losslessly"):
+            idx_with_negatives.astype(np.uint64)
+
     def test_astype_float64_to_object(self):
         float_index = Float64Index([0.0, 2.5, 5.0, 7.5, 10.0])
         result = float_index.astype(object)
diff --git a/pandas/tests/indexes/numeric/test_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py
index a70845a4def7f..1c4cbd21a988e 100644
--- a/pandas/tests/indexes/numeric/test_indexing.py
+++ b/pandas/tests/indexes/numeric/test_indexing.py
@@ -20,7 +20,7 @@
 @pytest.fixture
 def index_large():
     # large values used in UInt64Index tests where no compat needed with Int64/Float64
-    large = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
+    large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
     return UInt64Index(large)
 
 
@@ -161,7 +161,7 @@ def test_get_loc_float_index_nan_with_method(self, vals, method):
     @pytest.mark.parametrize("dtype", ["f8", "i8", "u8"])
     def test_get_loc_numericindex_none_raises(self, dtype):
         # case that goes through searchsorted and key is non-comparable to values
-        arr = np.arange(10 ** 7, dtype=dtype)
+        arr = np.arange(10**7, dtype=dtype)
         idx = Index(arr)
         with pytest.raises(KeyError, match="None"):
             idx.get_loc(None)
@@ -376,17 +376,17 @@ def test_get_indexer_int64(self):
         tm.assert_numpy_array_equal(indexer, expected)
 
     def test_get_indexer_uint64(self, index_large):
-        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
+        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2**63)
         indexer = index_large.get_indexer(target)
         expected = np.array([0, -1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
-        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
+        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2**63)
         indexer = index_large.get_indexer(target, method="pad")
         expected = np.array([0, 0, 1, 2, 3, 4, 4, 4, 4, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
-        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
+        target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2**63)
         indexer = index_large.get_indexer(target, method="backfill")
         expected = np.array([0, 1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
@@ -424,6 +424,17 @@ def test_where_uint64(self):
         result = idx.putmask(~mask, other)
         tm.assert_index_equal(result, expected)
 
+    def test_where_infers_type_instead_of_trying_to_convert_string_to_float(self):
+        # GH 32413
+        index = Index([1, np.nan])
+        cond = index.notna()
+        other = Index(["a", "b"], dtype="string")
+
+        expected = Index([1.0, "b"])
+        result = index.where(cond, other)
+
+        tm.assert_index_equal(result, expected)
+
 
 class TestTake:
     @pytest.mark.parametrize("klass", [Float64Index, Int64Index, UInt64Index])
diff --git a/pandas/tests/indexes/numeric/test_join.py b/pandas/tests/indexes/numeric/test_join.py
index 2a47289b65aad..9bbe7a64ada87 100644
--- a/pandas/tests/indexes/numeric/test_join.py
+++ b/pandas/tests/indexes/numeric/test_join.py
@@ -198,13 +198,13 @@ class TestJoinUInt64Index:
     @pytest.fixture
     def index_large(self):
         # large values used in TestUInt64Index where no compat needed with Int64/Float64
-        large = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
+        large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
         return UInt64Index(large)
 
     def test_join_inner(self, index_large):
-        other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other = UInt64Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
-            2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
+            2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
@@ -216,7 +216,7 @@ def test_join_inner(self, index_large):
         lidx = lidx.take(ind)
         ridx = ridx.take(ind)
 
-        eres = UInt64Index(2 ** 63 + np.array([10, 25], dtype="uint64"))
+        eres = UInt64Index(2**63 + np.array([10, 25], dtype="uint64"))
         elidx = np.array([1, 4], dtype=np.intp)
         eridx = np.array([5, 2], dtype=np.intp)
 
@@ -242,9 +242,9 @@ def test_join_inner(self, index_large):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_left(self, index_large):
-        other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other = UInt64Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
-            2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
+            2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
@@ -267,12 +267,12 @@ def test_join_left(self, index_large):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # non-unique
-        idx = UInt64Index(2 ** 63 + np.array([1, 1, 2, 5], dtype="uint64"))
-        idx2 = UInt64Index(2 ** 63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
+        idx = UInt64Index(2**63 + np.array([1, 1, 2, 5], dtype="uint64"))
+        idx2 = UInt64Index(2**63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
         res, lidx, ridx = idx2.join(idx, how="left", return_indexers=True)
 
         # 1 is in idx2, so it should be x2
-        eres = UInt64Index(2 ** 63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
+        eres = UInt64Index(2**63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
         eridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
         elidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
 
@@ -281,9 +281,9 @@ def test_join_left(self, index_large):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_right(self, index_large):
-        other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other = UInt64Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
-            2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
+            2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
@@ -309,12 +309,12 @@ def test_join_right(self, index_large):
         assert ridx is None
 
         # non-unique
-        idx = UInt64Index(2 ** 63 + np.array([1, 1, 2, 5], dtype="uint64"))
-        idx2 = UInt64Index(2 ** 63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
+        idx = UInt64Index(2**63 + np.array([1, 1, 2, 5], dtype="uint64"))
+        idx2 = UInt64Index(2**63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
         res, lidx, ridx = idx.join(idx2, how="right", return_indexers=True)
 
         # 1 is in idx2, so it should be x2
-        eres = UInt64Index(2 ** 63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
+        eres = UInt64Index(2**63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
         elidx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
         eridx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
 
@@ -324,20 +324,20 @@ def test_join_right(self, index_large):
 
     def test_join_non_int_index(self, index_large):
         other = Index(
-            2 ** 63 + np.array([1, 5, 7, 10, 20], dtype="uint64"), dtype=object
+            2**63 + np.array([1, 5, 7, 10, 20], dtype="uint64"), dtype=object
         )
 
         outer = index_large.join(other, how="outer")
         outer2 = other.join(index_large, how="outer")
         expected = Index(
-            2 ** 63 + np.array([0, 1, 5, 7, 10, 15, 20, 25], dtype="uint64")
+            2**63 + np.array([0, 1, 5, 7, 10, 15, 20, 25], dtype="uint64")
         )
         tm.assert_index_equal(outer, outer2)
         tm.assert_index_equal(outer, expected)
 
         inner = index_large.join(other, how="inner")
         inner2 = other.join(index_large, how="inner")
-        expected = Index(2 ** 63 + np.array([10, 20], dtype="uint64"))
+        expected = Index(2**63 + np.array([10, 20], dtype="uint64"))
         tm.assert_index_equal(inner, inner2)
         tm.assert_index_equal(inner, expected)
 
@@ -354,9 +354,9 @@ def test_join_non_int_index(self, index_large):
         tm.assert_index_equal(right2, index_large.astype(object))
 
     def test_join_outer(self, index_large):
-        other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other = UInt64Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
-            2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
+            2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
@@ -366,7 +366,7 @@ def test_join_outer(self, index_large):
         tm.assert_index_equal(res, noidx_res)
 
         eres = UInt64Index(
-            2 ** 63 + np.array([0, 1, 2, 7, 10, 12, 15, 20, 25], dtype="uint64")
+            2**63 + np.array([0, 1, 2, 7, 10, 12, 15, 20, 25], dtype="uint64")
         )
         elidx = np.array([0, -1, -1, -1, 1, -1, 2, 3, 4], dtype=np.intp)
         eridx = np.array([-1, 3, 4, 0, 5, 1, -1, -1, 2], dtype=np.intp)
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index af308379cba5e..23262cb2eb768 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -205,7 +205,7 @@ def test_equals_numeric_other_index_type(self, other):
     def test_lookups_datetimelike_values(self, vals, dtype):
 
         # If we have datetime64 or timedelta64 values, make sure they are
-        #  wrappped correctly  GH#31163
+        #  wrapped correctly  GH#31163
         ser = Series(vals, index=range(3, 6))
         ser.index = ser.index.astype(dtype)
 
@@ -326,19 +326,19 @@ def test_is_monotonic(self):
         index_cls = self._index_cls
 
         index = index_cls([1, 2, 3, 4])
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index._is_strictly_monotonic_increasing is True
         assert index.is_monotonic_decreasing is False
         assert index._is_strictly_monotonic_decreasing is False
 
         index = index_cls([4, 3, 2, 1])
-        assert index.is_monotonic is False
+        assert index.is_monotonic_increasing is False
         assert index._is_strictly_monotonic_increasing is False
         assert index._is_strictly_monotonic_decreasing is True
 
         index = index_cls([1])
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index.is_monotonic_decreasing is True
         assert index._is_strictly_monotonic_increasing is True
@@ -509,6 +509,20 @@ def test_constructor_coercion_signed_to_unsigned(
         with pytest.raises(OverflowError, match=msg):
             Index([-1], dtype=any_unsigned_int_numpy_dtype)
 
+    def test_constructor_np_signed(self, any_signed_int_numpy_dtype):
+        # GH#47475
+        scalar = np.dtype(any_signed_int_numpy_dtype).type(1)
+        result = Index([scalar])
+        expected = Int64Index([1])
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_np_unsigned(self, any_unsigned_int_numpy_dtype):
+        # GH#47475
+        scalar = np.dtype(any_unsigned_int_numpy_dtype).type(1)
+        result = Index([scalar])
+        expected = UInt64Index([1])
+        tm.assert_index_equal(result, expected)
+
     def test_coerce_list(self):
         # coerce things
         arr = Index([1, 2, 3, 4])
@@ -563,8 +577,8 @@ def simple_index(self, dtype):
 
     @pytest.fixture(
         params=[
-            [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25],
-            [2 ** 63 + 25, 2 ** 63 + 20, 2 ** 63 + 15, 2 ** 63 + 10, 2 ** 63],
+            [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
+            [2**63 + 25, 2**63 + 20, 2**63 + 15, 2**63 + 10, 2**63],
         ],
         ids=["index_inc", "index_dec"],
     )
@@ -594,21 +608,21 @@ def test_constructor(self, dtype):
         res = Index([1, 2, 3], dtype=dtype)
         tm.assert_index_equal(res, idx, exact=exact)
 
-        idx = index_cls([1, 2 ** 63])
-        res = Index([1, 2 ** 63], dtype=dtype)
+        idx = index_cls([1, 2**63])
+        res = Index([1, 2**63], dtype=dtype)
         tm.assert_index_equal(res, idx, exact=exact)
 
-        idx = index_cls([1, 2 ** 63])
-        res = Index([1, 2 ** 63])
+        idx = index_cls([1, 2**63])
+        res = Index([1, 2**63])
         tm.assert_index_equal(res, idx, exact=exact)
 
-        idx = Index([-1, 2 ** 63], dtype=object)
-        res = Index(np.array([-1, 2 ** 63], dtype=object))
+        idx = Index([-1, 2**63], dtype=object)
+        res = Index(np.array([-1, 2**63], dtype=object))
         tm.assert_index_equal(res, idx, exact=exact)
 
         # https://github.com/pandas-dev/pandas/issues/29526
-        idx = index_cls([1, 2 ** 63 + 1], dtype=dtype)
-        res = Index([1, 2 ** 63 + 1], dtype=dtype)
+        idx = index_cls([1, 2**63 + 1], dtype=dtype)
+        res = Index([1, 2**63 + 1], dtype=dtype)
         tm.assert_index_equal(res, idx, exact=exact)
 
     def test_constructor_does_not_cast_to_float(self):
@@ -657,7 +671,7 @@ def test_uint_index_does_not_convert_to_float64(box):
     )
     tm.assert_index_equal(result.index, expected)
 
-    tm.assert_equal(result, series[:3])
+    tm.assert_equal(result, series.iloc[:3])
 
 
 def test_float64_index_equals():
diff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py
index 72336d3e33b79..9f2174c2de51e 100644
--- a/pandas/tests/indexes/numeric/test_setops.py
+++ b/pandas/tests/indexes/numeric/test_setops.py
@@ -19,7 +19,7 @@
 @pytest.fixture
 def index_large():
     # large values used in TestUInt64Index where no compat needed with Int64/Float64
-    large = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
+    large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
     return UInt64Index(large)
 
 
@@ -89,7 +89,7 @@ def test_float64_index_difference(self):
         tm.assert_index_equal(result, string_index)
 
     def test_intersection_uint64_outside_int64_range(self, index_large):
-        other = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20])
+        other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20])
         result = index_large.intersection(other)
         expected = Index(np.sort(np.intersect1d(index_large.values, other.values)))
         tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/object/test_astype.py b/pandas/tests/indexes/object/test_astype.py
index 9bfc0c1312200..91e266e805868 100644
--- a/pandas/tests/indexes/object/test_astype.py
+++ b/pandas/tests/indexes/object/test_astype.py
@@ -1,4 +1,9 @@
-from pandas import Index
+import pytest
+
+from pandas import (
+    Index,
+    NaT,
+)
 import pandas._testing as tm
 
 
@@ -8,3 +13,12 @@ def test_astype_str_from_bytes():
     result = idx.astype(str)
     expected = Index(["あ", "a"], dtype="object")
     tm.assert_index_equal(result, expected)
+
+
+def test_astype_invalid_nas_to_tdt64_raises():
+    # GH#45722 don't cast np.datetime64 NaTs to timedelta64 NaT
+    idx = Index([NaT.asm8] * 2, dtype=object)
+
+    msg = r"Cannot cast Index to dtype timedelta64\[ns\]"
+    with pytest.raises(TypeError, match=msg):
+        idx.astype("m8[ns]")
diff --git a/pandas/tests/indexes/object/test_indexing.py b/pandas/tests/indexes/object/test_indexing.py
index 38bd96921b991..924a33169c132 100644
--- a/pandas/tests/indexes/object/test_indexing.py
+++ b/pandas/tests/indexes/object/test_indexing.py
@@ -128,6 +128,13 @@ def test_get_indexer_non_unique_np_nats(self, np_nat_fixture, np_nat_fixture2):
             tm.assert_numpy_array_equal(missing, expected_missing)
         # dt64nat vs td64nat
         else:
+            try:
+                np_nat_fixture == np_nat_fixture2
+            except (TypeError, OverflowError):
+                # Numpy will raise on uncomparable types, like
+                # np.datetime64('NaT', 'Y') and np.datetime64('NaT', 'ps')
+                # https://github.com/numpy/numpy/issues/22762
+                return
             index = Index(
                 np.array(
                     [
diff --git a/pandas/tests/indexes/period/methods/test_astype.py b/pandas/tests/indexes/period/methods/test_astype.py
index e2340a2db02f7..fbc1d3702115e 100644
--- a/pandas/tests/indexes/period/methods/test_astype.py
+++ b/pandas/tests/indexes/period/methods/test_astype.py
@@ -39,8 +39,7 @@ def test_astype_conversion(self):
         )
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            result = idx.astype(np.int64)
+        result = idx.astype(np.int64)
         expected = Int64Index(
             [16937] + [-9223372036854775808] * 3, dtype=np.int64, name="idx"
         )
@@ -51,17 +50,19 @@ def test_astype_conversion(self):
         tm.assert_index_equal(result, expected)
 
         idx = period_range("1990", "2009", freq="A", name="idx")
-        with tm.assert_produces_warning(FutureWarning):
-            result = idx.astype("i8")
+        result = idx.astype("i8")
         tm.assert_index_equal(result, Index(idx.asi8, name="idx"))
         tm.assert_numpy_array_equal(result.values, idx.asi8)
 
     def test_astype_uint(self):
         arr = period_range("2000", periods=2, name="idx")
         expected = UInt64Index(np.array([10957, 10958], dtype="uint64"), name="idx")
-        with tm.assert_produces_warning(FutureWarning):
-            tm.assert_index_equal(arr.astype("uint64"), expected)
-            tm.assert_index_equal(arr.astype("uint32"), expected)
+        tm.assert_index_equal(arr.astype("uint64"), expected)
+
+        msg = "will return exactly the specified dtype instead of uint64"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = arr.astype("uint32")
+        tm.assert_index_equal(res, expected)
 
     def test_astype_object(self):
         idx = PeriodIndex([], freq="M")
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index e372fd007630a..5dff5c2ad9c86 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -183,9 +183,10 @@ def test_constructor_datetime64arr(self):
         vals = np.arange(100000, 100000 + 10000, 100, dtype=np.int64)
         vals = vals.view(np.dtype("M8[us]"))
 
-        msg = r"Wrong dtype: datetime64\[us\]"
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(vals, freq="D")
+        pi = PeriodIndex(vals, freq="D")
+
+        expected = PeriodIndex(vals.astype("M8[ns]"), freq="D")
+        tm.assert_index_equal(pi, expected)
 
     @pytest.mark.parametrize("box", [None, "series", "index"])
     def test_constructor_datetime64arr_ok(self, box):
@@ -534,9 +535,6 @@ def test_shallow_copy_requires_disallow_period_index(self):
 
 
 class TestSeriesPeriod:
-    def setup_method(self, method):
-        self.series = Series(period_range("2000-01-01", periods=10, freq="D"))
-
     def test_constructor_cant_cast_period(self):
         msg = "Cannot cast PeriodIndex to dtype float64"
         with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/indexes/period/test_freq_attr.py b/pandas/tests/indexes/period/test_freq_attr.py
index 3bf3e700e5e72..e1ecffa4982bd 100644
--- a/pandas/tests/indexes/period/test_freq_attr.py
+++ b/pandas/tests/indexes/period/test_freq_attr.py
@@ -1,5 +1,7 @@
 import pytest
 
+from pandas.compat import PY311
+
 from pandas import (
     offsets,
     period_range,
@@ -17,5 +19,10 @@ def test_freq_setter_deprecated(self):
             idx.freq
 
         # warning for setter
-        with pytest.raises(AttributeError, match="can't set attribute"):
+        msg = (
+            "property 'freq' of 'PeriodArray' object has no setter"
+            if PY311
+            else "can't set attribute"
+        )
+        with pytest.raises(AttributeError, match=msg):
             idx.freq = offsets.Day()
diff --git a/pandas/tests/indexes/period/test_partial_slicing.py b/pandas/tests/indexes/period/test_partial_slicing.py
index 72e7e458b4e1f..2cf1cf0f15652 100644
--- a/pandas/tests/indexes/period/test_partial_slicing.py
+++ b/pandas/tests/indexes/period/test_partial_slicing.py
@@ -12,16 +12,20 @@
 
 
 class TestPeriodIndex:
-    def test_getitem_periodindex_duplicates_string_slice(self):
+    def test_getitem_periodindex_duplicates_string_slice(self, using_copy_on_write):
         # monotonic
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
         ts = Series(np.random.randn(len(idx)), index=idx)
+        original = ts.copy()
 
         result = ts["2007"]
         expected = ts[1:3]
         tm.assert_series_equal(result, expected)
         result[:] = 1
-        assert (ts[1:3] == 1).all()
+        if using_copy_on_write:
+            tm.assert_series_equal(ts, original)
+        else:
+            assert (ts[1:3] == 1).all()
 
         # not monotonic
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="A-JUN")
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 82a3721b0cbb9..41b76d6aced23 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -14,22 +14,28 @@ class TestPeriodRepresentation:
     Wish to match NumPy units
     """
 
-    def _check_freq(self, freq, base_date):
+    @pytest.mark.parametrize(
+        "freq, base_date",
+        [
+            ("W-THU", "1970-01-01"),
+            ("D", "1970-01-01"),
+            ("B", "1970-01-01"),
+            ("H", "1970-01-01"),
+            ("T", "1970-01-01"),
+            ("S", "1970-01-01"),
+            ("L", "1970-01-01"),
+            ("U", "1970-01-01"),
+            ("N", "1970-01-01"),
+            ("M", "1970-01"),
+            ("A", 1970),
+        ],
+    )
+    def test_freq(self, freq, base_date):
         rng = period_range(start=base_date, periods=10, freq=freq)
         exp = np.arange(10, dtype=np.int64)
 
         tm.assert_numpy_array_equal(rng.asi8, exp)
 
-    def test_annual(self):
-        self._check_freq("A", 1970)
-
-    def test_monthly(self):
-        self._check_freq("M", "1970-01")
-
-    @pytest.mark.parametrize("freq", ["W-THU", "D", "B", "H", "T", "S", "L", "U", "N"])
-    def test_freq(self, freq):
-        self._check_freq(freq, "1970-01-01")
-
 
 class TestPeriodIndexConversion:
     def test_tolist(self):
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index c45a4c771856c..1c65c369a7e99 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -311,34 +311,34 @@ def test_cache(self):
 
     def test_is_monotonic(self):
         index = RangeIndex(0, 20, 2)
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index.is_monotonic_decreasing is False
         assert index._is_strictly_monotonic_increasing is True
         assert index._is_strictly_monotonic_decreasing is False
 
         index = RangeIndex(4, 0, -1)
-        assert index.is_monotonic is False
+        assert index.is_monotonic_increasing is False
         assert index._is_strictly_monotonic_increasing is False
         assert index.is_monotonic_decreasing is True
         assert index._is_strictly_monotonic_decreasing is True
 
         index = RangeIndex(1, 2)
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index.is_monotonic_decreasing is True
         assert index._is_strictly_monotonic_increasing is True
         assert index._is_strictly_monotonic_decreasing is True
 
         index = RangeIndex(2, 1)
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index.is_monotonic_decreasing is True
         assert index._is_strictly_monotonic_increasing is True
         assert index._is_strictly_monotonic_decreasing is True
 
         index = RangeIndex(1, 1)
-        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
         assert index.is_monotonic_increasing is True
         assert index.is_monotonic_decreasing is True
         assert index._is_strictly_monotonic_increasing is True
diff --git a/pandas/tests/indexes/ranges/test_setops.py b/pandas/tests/indexes/ranges/test_setops.py
index 2942010af2720..71bd2f5590b8f 100644
--- a/pandas/tests/indexes/ranges/test_setops.py
+++ b/pandas/tests/indexes/ranges/test_setops.py
@@ -145,8 +145,9 @@ def test_union_noncomparable(self, sort):
         expected = Index(np.concatenate((other, index)))
         tm.assert_index_equal(result, expected)
 
-    @pytest.fixture(
-        params=[
+    @pytest.mark.parametrize(
+        "idx1, idx2, expected_sorted, expected_notsorted",
+        [
             (
                 RangeIndex(0, 10, 1),
                 RangeIndex(0, 10, 1),
@@ -157,13 +158,13 @@ def test_union_noncomparable(self, sort):
                 RangeIndex(0, 10, 1),
                 RangeIndex(5, 20, 1),
                 RangeIndex(0, 20, 1),
-                Int64Index(range(20)),
+                RangeIndex(0, 20, 1),
             ),
             (
                 RangeIndex(0, 10, 1),
                 RangeIndex(10, 20, 1),
                 RangeIndex(0, 20, 1),
-                Int64Index(range(20)),
+                RangeIndex(0, 20, 1),
             ),
             (
                 RangeIndex(0, -10, -1),
@@ -175,7 +176,7 @@ def test_union_noncomparable(self, sort):
                 RangeIndex(0, -10, -1),
                 RangeIndex(-10, -20, -1),
                 RangeIndex(-19, 1, 1),
-                Int64Index(range(0, -20, -1)),
+                RangeIndex(0, -20, -1),
             ),
             (
                 RangeIndex(0, 10, 2),
@@ -205,7 +206,7 @@ def test_union_noncomparable(self, sort):
                 RangeIndex(0, 100, 5),
                 RangeIndex(0, 100, 20),
                 RangeIndex(0, 100, 5),
-                Int64Index(range(0, 100, 5)),
+                RangeIndex(0, 100, 5),
             ),
             (
                 RangeIndex(0, -100, -5),
@@ -230,7 +231,7 @@ def test_union_noncomparable(self, sort):
                 RangeIndex(0, 100, 2),
                 RangeIndex(100, 150, 200),
                 RangeIndex(0, 102, 2),
-                Int64Index(range(0, 102, 2)),
+                RangeIndex(0, 102, 2),
             ),
             (
                 RangeIndex(0, -100, -2),
@@ -242,13 +243,13 @@ def test_union_noncomparable(self, sort):
                 RangeIndex(0, -100, -1),
                 RangeIndex(0, -50, -3),
                 RangeIndex(-99, 1, 1),
-                Int64Index(list(range(0, -100, -1))),
+                RangeIndex(0, -100, -1),
             ),
             (
                 RangeIndex(0, 1, 1),
                 RangeIndex(5, 6, 10),
                 RangeIndex(0, 6, 5),
-                Int64Index([0, 5]),
+                RangeIndex(0, 10, 5),
             ),
             (
                 RangeIndex(0, 10, 5),
@@ -274,16 +275,17 @@ def test_union_noncomparable(self, sort):
                 Int64Index([1, 5, 6]),
                 Int64Index([1, 5, 6]),
             ),
-        ]
+            # GH 43885
+            (
+                RangeIndex(0, 10),
+                RangeIndex(0, 5),
+                RangeIndex(0, 10),
+                RangeIndex(0, 10),
+            ),
+        ],
+        ids=lambda x: repr(x) if isinstance(x, RangeIndex) else x,
     )
-    def unions(self, request):
-        """Inputs and expected outputs for RangeIndex.union tests"""
-        return request.param
-
-    def test_union_sorted(self, unions):
-
-        idx1, idx2, expected_sorted, expected_notsorted = unions
-
+    def test_union_sorted(self, idx1, idx2, expected_sorted, expected_notsorted):
         res1 = idx1.union(idx2, sort=None)
         tm.assert_index_equal(res1, expected_sorted, exact=True)
 
diff --git a/pandas/tests/indexes/test_any_index.py b/pandas/tests/indexes/test_any_index.py
index c7aae5d69b8e3..b062dfb7a10ba 100644
--- a/pandas/tests/indexes/test_any_index.py
+++ b/pandas/tests/indexes/test_any_index.py
@@ -46,9 +46,14 @@ def test_mutability(index):
         index[0] = index[0]
 
 
-def test_map_identity_mapping(index):
+def test_map_identity_mapping(index, request):
     # GH#12766
+
     result = index.map(lambda x: x)
+    if index.dtype == object and result.dtype == bool:
+        assert (index == result).all()
+        # TODO: could work that into the 'exact="equiv"'?
+        return  # FIXME: doesn't belong in this file anymore!
     tm.assert_index_equal(result, index, exact="equiv")
 
 
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 3447a2ceef7c1..43b893b084672 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -2,6 +2,7 @@
 from datetime import datetime
 from io import StringIO
 import math
+import operator
 import re
 
 import numpy as np
@@ -318,18 +319,23 @@ def test_view_with_args(self, index):
     @pytest.mark.parametrize(
         "index",
         [
-            "unicode",
             "string",
             pytest.param("categorical", marks=pytest.mark.xfail(reason="gh-25464")),
-            "bool",
+            "bool-object",
+            "bool-dtype",
             "empty",
         ],
         indirect=True,
     )
     def test_view_with_args_object_array_raises(self, index):
-        msg = "Cannot change data-type for object array"
-        with pytest.raises(TypeError, match=msg):
-            index.view("i8")
+        if index.dtype == bool:
+            msg = "When changing to a larger dtype"
+            with pytest.raises(ValueError, match=msg):
+                index.view("i8")
+        else:
+            msg = "Cannot change data-type for object array"
+            with pytest.raises(TypeError, match=msg):
+                index.view("i8")
 
     @pytest.mark.parametrize("index", ["int", "range"], indirect=True)
     def test_astype(self, index):
@@ -397,9 +403,9 @@ def test_is_(self):
 
     def test_asof_numeric_vs_bool_raises(self):
         left = Index([1, 2, 3])
-        right = Index([True, False])
+        right = Index([True, False], dtype=object)
 
-        msg = "Cannot compare dtypes int64 and object"
+        msg = "Cannot compare dtypes int64 and bool"
         with pytest.raises(TypeError, match=msg):
             left.asof(right[0])
         # TODO: should right.asof(left[0]) also raise?
@@ -452,7 +458,7 @@ def test_empty_fancy_raises(self, index):
         with pytest.raises(IndexError, match=msg):
             index[empty_farr]
 
-    def test_union_dt_as_obj(self, sort, simple_index):
+    def test_union_dt_as_obj(self, simple_index):
         # TODO: Replace with fixturesult
         index = simple_index
         date_index = date_range("2019-01-01", periods=10)
@@ -526,7 +532,7 @@ def test_map_dictlike_simple(self, mapper):
             lambda values, index: Series(values, index),
         ],
     )
-    def test_map_dictlike(self, index, mapper):
+    def test_map_dictlike(self, index, mapper, request):
         # GH 12756
         if isinstance(index, CategoricalIndex):
             # Tested in test_categorical
@@ -591,7 +597,8 @@ def test_append_empty_preserve_name(self, name, expected):
         "index, expected",
         [
             ("string", False),
-            ("bool", False),
+            ("bool-object", False),
+            ("bool-dtype", False),
             ("categorical", False),
             ("int", True),
             ("datetime", False),
@@ -606,7 +613,8 @@ def test_is_numeric(self, index, expected):
         "index, expected",
         [
             ("string", True),
-            ("bool", True),
+            ("bool-object", True),
+            ("bool-dtype", False),
             ("categorical", False),
             ("int", False),
             ("datetime", False),
@@ -621,7 +629,8 @@ def test_is_object(self, index, expected):
         "index, expected",
         [
             ("string", False),
-            ("bool", False),
+            ("bool-object", False),
+            ("bool-dtype", False),
             ("categorical", False),
             ("int", False),
             ("datetime", True),
@@ -655,10 +664,12 @@ def test_format_missing(self, vals, nulls_fixture):
         # 2845
         vals = list(vals)  # Copy for each iteration
         vals.append(nulls_fixture)
-        index = Index(vals)
+        index = Index(vals, dtype=object)
+        # TODO: case with complex dtype?
 
         formatted = index.format()
-        expected = [str(index[0]), str(index[1]), str(index[2]), "NaN"]
+        null_repr = "NaN" if isinstance(nulls_fixture, float) else str(nulls_fixture)
+        expected = [str(index[0]), str(index[1]), str(index[2]), null_repr]
 
         assert formatted == expected
         assert index[3] is nulls_fixture
@@ -742,7 +753,7 @@ def test_drop_tuple(self, values, to_drop):
             tm.assert_index_equal(result, expected)
 
         removed = index.drop(to_drop[1])
-        msg = fr"\"\[{re.escape(to_drop[1].__repr__())}\] not found in axis\""
+        msg = rf"\"\[{re.escape(to_drop[1].__repr__())}\] not found in axis\""
         for drop_me in to_drop[1], [to_drop[1]]:
             with pytest.raises(KeyError, match=msg):
                 removed.drop(drop_me)
@@ -791,7 +802,7 @@ def test_isin(self, values, index, expected):
         result = index.isin(values)
         tm.assert_numpy_array_equal(result, expected)
 
-    def test_isin_nan_common_object(self, request, nulls_fixture, nulls_fixture2):
+    def test_isin_nan_common_object(self, nulls_fixture, nulls_fixture2):
         # Test cartesian product of null fixtures and ensure that we don't
         # mangle the various types (save a corner case with PyPy)
 
@@ -819,7 +830,7 @@ def test_isin_nan_common_object(self, request, nulls_fixture, nulls_fixture2):
                 np.array([False, False]),
             )
 
-    def test_isin_nan_common_float64(self, request, nulls_fixture):
+    def test_isin_nan_common_float64(self, nulls_fixture):
 
         if nulls_fixture is pd.NaT or nulls_fixture is pd.NA:
             # Check 1) that we cannot construct a Float64Index with this value
@@ -870,7 +881,7 @@ def test_isin_level_kwarg_bad_label_raises(self, label, index):
             msg = f"'Level {label} not found'"
         else:
             index = index.rename("foo")
-            msg = fr"Requested level \({label}\) does not match index name \(foo\)"
+            msg = rf"Requested level \({label}\) does not match index name \(foo\)"
         with pytest.raises(KeyError, match=msg):
             index.isin([], level=label)
 
@@ -916,7 +927,7 @@ def test_slice_keep_name(self):
 
     @pytest.mark.parametrize(
         "index",
-        ["unicode", "string", "datetime", "int", "uint", "float"],
+        ["string", "datetime", "int", "uint", "float"],
         indirect=True,
     )
     def test_join_self(self, index, join_type):
@@ -1094,6 +1105,14 @@ def test_reindex_no_type_preserve_target_empty_mi(self):
         assert result.levels[0].dtype.type == np.int64
         assert result.levels[1].dtype.type == np.float64
 
+    def test_reindex_ignoring_level(self):
+        # GH#35132
+        idx = Index([1, 2, 3], name="x")
+        idx2 = Index([1, 2, 3, 4], name="x")
+        expected = Index([1, 2, 3, 4], name="x")
+        result, _ = idx.reindex(idx2, level="x")
+        tm.assert_index_equal(result, expected)
+
     def test_groupby(self):
         index = Index(range(5))
         result = index.groupby(np.array([1, 1, 2, 2, 2]))
@@ -1586,3 +1605,16 @@ def test_get_attributes_dict_deprecated():
     with tm.assert_produces_warning(DeprecationWarning):
         attrs = idx._get_attributes_dict()
     assert attrs == {"name": None}
+
+
+@pytest.mark.parametrize("op", [operator.lt, operator.gt])
+def test_nan_comparison_same_object(op):
+    # GH#47105
+    idx = Index([np.nan])
+    expected = np.array([False])
+
+    result = op(idx, idx)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = op(idx, idx.copy())
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index 30db35525903c..40a107658231d 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -8,13 +8,13 @@
 import numpy as np
 import pytest
 
-from pandas.compat import IS64
-
-from pandas.core.dtypes.common import (
-    is_integer_dtype,
-    needs_i8_conversion,
+from pandas.compat import (
+    IS64,
+    pa_version_under7p0,
 )
 
+from pandas.core.dtypes.common import is_integer_dtype
+
 import pandas as pd
 from pandas import (
     CategoricalIndex,
@@ -91,7 +91,9 @@ def test_constructor_non_hashable_name(self, index_flat):
 
     def test_constructor_unwraps_index(self, index_flat):
         a = index_flat
-        b = type(a)(a)
+        # Passing dtype is necessary for Index([True, False], dtype=object)
+        #  case.
+        b = type(a)(a, dtype=a.dtype)
         tm.assert_equal(a._data, b._data)
 
     def test_to_flat_index(self, index_flat):
@@ -198,8 +200,8 @@ def test_unique_level(self, index_flat):
             index.unique(level=3)
 
         msg = (
-            fr"Requested level \(wrong\) does not match index name "
-            fr"\({re.escape(index.name.__repr__())}\)"
+            rf"Requested level \(wrong\) does not match index name "
+            rf"\({re.escape(index.name.__repr__())}\)"
         )
         with pytest.raises(KeyError, match=msg):
             index.unique(level="wrong")
@@ -383,19 +385,29 @@ def test_astype_preserves_name(self, index, dtype):
             index.name = "idx"
 
         warn = None
-        if dtype in ["int64", "uint64"]:
-            if needs_i8_conversion(index.dtype):
-                warn = FutureWarning
-        elif (
+        if (
             isinstance(index, DatetimeIndex)
             and index.tz is not None
             and dtype == "datetime64[ns]"
         ):
             # This astype is deprecated in favor of tz_localize
             warn = FutureWarning
+        elif index.dtype.kind == "c" and dtype in ["float64", "int64", "uint64"]:
+            # imaginary components discarded
+            warn = np.ComplexWarning
+
+        is_pyarrow_str = (
+            str(index.dtype) == "string[pyarrow]"
+            and pa_version_under7p0
+            and dtype == "category"
+        )
         try:
             # Some of these conversions cannot succeed so we use a try / except
-            with tm.assert_produces_warning(warn):
+            with tm.assert_produces_warning(
+                warn,
+                raise_on_extra_warnings=is_pyarrow_str,
+                check_stacklevel=False,
+            ):
                 result = index.astype(dtype)
         except (ValueError, TypeError, NotImplementedError, SystemError):
             return
@@ -432,6 +444,9 @@ def test_hasnans_isnans(self, index_flat):
             return
         elif isinstance(index, NumericIndex) and is_integer_dtype(index.dtype):
             return
+        elif index.dtype == bool:
+            # values[1] = np.nan below casts to True!
+            return
 
         values[1] = np.nan
 
@@ -451,12 +466,16 @@ def test_sort_values_invalid_na_position(index_with_missing, na_position):
 
 
 @pytest.mark.parametrize("na_position", ["first", "last"])
-def test_sort_values_with_missing(index_with_missing, na_position):
+def test_sort_values_with_missing(index_with_missing, na_position, request):
     # GH 35584. Test that sort_values works with missing values,
     # sort non-missing and place missing according to na_position
 
     if isinstance(index_with_missing, CategoricalIndex):
-        pytest.skip("missing value sorting order not well-defined")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="missing value sorting order not well-defined", strict=False
+            )
+        )
 
     missing_count = np.sum(index_with_missing.isna())
     not_na_vals = index_with_missing[index_with_missing.notna()].values
diff --git a/pandas/tests/indexes/test_frozen.py b/pandas/tests/indexes/test_frozen.py
index cde3fc00eaaaa..ace66b5b06a51 100644
--- a/pandas/tests/indexes/test_frozen.py
+++ b/pandas/tests/indexes/test_frozen.py
@@ -5,14 +5,22 @@
 from pandas.core.indexes.frozen import FrozenList
 
 
-class TestFrozenList:
+@pytest.fixture
+def lst():
+    return [1, 2, 3, 4, 5]
+
+
+@pytest.fixture
+def container(lst):
+    return FrozenList(lst)
 
-    unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])
 
-    def setup_method(self, _):
-        self.lst = [1, 2, 3, 4, 5]
-        self.container = FrozenList(self.lst)
+@pytest.fixture
+def unicode_container():
+    return FrozenList(["\u05d0", "\u05d1", "c"])
 
+
+class TestFrozenList:
     def check_mutable_error(self, *args, **kwargs):
         # Pass whatever function you normally would to pytest.raises
         # (after the Exception kind).
@@ -21,75 +29,75 @@ def check_mutable_error(self, *args, **kwargs):
         with pytest.raises(TypeError, match=msg):
             mutable_regex(*args, **kwargs)
 
-    def test_no_mutable_funcs(self):
+    def test_no_mutable_funcs(self, container):
         def setitem():
-            self.container[0] = 5
+            container[0] = 5
 
         self.check_mutable_error(setitem)
 
         def setslice():
-            self.container[1:2] = 3
+            container[1:2] = 3
 
         self.check_mutable_error(setslice)
 
         def delitem():
-            del self.container[0]
+            del container[0]
 
         self.check_mutable_error(delitem)
 
         def delslice():
-            del self.container[0:3]
+            del container[0:3]
 
         self.check_mutable_error(delslice)
 
         mutable_methods = ("extend", "pop", "remove", "insert")
 
         for meth in mutable_methods:
-            self.check_mutable_error(getattr(self.container, meth))
+            self.check_mutable_error(getattr(container, meth))
 
-    def test_slicing_maintains_type(self):
-        result = self.container[1:2]
-        expected = self.lst[1:2]
+    def test_slicing_maintains_type(self, container, lst):
+        result = container[1:2]
+        expected = lst[1:2]
         self.check_result(result, expected)
 
     def check_result(self, result, expected):
         assert isinstance(result, FrozenList)
         assert result == expected
 
-    def test_string_methods_dont_fail(self):
-        repr(self.container)
-        str(self.container)
-        bytes(self.container)
+    def test_string_methods_dont_fail(self, container):
+        repr(container)
+        str(container)
+        bytes(container)
 
-    def test_tricky_container(self):
-        repr(self.unicode_container)
-        str(self.unicode_container)
+    def test_tricky_container(self, unicode_container):
+        repr(unicode_container)
+        str(unicode_container)
 
-    def test_add(self):
-        result = self.container + (1, 2, 3)
-        expected = FrozenList(self.lst + [1, 2, 3])
+    def test_add(self, container, lst):
+        result = container + (1, 2, 3)
+        expected = FrozenList(lst + [1, 2, 3])
         self.check_result(result, expected)
 
-        result = (1, 2, 3) + self.container
-        expected = FrozenList([1, 2, 3] + self.lst)
+        result = (1, 2, 3) + container
+        expected = FrozenList([1, 2, 3] + lst)
         self.check_result(result, expected)
 
-    def test_iadd(self):
-        q = r = self.container
+    def test_iadd(self, container, lst):
+        q = r = container
 
         q += [5]
-        self.check_result(q, self.lst + [5])
+        self.check_result(q, lst + [5])
 
         # Other shouldn't be mutated.
-        self.check_result(r, self.lst)
+        self.check_result(r, lst)
 
-    def test_union(self):
-        result = self.container.union((1, 2, 3))
-        expected = FrozenList(self.lst + [1, 2, 3])
+    def test_union(self, container, lst):
+        result = container.union((1, 2, 3))
+        expected = FrozenList(lst + [1, 2, 3])
         self.check_result(result, expected)
 
-    def test_difference(self):
-        result = self.container.difference([2])
+    def test_difference(self, container):
+        result = container.difference([2])
         expected = FrozenList([1, 3, 4, 5])
         self.check_result(result, expected)
 
@@ -98,8 +106,8 @@ def test_difference_dupe(self):
         expected = FrozenList([1, 3])
         self.check_result(result, expected)
 
-    def test_tricky_container_to_bytes_raises(self):
+    def test_tricky_container_to_bytes_raises(self, unicode_container):
         # GH 26447
         msg = "^'str' object cannot be interpreted as an integer$"
         with pytest.raises(TypeError, match=msg):
-            bytes(self.unicode_container)
+            bytes(unicode_container)
diff --git a/pandas/tests/indexes/test_index_new.py b/pandas/tests/indexes/test_index_new.py
index f44bbac1226e1..9a57e3e08a59c 100644
--- a/pandas/tests/indexes/test_index_new.py
+++ b/pandas/tests/indexes/test_index_new.py
@@ -25,6 +25,7 @@
     Series,
     TimedeltaIndex,
     Timestamp,
+    array,
     date_range,
     period_range,
     timedelta_range,
@@ -73,7 +74,7 @@ def test_constructor_dtypes_to_object(self, cast_index, vals):
             index = Index(vals)
 
         assert type(index) is Index
-        assert index.dtype == object
+        assert index.dtype == bool
 
     def test_constructor_categorical_to_object(self):
         # GH#32167 Categorical data and dtype=object should return object-dtype
@@ -159,6 +160,13 @@ def test_constructor_datetime_and_datetime64(self, swap_objs):
 class TestDtypeEnforced:
     # check we don't silently ignore the dtype keyword
 
+    def test_constructor_object_dtype_with_ea_data(self, any_numeric_ea_dtype):
+        # GH#45206
+        arr = array([0], dtype=any_numeric_ea_dtype)
+
+        idx = Index(arr, dtype=object)
+        assert idx.dtype == object
+
     @pytest.mark.parametrize("dtype", [object, "float64", "uint64", "category"])
     def test_constructor_range_values_mismatched_dtype(self, dtype):
         rng = Index(range(5))
@@ -344,7 +352,7 @@ def test_constructor_ndarray_like(self, array):
         # it should be possible to convert any object that satisfies the numpy
         # ndarray interface directly into an Index
         class ArrayLike:
-            def __init__(self, array):
+            def __init__(self, array) -> None:
                 self.array = array
 
             def __array__(self, dtype=None) -> np.ndarray:
diff --git a/pandas/tests/indexes/test_indexing.py b/pandas/tests/indexes/test_indexing.py
index 739039241a31d..ab934df992d61 100644
--- a/pandas/tests/indexes/test_indexing.py
+++ b/pandas/tests/indexes/test_indexing.py
@@ -20,6 +20,7 @@
 from pandas.errors import InvalidIndexError
 
 from pandas import (
+    NA,
     DatetimeIndex,
     Index,
     IntervalIndex,
@@ -221,6 +222,13 @@ def test_get_loc_generator(self, index):
             # MultiIndex specifically checks for generator; others for scalar
             index.get_loc(x for x in range(5))
 
+    def test_get_loc_masked_duplicated_na(self):
+        # GH#48411
+        idx = Index([1, 2, NA, NA], dtype="Int64")
+        result = idx.get_loc(NA)
+        expected = np.array([False, False, True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
 
 class TestGetIndexer:
     def test_get_indexer_base(self, index):
@@ -253,6 +261,13 @@ def test_get_indexer_consistency(self, index):
         assert isinstance(indexer, np.ndarray)
         assert indexer.dtype == np.intp
 
+    def test_get_indexer_masked_duplicated_na(self):
+        # GH#48411
+        idx = Index([1, 2, NA, NA], dtype="Int64")
+        result = idx.get_indexer_for(Index([1, NA], dtype="Int64"))
+        expected = np.array([0, 2, 3], dtype=result.dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
 
 class TestConvertSliceIndexer:
     def test_convert_almost_null_slice(self, index):
diff --git a/pandas/tests/indexes/test_numpy_compat.py b/pandas/tests/indexes/test_numpy_compat.py
index 3fad8033410c8..453ece35a68e7 100644
--- a/pandas/tests/indexes/test_numpy_compat.py
+++ b/pandas/tests/indexes/test_numpy_compat.py
@@ -18,6 +18,20 @@
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
 
 
+def test_numpy_ufuncs_out(index):
+    result = index == index
+
+    out = np.empty(index.shape, dtype=bool)
+    np.equal(index, index, out=out)
+    tm.assert_numpy_array_equal(out, result)
+
+    if not index._is_multi:
+        # same thing on the ExtensionArray
+        out = np.empty(index.shape, dtype=bool)
+        np.equal(index.array, index.array, out=out)
+        tm.assert_numpy_array_equal(out, result)
+
+
 @pytest.mark.parametrize(
     "func",
     [
@@ -54,8 +68,11 @@ def test_numpy_ufuncs_basic(index, func):
         with tm.external_error_raised((TypeError, AttributeError)):
             with np.errstate(all="ignore"):
                 func(index)
-    elif isinstance(index, NumericIndex) or (
-        not isinstance(index.dtype, np.dtype) and index.dtype._is_numeric
+    elif (
+        isinstance(index, NumericIndex)
+        or (not isinstance(index.dtype, np.dtype) and index.dtype._is_numeric)
+        or (index.dtype.kind == "c" and func not in [np.deg2rad, np.rad2deg])
+        or index.dtype == bool
     ):
         # coerces to float (e.g. np.sin)
         with np.errstate(all="ignore"):
@@ -63,7 +80,7 @@ def test_numpy_ufuncs_basic(index, func):
             exp = Index(func(index.values), name=index.name)
 
         tm.assert_index_equal(result, exp)
-        if type(index) is not Index:
+        if type(index) is not Index or index.dtype == bool:
             # i.e NumericIndex
             assert isinstance(result, Float64Index)
         else:
@@ -82,7 +99,7 @@ def test_numpy_ufuncs_basic(index, func):
 @pytest.mark.parametrize(
     "func", [np.isfinite, np.isinf, np.isnan, np.signbit], ids=lambda x: x.__name__
 )
-def test_numpy_ufuncs_other(index, func, request):
+def test_numpy_ufuncs_other(index, func):
     # test ufuncs of numpy, see:
     # https://numpy.org/doc/stable/reference/ufuncs.html
     if isinstance(index, (DatetimeIndex, TimedeltaIndex)):
@@ -91,6 +108,10 @@ def test_numpy_ufuncs_other(index, func, request):
             # numpy 1.18 changed isinf and isnan to not raise on dt64/td64
             result = func(index)
             assert isinstance(result, np.ndarray)
+
+            out = np.empty(index.shape, dtype=bool)
+            func(index, out=out)
+            tm.assert_numpy_array_equal(out, result)
         else:
             with tm.external_error_raised(TypeError):
                 func(index)
@@ -99,8 +120,11 @@ def test_numpy_ufuncs_other(index, func, request):
         with tm.external_error_raised(TypeError):
             func(index)
 
-    elif isinstance(index, NumericIndex) or (
-        not isinstance(index.dtype, np.dtype) and index.dtype._is_numeric
+    elif (
+        isinstance(index, NumericIndex)
+        or (not isinstance(index.dtype, np.dtype) and index.dtype._is_numeric)
+        or (index.dtype.kind == "c" and func is not np.signbit)
+        or index.dtype == bool
     ):
         # Results in bool array
         result = func(index)
@@ -109,7 +133,15 @@ def test_numpy_ufuncs_other(index, func, request):
             assert isinstance(result, BooleanArray)
         else:
             assert isinstance(result, np.ndarray)
-        assert not isinstance(result, Index)
+
+        out = np.empty(index.shape, dtype=bool)
+        func(index, out=out)
+
+        if not isinstance(index.dtype, np.dtype):
+            tm.assert_numpy_array_equal(out, result._data)
+        else:
+            tm.assert_numpy_array_equal(out, result)
+
     else:
         if len(index) == 0:
             pass
@@ -146,3 +178,16 @@ def test_numpy_ufuncs_reductions(index, func, request):
         assert isna(expected)
     else:
         assert result == expected
+
+
+@pytest.mark.parametrize("func", [np.bitwise_and, np.bitwise_or, np.bitwise_xor])
+def test_numpy_ufuncs_bitwise(func):
+    # https://github.com/pandas-dev/pandas/issues/46769
+    idx1 = Index([1, 2, 3, 4], dtype="int64")
+    idx2 = Index([3, 4, 5, 6], dtype="int64")
+
+    with tm.assert_produces_warning(None):
+        result = func(idx1, idx2)
+
+    expected = Index(func(idx1.values, idx2.values))
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index a73ac89994761..d2f6a1736ff7c 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -8,8 +8,9 @@
 import numpy as np
 import pytest
 
+from pandas.compat import pa_version_under7p0
+
 from pandas.core.dtypes.cast import find_common_type
-from pandas.core.dtypes.common import is_dtype_equal
 
 from pandas import (
     CategoricalIndex,
@@ -33,11 +34,6 @@
     UInt64Index,
 )
 
-COMPATIBLE_INCONSISTENT_PAIRS = [
-    (np.float64, np.int64),
-    (np.float64, np.uint64),
-]
-
 
 def test_union_same_types(index):
     # Union with a non-unique, non-monotonic index raises error
@@ -55,18 +51,47 @@ def test_union_different_types(index_flat, index_flat2, request):
 
     if (
         not idx1.is_unique
+        and not idx2.is_unique
         and idx1.dtype.kind == "i"
-        and is_dtype_equal(idx2.dtype, "boolean")
+        and idx2.dtype.kind == "b"
     ) or (
         not idx2.is_unique
+        and not idx1.is_unique
         and idx2.dtype.kind == "i"
-        and is_dtype_equal(idx1.dtype, "boolean")
+        and idx1.dtype.kind == "b"
     ):
-        mark = pytest.mark.xfail(reason="GH#44000 True==1", raises=ValueError)
+        # Each condition had idx[1|2].is_monotonic_decreasing
+        # but failed when e.g.
+        # idx1 = Index(
+        # [True, True, True, True, True, True, True, True, False, False], dtype='bool'
+        # )
+        # idx2 = Int64Index([0, 0, 1, 1, 2, 2], dtype='int64')
+        mark = pytest.mark.xfail(
+            reason="GH#44000 True==1", raises=ValueError, strict=False
+        )
         request.node.add_marker(mark)
 
     common_dtype = find_common_type([idx1.dtype, idx2.dtype])
 
+    warn = None
+    if not len(idx1) or not len(idx2):
+        pass
+    elif (
+        idx1.dtype.kind == "c"
+        and (
+            idx2.dtype.kind not in ["i", "u", "f", "c"]
+            or not isinstance(idx2.dtype, np.dtype)
+        )
+    ) or (
+        idx2.dtype.kind == "c"
+        and (
+            idx1.dtype.kind not in ["i", "u", "f", "c"]
+            or not isinstance(idx1.dtype, np.dtype)
+        )
+    ):
+        # complex objects non-sortable
+        warn = RuntimeWarning
+
     any_uint64 = idx1.dtype == np.uint64 or idx2.dtype == np.uint64
     idx1_signed = is_signed_integer_dtype(idx1.dtype)
     idx2_signed = is_signed_integer_dtype(idx2.dtype)
@@ -76,8 +101,9 @@ def test_union_different_types(index_flat, index_flat2, request):
     idx1 = idx1.sort_values()
     idx2 = idx2.sort_values()
 
-    res1 = idx1.union(idx2)
-    res2 = idx2.union(idx1)
+    with tm.assert_produces_warning(warn, match="'<' not supported between"):
+        res1 = idx1.union(idx2)
+        res2 = idx2.union(idx1)
 
     if any_uint64 and (idx1_signed or idx2_signed):
         assert res1.dtype == np.dtype("O")
@@ -153,7 +179,8 @@ def test_dunder_inplace_setops_deprecated(index):
     with tm.assert_produces_warning(FutureWarning):
         index &= index
 
-    with tm.assert_produces_warning(FutureWarning):
+    is_pyarrow = str(index.dtype) == "string[pyarrow]" and pa_version_under7p0
+    with tm.assert_produces_warning(FutureWarning, raise_on_extra_warnings=is_pyarrow):
         index ^= index
 
 
@@ -231,7 +258,11 @@ def test_union_base(self, index):
     def test_difference_base(self, sort, index):
         first = index[2:]
         second = index[:4]
-        if isinstance(index, CategoricalIndex) or index.is_boolean():
+        if index.is_boolean():
+            # i think (TODO: be sure) there assumptions baked in about
+            #  the index fixture that don't hold here?
+            answer = set(first).difference(set(second))
+        elif isinstance(index, CategoricalIndex):
             answer = []
         else:
             answer = index[4:]
@@ -286,11 +317,13 @@ def test_symmetric_difference(self, index):
             (None, None, None),
         ],
     )
-    def test_corner_union(self, index_flat_unique, fname, sname, expected_name):
+    def test_corner_union(self, index_flat, fname, sname, expected_name):
         # GH#9943, GH#9862
         # Test unions with various name combinations
         # Do not test MultiIndex or repeats
-        index = index_flat_unique
+        if not index_flat.is_unique:
+            pytest.skip("Randomly generated index_flat was not unique.")
+        index = index_flat
 
         # Test copy.union(copy)
         first = index.copy().set_names(fname)
@@ -330,8 +363,10 @@ def test_corner_union(self, index_flat_unique, fname, sname, expected_name):
             (None, None, None),
         ],
     )
-    def test_union_unequal(self, index_flat_unique, fname, sname, expected_name):
-        index = index_flat_unique
+    def test_union_unequal(self, index_flat, fname, sname, expected_name):
+        if not index_flat.is_unique:
+            pytest.skip("Randomly generated index_flat was not unique.")
+        index = index_flat
 
         # test copy.union(subset) - need sort for unicode and string
         first = index.copy().set_names(fname)
@@ -350,10 +385,12 @@ def test_union_unequal(self, index_flat_unique, fname, sname, expected_name):
             (None, None, None),
         ],
     )
-    def test_corner_intersect(self, index_flat_unique, fname, sname, expected_name):
+    def test_corner_intersect(self, index_flat, fname, sname, expected_name):
         # GH#35847
         # Test intersections with various name combinations
-        index = index_flat_unique
+        if not index_flat.is_unique:
+            pytest.skip("Randomly generated index_flat was not unique.")
+        index = index_flat
 
         # Test copy.intersection(copy)
         first = index.copy().set_names(fname)
@@ -393,8 +430,10 @@ def test_corner_intersect(self, index_flat_unique, fname, sname, expected_name):
             (None, None, None),
         ],
     )
-    def test_intersect_unequal(self, index_flat_unique, fname, sname, expected_name):
-        index = index_flat_unique
+    def test_intersect_unequal(self, index_flat, fname, sname, expected_name):
+        if not index_flat.is_unique:
+            pytest.skip("Randomly generated index_flat was not unique.")
+        index = index_flat
 
         # test copy.intersection(subset) - need sort for unicode and string
         first = index.copy().set_names(fname)
@@ -432,7 +471,7 @@ def test_difference_preserves_type_empty(self, index, sort):
         expected = index[:0]
         tm.assert_index_equal(result, expected, exact=True)
 
-    def test_difference_name_retention_equals(self, index, sort, names):
+    def test_difference_name_retention_equals(self, index, names):
         if isinstance(index, MultiIndex):
             names = [[x] * index.nlevels for x in names]
         index = index.rename(names[0])
@@ -592,6 +631,20 @@ def test_union_with_duplicate_index_not_subset_and_non_monotonic(cls):
     tm.assert_index_equal(result, expected)
 
 
+def test_union_int_categorical_with_nan():
+    ci = CategoricalIndex([1, 2, np.nan])
+    assert ci.categories.dtype.kind == "i"
+
+    idx = Index([1, 2])
+
+    result = idx.union(ci)
+    expected = Index([1, 2, np.nan], dtype=np.float64)
+    tm.assert_index_equal(result, expected)
+
+    result = ci.union(idx)
+    tm.assert_index_equal(result, expected)
+
+
 class TestSetOpsUnsorted:
     # These may eventually belong in a dtype-specific test_setops, or
     #  parametrized over a more general fixture
diff --git a/pandas/tests/indexes/test_subclass.py b/pandas/tests/indexes/test_subclass.py
new file mode 100644
index 0000000000000..2ddf3baabbec0
--- /dev/null
+++ b/pandas/tests/indexes/test_subclass.py
@@ -0,0 +1,38 @@
+"""
+Tests involving custom Index subclasses
+"""
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    Index,
+)
+import pandas._testing as tm
+
+
+class CustomIndex(Index):
+    def __new__(cls, data, name=None):
+        # assert that this index class cannot hold strings
+        if any(isinstance(val, str) for val in data):
+            raise TypeError("CustomIndex cannot hold strings")
+
+        if name is None and hasattr(data, "name"):
+            name = data.name
+        data = np.array(data, dtype="O")
+
+        return cls._simple_new(data, name)
+
+
+def test_insert_fallback_to_base_index():
+    # https://github.com/pandas-dev/pandas/issues/47071
+
+    idx = CustomIndex([1, 2, 3])
+    result = idx.insert(0, "string")
+    expected = Index(["string", 1, 2, 3], dtype=object)
+    tm.assert_index_equal(result, expected)
+
+    df = DataFrame(
+        np.random.randn(2, 3), columns=idx, index=Index([1, 2], name="string")
+    )
+    result = df.reset_index()
+    tm.assert_index_equal(result.columns, expected)
diff --git a/pandas/tests/indexes/timedeltas/methods/test_astype.py b/pandas/tests/indexes/timedeltas/methods/test_astype.py
index 401b4feef2811..aa2f7b7af8d98 100644
--- a/pandas/tests/indexes/timedeltas/methods/test_astype.py
+++ b/pandas/tests/indexes/timedeltas/methods/test_astype.py
@@ -58,8 +58,7 @@ def test_astype(self):
         )
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            result = idx.astype(int)
+        result = idx.astype(int)
         expected = Int64Index(
             [100000000000000] + [-9223372036854775808] * 3, dtype=np.int64, name="idx"
         )
@@ -70,8 +69,7 @@ def test_astype(self):
         tm.assert_index_equal(result, expected)
 
         rng = timedelta_range("1 days", periods=10)
-        with tm.assert_produces_warning(FutureWarning):
-            result = rng.astype("i8")
+        result = rng.astype("i8")
         tm.assert_index_equal(result, Index(rng.asi8))
         tm.assert_numpy_array_equal(rng.asi8, result.values)
 
@@ -80,9 +78,12 @@ def test_astype_uint(self):
         expected = UInt64Index(
             np.array([3600000000000, 90000000000000], dtype="uint64")
         )
-        with tm.assert_produces_warning(FutureWarning):
-            tm.assert_index_equal(arr.astype("uint64"), expected)
-            tm.assert_index_equal(arr.astype("uint32"), expected)
+        tm.assert_index_equal(arr.astype("uint64"), expected)
+
+        msg = "will return exactly the specified dtype instead of uint64"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = arr.astype("uint32")
+        tm.assert_index_equal(res, expected)
 
     def test_astype_timedelta64(self):
         # GH 13149, GH 13209
diff --git a/pandas/tests/indexes/timedeltas/test_constructors.py b/pandas/tests/indexes/timedeltas/test_constructors.py
index dcddba8b22937..2a5b1be7bddbd 100644
--- a/pandas/tests/indexes/timedeltas/test_constructors.py
+++ b/pandas/tests/indexes/timedeltas/test_constructors.py
@@ -51,7 +51,7 @@ def test_infer_from_tdi(self):
         # GH#23539
         # fast-path for inferring a frequency if the passed data already
         #  has one
-        tdi = timedelta_range("1 second", periods=10 ** 7, freq="1s")
+        tdi = timedelta_range("1 second", periods=10**7, freq="1s")
 
         result = TimedeltaIndex(tdi, freq="infer")
         assert result.freq == tdi.freq
@@ -263,6 +263,9 @@ def test_explicit_none_freq(self):
         result = TimedeltaIndex(tdi._data, freq=None)
         assert result.freq is None
 
+        tda = TimedeltaArray(tdi, freq=None)
+        assert tda.freq is None
+
     def test_from_categorical(self):
         tdi = timedelta_range(1, periods=5)
 
diff --git a/pandas/tests/indexes/timedeltas/test_indexing.py b/pandas/tests/indexes/timedeltas/test_indexing.py
index b618f12e9f6c9..154a6289dfc00 100644
--- a/pandas/tests/indexes/timedeltas/test_indexing.py
+++ b/pandas/tests/indexes/timedeltas/test_indexing.py
@@ -14,6 +14,7 @@
     TimedeltaIndex,
     Timestamp,
     notna,
+    offsets,
     timedelta_range,
     to_timedelta,
 )
@@ -346,3 +347,14 @@ def test_contains_nonunique(self):
         ):
             idx = TimedeltaIndex(vals)
             assert idx[0] in idx
+
+    def test_contains(self):
+        # Checking for any NaT-like objects
+        # GH#13603
+        td = to_timedelta(range(5), unit="d") + offsets.Hour(1)
+        for v in [NaT, None, float("nan"), np.nan]:
+            assert not (v in td)
+
+        td = to_timedelta([NaT])
+        for v in [NaT, None, float("nan"), np.nan]:
+            assert v in td
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index 8ceef8186e4ea..6904a847b04ed 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -105,7 +105,7 @@ def test_freq_conversion_always_floating(self):
         tdi = timedelta_range("1 Day", periods=30)
 
         res = tdi.astype("m8[s]")
-        expected = Index((tdi.view("i8") / 10 ** 9).astype(np.float64))
+        expected = Index((tdi.view("i8") / 10**9).astype(np.float64))
         tm.assert_index_equal(res, expected)
 
         # check this matches Series and TimedeltaArray
diff --git a/pandas/tests/indexing/common.py b/pandas/tests/indexing/common.py
index f8db005583bd8..ea9f2584196d3 100644
--- a/pandas/tests/indexing/common.py
+++ b/pandas/tests/indexing/common.py
@@ -43,7 +43,7 @@ class Base:
         "multi",
     }
 
-    def setup_method(self, method):
+    def setup_method(self):
 
         self.series_ints = Series(np.random.rand(4), index=np.arange(0, 8, 2))
         self.frame_ints = DataFrame(
diff --git a/pandas/tests/indexing/interval/test_interval_new.py b/pandas/tests/indexing/interval/test_interval_new.py
index aad6523357df6..4b89232f9fb12 100644
--- a/pandas/tests/indexing/interval/test_interval_new.py
+++ b/pandas/tests/indexing/interval/test_interval_new.py
@@ -3,7 +3,10 @@
 import numpy as np
 import pytest
 
+from pandas.compat import IS64
+
 from pandas import (
+    Index,
     Interval,
     IntervalIndex,
     Series,
@@ -207,3 +210,24 @@ def test_loc_getitem_missing_key_error_message(
         obj = frame_or_series(ser)
         with pytest.raises(KeyError, match=r"\[6\]"):
             obj.loc[[4, 5, 6]]
+
+
+@pytest.mark.xfail(not IS64, reason="GH 23440")
+@pytest.mark.parametrize(
+    "intervals",
+    [
+        ([Interval(-np.inf, 0.0), Interval(0.0, 1.0)]),
+        ([Interval(-np.inf, -2.0), Interval(-2.0, -1.0)]),
+        ([Interval(-1.0, 0.0), Interval(0.0, np.inf)]),
+        ([Interval(1.0, 2.0), Interval(2.0, np.inf)]),
+    ],
+)
+def test_repeating_interval_index_with_infs(intervals):
+    # GH 46658
+
+    interval_index = Index(intervals * 51)
+
+    expected = np.arange(1, 102, 2, dtype=np.intp)
+    result = interval_index.get_indexer_for([intervals[1]])
+
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
index 6ccd44e698a8a..2efb288a73f8d 100644
--- a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
@@ -1,6 +1,7 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SettingWithCopyError
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -9,10 +10,9 @@
     Series,
 )
 import pandas._testing as tm
-import pandas.core.common as com
 
 
-def test_detect_chained_assignment():
+def test_detect_chained_assignment(using_copy_on_write):
     # Inplace ops, originally from:
     # https://stackoverflow.com/questions/20508968/series-fillna-in-a-multiindex-dataframe-does-not-fill-is-this-a-bug
     a = [12, 23]
@@ -29,17 +29,21 @@ def test_detect_chained_assignment():
     multiind = MultiIndex.from_tuples(tuples, names=["part", "side"])
     zed = DataFrame(events, index=["a", "b"], columns=multiind)
 
-    msg = "A value is trying to be set on a copy of a slice from a DataFrame"
-    with pytest.raises(com.SettingWithCopyError, match=msg):
+    if using_copy_on_write:
         zed["eyes"]["right"].fillna(value=555, inplace=True)
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            zed["eyes"]["right"].fillna(value=555, inplace=True)
 
 
 @td.skip_array_manager_invalid_test  # with ArrayManager df.loc[0] is not a view
-def test_cache_updating():
+def test_cache_updating(using_copy_on_write):
     # 5216
     # make sure that we don't try to set a dead cache
     a = np.random.rand(10, 3)
     df = DataFrame(a, columns=["x", "y", "z"])
+    df_original = df.copy()
     tuples = [(i, j) for i in range(5) for j in range(2)]
     index = MultiIndex.from_tuples(tuples)
     df.index = index
@@ -48,7 +52,10 @@ def test_cache_updating():
     # but actually works, since everything is a view
     df.loc[0]["z"].iloc[0] = 1.0
     result = df.loc[(0, 0), "z"]
-    assert result == 1
+    if using_copy_on_write:
+        assert result == df_original.loc[0, "z"]
+    else:
+        assert result == 1
 
     # correct setting
     df.loc[(0, 0), "z"] = 2
diff --git a/pandas/tests/indexing/multiindex/test_loc.py b/pandas/tests/indexing/multiindex/test_loc.py
index 6e59311634c76..5cf044280b391 100644
--- a/pandas/tests/indexing/multiindex/test_loc.py
+++ b/pandas/tests/indexing/multiindex/test_loc.py
@@ -1,7 +1,10 @@
 import numpy as np
 import pytest
 
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    IndexingError,
+    PerformanceWarning,
+)
 
 import pandas as pd
 from pandas import (
@@ -11,7 +14,6 @@
     Series,
 )
 import pandas._testing as tm
-from pandas.core.indexing import IndexingError
 
 
 @pytest.fixture
@@ -402,6 +404,18 @@ def test_sorted_multiindex_after_union(self):
         result = df.loc["2011-01-01":"2011-01-02"]
         tm.assert_frame_equal(result, expected)
 
+    def test_loc_no_second_level_index(self):
+        # GH#43599
+        df = DataFrame(
+            index=MultiIndex.from_product([list("ab"), list("cd"), list("e")]),
+            columns=["Val"],
+        )
+        res = df.loc[np.s_[:, "c", :]]
+        expected = DataFrame(
+            index=MultiIndex.from_product([list("ab"), list("e")]), columns=["Val"]
+        )
+        tm.assert_frame_equal(res, expected)
+
 
 @pytest.mark.parametrize(
     "indexer, pos",
@@ -526,8 +540,11 @@ def test_loc_setitem_single_column_slice():
         columns=MultiIndex.from_tuples([("A", "1"), ("A", "2"), ("B", "1")]),
     )
     expected = df.copy()
-    df.loc[:, "B"] = np.arange(4)
-    expected.iloc[:, 2] = np.arange(4)
+    msg = "will attempt to set the values inplace instead"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        df.loc[:, "B"] = np.arange(4)
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        expected.iloc[:, 2] = np.arange(4)
     tm.assert_frame_equal(df, expected)
 
 
diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index 9fa873a212cbd..08e15545cb998 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 import pandas._libs.index as _index
 from pandas.errors import PerformanceWarning
@@ -149,3 +150,80 @@ def test_rename_multiindex_with_duplicates(self):
         mi2 = MultiIndex.from_tuples([("Apple", "cat"), ("B", "cat"), ("B", "cat")])
         expected = DataFrame(index=mi2)
         tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "data_result, data_expected",
+        [
+            (
+                [
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [(np.nan, np.nan), (82.0, np.nan)],
+                    [1, 2],
+                    [1, 2],
+                ],
+                [
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [1, 2],
+                    [1, 1],
+                ],
+            ),
+            (
+                [
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [(np.nan, np.nan), (81.0, np.nan)],
+                    [1, 2],
+                    [1, 2],
+                ],
+                [
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [(81.0, np.nan), (np.nan, np.nan)],
+                    [1, 2],
+                    [2, 1],
+                ],
+            ),
+        ],
+    )
+    def test_subtracting_two_series_with_unordered_index_and_all_nan_index(
+        self, data_result, data_expected
+    ):
+        # GH 38439
+        a_index_result = MultiIndex.from_tuples(data_result[0])
+        b_index_result = MultiIndex.from_tuples(data_result[1])
+        a_series_result = Series(data_result[2], index=a_index_result)
+        b_series_result = Series(data_result[3], index=b_index_result)
+        result = a_series_result.align(b_series_result)
+
+        a_index_expected = MultiIndex.from_tuples(data_expected[0])
+        b_index_expected = MultiIndex.from_tuples(data_expected[1])
+        a_series_expected = Series(data_expected[2], index=a_index_expected)
+        b_series_expected = Series(data_expected[3], index=b_index_expected)
+        a_series_expected.index = a_series_expected.index.set_levels(
+            [
+                a_series_expected.index.levels[0].astype("float"),
+                a_series_expected.index.levels[1].astype("float"),
+            ]
+        )
+        b_series_expected.index = b_series_expected.index.set_levels(
+            [
+                b_series_expected.index.levels[0].astype("float"),
+                b_series_expected.index.levels[1].astype("float"),
+            ]
+        )
+
+        tm.assert_series_equal(result[0], a_series_expected)
+        tm.assert_series_equal(result[1], b_series_expected)
+
+    def test_nunique_smoke(self):
+        # GH 34019
+        n = DataFrame([[1, 2], [1, 2]]).set_index([0, 1]).index.nunique()
+        assert n == 1
+
+    def test_multiindex_repeated_keys(self):
+        # GH19414
+        tm.assert_series_equal(
+            Series([1, 2], MultiIndex.from_arrays([["a", "b"]])).loc[
+                ["a", "a", "b", "b"]
+            ],
+            Series([1, 1, 2, 2], MultiIndex.from_arrays([["a", "a", "b", "b"]])),
+        )
diff --git a/pandas/tests/indexing/multiindex/test_partial.py b/pandas/tests/indexing/multiindex/test_partial.py
index 9d5e65e692fdc..cface630c6647 100644
--- a/pandas/tests/indexing/multiindex/test_partial.py
+++ b/pandas/tests/indexing/multiindex/test_partial.py
@@ -122,26 +122,32 @@ def test_getitem_partial_column_select(self):
     # TODO(ArrayManager) rewrite test to not use .values
     # exp.loc[2000, 4].values[:] select multiple columns -> .values is not a view
     @td.skip_array_manager_invalid_test
-    def test_partial_set(self, multiindex_year_month_day_dataframe_random_data):
+    def test_partial_set(
+        self, multiindex_year_month_day_dataframe_random_data, using_copy_on_write
+    ):
         # GH #397
         ymd = multiindex_year_month_day_dataframe_random_data
         df = ymd.copy()
         exp = ymd.copy()
         df.loc[2000, 4] = 0
-        exp.loc[2000, 4].values[:] = 0
+        exp.iloc[65:85] = 0
         tm.assert_frame_equal(df, exp)
 
         df["A"].loc[2000, 4] = 1
-        exp["A"].loc[2000, 4].values[:] = 1
+        if not using_copy_on_write:
+            exp["A"].loc[2000, 4].values[:] = 1
         tm.assert_frame_equal(df, exp)
 
         df.loc[2000] = 5
-        exp.loc[2000].values[:] = 5
+        exp.iloc[:100] = 5
         tm.assert_frame_equal(df, exp)
 
         # this works...for now
         df["A"].iloc[14] = 5
-        assert df["A"].iloc[14] == 5
+        if using_copy_on_write:
+            df["A"].iloc[14] == exp["A"].iloc[14]
+        else:
+            assert df["A"].iloc[14] == 5
 
     @pytest.mark.parametrize("dtype", [int, float])
     def test_getitem_intkey_leading_level(
diff --git a/pandas/tests/indexing/multiindex/test_setitem.py b/pandas/tests/indexing/multiindex/test_setitem.py
index 47868779c7ef7..ac10a6d82dc89 100644
--- a/pandas/tests/indexing/multiindex/test_setitem.py
+++ b/pandas/tests/indexing/multiindex/test_setitem.py
@@ -1,6 +1,7 @@
 import numpy as np
 import pytest
 
+from pandas.errors import SettingWithCopyError
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -14,7 +15,6 @@
     notna,
 )
 import pandas._testing as tm
-import pandas.core.common as com
 
 
 def assert_equal(a, b):
@@ -196,7 +196,7 @@ def test_multiindex_assignment(self):
         df.loc[4, "d"] = arr
         tm.assert_series_equal(df.loc[4, "d"], Series(arr, index=[8, 10], name="d"))
 
-    def test_multiindex_assignment_single_dtype(self, using_array_manager):
+    def test_multiindex_assignment_single_dtype(self, using_copy_on_write):
         # GH3777 part 2b
         # single dtype
         arr = np.array([0.0, 1.0])
@@ -214,10 +214,9 @@ def test_multiindex_assignment_single_dtype(self, using_array_manager):
         exp = Series(arr, index=[8, 10], name="c", dtype="int64")
         result = df.loc[4, "c"]
         tm.assert_series_equal(result, exp)
-        if not using_array_manager:
-            # FIXME(ArrayManager): this correctly preserves dtype,
-            #  but incorrectly is not inplace.
-            # extra check for inplace-ness
+
+        # extra check for inplace-ness
+        if not using_copy_on_write:
             tm.assert_numpy_array_equal(view, exp.values)
 
         # arr + 0.5 cannot be cast losslessly to int, so we upcast
@@ -407,16 +406,23 @@ def test_setitem_change_dtype(self, multiindex_dataframe_random_data):
         reindexed = dft.reindex(columns=[("foo", "two")])
         tm.assert_series_equal(reindexed["foo", "two"], s > s.median())
 
-    def test_set_column_scalar_with_loc(self, multiindex_dataframe_random_data):
+    def test_set_column_scalar_with_loc(
+        self, multiindex_dataframe_random_data, using_copy_on_write
+    ):
         frame = multiindex_dataframe_random_data
         subset = frame.index[[1, 4, 5]]
 
         frame.loc[subset] = 99
         assert (frame.loc[subset].values == 99).all()
 
+        frame_original = frame.copy()
         col = frame["B"]
         col[subset] = 97
-        assert (frame.loc[subset, "B"] == 97).all()
+        if using_copy_on_write:
+            # chained setitem doesn't work with CoW
+            tm.assert_frame_equal(frame, frame_original)
+        else:
+            assert (frame.loc[subset, "B"] == 97).all()
 
     def test_nonunique_assignment_1750(self):
         df = DataFrame(
@@ -489,21 +495,32 @@ def test_frame_setitem_view_direct(multiindex_dataframe_random_data):
     assert (df["foo"].values == 0).all()
 
 
-def test_frame_setitem_copy_raises(multiindex_dataframe_random_data):
+def test_frame_setitem_copy_raises(
+    multiindex_dataframe_random_data, using_copy_on_write
+):
     # will raise/warn as its chained assignment
     df = multiindex_dataframe_random_data.T
-    msg = "A value is trying to be set on a copy of a slice from a DataFrame"
-    with pytest.raises(com.SettingWithCopyError, match=msg):
+    if using_copy_on_write:
+        # TODO(CoW) it would be nice if this could still warn/raise
         df["foo"]["one"] = 2
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            df["foo"]["one"] = 2
 
 
-def test_frame_setitem_copy_no_write(multiindex_dataframe_random_data):
+def test_frame_setitem_copy_no_write(
+    multiindex_dataframe_random_data, using_copy_on_write
+):
     frame = multiindex_dataframe_random_data.T
     expected = frame
     df = frame.copy()
-    msg = "A value is trying to be set on a copy of a slice from a DataFrame"
-    with pytest.raises(com.SettingWithCopyError, match=msg):
+    if using_copy_on_write:
         df["foo"]["one"] = 2
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            df["foo"]["one"] = 2
 
     result = df
     tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/multiindex/test_slice.py b/pandas/tests/indexing/multiindex/test_slice.py
index 55d45a21d643a..91ea1f7cec324 100644
--- a/pandas/tests/indexing/multiindex/test_slice.py
+++ b/pandas/tests/indexing/multiindex/test_slice.py
@@ -758,12 +758,48 @@ def test_int_series_slicing(self, multiindex_year_month_day_dataframe_random_dat
         expected = ymd.reindex(s.index[5:])
         tm.assert_frame_equal(result, expected)
 
-    def test_loc_slice_negative_stepsize(self):
+    @pytest.mark.parametrize(
+        "dtype, loc, iloc",
+        [
+            # dtype = int, step = -1
+            ("int", slice(None, None, -1), slice(None, None, -1)),
+            ("int", slice(3, None, -1), slice(3, None, -1)),
+            ("int", slice(None, 1, -1), slice(None, 0, -1)),
+            ("int", slice(3, 1, -1), slice(3, 0, -1)),
+            # dtype = int, step = -2
+            ("int", slice(None, None, -2), slice(None, None, -2)),
+            ("int", slice(3, None, -2), slice(3, None, -2)),
+            ("int", slice(None, 1, -2), slice(None, 0, -2)),
+            ("int", slice(3, 1, -2), slice(3, 0, -2)),
+            # dtype = str, step = -1
+            ("str", slice(None, None, -1), slice(None, None, -1)),
+            ("str", slice("d", None, -1), slice(3, None, -1)),
+            ("str", slice(None, "b", -1), slice(None, 0, -1)),
+            ("str", slice("d", "b", -1), slice(3, 0, -1)),
+            # dtype = str, step = -2
+            ("str", slice(None, None, -2), slice(None, None, -2)),
+            ("str", slice("d", None, -2), slice(3, None, -2)),
+            ("str", slice(None, "b", -2), slice(None, 0, -2)),
+            ("str", slice("d", "b", -2), slice(3, 0, -2)),
+        ],
+    )
+    def test_loc_slice_negative_stepsize(self, dtype, loc, iloc):
         # GH#38071
-        mi = MultiIndex.from_product([["a", "b"], [0, 1]])
-        df = DataFrame([[1, 2], [3, 4], [5, 6], [7, 8]], index=mi)
-        result = df.loc[("a", slice(None, None, -1)), :]
-        expected = DataFrame(
-            [[3, 4], [1, 2]], index=MultiIndex.from_tuples([("a", 1), ("a", 0)])
-        )
-        tm.assert_frame_equal(result, expected)
+        labels = {
+            "str": list("abcde"),
+            "int": range(5),
+        }[dtype]
+
+        mi = MultiIndex.from_arrays([labels] * 2)
+        df = DataFrame(1.0, index=mi, columns=["A"])
+
+        SLC = pd.IndexSlice
+
+        expected = df.iloc[iloc, :]
+        result_get_loc = df.loc[SLC[loc], :]
+        result_get_locs_level_0 = df.loc[SLC[loc, :], :]
+        result_get_locs_level_1 = df.loc[SLC[:, loc], :]
+
+        tm.assert_frame_equal(result_get_loc, expected)
+        tm.assert_frame_equal(result_get_locs_level_0, expected)
+        tm.assert_frame_equal(result_get_locs_level_1, expected)
diff --git a/pandas/tests/indexing/multiindex/test_sorted.py b/pandas/tests/indexing/multiindex/test_sorted.py
index 6ba083d65ac3f..2214aaa9cfbdb 100644
--- a/pandas/tests/indexing/multiindex/test_sorted.py
+++ b/pandas/tests/indexing/multiindex/test_sorted.py
@@ -54,17 +54,17 @@ def test_frame_getitem_not_sorted2(self, key):
         with tm.assert_produces_warning(FutureWarning):
             return_value = df2.index.set_codes([0, 1, 0, 2], level="col1", inplace=True)
         assert return_value is None
-        assert not df2.index.is_monotonic
+        assert not df2.index.is_monotonic_increasing
 
         assert df2_original.index.equals(df2.index)
         expected = df2.sort_index(key=key)
-        assert expected.index.is_monotonic
+        assert expected.index.is_monotonic_increasing
 
         result = df2.sort_index(level=0, key=key)
-        assert result.index.is_monotonic
+        assert result.index.is_monotonic_increasing
         tm.assert_frame_equal(result, expected)
 
-    def test_sort_values_key(self, multiindex_dataframe_random_data):
+    def test_sort_values_key(self):
         arrays = [
             ["bar", "bar", "baz", "baz", "qux", "qux", "foo", "foo"],
             ["one", "two", "one", "two", "one", "two", "one", "two"],
diff --git a/pandas/tests/indexing/test_at.py b/pandas/tests/indexing/test_at.py
index d6be817ab6f77..adbc0e2f8127a 100644
--- a/pandas/tests/indexing/test_at.py
+++ b/pandas/tests/indexing/test_at.py
@@ -6,10 +6,13 @@
 import numpy as np
 import pytest
 
+from pandas.errors import InvalidIndexError
+
 from pandas import (
     CategoricalDtype,
     CategoricalIndex,
     DataFrame,
+    MultiIndex,
     Series,
     Timestamp,
 )
@@ -48,6 +51,29 @@ def test_selection_methods_of_assigned_col():
 
 
 class TestAtSetItem:
+    def test_at_setitem_item_cache_cleared(self):
+        # GH#22372 Note the multi-step construction is necessary to trigger
+        #  the original bug. pandas/issues/22372#issuecomment-413345309
+        df = DataFrame(index=[0])
+        df["x"] = 1
+        df["cost"] = 2
+
+        # accessing df["cost"] adds "cost" to the _item_cache
+        df["cost"]
+
+        # This loc[[0]] lookup used to call _consolidate_inplace at the
+        #  BlockManager level, which failed to clear the _item_cache
+        df.loc[[0]]
+
+        df.at[0, "x"] = 4
+        df.at[0, "cost"] = 789
+
+        expected = DataFrame({"x": [4], "cost": 789}, index=[0])
+        tm.assert_frame_equal(df, expected)
+
+        # And in particular, check that the _item_cache has updated correctly.
+        tm.assert_series_equal(df["cost"], expected["cost"])
+
     def test_at_setitem_mixed_index_assignment(self):
         # GH#19860
         ser = Series([1, 2, 3, 4, 5], index=["a", "b", "c", 1, 2])
@@ -73,6 +99,18 @@ def test_at_setitem_categorical_missing(self):
 
         tm.assert_frame_equal(df, expected)
 
+    def test_at_setitem_multiindex(self):
+        df = DataFrame(
+            np.zeros((3, 2), dtype="int64"),
+            columns=MultiIndex.from_tuples([("a", 0), ("a", 1)]),
+        )
+        df.at[0, "a"] = 10
+        expected = DataFrame(
+            [[10, 10], [0, 0], [0, 0]],
+            columns=MultiIndex.from_tuples([("a", 0), ("a", 1)]),
+        )
+        tm.assert_frame_equal(df, expected)
+
 
 class TestAtSetItemWithExpansion:
     def test_at_setitem_expansion_series_dt64tz_value(self, tz_naive_fixture):
@@ -156,6 +194,16 @@ def test_at_frame_raises_key_error2(self, indexer_al):
         with pytest.raises(KeyError, match="^0$"):
             indexer_al(df)["a", 0]
 
+    def test_at_frame_multiple_columns(self):
+        # GH#48296 - at shouldn't modify multiple columns
+        df = DataFrame({"a": [1, 2], "b": [3, 4]})
+        new_row = [6, 7]
+        with pytest.raises(
+            InvalidIndexError,
+            match=f"You can only assign a scalar value not a \\{type(new_row)}",
+        ):
+            df.at[5] = new_row
+
     def test_at_getitem_mixed_index_no_fallback(self):
         # GH#19860
         ser = Series([1, 2, 3, 4, 5], index=["a", "b", "c", 1, 2])
@@ -176,3 +224,13 @@ def test_at_categorical_integers(self):
             for key in [0, 1]:
                 with pytest.raises(KeyError, match=str(key)):
                     df.at[key, key]
+
+    def test_at_applied_for_rows(self):
+        # GH#48729 .at should raise InvalidIndexError when assigning rows
+        df = DataFrame(index=["a"], columns=["col1", "col2"])
+        new_row = [123, 15]
+        with pytest.raises(
+            InvalidIndexError,
+            match=f"You can only assign a scalar value not a \\{type(new_row)}",
+        ):
+            df.at["a"] = new_row
diff --git a/pandas/tests/indexing/test_categorical.py b/pandas/tests/indexing/test_categorical.py
index 870043897e8e2..b94323e975cd7 100644
--- a/pandas/tests/indexing/test_categorical.py
+++ b/pandas/tests/indexing/test_categorical.py
@@ -20,32 +20,37 @@
 from pandas.api.types import CategoricalDtype as CDT
 
 
-class TestCategoricalIndex:
-    def setup_method(self, method):
+@pytest.fixture
+def df():
+    return DataFrame(
+        {
+            "A": np.arange(6, dtype="int64"),
+        },
+        index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cab")), name="B"),
+    )
+
+
+@pytest.fixture
+def df2():
+    return DataFrame(
+        {
+            "A": np.arange(6, dtype="int64"),
+        },
+        index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cabe")), name="B"),
+    )
 
-        self.df = DataFrame(
-            {
-                "A": np.arange(6, dtype="int64"),
-            },
-            index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cab")), name="B"),
-        )
-        self.df2 = DataFrame(
-            {
-                "A": np.arange(6, dtype="int64"),
-            },
-            index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cabe")), name="B"),
-        )
 
-    def test_loc_scalar(self):
+class TestCategoricalIndex:
+    def test_loc_scalar(self, df):
         dtype = CDT(list("cab"))
-        result = self.df.loc["a"]
+        result = df.loc["a"]
         bidx = Series(list("aaa"), name="B").astype(dtype)
         assert bidx.dtype == dtype
 
         expected = DataFrame({"A": [0, 1, 5]}, index=Index(bidx))
         tm.assert_frame_equal(result, expected)
 
-        df = self.df.copy()
+        df = df.copy()
         df.loc["a"] = 20
         bidx2 = Series(list("aabbca"), name="B").astype(dtype)
         assert bidx2.dtype == dtype
@@ -68,9 +73,8 @@ def test_loc_scalar(self):
         df2.loc["d"] = 10
         tm.assert_frame_equal(df2, expected)
 
-    def test_loc_setitem_with_expansion_non_category(self):
+    def test_loc_setitem_with_expansion_non_category(self, df):
         # Setting-with-expansion with a new key "d" that is not among caegories
-        df = self.df
         df.loc["a"] = 20
 
         # Setting a new row on an existing column
@@ -97,9 +101,9 @@ def test_loc_setitem_with_expansion_non_category(self):
         )
         tm.assert_frame_equal(df4, expected3)
 
-    def test_loc_getitem_scalar_non_category(self):
+    def test_loc_getitem_scalar_non_category(self, df):
         with pytest.raises(KeyError, match="^1$"):
-            self.df.loc[1]
+            df.loc[1]
 
     def test_slicing(self):
         cat = Series(Categorical([1, 2, 3, 4]))
@@ -287,31 +291,31 @@ def test_slicing_doc_examples(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_loc_getitem_listlike_labels(self):
+    def test_loc_getitem_listlike_labels(self, df):
         # list of labels
-        result = self.df.loc[["c", "a"]]
-        expected = self.df.iloc[[4, 0, 1, 5]]
+        result = df.loc[["c", "a"]]
+        expected = df.iloc[[4, 0, 1, 5]]
         tm.assert_frame_equal(result, expected, check_index_type=True)
 
-    def test_loc_getitem_listlike_unused_category(self):
+    def test_loc_getitem_listlike_unused_category(self, df2):
         # GH#37901 a label that is in index.categories but not in index
         # listlike containing an element in the categories but not in the values
         with pytest.raises(KeyError, match=re.escape("['e'] not in index")):
-            self.df2.loc[["a", "b", "e"]]
+            df2.loc[["a", "b", "e"]]
 
-    def test_loc_getitem_label_unused_category(self):
+    def test_loc_getitem_label_unused_category(self, df2):
         # element in the categories but not in the values
         with pytest.raises(KeyError, match=r"^'e'$"):
-            self.df2.loc["e"]
+            df2.loc["e"]
 
-    def test_loc_getitem_non_category(self):
+    def test_loc_getitem_non_category(self, df2):
         # not all labels in the categories
         with pytest.raises(KeyError, match=re.escape("['d'] not in index")):
-            self.df2.loc[["a", "d"]]
+            df2.loc[["a", "d"]]
 
-    def test_loc_setitem_expansion_label_unused_category(self):
+    def test_loc_setitem_expansion_label_unused_category(self, df2):
         # assigning with a label that is in the categories but not in the index
-        df = self.df2.copy()
+        df = df2.copy()
         df.loc["e"] = 20
         result = df.loc[["a", "b", "e"]]
         exp_index = CategoricalIndex(list("aaabbe"), categories=list("cabe"), name="B")
@@ -450,17 +454,17 @@ def test_ix_categorical_index_non_unique(self):
         )
         tm.assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
 
-    def test_loc_slice(self):
+    def test_loc_slice(self, df):
         # GH9748
         msg = (
             "cannot do slice indexing on CategoricalIndex with these "
             r"indexers \[1\] of type int"
         )
         with pytest.raises(TypeError, match=msg):
-            self.df.loc[1:5]
+            df.loc[1:5]
 
-        result = self.df.loc["b":"c"]
-        expected = self.df.iloc[[2, 3, 4]]
+        result = df.loc["b":"c"]
+        expected = df.iloc[[2, 3, 4]]
         tm.assert_frame_equal(result, expected)
 
     def test_loc_and_at_with_categorical_index(self):
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index 4fb90a2d95ac9..81914e1b8052f 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -3,6 +3,10 @@
 import numpy as np
 import pytest
 
+from pandas.errors import (
+    SettingWithCopyError,
+    SettingWithCopyWarning,
+)
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -14,7 +18,6 @@
     option_context,
 )
 import pandas._testing as tm
-import pandas.core.common as com
 
 msg = "A value is trying to be set on a copy of a slice from a DataFrame"
 
@@ -29,7 +32,7 @@ def random_text(nobs=100):
 
 
 class TestCaching:
-    def test_slice_consolidate_invalidate_item_cache(self):
+    def test_slice_consolidate_invalidate_item_cache(self, using_copy_on_write):
 
         # this is chained assignment, but will 'work'
         with option_context("chained_assignment", None):
@@ -49,7 +52,11 @@ def test_slice_consolidate_invalidate_item_cache(self):
             # Assignment to wrong series
             df["bb"].iloc[0] = 0.17
             df._clear_item_cache()
-            tm.assert_almost_equal(df["bb"][0], 0.17)
+            if not using_copy_on_write:
+                tm.assert_almost_equal(df["bb"][0], 0.17)
+            else:
+                # with ArrayManager, parent is not mutated with chained assignment
+                tm.assert_almost_equal(df["bb"][0], 2.2)
 
     @pytest.mark.parametrize("do_ref", [True, False])
     def test_setitem_cache_updating(self, do_ref):
@@ -68,7 +75,7 @@ def test_setitem_cache_updating(self, do_ref):
         assert df.loc[0, "c"] == 0.0
         assert df.loc[7, "c"] == 1.0
 
-    def test_setitem_cache_updating_slices(self):
+    def test_setitem_cache_updating_slices(self, using_copy_on_write):
         # GH 7084
         # not updating cache on series setting with slices
         expected = DataFrame(
@@ -89,12 +96,17 @@ def test_setitem_cache_updating_slices(self):
         # try via a chain indexing
         # this actually works
         out = DataFrame({"A": [0, 0, 0]}, index=date_range("5/7/2014", "5/9/2014"))
+        out_original = out.copy()
         for ix, row in df.iterrows():
             v = out[row["C"]][six:eix] + row["D"]
             out[row["C"]][six:eix] = v
 
-        tm.assert_frame_equal(out, expected)
-        tm.assert_series_equal(out["A"], expected["A"])
+        if not using_copy_on_write:
+            tm.assert_frame_equal(out, expected)
+            tm.assert_series_equal(out["A"], expected["A"])
+        else:
+            tm.assert_frame_equal(out, out_original)
+            tm.assert_series_equal(out["A"], out_original["A"])
 
         out = DataFrame({"A": [0, 0, 0]}, index=date_range("5/7/2014", "5/9/2014"))
         for ix, row in df.iterrows():
@@ -120,7 +132,7 @@ def test_altering_series_clears_parent_cache(self):
 
 
 class TestChaining:
-    def test_setitem_chained_setfault(self):
+    def test_setitem_chained_setfault(self, using_copy_on_write):
 
         # GH6026
         data = ["right", "left", "left", "left", "right", "left", "timeout"]
@@ -129,24 +141,38 @@ def test_setitem_chained_setfault(self):
         df = DataFrame({"response": np.array(data)})
         mask = df.response == "timeout"
         df.response[mask] = "none"
-        tm.assert_frame_equal(df, DataFrame({"response": mdata}))
+        if using_copy_on_write:
+            tm.assert_frame_equal(df, DataFrame({"response": data}))
+        else:
+            tm.assert_frame_equal(df, DataFrame({"response": mdata}))
 
         recarray = np.rec.fromarrays([data], names=["response"])
         df = DataFrame(recarray)
         mask = df.response == "timeout"
         df.response[mask] = "none"
-        tm.assert_frame_equal(df, DataFrame({"response": mdata}))
+        if using_copy_on_write:
+            tm.assert_frame_equal(df, DataFrame({"response": data}))
+        else:
+            tm.assert_frame_equal(df, DataFrame({"response": mdata}))
 
         df = DataFrame({"response": data, "response1": data})
+        df_original = df.copy()
         mask = df.response == "timeout"
         df.response[mask] = "none"
-        tm.assert_frame_equal(df, DataFrame({"response": mdata, "response1": data}))
+        if using_copy_on_write:
+            tm.assert_frame_equal(df, df_original)
+        else:
+            tm.assert_frame_equal(df, DataFrame({"response": mdata, "response1": data}))
 
         # GH 6056
         expected = DataFrame({"A": [np.nan, "bar", "bah", "foo", "bar"]})
         df = DataFrame({"A": np.array(["foo", "bar", "bah", "foo", "bar"])})
         df["A"].iloc[0] = np.nan
         result = df.head()
+        if using_copy_on_write:
+            expected = DataFrame({"A": ["foo", "bar", "bah", "foo", "bar"]})
+        else:
+            expected = DataFrame({"A": [np.nan, "bar", "bah", "foo", "bar"]})
         tm.assert_frame_equal(result, expected)
 
         df = DataFrame({"A": np.array(["foo", "bar", "bah", "foo", "bar"])})
@@ -155,21 +181,28 @@ def test_setitem_chained_setfault(self):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment(self):
-
-        pd.set_option("chained_assignment", "raise")
+    def test_detect_chained_assignment(self, using_copy_on_write):
 
-        # work with the chain
-        expected = DataFrame([[-5, 1], [-6, 3]], columns=list("AB"))
-        df = DataFrame(np.arange(4).reshape(2, 2), columns=list("AB"), dtype="int64")
-        assert df._is_copy is None
+        with option_context("chained_assignment", "raise"):
+            # work with the chain
+            expected = DataFrame([[-5, 1], [-6, 3]], columns=list("AB"))
+            df = DataFrame(
+                np.arange(4).reshape(2, 2), columns=list("AB"), dtype="int64"
+            )
+            df_original = df.copy()
+            assert df._is_copy is None
 
-        df["A"][0] = -5
-        df["A"][1] = -6
-        tm.assert_frame_equal(df, expected)
+            df["A"][0] = -5
+            df["A"][1] = -6
+            if using_copy_on_write:
+                tm.assert_frame_equal(df, df_original)
+            else:
+                tm.assert_frame_equal(df, expected)
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_raises(self, using_array_manager):
+    def test_detect_chained_assignment_raises(
+        self, using_array_manager, using_copy_on_write
+    ):
 
         # test with the chaining
         df = DataFrame(
@@ -178,17 +211,21 @@ def test_detect_chained_assignment_raises(self, using_array_manager):
                 "B": np.array(np.arange(2, 4), dtype=np.float64),
             }
         )
+        df_original = df.copy()
         assert df._is_copy is None
 
-        if not using_array_manager:
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            df["A"][0] = -5
+            df["A"][1] = -6
+            tm.assert_frame_equal(df, df_original)
+        elif not using_array_manager:
+            with pytest.raises(SettingWithCopyError, match=msg):
                 df["A"][0] = -5
 
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            with pytest.raises(SettingWithCopyError, match=msg):
                 df["A"][1] = np.nan
 
             assert df["A"]._is_copy is None
-
         else:
             # INFO(ArrayManager) for ArrayManager it doesn't matter that it's
             # a mixed dataframe
@@ -199,7 +236,7 @@ def test_detect_chained_assignment_raises(self, using_array_manager):
             tm.assert_frame_equal(df, expected)
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_fails(self):
+    def test_detect_chained_assignment_fails(self, using_copy_on_write):
 
         # Using a copy (the chain), fails
         df = DataFrame(
@@ -209,11 +246,15 @@ def test_detect_chained_assignment_fails(self):
             }
         )
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            # TODO(CoW) can we still warn here?
             df.loc[0]["A"] = -5
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df.loc[0]["A"] = -5
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_doc_example(self):
+    def test_detect_chained_assignment_doc_example(self, using_copy_on_write):
 
         # Doc example
         df = DataFrame(
@@ -224,30 +265,43 @@ def test_detect_chained_assignment_doc_example(self):
         )
         assert df._is_copy is None
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            # TODO(CoW) can we still warn here?
             indexer = df.a.str.startswith("o")
             df[indexer]["c"] = 42
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                indexer = df.a.str.startswith("o")
+                df[indexer]["c"] = 42
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_object_dtype(self, using_array_manager):
+    def test_detect_chained_assignment_object_dtype(
+        self, using_array_manager, using_copy_on_write
+    ):
 
         expected = DataFrame({"A": [111, "bbb", "ccc"], "B": [1, 2, 3]})
         df = DataFrame({"A": ["aaa", "bbb", "ccc"], "B": [1, 2, 3]})
+        df_original = df.copy()
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
-            df.loc[0]["A"] = 111
+        if not using_copy_on_write:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df.loc[0]["A"] = 111
 
-        if not using_array_manager:
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            # TODO(CoW) can we still warn here?
+            df["A"][0] = 111
+            tm.assert_frame_equal(df, df_original)
+        elif not using_array_manager:
+            with pytest.raises(SettingWithCopyError, match=msg):
                 df["A"][0] = 111
 
             df.loc[0, "A"] = 111
+            tm.assert_frame_equal(df, expected)
         else:
             # INFO(ArrayManager) for ArrayManager it doesn't matter that it's
             # a mixed dataframe
             df["A"][0] = 111
-
-        tm.assert_frame_equal(df, expected)
+            tm.assert_frame_equal(df, expected)
 
     @pytest.mark.arm_slow
     def test_detect_chained_assignment_is_copy_pickle(self):
@@ -295,8 +349,9 @@ def test_detect_chained_assignment_implicit_take(self):
         df["letters"] = df["letters"].apply(str.lower)
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_implicit_take2(self):
-
+    def test_detect_chained_assignment_implicit_take2(self, using_copy_on_write):
+        if using_copy_on_write:
+            pytest.skip("_is_copy is not always set for CoW")
         # Implicitly take 2
         df = random_text(100000)
         indexer = df.letters.apply(lambda x: len(x) > 10)
@@ -352,18 +407,26 @@ def test_detect_chained_assignment_false_positives(self):
         str(df)
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_undefined_column(self):
+    def test_detect_chained_assignment_undefined_column(self, using_copy_on_write):
 
         # from SO:
         # https://stackoverflow.com/questions/24054495/potential-bug-setting-value-for-undefined-column-using-iloc
         df = DataFrame(np.arange(0, 9), columns=["count"])
         df["group"] = "b"
+        df_original = df.copy()
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
+            # TODO(CoW) can we still warn here?
             df.iloc[0:5]["group"] = "a"
+            tm.assert_frame_equal(df, df_original)
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df.iloc[0:5]["group"] = "a"
 
     @pytest.mark.arm_slow
-    def test_detect_chained_assignment_changing_dtype(self, using_array_manager):
+    def test_detect_chained_assignment_changing_dtype(
+        self, using_array_manager, using_copy_on_write
+    ):
 
         # Mixed type setting but same dtype & changing dtype
         df = DataFrame(
@@ -374,32 +437,45 @@ def test_detect_chained_assignment_changing_dtype(self, using_array_manager):
                 "D": ["a", "b", "c", "d", "e"],
             }
         )
+        df_original = df.copy()
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
             df.loc[2]["D"] = "foo"
-
-        with pytest.raises(com.SettingWithCopyError, match=msg):
             df.loc[2]["C"] = "foo"
+            df["C"][2] = "foo"
+            tm.assert_frame_equal(df, df_original)
+
+        if not using_copy_on_write:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df.loc[2]["D"] = "foo"
+
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df.loc[2]["C"] = "foo"
 
-        if not using_array_manager:
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            if not using_array_manager:
+                with pytest.raises(SettingWithCopyError, match=msg):
+                    df["C"][2] = "foo"
+            else:
+                # INFO(ArrayManager) for ArrayManager it doesn't matter if it's
+                # changing the dtype or not
                 df["C"][2] = "foo"
-        else:
-            # INFO(ArrayManager) for ArrayManager it doesn't matter if it's
-            # changing the dtype or not
-            df["C"][2] = "foo"
-            assert df.loc[2, "C"] == "foo"
+                assert df.loc[2, "C"] == "foo"
 
-    def test_setting_with_copy_bug(self):
+    def test_setting_with_copy_bug(self, using_copy_on_write):
 
         # operating on a copy
         df = DataFrame(
             {"a": list(range(4)), "b": list("ab.."), "c": ["a", "b", np.nan, "d"]}
         )
+        df_original = df.copy()
         mask = pd.isna(df.c)
 
-        with pytest.raises(com.SettingWithCopyError, match=msg):
+        if using_copy_on_write:
             df[["c"]][mask] = df[["b"]][mask]
+            tm.assert_frame_equal(df, df_original)
+        else:
+            with pytest.raises(SettingWithCopyError, match=msg):
+                df[["c"]][mask] = df[["b"]][mask]
 
     def test_setting_with_copy_bug_no_warning(self):
         # invalid warning as we are returning a new object
@@ -410,38 +486,38 @@ def test_setting_with_copy_bug_no_warning(self):
         # this should not raise
         df2["y"] = ["g", "h", "i"]
 
-    def test_detect_chained_assignment_warnings_errors(self):
+    def test_detect_chained_assignment_warnings_errors(self, using_copy_on_write):
         df = DataFrame({"A": ["aaa", "bbb", "ccc"], "B": [1, 2, 3]})
+        if using_copy_on_write:
+            df.loc[0]["A"] = 111
+            return
+
         with option_context("chained_assignment", "warn"):
-            with tm.assert_produces_warning(com.SettingWithCopyWarning):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
                 df.loc[0]["A"] = 111
 
         with option_context("chained_assignment", "raise"):
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            with pytest.raises(SettingWithCopyError, match=msg):
                 df.loc[0]["A"] = 111
 
-    def test_detect_chained_assignment_warnings_filter_and_dupe_cols(self):
-        # xref gh-13017.
-        with option_context("chained_assignment", "warn"):
-            df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=["a", "a", "c"])
-
-            with tm.assert_produces_warning(com.SettingWithCopyWarning):
-                df.c.loc[df.c > 0] = None
-
-            expected = DataFrame(
-                [[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=["a", "a", "c"]
-            )
-            tm.assert_frame_equal(df, expected)
-
     @pytest.mark.parametrize("rhs", [3, DataFrame({0: [1, 2, 3, 4]})])
-    def test_detect_chained_assignment_warning_stacklevel(self, rhs):
+    def test_detect_chained_assignment_warning_stacklevel(
+        self, rhs, using_copy_on_write
+    ):
         # GH#42570
         df = DataFrame(np.arange(25).reshape(5, 5))
+        df_original = df.copy()
         chained = df.loc[:3]
         with option_context("chained_assignment", "warn"):
-            with tm.assert_produces_warning(com.SettingWithCopyWarning) as t:
-                chained[2] = rhs
-                assert t[0].filename == __file__
+            if not using_copy_on_write:
+                with tm.assert_produces_warning(SettingWithCopyWarning) as t:
+                    chained[2] = rhs
+                    assert t[0].filename == __file__
+            else:
+                # INFO(CoW) no warning, and original dataframe not changed
+                with tm.assert_produces_warning(None):
+                    chained[2] = rhs
+                tm.assert_frame_equal(df, df_original)
 
     # TODO(ArrayManager) fast_xs with array-like scalars is not yet working
     @td.skip_array_manager_not_yet_implemented
@@ -492,7 +568,7 @@ def test_cache_updating2(self):
         expected = Series([0, 0, 0, 2, 0], name="f")
         tm.assert_series_equal(df.f, expected)
 
-    def test_iloc_setitem_chained_assignment(self):
+    def test_iloc_setitem_chained_assignment(self, using_copy_on_write):
         # GH#3970
         with option_context("chained_assignment", None):
             df = DataFrame({"aa": range(5), "bb": [2.2] * 5})
@@ -506,7 +582,10 @@ def test_iloc_setitem_chained_assignment(self):
             df.iloc[ck]
 
             df["bb"].iloc[0] = 0.15
-            assert df["bb"].iloc[0] == 0.15
+            if not using_copy_on_write:
+                assert df["bb"].iloc[0] == 0.15
+            else:
+                assert df["bb"].iloc[0] == 2.2
 
     def test_getitem_loc_assignment_slice_state(self):
         # GH 13569
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index 75337cb3f453f..2d54a9ba370ca 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from datetime import timedelta
+from datetime import (
+    datetime,
+    timedelta,
+)
 import itertools
 
 import numpy as np
@@ -78,182 +81,9 @@ class TestSetitemCoercion(CoercionBase):
 
     method = "setitem"
 
-    def _assert_setitem_series_conversion(
-        self, original_series, loc_value, expected_series, expected_dtype
-    ):
-        """test series value's coercion triggered by assignment"""
-        temp = original_series.copy()
-        temp[1] = loc_value
-        tm.assert_series_equal(temp, expected_series)
-        # check dtype explicitly for sure
-        assert temp.dtype == expected_dtype
-
-        temp = original_series.copy()
-        temp.loc[1] = loc_value
-        tm.assert_series_equal(temp, expected_series)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, object)]
-    )
-    def test_setitem_series_object(self, val, exp_dtype):
-        obj = pd.Series(list("abcd"))
-        assert obj.dtype == object
-
-        exp = pd.Series(["a", val, "c", "d"])
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [(1, np.int64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)],
-    )
-    def test_setitem_series_int64(self, val, exp_dtype):
-        obj = pd.Series([1, 2, 3, 4])
-        assert obj.dtype == np.int64
-
-        exp = pd.Series([1, val, 3, 4])
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype", [(np.int32(1), np.int8), (np.int16(2 ** 9), np.int16)]
-    )
-    def test_setitem_series_int8(self, val, exp_dtype):
-        obj = pd.Series([1, 2, 3, 4], dtype=np.int8)
-        assert obj.dtype == np.int8
-
-        warn = None if exp_dtype is np.int8 else FutureWarning
-        msg = "Values are too large to be losslessly cast to int8"
-        with tm.assert_produces_warning(warn, match=msg):
-            exp = pd.Series([1, val, 3, 4], dtype=np.int8)
-
-        exp = pd.Series([1, val, 3, 4], dtype=exp_dtype)
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [(1, np.float64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)],
-    )
-    def test_setitem_series_float64(self, val, exp_dtype):
-        obj = pd.Series([1.1, 2.2, 3.3, 4.4])
-        assert obj.dtype == np.float64
-
-        exp = pd.Series([1.1, val, 3.3, 4.4])
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [
-            (1, np.complex128),
-            (1.1, np.complex128),
-            (1 + 1j, np.complex128),
-            (True, object),
-        ],
-    )
-    def test_setitem_series_complex128(self, val, exp_dtype):
-        obj = pd.Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
-        assert obj.dtype == np.complex128
-
-        exp = pd.Series([1 + 1j, val, 3 + 3j, 4 + 4j])
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [
-            (1, object),
-            ("3", object),
-            (3, object),
-            (1.1, object),
-            (1 + 1j, object),
-            (True, np.bool_),
-        ],
-    )
-    def test_setitem_series_bool(self, val, exp_dtype):
-        obj = pd.Series([True, False, True, False])
-        assert obj.dtype == np.bool_
-
-        exp = pd.Series([True, val, True, False], dtype=exp_dtype)
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [(pd.Timestamp("2012-01-01"), "datetime64[ns]"), (1, object), ("x", object)],
-    )
-    def test_setitem_series_datetime64(self, val, exp_dtype):
-        obj = pd.Series(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2011-01-02"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2011-01-04"),
-            ]
-        )
-        assert obj.dtype == "datetime64[ns]"
-
-        exp = pd.Series(
-            [
-                pd.Timestamp("2011-01-01"),
-                val,
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2011-01-04"),
-            ]
-        )
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [
-            (pd.Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]"),
-            (pd.Timestamp("2012-01-01", tz="US/Pacific"), object),
-            (pd.Timestamp("2012-01-01"), object),
-            (1, object),
-        ],
-    )
-    def test_setitem_series_datetime64tz(self, val, exp_dtype):
-        tz = "US/Eastern"
-        obj = pd.Series(
-            [
-                pd.Timestamp("2011-01-01", tz=tz),
-                pd.Timestamp("2011-01-02", tz=tz),
-                pd.Timestamp("2011-01-03", tz=tz),
-                pd.Timestamp("2011-01-04", tz=tz),
-            ]
-        )
-        assert obj.dtype == "datetime64[ns, US/Eastern]"
-
-        exp = pd.Series(
-            [
-                pd.Timestamp("2011-01-01", tz=tz),
-                val,
-                # once deprecation is enforced
-                # val if getattr(val, "tz", None) is None else val.tz_convert(tz),
-                pd.Timestamp("2011-01-03", tz=tz),
-                pd.Timestamp("2011-01-04", tz=tz),
-            ]
-        )
-        warn = None
-        if getattr(val, "tz", None) is not None and val.tz != obj[0].tz:
-            warn = FutureWarning
-        with tm.assert_produces_warning(warn, match="mismatched timezones"):
-            self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "val,exp_dtype",
-        [(pd.Timedelta("12 day"), "timedelta64[ns]"), (1, object), ("x", object)],
-    )
-    def test_setitem_series_timedelta64(self, val, exp_dtype):
-        obj = pd.Series(
-            [
-                pd.Timedelta("1 day"),
-                pd.Timedelta("2 day"),
-                pd.Timedelta("3 day"),
-                pd.Timedelta("4 day"),
-            ]
-        )
-        assert obj.dtype == "timedelta64[ns]"
-
-        exp = pd.Series(
-            [pd.Timedelta("1 day"), val, pd.Timedelta("3 day"), pd.Timedelta("4 day")]
-        )
-        self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
+    # disable comprehensiveness tests, as most of these have been moved to
+    #  tests.series.indexing.test_setitem in SetitemCastingEquivalents subclasses.
+    klasses: list[str] = []
 
     def test_setitem_series_no_coercion_from_values_list(self):
         # GH35865 - int casted to str when internally calling np.array(ser.values)
@@ -435,7 +265,7 @@ def test_insert_index_float64(self, insert, coerced_val, coerced_dtype):
         "insert_value",
         [pd.Timestamp("2012-01-01"), pd.Timestamp("2012-01-01", tz="Asia/Tokyo"), 1],
     )
-    def test_insert_index_datetimes(self, request, fill_val, exp_dtype, insert_value):
+    def test_insert_index_datetimes(self, fill_val, exp_dtype, insert_value):
 
         obj = pd.DatetimeIndex(
             ["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"], tz=fill_val.tz
@@ -556,6 +386,7 @@ def test_insert_index_bool(self):
 class TestWhereCoercion(CoercionBase):
 
     method = "where"
+    _cond = np.array([True, False, True, False])
 
     def _assert_where_conversion(
         self, original, cond, values, expected, expected_dtype
@@ -566,6 +397,26 @@ def _assert_where_conversion(
         tm.assert_equal(res, expected)
         assert res.dtype == expected_dtype
 
+    def _construct_exp(self, obj, klass, fill_val, exp_dtype):
+        if fill_val is True:
+            values = klass([True, False, True, True])
+        elif isinstance(fill_val, (datetime, np.datetime64)):
+            values = pd.date_range(fill_val, periods=4)
+        else:
+            values = klass(x * fill_val for x in [5, 6, 7, 8])
+
+        exp = klass([obj[0], values[1], obj[2], values[3]], dtype=exp_dtype)
+        return values, exp
+
+    def _run_test(self, obj, fill_val, klass, exp_dtype):
+        cond = klass(self._cond)
+
+        exp = klass([obj[0], fill_val, obj[2], fill_val], dtype=exp_dtype)
+        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
+
+        values, exp = self._construct_exp(obj, klass, fill_val, exp_dtype)
+        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
         [(1, object), (1.1, object), (1 + 1j, object), (True, object)],
@@ -574,23 +425,7 @@ def test_where_object(self, index_or_series, fill_val, exp_dtype):
         klass = index_or_series
         obj = klass(list("abcd"))
         assert obj.dtype == object
-        cond = klass([True, False, True, False])
-
-        if fill_val is True and klass is pd.Series:
-            ret_val = 1
-        else:
-            ret_val = fill_val
-
-        exp = klass(["a", ret_val, "c", ret_val])
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        if fill_val is True:
-            values = klass([True, False, True, True])
-        else:
-            values = klass(x * fill_val for x in [5, 6, 7, 8])
-
-        exp = klass(["a", values[1], "c", values[3]])
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
@@ -598,23 +433,10 @@ def test_where_object(self, index_or_series, fill_val, exp_dtype):
     )
     def test_where_int64(self, index_or_series, fill_val, exp_dtype, request):
         klass = index_or_series
-        if klass is pd.Index and exp_dtype is np.complex128:
-            mark = pytest.mark.xfail(reason="Complex Index not supported")
-            request.node.add_marker(mark)
 
         obj = klass([1, 2, 3, 4])
         assert obj.dtype == np.int64
-        cond = klass([True, False, True, False])
-
-        exp = klass([1, fill_val, 3, fill_val])
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        if fill_val is True:
-            values = klass([True, False, True, True])
-        else:
-            values = klass(x * fill_val for x in [5, 6, 7, 8])
-        exp = klass([1, values[1], 3, values[3]])
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.parametrize(
         "fill_val, exp_dtype",
@@ -622,23 +444,10 @@ def test_where_int64(self, index_or_series, fill_val, exp_dtype, request):
     )
     def test_where_float64(self, index_or_series, fill_val, exp_dtype, request):
         klass = index_or_series
-        if klass is pd.Index and exp_dtype is np.complex128:
-            mark = pytest.mark.xfail(reason="Complex Index not supported")
-            request.node.add_marker(mark)
 
         obj = klass([1.1, 2.2, 3.3, 4.4])
         assert obj.dtype == np.float64
-        cond = klass([True, False, True, False])
-
-        exp = klass([1.1, fill_val, 3.3, fill_val])
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        if fill_val is True:
-            values = klass([True, False, True, True])
-        else:
-            values = klass(x * fill_val for x in [5, 6, 7, 8])
-        exp = klass([1.1, values[1], 3.3, values[3]])
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
@@ -649,42 +458,22 @@ def test_where_float64(self, index_or_series, fill_val, exp_dtype, request):
             (True, object),
         ],
     )
-    def test_where_series_complex128(self, fill_val, exp_dtype):
-        klass = pd.Series
-        obj = klass([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
+    def test_where_complex128(self, index_or_series, fill_val, exp_dtype):
+        klass = index_or_series
+        obj = klass([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j], dtype=np.complex128)
         assert obj.dtype == np.complex128
-        cond = klass([True, False, True, False])
-
-        exp = klass([1 + 1j, fill_val, 3 + 3j, fill_val])
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        if fill_val is True:
-            values = klass([True, False, True, True])
-        else:
-            values = klass(x * fill_val for x in [5, 6, 7, 8])
-        exp = klass([1 + 1j, values[1], 3 + 3j, values[3]], dtype=exp_dtype)
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
         [(1, object), (1.1, object), (1 + 1j, object), (True, np.bool_)],
     )
     def test_where_series_bool(self, fill_val, exp_dtype):
-        klass = pd.Series
+        klass = pd.Series  # TODO: use index_or_series once we have Index[bool]
 
         obj = klass([True, False, True, False])
         assert obj.dtype == np.bool_
-        cond = klass([True, False, True, False])
-
-        exp = klass([True, fill_val, True, fill_val])
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        if fill_val is True:
-            values = klass([True, False, True, True])
-        else:
-            values = klass(x * fill_val for x in [5, 6, 7, 8])
-        exp = klass([True, values[1], True, values[3]])
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
@@ -694,112 +483,20 @@ def test_where_series_bool(self, fill_val, exp_dtype):
         ],
         ids=["datetime64", "datetime64tz"],
     )
-    def test_where_series_datetime64(self, fill_val, exp_dtype):
-        obj = pd.Series(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2011-01-02"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2011-01-04"),
-            ]
-        )
-        assert obj.dtype == "datetime64[ns]"
-        cond = pd.Series([True, False, True, False])
-
-        exp = pd.Series(
-            [pd.Timestamp("2011-01-01"), fill_val, pd.Timestamp("2011-01-03"), fill_val]
-        )
-        self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
-
-        values = pd.Series(pd.date_range(fill_val, periods=4))
-        if fill_val.tz:
-            exp = pd.Series(
-                [
-                    pd.Timestamp("2011-01-01"),
-                    pd.Timestamp("2012-01-02 00:00", tz="US/Eastern"),
-                    pd.Timestamp("2011-01-03"),
-                    pd.Timestamp("2012-01-04 00:00", tz="US/Eastern"),
-                ]
-            )
-            self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
-
-        exp = pd.Series(
-            [
-                pd.Timestamp("2011-01-01"),
-                values[1],
-                pd.Timestamp("2011-01-03"),
-                values[3],
-            ]
-        )
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
-
-    @pytest.mark.parametrize(
-        "fill_val",
-        [
-            pd.Timestamp("2012-01-01"),
-            pd.Timestamp("2012-01-01").to_datetime64(),
-            pd.Timestamp("2012-01-01").to_pydatetime(),
-        ],
-    )
-    def test_where_index_datetime(self, fill_val):
-        exp_dtype = "datetime64[ns]"
-        obj = pd.Index(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2011-01-02"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2011-01-04"),
-            ]
-        )
-        assert obj.dtype == "datetime64[ns]"
-        cond = pd.Index([True, False, True, False])
-
-        result = obj.where(cond, fill_val)
-        expected = pd.DatetimeIndex([obj[0], fill_val, obj[2], fill_val])
-        tm.assert_index_equal(result, expected)
-
-        values = pd.Index(pd.date_range(fill_val, periods=4))
-        exp = pd.Index(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2012-01-02"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2012-01-04"),
-            ]
-        )
-
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+    def test_where_datetime64(self, index_or_series, fill_val, exp_dtype):
+        klass = index_or_series
 
-    def test_where_index_datetime64tz(self):
-        fill_val = pd.Timestamp("2012-01-01", tz="US/Eastern")
-        exp_dtype = object
-        obj = pd.Index(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2011-01-02"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2011-01-04"),
-            ]
-        )
+        obj = klass(pd.date_range("2011-01-01", periods=4, freq="D")._with_freq(None))
         assert obj.dtype == "datetime64[ns]"
-        cond = pd.Index([True, False, True, False])
 
-        res = obj.where(cond, fill_val)
-        expected = pd.Index([obj[0], fill_val, obj[2], fill_val], dtype=object)
-        tm.assert_index_equal(res, expected)
-
-        values = pd.Index(pd.date_range(fill_val, periods=4))
-        exp = pd.Index(
-            [
-                pd.Timestamp("2011-01-01"),
-                pd.Timestamp("2012-01-02", tz="US/Eastern"),
-                pd.Timestamp("2011-01-03"),
-                pd.Timestamp("2012-01-04", tz="US/Eastern"),
-            ],
-            dtype=exp_dtype,
-        )
-
-        self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
+        fv = fill_val
+        # do the check with each of the available datetime scalars
+        if exp_dtype == "datetime64[ns]":
+            for scalar in [fv, fv.to_pydatetime(), fv.to_datetime64()]:
+                self._run_test(obj, scalar, klass, exp_dtype)
+        else:
+            for scalar in [fv, fv.to_pydatetime()]:
+                self._run_test(obj, fill_val, klass, exp_dtype)
 
     @pytest.mark.xfail(reason="Test not implemented")
     def test_where_index_complex128(self):
@@ -842,7 +539,7 @@ def test_where_index_period(self):
 
         cond = np.array([False, True, False])
 
-        # Passinga  valid scalar
+        # Passing a valid scalar
         value = pi[-1] + pi.freq * 10
         expected = pd.PeriodIndex([value, pi[1], value])
         result = pi.where(cond, value)
@@ -905,11 +602,6 @@ def test_fillna_float64(self, index_or_series, fill_val, fill_dtype):
         assert obj.dtype == np.float64
 
         exp = klass([1.1, fill_val, 3.3, 4.4])
-        # float + complex -> we don't support a complex Index
-        # complex for Series,
-        # object for Index
-        if fill_dtype == np.complex128 and klass == pd.Index:
-            fill_dtype = object
         self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
     @pytest.mark.parametrize(
@@ -921,11 +613,12 @@ def test_fillna_float64(self, index_or_series, fill_val, fill_dtype):
             (True, object),
         ],
     )
-    def test_fillna_series_complex128(self, fill_val, fill_dtype):
-        obj = pd.Series([1 + 1j, np.nan, 3 + 3j, 4 + 4j])
+    def test_fillna_complex128(self, index_or_series, fill_val, fill_dtype):
+        klass = index_or_series
+        obj = klass([1 + 1j, np.nan, 3 + 3j, 4 + 4j], dtype=np.complex128)
         assert obj.dtype == np.complex128
 
-        exp = pd.Series([1 + 1j, fill_val, 3 + 3j, 4 + 4j])
+        exp = klass([1 + 1j, fill_val, 3 + 3j, 4 + 4j])
         self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
     @pytest.mark.parametrize(
@@ -1001,6 +694,30 @@ def test_fillna_datetime64tz(self, index_or_series, fill_val, fill_dtype):
         with tm.assert_produces_warning(warn, match="mismatched timezone"):
             self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
+    @pytest.mark.parametrize(
+        "fill_val",
+        [
+            1,
+            1.1,
+            1 + 1j,
+            True,
+            pd.Interval(1, 2, closed="left"),
+            pd.Timestamp("2012-01-01", tz="US/Eastern"),
+            pd.Timestamp("2012-01-01"),
+            pd.Timedelta(days=1),
+            pd.Period("2016-01-01", "D"),
+        ],
+    )
+    def test_fillna_interval(self, index_or_series, fill_val):
+        ii = pd.interval_range(1.0, 5.0, closed="right").insert(1, np.nan)
+        assert isinstance(ii.dtype, pd.IntervalDtype)
+        obj = index_or_series(ii)
+
+        exp = index_or_series([ii[0], fill_val, ii[2], ii[3], ii[4]], dtype=object)
+
+        fill_dtype = object
+        self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
+
     @pytest.mark.xfail(reason="Test not implemented")
     def test_fillna_series_int64(self):
         raise NotImplementedError
@@ -1021,9 +738,30 @@ def test_fillna_index_bool(self):
     def test_fillna_series_timedelta64(self):
         raise NotImplementedError
 
-    @pytest.mark.xfail(reason="Test not implemented")
-    def test_fillna_series_period(self):
-        raise NotImplementedError
+    @pytest.mark.parametrize(
+        "fill_val",
+        [
+            1,
+            1.1,
+            1 + 1j,
+            True,
+            pd.Interval(1, 2, closed="left"),
+            pd.Timestamp("2012-01-01", tz="US/Eastern"),
+            pd.Timestamp("2012-01-01"),
+            pd.Timedelta(days=1),
+            pd.Period("2016-01-01", "W"),
+        ],
+    )
+    def test_fillna_series_period(self, index_or_series, fill_val):
+
+        pi = pd.period_range("2016-01-01", periods=4, freq="D").insert(1, pd.NaT)
+        assert isinstance(pi.dtype, pd.PeriodDtype)
+        obj = index_or_series(pi)
+
+        exp = index_or_series([pi[0], fill_val, pi[2], pi[3], pi[4]], dtype=object)
+
+        fill_dtype = object
+        self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
     @pytest.mark.xfail(reason="Test not implemented")
     def test_fillna_index_timedelta64(self):
diff --git a/pandas/tests/indexing/test_datetime.py b/pandas/tests/indexing/test_datetime.py
index 332ab02255911..8d498b59c55d1 100644
--- a/pandas/tests/indexing/test_datetime.py
+++ b/pandas/tests/indexing/test_datetime.py
@@ -10,6 +10,22 @@
 
 
 class TestDatetimeIndex:
+    def test_get_loc_naive_dti_aware_str_deprecated(self):
+        # GH#46903
+        ts = Timestamp("20130101").value
+        dti = pd.DatetimeIndex([ts + 50 + i for i in range(100)])
+        ser = Series(range(100), index=dti)
+
+        key = "2013-01-01 00:00:00.000000050+0000"
+        msg = "Indexing a timezone-naive DatetimeIndex with a timezone-aware datetime"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser[key]
+        assert res == 0
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            loc = dti.get_loc(key)
+        assert loc == 0
+
     def test_indexing_with_datetime_tz(self):
 
         # GH#8260
diff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py
index 902bd943584d9..afc2def7ba8a1 100644
--- a/pandas/tests/indexing/test_floats.py
+++ b/pandas/tests/indexing/test_floats.py
@@ -45,7 +45,6 @@ def check(self, result, original, indexer, getitem):
         "index_func",
         [
             tm.makeStringIndex,
-            tm.makeUnicodeIndex,
             tm.makeCategoricalIndex,
             tm.makeDateIndex,
             tm.makeTimedeltaIndex,
@@ -83,7 +82,6 @@ def test_scalar_non_numeric(self, index_func, frame_or_series, indexer_sl):
         "index_func",
         [
             tm.makeStringIndex,
-            tm.makeUnicodeIndex,
             tm.makeCategoricalIndex,
             tm.makeDateIndex,
             tm.makeTimedeltaIndex,
@@ -220,7 +218,6 @@ def test_scalar_float(self, frame_or_series):
         "index_func",
         [
             tm.makeStringIndex,
-            tm.makeUnicodeIndex,
             tm.makeDateIndex,
             tm.makeTimedeltaIndex,
             tm.makePeriodIndex,
@@ -240,13 +237,13 @@ def test_slice_non_numeric(self, index_func, idx, frame_or_series, indexer_sli):
         if indexer_sli is tm.iloc:
             msg = (
                 "cannot do positional indexing "
-                fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
+                rf"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
                 "type float"
             )
         else:
             msg = (
                 "cannot do slice indexing "
-                fr"on {type(index).__name__} with these indexers "
+                rf"on {type(index).__name__} with these indexers "
                 r"\[(3|4)(\.0)?\] "
                 r"of type (float|int)"
             )
@@ -306,7 +303,7 @@ def test_slice_integer(self):
             # positional indexing
             msg = (
                 "cannot do slice indexing "
-                fr"on {type(index).__name__} with these indexers \[-6\.0\] of "
+                rf"on {type(index).__name__} with these indexers \[-6\.0\] of "
                 "type float"
             )
             with pytest.raises(TypeError, match=msg):
@@ -330,7 +327,7 @@ def test_slice_integer(self):
                 # positional indexing
                 msg = (
                     "cannot do slice indexing "
-                    fr"on {type(index).__name__} with these indexers \[(2|3)\.5\] of "
+                    rf"on {type(index).__name__} with these indexers \[(2|3)\.5\] of "
                     "type float"
                 )
                 with pytest.raises(TypeError, match=msg):
@@ -350,7 +347,7 @@ def test_integer_positional_indexing(self, idx):
         klass = RangeIndex
         msg = (
             "cannot do (slice|positional) indexing "
-            fr"on {klass.__name__} with these indexers \[(2|4)\.0\] of "
+            rf"on {klass.__name__} with these indexers \[(2|4)\.0\] of "
             "type float"
         )
         with pytest.raises(TypeError, match=msg):
@@ -376,7 +373,7 @@ def test_slice_integer_frame_getitem(self, index_func):
             # positional indexing
             msg = (
                 "cannot do slice indexing "
-                fr"on {type(index).__name__} with these indexers \[(0|1)\.0\] of "
+                rf"on {type(index).__name__} with these indexers \[(0|1)\.0\] of "
                 "type float"
             )
             with pytest.raises(TypeError, match=msg):
@@ -391,7 +388,7 @@ def test_slice_integer_frame_getitem(self, index_func):
         # positional indexing
         msg = (
             "cannot do slice indexing "
-            fr"on {type(index).__name__} with these indexers \[-10\.0\] of "
+            rf"on {type(index).__name__} with these indexers \[-10\.0\] of "
             "type float"
         )
         with pytest.raises(TypeError, match=msg):
@@ -410,7 +407,7 @@ def test_slice_integer_frame_getitem(self, index_func):
             # positional indexing
             msg = (
                 "cannot do slice indexing "
-                fr"on {type(index).__name__} with these indexers \[0\.5\] of "
+                rf"on {type(index).__name__} with these indexers \[0\.5\] of "
                 "type float"
             )
             with pytest.raises(TypeError, match=msg):
@@ -434,7 +431,7 @@ def test_float_slice_getitem_with_integer_index_raises(self, idx, index_func):
         # positional indexing
         msg = (
             "cannot do slice indexing "
-            fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
+            rf"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
             "type float"
         )
         with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/indexing/test_iat.py b/pandas/tests/indexing/test_iat.py
index f1fe464ca0854..916303884df88 100644
--- a/pandas/tests/indexing/test_iat.py
+++ b/pandas/tests/indexing/test_iat.py
@@ -29,3 +29,21 @@ def test_iat_getitem_series_with_period_index():
     expected = ser[index[0]]
     result = ser.iat[0]
     assert expected == result
+
+
+def test_iat_setitem_item_cache_cleared(indexer_ial, using_copy_on_write):
+    # GH#45684
+    data = {"x": np.arange(8, dtype=np.int64), "y": np.int64(0)}
+    df = DataFrame(data).copy()
+    ser = df["y"]
+
+    # previously this iat setting would split the block and fail to clear
+    #  the item_cache.
+    indexer_ial(df)[7, 0] = 9999
+
+    indexer_ial(df)[7, 1] = 1234
+
+    assert df.iat[7, 1] == 1234
+    if not using_copy_on_write:
+        assert ser.iloc[-1] == 1234
+    assert df.iloc[-1, -1] == 1234
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index ee9d276925d41..dcc95d9e41a5a 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -10,6 +10,7 @@
 import numpy as np
 import pytest
 
+from pandas.errors import IndexingError
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -21,14 +22,16 @@
     Interval,
     NaT,
     Series,
+    Timestamp,
     array,
     concat,
     date_range,
+    interval_range,
     isna,
+    to_datetime,
 )
 import pandas._testing as tm
 from pandas.api.types import is_scalar
-from pandas.core.indexing import IndexingError
 from pandas.tests.indexing.common import Base
 
 # We pass through the error message from numpy
@@ -77,13 +80,16 @@ def test_iloc_setitem_fullcol_categorical(self, indexer, key, using_array_manage
 
         df = frame.copy()
         orig_vals = df.values
-        indexer(df)[key, 0] = cat
 
         overwrite = isinstance(key, slice) and key == slice(None)
-
-        if overwrite or using_array_manager:
-            # TODO(ArrayManager) we always overwrite because ArrayManager takes
-            #  the "split" path, which still overwrites
+        warn = None
+        if overwrite:
+            warn = DeprecationWarning
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(warn, match=msg):
+            indexer(df)[key, 0] = cat
+
+        if overwrite:
             # TODO: GH#39986 this probably shouldn't behave differently
             expected = DataFrame({0: cat})
             assert not np.shares_memory(df.values, orig_vals)
@@ -102,21 +108,22 @@ def test_iloc_setitem_fullcol_categorical(self, indexer, key, using_array_manage
         frame = DataFrame({0: np.array([0, 1, 2], dtype=object), 1: range(3)})
         df = frame.copy()
         orig_vals = df.values
-        indexer(df)[key, 0] = cat
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            indexer(df)[key, 0] = cat
         expected = DataFrame({0: cat, 1: range(3)})
         tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize("box", [array, Series])
-    def test_iloc_setitem_ea_inplace(self, frame_or_series, box, using_array_manager):
+    def test_iloc_setitem_ea_inplace(self, frame_or_series, box):
         # GH#38952 Case with not setting a full column
         #  IntegerArray without NAs
         arr = array([1, 2, 3, 4])
         obj = frame_or_series(arr.to_numpy("i8"))
 
-        if frame_or_series is Series or not using_array_manager:
+        if frame_or_series is Series:
             values = obj.values
         else:
-            values = obj[0].values
+            values = obj._mgr.arrays[0]
 
         if frame_or_series is Series:
             obj.iloc[:2] = box(arr[2:])
@@ -130,10 +137,7 @@ def test_iloc_setitem_ea_inplace(self, frame_or_series, box, using_array_manager
         if frame_or_series is Series:
             assert obj.values is values
         else:
-            if using_array_manager:
-                assert obj[0].values is values
-            else:
-                assert obj.values.base is values.base and values.base is not None
+            assert np.shares_memory(obj[0].values, values)
 
     def test_is_scalar_access(self):
         # GH#32085 index with duplicates doesn't matter for _is_scalar_access
@@ -747,7 +751,7 @@ def test_iloc_mask(self):
 
         # the possibilities
         locs = np.arange(4)
-        nums = 2 ** locs
+        nums = 2**locs
         reps = [bin(num) for num in nums]
         df = DataFrame({"locs": locs, "nums": nums}, reps)
 
@@ -839,7 +843,9 @@ def test_iloc_empty_list_indexer_is_ok(self):
             df.iloc[[]], df.iloc[:0, :], check_index_type=True, check_column_type=True
         )
 
-    def test_identity_slice_returns_new_object(self, using_array_manager, request):
+    def test_identity_slice_returns_new_object(
+        self, using_array_manager, using_copy_on_write, request
+    ):
         # GH13873
         if using_array_manager:
             mark = pytest.mark.xfail(
@@ -855,8 +861,12 @@ def test_identity_slice_returns_new_object(self, using_array_manager, request):
         assert np.shares_memory(original_df["a"], sliced_df["a"])
 
         # Setting using .loc[:, "a"] sets inplace so alters both sliced and orig
+        # depending on CoW
         original_df.loc[:, "a"] = [4, 4, 4]
-        assert (sliced_df["a"] == 4).all()
+        if using_copy_on_write:
+            assert (sliced_df["a"] == [1, 2, 3]).all()
+        else:
+            assert (sliced_df["a"] == 4).all()
 
         original_series = Series([1, 2, 3, 4, 5, 6])
         sliced_series = original_series.iloc[:]
@@ -864,7 +874,11 @@ def test_identity_slice_returns_new_object(self, using_array_manager, request):
 
         # should also be a shallow copy
         original_series[:3] = [7, 8, 9]
-        assert all(sliced_series[:3] == [7, 8, 9])
+        if using_copy_on_write:
+            # shallow copy not updated (CoW)
+            assert all(sliced_series[:3] == [1, 2, 3])
+        else:
+            assert all(sliced_series[:3] == [7, 8, 9])
 
     def test_indexing_zerodim_np_array(self):
         # GH24919
@@ -879,16 +893,26 @@ def test_series_indexing_zerodim_np_array(self):
         result = s.iloc[np.array(0)]
         assert result == 1
 
-    @pytest.mark.xfail(reason="https://github.com/pandas-dev/pandas/issues/33457")
-    def test_iloc_setitem_categorical_updates_inplace(self):
+    @td.skip_array_manager_not_yet_implemented
+    def test_iloc_setitem_categorical_updates_inplace(self, using_copy_on_write):
         # Mixed dtype ensures we go through take_split_path in setitem_with_indexer
         cat = Categorical(["A", "B", "C"])
-        df = DataFrame({1: cat, 2: [1, 2, 3]})
+        cat_original = cat.copy()
+        df = DataFrame({1: cat, 2: [1, 2, 3]}, copy=False)
+
+        assert tm.shares_memory(df[1], cat)
 
         # This should modify our original values in-place
-        df.iloc[:, 0] = cat[::-1]
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 0] = cat[::-1]
+
+        if not using_copy_on_write:
+            assert tm.shares_memory(df[1], cat)
+            expected = Categorical(["C", "B", "A"], categories=["A", "B", "C"])
+        else:
+            expected = cat_original
 
-        expected = Categorical(["C", "B", "A"])
         tm.assert_categorical_equal(cat, expected)
 
     def test_iloc_with_boolean_operation(self):
@@ -998,9 +1022,6 @@ def test_iloc_getitem_readonly_key(self):
         expected = df["data"].loc[[1, 3, 6]]
         tm.assert_series_equal(result, expected)
 
-    # TODO(ArrayManager) setting single item with an iterable doesn't work yet
-    # in the "split" path
-    @td.skip_array_manager_not_yet_implemented
     def test_iloc_assign_series_to_df_cell(self):
         # GH 37593
         df = DataFrame(columns=["a"], index=[0])
@@ -1076,7 +1097,7 @@ def test_iloc_getitem_float_duplicates(self):
     def test_iloc_setitem_custom_object(self):
         # iloc with an object
         class TO:
-            def __init__(self, value):
+            def __init__(self, value) -> None:
                 self.value = value
 
             def __str__(self) -> str:
@@ -1177,6 +1198,38 @@ def test_iloc_setitem_2d_ndarray_into_ea_block(self):
         expected = DataFrame({"status": ["a", "a", "c"]}, dtype=df["status"].dtype)
         tm.assert_frame_equal(df, expected)
 
+    @td.skip_array_manager_not_yet_implemented
+    def test_iloc_getitem_int_single_ea_block_view(self):
+        # GH#45241
+        # TODO: make an extension interface test for this?
+        arr = interval_range(1, 10.0)._values
+        df = DataFrame(arr)
+
+        # ser should be a *view* on the DataFrame data
+        ser = df.iloc[2]
+
+        # if we have a view, then changing arr[2] should also change ser[0]
+        assert arr[2] != arr[-1]  # otherwise the rest isn't meaningful
+        arr[2] = arr[-1]
+        assert ser[0] == arr[-1]
+
+    def test_iloc_setitem_multicolumn_to_datetime(self, using_array_manager):
+
+        # GH#20511
+        df = DataFrame({"A": ["2022-01-01", "2022-01-02"], "B": ["2021", "2022"]})
+
+        df.iloc[:, [0]] = DataFrame({"A": to_datetime(["2021", "2022"])})
+        expected = DataFrame(
+            {
+                "A": [
+                    Timestamp("2021-01-01 00:00:00"),
+                    Timestamp("2022-01-01 00:00:00"),
+                ],
+                "B": ["2021", "2022"],
+            }
+        )
+        tm.assert_frame_equal(df, expected, check_dtype=using_array_manager)
+
 
 class TestILocErrors:
     # NB: this test should work for _any_ Series we can pass as
@@ -1208,8 +1261,6 @@ def test_iloc_getitem_setitem_fancy_exceptions(self, float_frame):
             # GH#32257 we let numpy do validation, get their exception
             float_frame.iloc[:, :, :] = 1
 
-    # TODO(ArrayManager) "split" path doesn't properly implement DataFrame indexer
-    @td.skip_array_manager_not_yet_implemented
     def test_iloc_frame_indexer(self):
         # GH#39004
         df = DataFrame({"a": [1, 2, 3]})
@@ -1262,7 +1313,10 @@ def test_iloc_setitem_dtypes_duplicate_columns(
     ):
         # GH#22035
         df = DataFrame([[init_value, "str", "str2"]], columns=["a", "b", "b"])
-        df.iloc[:, 0] = df.iloc[:, 0].astype(dtypes)
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 0] = df.iloc[:, 0].astype(dtypes)
+
         expected_df = DataFrame(
             [[expected_value, "str", "str2"]], columns=["a", "b", "b"]
         )
@@ -1356,8 +1410,9 @@ def test_frame_iloc_setitem_callable(self):
 
 
 class TestILocSeries:
-    def test_iloc(self):
+    def test_iloc(self, using_copy_on_write):
         ser = Series(np.random.randn(10), index=list(range(0, 20, 2)))
+        ser_original = ser.copy()
 
         for i in range(len(ser)):
             result = ser.iloc[i]
@@ -1370,8 +1425,13 @@ def test_iloc(self):
         tm.assert_series_equal(result, expected)
 
         # test slice is a view
-        result[:] = 0
-        assert (ser[1:3] == 0).all()
+        with tm.assert_produces_warning(None):
+            # GH#45324 make sure we aren't giving a spurious FutureWarning
+            result[:] = 0
+        if using_copy_on_write:
+            tm.assert_series_equal(ser, ser_original)
+        else:
+            assert (ser.iloc[1:3] == 0).all()
 
         # list of integers
         result = ser.iloc[[0, 2, 3, 4, 5]]
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index 36176bb8194d4..210c75b075011 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -1,5 +1,6 @@
 """ test fancy indexing & misc """
 
+import array
 from datetime import datetime
 import re
 import weakref
@@ -7,7 +8,7 @@
 import numpy as np
 import pytest
 
-import pandas.util._test_decorators as td
+from pandas.errors import IndexingError
 
 from pandas.core.dtypes.common import (
     is_float_dtype,
@@ -68,7 +69,8 @@ def test_setitem_ndarray_1d_2(self):
 
         msg = "Must have equal len keys and value when setting with an iterable"
         with pytest.raises(ValueError, match=msg):
-            df[2:5] = np.arange(1, 4) * 1j
+            with tm.assert_produces_warning(FutureWarning, match="label-based"):
+                df[2:5] = np.arange(1, 4) * 1j
 
     def test_getitem_ndarray_3d(
         self, index, frame_or_series, indexer_sli, using_array_manager
@@ -503,9 +505,6 @@ def test_multi_assign_broadcasting_rhs(self):
         df.loc[df["A"] == 0, ["A", "B"]] = df["D"]
         tm.assert_frame_equal(df, expected)
 
-    # TODO(ArrayManager) setting single item with an iterable doesn't work yet
-    # in the "split" path
-    @td.skip_array_manager_not_yet_implemented
     def test_setitem_list(self):
 
         # GH 6043
@@ -550,14 +549,17 @@ def test_astype_assignment(self):
         )
 
         df = df_orig.copy()
-        df.iloc[:, 0:2] = df.iloc[:, 0:2].astype(np.int64)
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 0:2] = df.iloc[:, 0:2].astype(np.int64)
         expected = DataFrame(
             [[1, 2, "3", ".4", 5, 6.0, "foo"]], columns=list("ABCDEFG")
         )
         tm.assert_frame_equal(df, expected)
 
         df = df_orig.copy()
-        df.iloc[:, 0:2] = df.iloc[:, 0:2]._convert(datetime=True, numeric=True)
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 0:2] = df.iloc[:, 0:2]._convert(datetime=True, numeric=True)
         expected = DataFrame(
             [[1, 2, "3", ".4", 5, 6.0, "foo"]], columns=list("ABCDEFG")
         )
@@ -565,14 +567,16 @@ def test_astype_assignment(self):
 
         # GH5702 (loc)
         df = df_orig.copy()
-        df.loc[:, "A"] = df.loc[:, "A"].astype(np.int64)
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, "A"] = df.loc[:, "A"].astype(np.int64)
         expected = DataFrame(
             [[1, "2", "3", ".4", 5, 6.0, "foo"]], columns=list("ABCDEFG")
         )
         tm.assert_frame_equal(df, expected)
 
         df = df_orig.copy()
-        df.loc[:, ["B", "C"]] = df.loc[:, ["B", "C"]].astype(np.int64)
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, ["B", "C"]] = df.loc[:, ["B", "C"]].astype(np.int64)
         expected = DataFrame(
             [["1", 2, 3, ".4", 5, 6.0, "foo"]], columns=list("ABCDEFG")
         )
@@ -581,12 +585,15 @@ def test_astype_assignment(self):
     def test_astype_assignment_full_replacements(self):
         # full replacements / no nans
         df = DataFrame({"A": [1.0, 2.0, 3.0, 4.0]})
-        df.iloc[:, 0] = df["A"].astype(np.int64)
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.iloc[:, 0] = df["A"].astype(np.int64)
         expected = DataFrame({"A": [1, 2, 3, 4]})
         tm.assert_frame_equal(df, expected)
 
         df = DataFrame({"A": [1.0, 2.0, 3.0, 4.0]})
-        df.loc[:, "A"] = df["A"].astype(np.int64)
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, "A"] = df["A"].astype(np.int64)
         expected = DataFrame({"A": [1, 2, 3, 4]})
         tm.assert_frame_equal(df, expected)
 
@@ -704,20 +711,20 @@ def run_tests(df, rhs, right_loc, right_iloc):
         right_iloc["jolie"] = ["@2", -26.0, -18.0, -10.0, "@18"]
         run_tests(df, rhs, right_loc, right_iloc)
 
-    def test_str_label_slicing_with_negative_step(self):
+    @pytest.mark.parametrize(
+        "idx", [_mklbl("A", 20), np.arange(20) + 100, np.linspace(100, 150, 20)]
+    )
+    def test_str_label_slicing_with_negative_step(self, idx):
         SLC = pd.IndexSlice
 
-        for idx in [_mklbl("A", 20), np.arange(20) + 100, np.linspace(100, 150, 20)]:
-            idx = Index(idx)
-            ser = Series(np.arange(20), index=idx)
-            tm.assert_indexing_slices_equivalent(ser, SLC[idx[9] :: -1], SLC[9::-1])
-            tm.assert_indexing_slices_equivalent(ser, SLC[: idx[9] : -1], SLC[:8:-1])
-            tm.assert_indexing_slices_equivalent(
-                ser, SLC[idx[13] : idx[9] : -1], SLC[13:8:-1]
-            )
-            tm.assert_indexing_slices_equivalent(
-                ser, SLC[idx[9] : idx[13] : -1], SLC[:0]
-            )
+        idx = Index(idx)
+        ser = Series(np.arange(20), index=idx)
+        tm.assert_indexing_slices_equivalent(ser, SLC[idx[9] :: -1], SLC[9::-1])
+        tm.assert_indexing_slices_equivalent(ser, SLC[: idx[9] : -1], SLC[:8:-1])
+        tm.assert_indexing_slices_equivalent(
+            ser, SLC[idx[13] : idx[9] : -1], SLC[13:8:-1]
+        )
+        tm.assert_indexing_slices_equivalent(ser, SLC[idx[9] : idx[13] : -1], SLC[:0])
 
     def test_slice_with_zero_step_raises(self, index, indexer_sl, frame_or_series):
         obj = frame_or_series(np.arange(len(index)), index=index)
@@ -985,3 +992,123 @@ def test_extension_array_cross_section_converts():
 
     result = df.iloc[0]
     tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, keys",
+    [(Series([10]), (0, 0)), (Series([1, 2, 3], index=list("abc")), (0, 1))],
+)
+def test_ser_tup_indexer_exceeds_dimensions(ser, keys, indexer_li):
+    # GH#13831
+    exp_err, exp_msg = IndexingError, "Too many indexers"
+    with pytest.raises(exp_err, match=exp_msg):
+        indexer_li(ser)[keys]
+
+    if indexer_li == tm.iloc:
+        # For iloc.__setitem__ we let numpy handle the error reporting.
+        exp_err, exp_msg = IndexError, "too many indices for array"
+
+    with pytest.raises(exp_err, match=exp_msg):
+        indexer_li(ser)[keys] = 0
+
+
+def test_ser_list_indexer_exceeds_dimensions(indexer_li):
+    # GH#13831
+    # Make sure an exception is raised when a tuple exceeds the dimension of the series,
+    # but not list when a list is used.
+    ser = Series([10])
+    res = indexer_li(ser)[[0, 0]]
+    exp = Series([10, 10], index=Index([0, 0]))
+    tm.assert_series_equal(res, exp)
+
+
+@pytest.mark.parametrize(
+    "value", [(0, 1), [0, 1], np.array([0, 1]), array.array("b", [0, 1])]
+)
+def test_scalar_setitem_with_nested_value(value):
+    # For numeric data, we try to unpack and thus raise for mismatching length
+    df = DataFrame({"A": [1, 2, 3]})
+    msg = "|".join(
+        [
+            "Must have equal len keys and value",
+            "setting an array element with a sequence",
+        ]
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.loc[0, "B"] = value
+
+    # TODO For object dtype this happens as well, but should we rather preserve
+    # the nested data and set as such?
+    df = DataFrame({"A": [1, 2, 3], "B": np.array([1, "a", "b"], dtype=object)})
+    with pytest.raises(ValueError, match="Must have equal len keys and value"):
+        df.loc[0, "B"] = value
+    # if isinstance(value, np.ndarray):
+    #     assert (df.loc[0, "B"] == value).all()
+    # else:
+    #     assert df.loc[0, "B"] == value
+
+
+@pytest.mark.parametrize(
+    "value", [(0, 1), [0, 1], np.array([0, 1]), array.array("b", [0, 1])]
+)
+def test_scalar_setitem_series_with_nested_value(value, indexer_sli):
+    # For numeric data, we try to unpack and thus raise for mismatching length
+    ser = Series([1, 2, 3])
+    with pytest.raises(ValueError, match="setting an array element with a sequence"):
+        indexer_sli(ser)[0] = value
+
+    # but for object dtype we preserve the nested data and set as such
+    ser = Series([1, "a", "b"], dtype=object)
+    indexer_sli(ser)[0] = value
+    if isinstance(value, np.ndarray):
+        assert (ser.loc[0] == value).all()
+    else:
+        assert ser.loc[0] == value
+
+
+@pytest.mark.parametrize(
+    "value", [(0.0,), [0.0], np.array([0.0]), array.array("d", [0.0])]
+)
+def test_scalar_setitem_with_nested_value_length1(value):
+    # https://github.com/pandas-dev/pandas/issues/46268
+
+    # For numeric data, assigning length-1 array to scalar position gets unpacked
+    df = DataFrame({"A": [1, 2, 3]})
+    df.loc[0, "B"] = value
+    expected = DataFrame({"A": [1, 2, 3], "B": [0.0, np.nan, np.nan]})
+    tm.assert_frame_equal(df, expected)
+
+    # but for object dtype we preserve the nested data
+    df = DataFrame({"A": [1, 2, 3], "B": np.array([1, "a", "b"], dtype=object)})
+    df.loc[0, "B"] = value
+    if isinstance(value, np.ndarray):
+        assert (df.loc[0, "B"] == value).all()
+    else:
+        assert df.loc[0, "B"] == value
+
+
+@pytest.mark.parametrize(
+    "value", [(0.0,), [0.0], np.array([0.0]), array.array("d", [0.0])]
+)
+def test_scalar_setitem_series_with_nested_value_length1(value, indexer_sli):
+    # For numeric data, assigning length-1 array to scalar position gets unpacked
+    # TODO this only happens in case of ndarray, should we make this consistent
+    # for all list-likes? (as happens for DataFrame.(i)loc, see test above)
+    ser = Series([1.0, 2.0, 3.0])
+    if isinstance(value, np.ndarray):
+        indexer_sli(ser)[0] = value
+        expected = Series([0.0, 2.0, 3.0])
+        tm.assert_series_equal(ser, expected)
+    else:
+        with pytest.raises(
+            ValueError, match="setting an array element with a sequence"
+        ):
+            indexer_sli(ser)[0] = value
+
+    # but for object dtype we preserve the nested data
+    ser = Series([1, "a", "b"], dtype=object)
+    indexer_sli(ser)[0] = value
+    if isinstance(value, np.ndarray):
+        assert (ser.loc[0] == value).all()
+    else:
+        assert ser.loc[0] == value
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 63c5091865160..235ad3d213a62 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -12,11 +12,13 @@
 import numpy as np
 import pytest
 
+from pandas.errors import IndexingError
 import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
     Categorical,
+    CategoricalDtype,
     CategoricalIndex,
     DataFrame,
     DatetimeIndex,
@@ -24,6 +26,7 @@
     IndexSlice,
     MultiIndex,
     Period,
+    PeriodIndex,
     Series,
     SparseDtype,
     Timedelta,
@@ -36,13 +39,26 @@
 import pandas._testing as tm
 from pandas.api.types import is_scalar
 from pandas.core.api import Float64Index
-from pandas.core.indexing import (
-    IndexingError,
-    _one_ellipsis_message,
-)
+from pandas.core.indexing import _one_ellipsis_message
 from pandas.tests.indexing.common import Base
 
 
+@pytest.mark.parametrize(
+    "series, new_series, expected_ser",
+    [
+        [[np.nan, np.nan, "b"], ["a", np.nan, np.nan], [False, True, True]],
+        [[np.nan, "b"], ["a", np.nan], [False, True]],
+    ],
+)
+def test_not_change_nan_loc(series, new_series, expected_ser):
+    # GH 28403
+    df = DataFrame({"A": series})
+    df.loc[:, "A"] = new_series
+    expected = DataFrame({"A": expected_ser})
+    tm.assert_frame_equal(df.isna(), expected)
+    tm.assert_frame_equal(df.notna(), ~expected)
+
+
 class TestLoc(Base):
     def test_loc_getitem_int(self):
 
@@ -54,42 +70,45 @@ def test_loc_getitem_label(self):
         # label
         self.check_result("loc", "c", typs=["empty"], fails=KeyError)
 
-    def test_loc_getitem_label_out_of_range(self):
+    @pytest.mark.parametrize(
+        "key, typs, axes",
+        [
+            ["f", ["ints", "uints", "labels", "mixed", "ts"], None],
+            ["f", ["floats"], None],
+            [20, ["ints", "uints", "mixed"], None],
+            [20, ["labels"], None],
+            [20, ["ts"], 0],
+            [20, ["floats"], 0],
+        ],
+    )
+    def test_loc_getitem_label_out_of_range(self, key, typs, axes):
 
         # out of range label
-        self.check_result(
-            "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError
-        )
-        self.check_result("loc", "f", typs=["floats"], fails=KeyError)
-        self.check_result("loc", "f", typs=["floats"], fails=KeyError)
-        self.check_result("loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError)
-        self.check_result("loc", 20, typs=["labels"], fails=KeyError)
-        self.check_result("loc", 20, typs=["ts"], axes=0, fails=KeyError)
-        self.check_result("loc", 20, typs=["floats"], axes=0, fails=KeyError)
+        self.check_result("loc", key, typs=typs, axes=axes, fails=KeyError)
 
-    def test_loc_getitem_label_list(self):
+    @pytest.mark.parametrize(
+        "key, typs",
+        [
+            [[0, 1, 2], ["ints", "uints", "floats"]],
+            [[1, 3.0, "A"], ["ints", "uints", "floats"]],
+        ],
+    )
+    def test_loc_getitem_label_list(self, key, typs):
         # list of labels
-        self.check_result(
-            "loc", [0, 1, 2], typs=["ints", "uints", "floats"], fails=KeyError
-        )
-        self.check_result(
-            "loc", [1, 3.0, "A"], typs=["ints", "uints", "floats"], fails=KeyError
-        )
+        self.check_result("loc", key, typs=typs, fails=KeyError)
 
-    def test_loc_getitem_label_list_with_missing(self):
-        self.check_result("loc", [0, 1, 2], typs=["empty"], fails=KeyError)
-        self.check_result(
-            "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError
-        )
-
-        self.check_result(
-            "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError
-        )
-
-        # GH 17758 - MultiIndex and missing keys
-        self.check_result(
-            "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError
-        )
+    @pytest.mark.parametrize(
+        "key, typs, axes",
+        [
+            [[0, 1, 2], ["empty"], None],
+            [[0, 2, 10], ["ints", "uints", "floats"], 0],
+            [[3, 6, 7], ["ints", "uints", "floats"], 1],
+            # GH 17758 - MultiIndex and missing keys
+            [[(1, 3), (1, 4), (2, 5)], ["multi"], 0],
+        ],
+    )
+    def test_loc_getitem_label_list_with_missing(self, key, typs, axes):
+        self.check_result("loc", key, typs=typs, axes=axes, fails=KeyError)
 
     def test_loc_getitem_label_list_fails(self):
         # fails
@@ -108,7 +127,22 @@ def test_loc_getitem_bool(self):
 
         self.check_result("loc", b, typs=["empty"], fails=IndexError)
 
-    def test_loc_getitem_label_slice(self):
+    @pytest.mark.parametrize(
+        "slc, typs, axes, fails",
+        [
+            [
+                slice(1, 3),
+                ["labels", "mixed", "empty", "ts", "floats"],
+                None,
+                TypeError,
+            ],
+            [slice("20130102", "20130104"), ["ts"], 1, TypeError],
+            [slice(2, 8), ["mixed"], 0, TypeError],
+            [slice(2, 8), ["mixed"], 1, KeyError],
+            [slice(2, 4, 2), ["mixed"], 0, TypeError],
+        ],
+    )
+    def test_loc_getitem_label_slice(self, slc, typs, axes, fails):
 
         # label slices (with ints)
 
@@ -118,20 +152,10 @@ def test_loc_getitem_label_slice(self):
 
         self.check_result(
             "loc",
-            slice(1, 3),
-            typs=["labels", "mixed", "empty", "ts", "floats"],
-            fails=TypeError,
-        )
-
-        self.check_result(
-            "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError
-        )
-
-        self.check_result("loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError)
-        self.check_result("loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError)
-
-        self.check_result(
-            "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError
+            slc,
+            typs=typs,
+            axes=axes,
+            fails=fails,
         )
 
     def test_setitem_from_duplicate_axis(self):
@@ -201,6 +225,13 @@ def test_loc_getitem_single_boolean_arg(self, obj, key, exp):
 
 class TestLocBaseIndependent:
     # Tests for loc that do not depend on subclassing Base
+    def test_loc_npstr(self):
+        # GH#45580
+        df = DataFrame(index=date_range("2021", "2022"))
+        result = df.loc[np.array(["2021/6/1"])[0] :]
+        expected = df.iloc[151:]
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize(
         "msg, key",
         [
@@ -336,7 +367,9 @@ def test_loc_setitem_dtype(self):
         # GH31340
         df = DataFrame({"id": ["A"], "a": [1.2], "b": [0.0], "c": [-2.5]})
         cols = ["a", "b", "c"]
-        df.loc[:, cols] = df.loc[:, cols].astype("float32")
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, cols] = df.loc[:, cols].astype("float32")
 
         expected = DataFrame(
             {
@@ -567,7 +600,8 @@ def test_loc_setitem_consistency_empty(self):
         expected = DataFrame(columns=["x", "y"])
         expected["x"] = expected["x"].astype(np.int64)
         df = DataFrame(columns=["x", "y"])
-        df.loc[:, "x"] = 1
+        with tm.assert_produces_warning(None):
+            df.loc[:, "x"] = 1
         tm.assert_frame_equal(df, expected)
 
         df = DataFrame(columns=["x", "y"])
@@ -598,20 +632,29 @@ def test_loc_setitem_consistency_slice_column_len(self):
         ]
         df = DataFrame(values, index=mi, columns=cols)
 
-        df.loc[:, ("Respondent", "StartDate")] = to_datetime(
-            df.loc[:, ("Respondent", "StartDate")]
-        )
-        df.loc[:, ("Respondent", "EndDate")] = to_datetime(
-            df.loc[:, ("Respondent", "EndDate")]
-        )
-        df.loc[:, ("Respondent", "Duration")] = (
-            df.loc[:, ("Respondent", "EndDate")]
-            - df.loc[:, ("Respondent", "StartDate")]
-        )
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, ("Respondent", "StartDate")] = to_datetime(
+                df.loc[:, ("Respondent", "StartDate")]
+            )
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, ("Respondent", "EndDate")] = to_datetime(
+                df.loc[:, ("Respondent", "EndDate")]
+            )
+        with tm.assert_produces_warning(None, match=msg):
+            # Adding a new key -> no warning
+            df.loc[:, ("Respondent", "Duration")] = (
+                df.loc[:, ("Respondent", "EndDate")]
+                - df.loc[:, ("Respondent", "StartDate")]
+            )
+
+        with tm.assert_produces_warning(None, match=msg):
+            # timedelta64[s] -> float64, so this cannot be done inplace, so
+            #  no warning
+            df.loc[:, ("Respondent", "Duration")] = df.loc[
+                :, ("Respondent", "Duration")
+            ].astype("timedelta64[s]")
 
-        df.loc[:, ("Respondent", "Duration")] = df.loc[
-            :, ("Respondent", "Duration")
-        ].astype("timedelta64[s]")
         expected = Series(
             [1380, 720, 840, 2160.0], index=df.index, name=("Respondent", "Duration")
         )
@@ -661,7 +704,7 @@ def test_loc_modify_datetime(self):
 
         tm.assert_frame_equal(df, expected)
 
-    def test_loc_setitem_frame_with_reindex(self, using_array_manager):
+    def test_loc_setitem_frame_with_reindex(self):
         # GH#6254 setting issue
         df = DataFrame(index=[3, 5, 4], columns=["A"], dtype=float)
         df.loc[[4, 3, 5], "A"] = np.array([1, 2, 3], dtype="int64")
@@ -669,10 +712,6 @@ def test_loc_setitem_frame_with_reindex(self, using_array_manager):
         # setting integer values into a float dataframe with loc is inplace,
         #  so we retain float dtype
         ser = Series([2, 3, 1], index=[3, 5, 4], dtype=float)
-        if using_array_manager:
-            # TODO(ArrayManager) with "split" path, we still overwrite the column
-            # and therefore don't take the dtype of the underlying object into account
-            ser = Series([2, 3, 1], index=[3, 5, 4], dtype="int64")
         expected = DataFrame({"A": ser})
         tm.assert_frame_equal(df, expected)
 
@@ -680,7 +719,9 @@ def test_loc_setitem_frame_with_reindex_mixed(self):
         # GH#40480
         df = DataFrame(index=[3, 5, 4], columns=["A", "B"], dtype=float)
         df["B"] = "string"
-        df.loc[[4, 3, 5], "A"] = np.array([1, 2, 3], dtype="int64")
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[[4, 3, 5], "A"] = np.array([1, 2, 3], dtype="int64")
         ser = Series([2, 3, 1], index=[3, 5, 4], dtype="int64")
         expected = DataFrame({"A": ser})
         expected["B"] = "string"
@@ -690,13 +731,12 @@ def test_loc_setitem_frame_with_inverted_slice(self):
         # GH#40480
         df = DataFrame(index=[1, 2, 3], columns=["A", "B"], dtype=float)
         df["B"] = "string"
-        df.loc[slice(3, 0, -1), "A"] = np.array([1, 2, 3], dtype="int64")
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[slice(3, 0, -1), "A"] = np.array([1, 2, 3], dtype="int64")
         expected = DataFrame({"A": [3, 2, 1], "B": "string"}, index=[1, 2, 3])
         tm.assert_frame_equal(df, expected)
 
-    # TODO(ArrayManager) "split" path overwrites column and therefore don't take
-    # the dtype of the underlying object into account
-    @td.skip_array_manager_not_yet_implemented
     def test_loc_setitem_empty_frame(self):
         # GH#6252 setting with an empty frame
         keys1 = ["@" + str(i) for i in range(5)]
@@ -866,7 +906,14 @@ def test_loc_setitem_with_scalar_index(self, indexer, value):
     def test_loc_setitem_missing_columns(self, index, box, expected):
         # GH 29334
         df = DataFrame([[1, 2], [3, 4], [5, 6]], columns=["A", "B"])
-        df.loc[index] = box
+
+        warn = None
+        if isinstance(index[0], slice) and index[0] == slice(None):
+            warn = DeprecationWarning
+
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(warn, match=msg):
+            df.loc[index] = box
         tm.assert_frame_equal(df, expected)
 
     def test_loc_coercion(self):
@@ -956,55 +1003,40 @@ def test_loc_non_unique(self):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.arm_slow
-    def test_loc_non_unique_memory_error(self):
+    @pytest.mark.parametrize("length, l2", [[900, 100], [900000, 100000]])
+    def test_loc_non_unique_memory_error(self, length, l2):
 
         # GH 4280
         # non_unique index with a large selection triggers a memory error
 
         columns = list("ABCDEFG")
 
-        def gen_test(length, l2):
-            return pd.concat(
-                [
-                    DataFrame(
-                        np.random.randn(length, len(columns)),
-                        index=np.arange(length),
-                        columns=columns,
-                    ),
-                    DataFrame(
-                        np.ones((l2, len(columns))), index=[0] * l2, columns=columns
-                    ),
-                ]
-            )
-
-        def gen_expected(df, mask):
-            len_mask = len(mask)
-            return pd.concat(
-                [
-                    df.take([0]),
-                    DataFrame(
-                        np.ones((len_mask, len(columns))),
-                        index=[0] * len_mask,
-                        columns=columns,
-                    ),
-                    df.take(mask[1:]),
-                ]
-            )
-
-        df = gen_test(900, 100)
-        assert df.index.is_unique is False
-
-        mask = np.arange(100)
-        result = df.loc[mask]
-        expected = gen_expected(df, mask)
-        tm.assert_frame_equal(result, expected)
+        df = pd.concat(
+            [
+                DataFrame(
+                    np.random.randn(length, len(columns)),
+                    index=np.arange(length),
+                    columns=columns,
+                ),
+                DataFrame(np.ones((l2, len(columns))), index=[0] * l2, columns=columns),
+            ]
+        )
 
-        df = gen_test(900000, 100000)
         assert df.index.is_unique is False
 
-        mask = np.arange(100000)
+        mask = np.arange(l2)
         result = df.loc[mask]
-        expected = gen_expected(df, mask)
+        expected = pd.concat(
+            [
+                df.take([0]),
+                DataFrame(
+                    np.ones((len(mask), len(columns))),
+                    index=[0] * len(mask),
+                    columns=columns,
+                ),
+                df.take(mask[1:]),
+            ]
+        )
         tm.assert_frame_equal(result, expected)
 
     def test_loc_name(self):
@@ -1033,7 +1065,9 @@ def test_loc_empty_list_indexer_is_ok(self):
             df.loc[[]], df.iloc[:0, :], check_index_type=True, check_column_type=True
         )
 
-    def test_identity_slice_returns_new_object(self, using_array_manager, request):
+    def test_identity_slice_returns_new_object(
+        self, using_array_manager, request, using_copy_on_write
+    ):
         # GH13873
         if using_array_manager:
             mark = pytest.mark.xfail(
@@ -1050,8 +1084,12 @@ def test_identity_slice_returns_new_object(self, using_array_manager, request):
         assert np.shares_memory(original_df["a"]._values, sliced_df["a"]._values)
 
         # Setting using .loc[:, "a"] sets inplace so alters both sliced and orig
+        # depending on CoW
         original_df.loc[:, "a"] = [4, 4, 4]
-        assert (sliced_df["a"] == 4).all()
+        if using_copy_on_write:
+            assert (sliced_df["a"] == [1, 2, 3]).all()
+        else:
+            assert (sliced_df["a"] == 4).all()
 
         # These should not return copies
         assert original_df is original_df.loc[:, :]
@@ -1065,7 +1103,10 @@ def test_identity_slice_returns_new_object(self, using_array_manager, request):
         assert original_series[:] is not original_series
 
         original_series[:3] = [7, 8, 9]
-        assert all(sliced_series[:3] == [7, 8, 9])
+        if using_copy_on_write:
+            assert all(sliced_series[:3] == [1, 2, 3])
+        else:
+            assert all(sliced_series[:3] == [7, 8, 9])
 
     @pytest.mark.xfail(reason="accidental fix reverted - GH37497")
     def test_loc_copy_vs_view(self):
@@ -1114,6 +1155,8 @@ def test_loc_uint64_disallow_negative(self):
             # don't wrap around
             ser.loc[[-1]]
 
+    # FIXME: warning issued here is false-positive
+    @pytest.mark.filterwarnings("ignore:.*will attempt to set.*:FutureWarning")
     def test_loc_setitem_empty_append_expands_rows(self):
         # GH6173, various appends to an empty dataframe
 
@@ -1125,6 +1168,8 @@ def test_loc_setitem_empty_append_expands_rows(self):
         df.loc[:, "x"] = data
         tm.assert_frame_equal(df, expected)
 
+    # FIXME: warning issued here is false-positive
+    @pytest.mark.filterwarnings("ignore:.*will attempt to set.*:FutureWarning")
     def test_loc_setitem_empty_append_expands_rows_mixed_dtype(self):
         # GH#37932 same as test_loc_setitem_empty_append_expands_rows
         #  but with mixed dtype so we go through take_split_path
@@ -1232,6 +1277,10 @@ def test_loc_getitem_time_object(self, frame_or_series):
     @pytest.mark.parametrize("spmatrix_t", ["coo_matrix", "csc_matrix", "csr_matrix"])
     @pytest.mark.parametrize("dtype", [np.int64, np.float64, complex])
     @td.skip_if_no_scipy
+    @pytest.mark.filterwarnings(
+        # TODO(2.0): remove filtering; note only needed for using_array_manager
+        "ignore:The behavior of .astype from SparseDtype.*FutureWarning"
+    )
     def test_loc_getitem_range_from_spmatrix(self, spmatrix_t, dtype):
         import scipy.sparse
 
@@ -1291,6 +1340,14 @@ def test_loc_getitem_sparse_series(self):
         expected = Series([1.0, 0.0], dtype=SparseDtype("float64", 0.0))
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize("indexer", ["loc", "iloc"])
+    def test_getitem_single_row_sparse_df(self, indexer):
+        # GH#46406
+        df = DataFrame([[1.0, 0.0, 1.5], [0.0, 2.0, 0.0]], dtype=SparseDtype(float))
+        result = getattr(df, indexer)[0]
+        expected = Series([1.0, 0.0, 1.5], dtype=SparseDtype(float), name=0)
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize("key_type", [iter, np.array, Series, Index])
     def test_loc_getitem_iterable(self, float_frame, key_type):
         idx = key_type(["A", "B", "C"])
@@ -1307,11 +1364,11 @@ def test_loc_getitem_timedelta_0seconds(self):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "val,expected", [(2 ** 63 - 1, Series([1])), (2 ** 63, Series([2]))]
+        "val,expected", [(2**63 - 1, Series([1])), (2**63, Series([2]))]
     )
     def test_loc_getitem_uint64_scalar(self, val, expected):
         # see GH#19399
-        df = DataFrame([1, 2], index=[2 ** 63 - 1, 2 ** 63])
+        df = DataFrame([1, 2], index=[2**63 - 1, 2**63])
         result = df.loc[val]
 
         expected.name = val
@@ -1366,7 +1423,10 @@ def test_loc_setitem_single_row_categorical(self):
         # GH#25495
         df = DataFrame({"Alpha": ["a"], "Numeric": [0]})
         categories = Categorical(df["Alpha"], categories=["a", "b", "c"])
-        df.loc[:, "Alpha"] = categories
+
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, "Alpha"] = categories
 
         result = df["Alpha"]
         expected = Series(categories, index=df.index, name="Alpha")
@@ -1562,6 +1622,19 @@ def test_loc_setitem_cast3(self):
         df.one = np.int8(7)
         assert df.dtypes.one == np.dtype(np.int8)
 
+    def test_loc_setitem_range_key(self, frame_or_series):
+        # GH#45479 don't treat range key as positional
+        obj = frame_or_series(range(5), index=[3, 4, 1, 0, 2])
+
+        values = [9, 10, 11]
+        if obj.ndim == 2:
+            values = [[9], [10], [11]]
+
+        obj.loc[range(3)] = values
+
+        expected = frame_or_series([0, 1, 10, 9, 11], index=obj.index)
+        tm.assert_equal(obj, expected)
+
 
 class TestLocWithEllipsis:
     @pytest.fixture(params=[tm.loc, tm.iloc])
@@ -1764,6 +1837,54 @@ def test_loc_getitem_sorted_index_level_with_duplicates(self):
         result = df.loc[("foo", "bar")]
         tm.assert_frame_equal(result, expected)
 
+    def test_additional_element_to_categorical_series_loc(self):
+        # GH#47677
+        result = Series(["a", "b", "c"], dtype="category")
+        result.loc[3] = 0
+        expected = Series(["a", "b", "c", 0], dtype="object")
+        tm.assert_series_equal(result, expected)
+
+    def test_additional_categorical_element_loc(self):
+        # GH#47677
+        result = Series(["a", "b", "c"], dtype="category")
+        result.loc[3] = "a"
+        expected = Series(["a", "b", "c", "a"], dtype="category")
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_set_nan_in_categorical_series(self, any_numeric_ea_dtype):
+        # GH#47677
+        srs = Series(
+            [1, 2, 3],
+            dtype=CategoricalDtype(Index([1, 2, 3], dtype=any_numeric_ea_dtype)),
+        )
+        # enlarge
+        srs.loc[3] = np.nan
+        expected = Series(
+            [1, 2, 3, np.nan],
+            dtype=CategoricalDtype(Index([1, 2, 3], dtype=any_numeric_ea_dtype)),
+        )
+        tm.assert_series_equal(srs, expected)
+        # set into
+        srs.loc[1] = np.nan
+        expected = Series(
+            [1, np.nan, 3, np.nan],
+            dtype=CategoricalDtype(Index([1, 2, 3], dtype=any_numeric_ea_dtype)),
+        )
+        tm.assert_series_equal(srs, expected)
+
+    @pytest.mark.parametrize("na", (np.nan, pd.NA, None, pd.NaT))
+    def test_loc_consistency_series_enlarge_set_into(self, na):
+        # GH#47677
+        srs_enlarge = Series(["a", "b", "c"], dtype="category")
+        srs_enlarge.loc[3] = na
+
+        srs_setinto = Series(["a", "b", "c", "a"], dtype="category")
+        srs_setinto.loc[3] = na
+
+        tm.assert_series_equal(srs_enlarge, srs_setinto)
+        expected = Series(["a", "b", "c", na], dtype="category")
+        tm.assert_series_equal(srs_enlarge, expected)
+
     def test_loc_getitem_preserves_index_level_category_dtype(self):
         # GH#15166
         df = DataFrame(
@@ -1825,9 +1946,9 @@ class TestLocSetitemWithExpansion:
     @pytest.mark.slow
     def test_loc_setitem_with_expansion_large_dataframe(self):
         # GH#10692
-        result = DataFrame({"x": range(10 ** 6)}, dtype="int64")
+        result = DataFrame({"x": range(10**6)}, dtype="int64")
         result.loc[len(result)] = len(result) + 1
-        expected = DataFrame({"x": range(10 ** 6 + 1)}, dtype="int64")
+        expected = DataFrame({"x": range(10**6 + 1)}, dtype="int64")
         tm.assert_frame_equal(result, expected)
 
     def test_loc_setitem_empty_series(self):
@@ -1840,12 +1961,20 @@ def test_loc_setitem_empty_series(self):
         ser.loc[3] = 3
         tm.assert_series_equal(ser, Series([1, 3], index=[1, 3]))
 
+    def test_loc_setitem_empty_series_float(self):
+        # GH#5226
+
+        # partially set with an empty object series
         ser = Series(dtype=object)
         ser.loc[1] = 1.0
         tm.assert_series_equal(ser, Series([1.0], index=[1]))
         ser.loc[3] = 3.0
         tm.assert_series_equal(ser, Series([1.0, 3.0], index=[1, 3]))
 
+    def test_loc_setitem_empty_series_str_idx(self):
+        # GH#5226
+
+        # partially set with an empty object series
         ser = Series(dtype=object)
         ser.loc["foo"] = 1
         tm.assert_series_equal(ser, Series([1], index=["foo"]))
@@ -1864,24 +1993,26 @@ def test_loc_setitem_incremental_with_dst(self):
         expected = Series(1, index=idxs)
         tm.assert_series_equal(result, expected)
 
-    def test_loc_setitem_datetime_keys_cast(self):
-        # GH#9516
-        dt1 = Timestamp("20130101 09:00:00")
-        dt2 = Timestamp("20130101 10:00:00")
-
-        for conv in [
+    @pytest.mark.parametrize(
+        "conv",
+        [
             lambda x: x,
             lambda x: x.to_datetime64(),
             lambda x: x.to_pydatetime(),
             lambda x: np.datetime64(x),
-        ]:
-
-            df = DataFrame()
-            df.loc[conv(dt1), "one"] = 100
-            df.loc[conv(dt2), "one"] = 200
+        ],
+        ids=["self", "to_datetime64", "to_pydatetime", "np.datetime64"],
+    )
+    def test_loc_setitem_datetime_keys_cast(self, conv):
+        # GH#9516
+        dt1 = Timestamp("20130101 09:00:00")
+        dt2 = Timestamp("20130101 10:00:00")
+        df = DataFrame()
+        df.loc[conv(dt1), "one"] = 100
+        df.loc[conv(dt2), "one"] = 200
 
-            expected = DataFrame({"one": [100.0, 200.0]}, index=[dt1, dt2])
-            tm.assert_frame_equal(df, expected)
+        expected = DataFrame({"one": [100.0, 200.0]}, index=[dt1, dt2])
+        tm.assert_frame_equal(df, expected)
 
     def test_loc_setitem_categorical_column_retains_dtype(self, ordered):
         # GH16360
@@ -1943,7 +2074,7 @@ def test_loc_setitem_with_expansion_inf_upcast_empty(self):
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.filterwarnings("ignore:indexing past lexsort depth")
-    def test_loc_setitem_with_expansion_nonunique_index(self, index, request):
+    def test_loc_setitem_with_expansion_nonunique_index(self, index):
         # GH#40096
         if not len(index):
             return
@@ -2443,6 +2574,35 @@ def test_loc_setitem_boolean_and_column(self, float_frame):
 
         tm.assert_frame_equal(float_frame, expected)
 
+    def test_loc_setitem_ndframe_values_alignment(self, using_copy_on_write):
+        # GH#45501
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df.loc[[False, False, True], ["a"]] = DataFrame(
+            {"a": [10, 20, 30]}, index=[2, 1, 0]
+        )
+
+        expected = DataFrame({"a": [1, 2, 10], "b": [4, 5, 6]})
+        tm.assert_frame_equal(df, expected)
+
+        # same thing with Series RHS
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df.loc[[False, False, True], ["a"]] = Series([10, 11, 12], index=[2, 1, 0])
+        tm.assert_frame_equal(df, expected)
+
+        # same thing but setting "a" instead of ["a"]
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df.loc[[False, False, True], "a"] = Series([10, 11, 12], index=[2, 1, 0])
+        tm.assert_frame_equal(df, expected)
+
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df_orig = df.copy()
+        ser = df["a"]
+        ser.loc[[False, False, True]] = Series([10, 11, 12], index=[2, 1, 0])
+        if using_copy_on_write:
+            tm.assert_frame_equal(df, df_orig)
+        else:
+            tm.assert_frame_equal(df, expected)
+
 
 class TestLocListlike:
     @pytest.mark.parametrize("box", [lambda x: x, np.asarray, list])
@@ -2684,6 +2844,18 @@ def test_loc_with_period_index_indexer():
     tm.assert_frame_equal(df, df.loc[list(idx)])
 
 
+def test_loc_setitem_multiindex_timestamp():
+    # GH#13831
+    vals = np.random.randn(8, 6)
+    idx = date_range("1/1/2000", periods=8)
+    cols = ["A", "B", "C", "D", "E", "F"]
+    exp = DataFrame(vals, index=idx, columns=cols)
+    exp.loc[exp.index[1], ("A", "B")] = np.nan
+    vals[1][0:2] = np.nan
+    res = DataFrame(vals, index=idx, columns=cols)
+    tm.assert_frame_equal(res, exp)
+
+
 def test_loc_getitem_multiindex_tuple_level():
     # GH#27591
     lev1 = ["a", "b", "c"]
@@ -2734,11 +2906,67 @@ def test_loc_getitem_nullable_index_with_duplicates():
     tm.assert_series_equal(res, expected)
 
 
+@pytest.mark.parametrize("value", [300, np.uint16(300), np.int16(300)])
+def test_loc_setitem_uint8_upcast(value):
+    # GH#26049
+
+    df = DataFrame([1, 2, 3, 4], columns=["col1"], dtype="uint8")
+    df.loc[2, "col1"] = value  # value that can't be held in uint8
+
+    expected = DataFrame([1, 2, 300, 4], columns=["col1"], dtype="uint16")
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize(
+    "fill_val,exp_dtype",
+    [
+        (Timestamp("2022-01-06"), "datetime64[ns]"),
+        (Timestamp("2022-01-07", tz="US/Eastern"), "datetime64[ns, US/Eastern]"),
+    ],
+)
+def test_loc_setitem_using_datetimelike_str_as_index(fill_val, exp_dtype):
+
+    data = ["2022-01-02", "2022-01-03", "2022-01-04", fill_val.date()]
+    index = DatetimeIndex(data, tz=fill_val.tz, dtype=exp_dtype)
+    df = DataFrame([10, 11, 12, 14], columns=["a"], index=index)
+    # adding new row using an unexisting datetime-like str index
+    df.loc["2022-01-08", "a"] = 13
+
+    data.append("2022-01-08")
+    expected_index = DatetimeIndex(data, dtype=exp_dtype)
+    tm.assert_index_equal(df.index, expected_index, exact=True)
+
+
+def test_loc_set_int_dtype():
+    # GH#23326
+    df = DataFrame([list("abc")])
+    df.loc[:, "col1"] = 5
+
+    expected = DataFrame({0: ["a"], 1: ["b"], 2: ["c"], "col1": [5]})
+    tm.assert_frame_equal(df, expected)
+
+
+def test_loc_periodindex_3_levels():
+    # GH#24091
+    p_index = PeriodIndex(
+        ["20181101 1100", "20181101 1200", "20181102 1300", "20181102 1400"],
+        name="datetime",
+        freq="B",
+    )
+    mi_series = DataFrame(
+        [["A", "B", 1.0], ["A", "C", 2.0], ["Z", "Q", 3.0], ["W", "F", 4.0]],
+        index=p_index,
+        columns=["ONE", "TWO", "VALUES"],
+    )
+    mi_series = mi_series.set_index(["ONE", "TWO"], append=True)["VALUES"]
+    assert mi_series.loc[(p_index[0], "A", "B")] == 1.0
+
+
 class TestLocSeries:
-    @pytest.mark.parametrize("val,expected", [(2 ** 63 - 1, 3), (2 ** 63, 4)])
+    @pytest.mark.parametrize("val,expected", [(2**63 - 1, 3), (2**63, 4)])
     def test_loc_uint64(self, val, expected):
         # see GH#19399
-        ser = Series({2 ** 63 - 1: 3, 2 ** 63: 4})
+        ser = Series({2**63 - 1: 3, 2**63: 4})
         assert ser.loc[val] == expected
 
     def test_loc_getitem(self, string_series, datetime_series):
@@ -2908,11 +3136,11 @@ def test_loc_series_getitem_too_many_dimensions(self, indexer):
             index=MultiIndex.from_tuples([("A", "0"), ("A", "1"), ("B", "0")]),
             data=[21, 22, 23],
         )
-        msg = "Too many indices"
-        with pytest.raises(ValueError, match=msg):
+        msg = "Too many indexers"
+        with pytest.raises(IndexingError, match=msg):
             ser.loc[indexer, :]
 
-        with pytest.raises(ValueError, match=msg):
+        with pytest.raises(IndexingError, match=msg):
             ser.loc[indexer, :] = 1
 
     def test_loc_setitem(self, string_series):
@@ -2983,3 +3211,11 @@ def test_getitem_loc_str_periodindex(self):
         index = pd.period_range(start="2000", periods=20, freq="B")
         series = Series(range(20), index=index)
         assert series.loc["2000-01-14"] == 9
+
+    def test_deprecation_warnings_raised_loc(self):
+        # GH#48673
+        with tm.assert_produces_warning(DeprecationWarning):
+            values = np.arange(4).reshape(2, 2)
+            df = DataFrame(values, columns=["a", "b"])
+            new = np.array([10, 11]).astype(np.int16)
+            df.loc[:, "a"] = new
diff --git a/pandas/tests/indexing/test_partial.py b/pandas/tests/indexing/test_partial.py
index 8251f09b97062..f973bdf7ea6f6 100644
--- a/pandas/tests/indexing/test_partial.py
+++ b/pandas/tests/indexing/test_partial.py
@@ -266,7 +266,7 @@ def test_partial_setting(self):
         with pytest.raises(IndexError, match=msg):
             s.iat[3] = 5.0
 
-    def test_partial_setting_frame(self):
+    def test_partial_setting_frame(self, using_array_manager):
         df_orig = DataFrame(
             np.arange(6).reshape(3, 2), columns=["A", "B"], dtype="int64"
         )
@@ -279,6 +279,8 @@ def test_partial_setting_frame(self):
             df.iloc[4, 2] = 5.0
 
         msg = "index 2 is out of bounds for axis 0 with size 2"
+        if using_array_manager:
+            msg = "list index out of range"
         with pytest.raises(IndexError, match=msg):
             df.iat[4, 2] = 5.0
 
@@ -309,7 +311,9 @@ def test_partial_setting_frame(self):
         expected = DataFrame(dict({"A": [0, 2, 4], "B": Series([0, 2, 4])}))
         df = df_orig.copy()
         df["B"] = df["B"].astype(np.float64)
-        df.loc[:, "B"] = df.loc[:, "A"]
+        msg = "will attempt to set the values inplace instead"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.loc[:, "B"] = df.loc[:, "A"]
         tm.assert_frame_equal(df, expected)
 
         # single dtype frame, partial setting
diff --git a/pandas/tests/indexing/test_scalar.py b/pandas/tests/indexing/test_scalar.py
index d5268a1b1bc81..552db9c5e164d 100644
--- a/pandas/tests/indexing/test_scalar.py
+++ b/pandas/tests/indexing/test_scalar.py
@@ -19,33 +19,6 @@
 
 
 class TestScalar(Base):
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_at_and_iat_get(self, kind):
-        def _check(f, func, values=False):
-
-            if f is not None:
-                indices = self.generate_indices(f, values)
-                for i in indices:
-                    result = getattr(f, func)[i]
-                    expected = self.get_value(func, f, i, values)
-                    tm.assert_almost_equal(result, expected)
-
-        d = getattr(self, kind)
-
-        # iat
-        for f in [d["ints"], d["uints"]]:
-            _check(f, "iat", values=True)
-
-        for f in [d["labels"], d["ts"], d["floats"]]:
-            if f is not None:
-                msg = "iAt based indexing can only have integer indexers"
-                with pytest.raises(ValueError, match=msg):
-                    self.check_values(f, "iat")
-
-        # at
-        for f in [d["ints"], d["uints"], d["labels"], d["ts"], d["floats"]]:
-            _check(f, "at")
-
     @pytest.mark.parametrize("kind", ["series", "frame"])
     @pytest.mark.parametrize("col", ["ints", "uints"])
     def test_iat_set_ints(self, kind, col):
@@ -103,24 +76,24 @@ def test_at_iat_coercion(self):
         xp = s.values[5]
         assert result == xp
 
+    @pytest.mark.parametrize(
+        "ser, expected",
+        [
+            [
+                Series(["2014-01-01", "2014-02-02"], dtype="datetime64[ns]"),
+                Timestamp("2014-02-02"),
+            ],
+            [
+                Series(["1 days", "2 days"], dtype="timedelta64[ns]"),
+                Timedelta("2 days"),
+            ],
+        ],
+    )
+    def test_iloc_iat_coercion_datelike(self, indexer_ial, ser, expected):
         # GH 7729
         # make sure we are boxing the returns
-        s = Series(["2014-01-01", "2014-02-02"], dtype="datetime64[ns]")
-        expected = Timestamp("2014-02-02")
-
-        for r in [lambda: s.iat[1], lambda: s.iloc[1]]:
-            result = r()
-            assert result == expected
-
-        s = Series(["1 days", "2 days"], dtype="timedelta64[ns]")
-        expected = Timedelta("2 days")
-
-        for r in [lambda: s.iat[1], lambda: s.iloc[1]]:
-            result = r()
-            assert result == expected
-
-    def test_iat_invalid_args(self):
-        pass
+        result = indexer_ial(ser)[1]
+        assert result == expected
 
     def test_imethods_with_dups(self):
 
diff --git a/pandas/tests/interchange/__init__.py b/pandas/tests/interchange/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/interchange/conftest.py b/pandas/tests/interchange/conftest.py
new file mode 100644
index 0000000000000..f552ba442a916
--- /dev/null
+++ b/pandas/tests/interchange/conftest.py
@@ -0,0 +1,12 @@
+import pytest
+
+import pandas as pd
+
+
+@pytest.fixture
+def df_from_dict():
+    def maker(dct, is_categorical=False):
+        df = pd.DataFrame(dct)
+        return df.astype("category") if is_categorical else df
+
+    return maker
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
new file mode 100644
index 0000000000000..078a17510d502
--- /dev/null
+++ b/pandas/tests/interchange/test_impl.py
@@ -0,0 +1,206 @@
+from datetime import datetime
+import random
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.interchange.column import PandasColumn
+from pandas.core.interchange.dataframe_protocol import (
+    ColumnNullType,
+    DtypeKind,
+)
+from pandas.core.interchange.from_dataframe import from_dataframe
+
+test_data_categorical = {
+    "ordered": pd.Categorical(list("testdata") * 30, ordered=True),
+    "unordered": pd.Categorical(list("testdata") * 30, ordered=False),
+}
+
+NCOLS, NROWS = 100, 200
+
+
+def _make_data(make_one):
+    return {
+        f"col{int((i - NCOLS / 2) % NCOLS + 1)}": [make_one() for _ in range(NROWS)]
+        for i in range(NCOLS)
+    }
+
+
+int_data = _make_data(lambda: random.randint(-100, 100))
+uint_data = _make_data(lambda: random.randint(1, 100))
+bool_data = _make_data(lambda: random.choice([True, False]))
+float_data = _make_data(lambda: random.random())
+datetime_data = _make_data(
+    lambda: datetime(
+        year=random.randint(1900, 2100),
+        month=random.randint(1, 12),
+        day=random.randint(1, 20),
+    )
+)
+
+string_data = {
+    "separator data": [
+        "abC|DeF,Hik",
+        "234,3245.67",
+        "gSaf,qWer|Gre",
+        "asd3,4sad|",
+        np.NaN,
+    ]
+}
+
+
+@pytest.mark.parametrize("data", [("ordered", True), ("unordered", False)])
+def test_categorical_dtype(data):
+    df = pd.DataFrame({"A": (test_data_categorical[data[0]])})
+
+    col = df.__dataframe__().get_column_by_name("A")
+    assert col.dtype[0] == DtypeKind.CATEGORICAL
+    assert col.null_count == 0
+    assert col.describe_null == (ColumnNullType.USE_SENTINEL, -1)
+    assert col.num_chunks() == 1
+    desc_cat = col.describe_categorical
+    assert desc_cat["is_ordered"] == data[1]
+    assert desc_cat["is_dictionary"] is True
+    assert isinstance(desc_cat["categories"], PandasColumn)
+    tm.assert_series_equal(
+        desc_cat["categories"]._col, pd.Series(["a", "d", "e", "s", "t"])
+    )
+
+    tm.assert_frame_equal(df, from_dataframe(df.__dataframe__()))
+
+
+@pytest.mark.parametrize(
+    "data", [int_data, uint_data, float_data, bool_data, datetime_data]
+)
+def test_dataframe(data):
+    df = pd.DataFrame(data)
+
+    df2 = df.__dataframe__()
+
+    assert df2.num_columns() == NCOLS
+    assert df2.num_rows() == NROWS
+
+    assert list(df2.column_names()) == list(data.keys())
+
+    indices = (0, 2)
+    names = tuple(list(data.keys())[idx] for idx in indices)
+
+    result = from_dataframe(df2.select_columns(indices))
+    expected = from_dataframe(df2.select_columns_by_name(names))
+    tm.assert_frame_equal(result, expected)
+
+    assert isinstance(result.attrs["_INTERCHANGE_PROTOCOL_BUFFERS"], list)
+    assert isinstance(expected.attrs["_INTERCHANGE_PROTOCOL_BUFFERS"], list)
+
+
+def test_missing_from_masked():
+    df = pd.DataFrame(
+        {
+            "x": np.array([1, 2, 3, 4, 0]),
+            "y": np.array([1.5, 2.5, 3.5, 4.5, 0]),
+            "z": np.array([True, False, True, True, True]),
+        }
+    )
+
+    df2 = df.__dataframe__()
+
+    rng = np.random.RandomState(42)
+    dict_null = {col: rng.randint(low=0, high=len(df)) for col in df.columns}
+    for col, num_nulls in dict_null.items():
+        null_idx = df.index[
+            rng.choice(np.arange(len(df)), size=num_nulls, replace=False)
+        ]
+        df.loc[null_idx, col] = None
+
+    df2 = df.__dataframe__()
+
+    assert df2.get_column_by_name("x").null_count == dict_null["x"]
+    assert df2.get_column_by_name("y").null_count == dict_null["y"]
+    assert df2.get_column_by_name("z").null_count == dict_null["z"]
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"x": [1.5, 2.5, 3.5], "y": [9.2, 10.5, 11.8]},
+        {"x": [1, 2, 0], "y": [9.2, 10.5, 11.8]},
+        {
+            "x": np.array([True, True, False]),
+            "y": np.array([1, 2, 0]),
+            "z": np.array([9.2, 10.5, 11.8]),
+        },
+    ],
+)
+def test_mixed_data(data):
+    df = pd.DataFrame(data)
+    df2 = df.__dataframe__()
+
+    for col_name in df.columns:
+        assert df2.get_column_by_name(col_name).null_count == 0
+
+
+def test_mixed_missing():
+    df = pd.DataFrame(
+        {
+            "x": np.array([True, None, False, None, True]),
+            "y": np.array([None, 2, None, 1, 2]),
+            "z": np.array([9.2, 10.5, None, 11.8, None]),
+        }
+    )
+
+    df2 = df.__dataframe__()
+
+    for col_name in df.columns:
+        assert df2.get_column_by_name(col_name).null_count == 2
+
+
+def test_string():
+    test_str_data = string_data["separator data"] + [""]
+    df = pd.DataFrame({"A": test_str_data})
+    col = df.__dataframe__().get_column_by_name("A")
+
+    assert col.size() == 6
+    assert col.null_count == 1
+    assert col.dtype[0] == DtypeKind.STRING
+    assert col.describe_null == (ColumnNullType.USE_BYTEMASK, 0)
+
+    df_sliced = df[1:]
+    col = df_sliced.__dataframe__().get_column_by_name("A")
+    assert col.size() == 5
+    assert col.null_count == 1
+    assert col.dtype[0] == DtypeKind.STRING
+    assert col.describe_null == (ColumnNullType.USE_BYTEMASK, 0)
+
+
+def test_nonstring_object():
+    df = pd.DataFrame({"A": ["a", 10, 1.0, ()]})
+    col = df.__dataframe__().get_column_by_name("A")
+    with pytest.raises(NotImplementedError, match="not supported yet"):
+        col.dtype
+
+
+def test_datetime():
+    df = pd.DataFrame({"A": [pd.Timestamp("2022-01-01"), pd.NaT]})
+    col = df.__dataframe__().get_column_by_name("A")
+
+    assert col.size() == 2
+    assert col.null_count == 1
+    assert col.dtype[0] == DtypeKind.DATETIME
+    assert col.describe_null == (ColumnNullType.USE_SENTINEL, iNaT)
+
+    tm.assert_frame_equal(df, from_dataframe(df.__dataframe__()))
+
+
+@td.skip_if_np_lt("1.23")
+def test_categorical_to_numpy_dlpack():
+    # https://github.com/pandas-dev/pandas/issues/48393
+    df = pd.DataFrame({"A": pd.Categorical(["a", "b", "a"])})
+    col = df.__dataframe__().get_column_by_name("A")
+    result = np.from_dlpack(col.get_buffers()["data"][0])
+    expected = np.array([0, 1, 0], dtype="int8")
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/interchange/test_spec_conformance.py b/pandas/tests/interchange/test_spec_conformance.py
new file mode 100644
index 0000000000000..965938b111e86
--- /dev/null
+++ b/pandas/tests/interchange/test_spec_conformance.py
@@ -0,0 +1,164 @@
+"""
+A verbatim copy (vendored) of the spec tests.
+Taken from https://github.com/data-apis/dataframe-api
+"""
+import ctypes
+import math
+
+import pytest
+
+
+@pytest.mark.parametrize(
+    "test_data",
+    [
+        {"a": ["foo", "bar"], "b": ["baz", "qux"]},
+        {"a": [1.5, 2.5, 3.5], "b": [9.2, 10.5, 11.8]},
+        {"A": [1, 2, 3, 4], "B": [1, 2, 3, 4]},
+    ],
+    ids=["str_data", "float_data", "int_data"],
+)
+def test_only_one_dtype(test_data, df_from_dict):
+    columns = list(test_data.keys())
+    df = df_from_dict(test_data)
+    dfX = df.__dataframe__()
+
+    column_size = len(test_data[columns[0]])
+    for column in columns:
+        null_count = dfX.get_column_by_name(column).null_count
+        assert null_count == 0
+        assert isinstance(null_count, int)
+        assert dfX.get_column_by_name(column).size() == column_size
+        assert dfX.get_column_by_name(column).offset == 0
+
+
+def test_mixed_dtypes(df_from_dict):
+    df = df_from_dict(
+        {
+            "a": [1, 2, 3],  # dtype kind INT = 0
+            "b": [3, 4, 5],  # dtype kind INT = 0
+            "c": [1.5, 2.5, 3.5],  # dtype kind FLOAT = 2
+            "d": [9, 10, 11],  # dtype kind INT = 0
+            "e": [True, False, True],  # dtype kind BOOLEAN = 20
+            "f": ["a", "", "c"],  # dtype kind STRING = 21
+        }
+    )
+    dfX = df.__dataframe__()
+    # for meanings of dtype[0] see the spec; we cannot import the spec here as this
+    # file is expected to be vendored *anywhere*;
+    # values for dtype[0] are explained above
+    columns = {"a": 0, "b": 0, "c": 2, "d": 0, "e": 20, "f": 21}
+
+    for column, kind in columns.items():
+        colX = dfX.get_column_by_name(column)
+        assert colX.null_count == 0
+        assert isinstance(colX.null_count, int)
+        assert colX.size() == 3
+        assert colX.offset == 0
+
+        assert colX.dtype[0] == kind
+
+    assert dfX.get_column_by_name("c").dtype[1] == 64
+
+
+def test_na_float(df_from_dict):
+    df = df_from_dict({"a": [1.0, math.nan, 2.0]})
+    dfX = df.__dataframe__()
+    colX = dfX.get_column_by_name("a")
+    assert colX.null_count == 1
+    assert isinstance(colX.null_count, int)
+
+
+def test_noncategorical(df_from_dict):
+    df = df_from_dict({"a": [1, 2, 3]})
+    dfX = df.__dataframe__()
+    colX = dfX.get_column_by_name("a")
+    with pytest.raises(TypeError, match=".*categorical.*"):
+        colX.describe_categorical
+
+
+def test_categorical(df_from_dict):
+    df = df_from_dict(
+        {"weekday": ["Mon", "Tue", "Mon", "Wed", "Mon", "Thu", "Fri", "Sat", "Sun"]},
+        is_categorical=True,
+    )
+
+    colX = df.__dataframe__().get_column_by_name("weekday")
+    categorical = colX.describe_categorical
+    assert isinstance(categorical["is_ordered"], bool)
+    assert isinstance(categorical["is_dictionary"], bool)
+
+
+def test_dataframe(df_from_dict):
+    df = df_from_dict(
+        {"x": [True, True, False], "y": [1, 2, 0], "z": [9.2, 10.5, 11.8]}
+    )
+    dfX = df.__dataframe__()
+
+    assert dfX.num_columns() == 3
+    assert dfX.num_rows() == 3
+    assert dfX.num_chunks() == 1
+    assert list(dfX.column_names()) == ["x", "y", "z"]
+    assert list(dfX.select_columns((0, 2)).column_names()) == list(
+        dfX.select_columns_by_name(("x", "z")).column_names()
+    )
+
+
+@pytest.mark.parametrize(["size", "n_chunks"], [(10, 3), (12, 3), (12, 5)])
+def test_df_get_chunks(size, n_chunks, df_from_dict):
+    df = df_from_dict({"x": list(range(size))})
+    dfX = df.__dataframe__()
+    chunks = list(dfX.get_chunks(n_chunks))
+    assert len(chunks) == n_chunks
+    assert sum(chunk.num_rows() for chunk in chunks) == size
+
+
+@pytest.mark.parametrize(["size", "n_chunks"], [(10, 3), (12, 3), (12, 5)])
+def test_column_get_chunks(size, n_chunks, df_from_dict):
+    df = df_from_dict({"x": list(range(size))})
+    dfX = df.__dataframe__()
+    chunks = list(dfX.get_column(0).get_chunks(n_chunks))
+    assert len(chunks) == n_chunks
+    assert sum(chunk.size() for chunk in chunks) == size
+
+
+def test_get_columns(df_from_dict):
+    df = df_from_dict({"a": [0, 1], "b": [2.5, 3.5]})
+    dfX = df.__dataframe__()
+    for colX in dfX.get_columns():
+        assert colX.size() == 2
+        assert colX.num_chunks() == 1
+    # for meanings of dtype[0] see the spec; we cannot import the spec here as this
+    # file is expected to be vendored *anywhere*
+    assert dfX.get_column(0).dtype[0] == 0  # INT
+    assert dfX.get_column(1).dtype[0] == 2  # FLOAT
+
+
+def test_buffer(df_from_dict):
+    arr = [0, 1, -1]
+    df = df_from_dict({"a": arr})
+    dfX = df.__dataframe__()
+    colX = dfX.get_column(0)
+    bufX = colX.get_buffers()
+
+    dataBuf, dataDtype = bufX["data"]
+
+    assert dataBuf.bufsize > 0
+    assert dataBuf.ptr != 0
+    device, _ = dataBuf.__dlpack_device__()
+
+    # for meanings of dtype[0] see the spec; we cannot import the spec here as this
+    # file is expected to be vendored *anywhere*
+    assert dataDtype[0] == 0  # INT
+
+    if device == 1:  # CPU-only as we're going to directly read memory here
+        bitwidth = dataDtype[1]
+        ctype = {
+            8: ctypes.c_int8,
+            16: ctypes.c_int16,
+            32: ctypes.c_int32,
+            64: ctypes.c_int64,
+        }[bitwidth]
+
+        for idx, truth in enumerate(arr):
+            val = ctype.from_address(dataBuf.ptr + idx * (bitwidth // 8)).value
+            assert val == truth, f"Buffer at index {idx} mismatch"
diff --git a/pandas/tests/interchange/test_utils.py b/pandas/tests/interchange/test_utils.py
new file mode 100644
index 0000000000000..4fd42abb7f3f1
--- /dev/null
+++ b/pandas/tests/interchange/test_utils.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas.core.interchange.utils import dtype_to_arrow_c_fmt
+
+# TODO: use ArrowSchema to get reference C-string.
+# At the time, there is no way to access ArrowSchema holding a type format string
+# from python. The only way to access it is to export the structure to a C-pointer,
+# see DataType._export_to_c() method defined in
+# https://github.com/apache/arrow/blob/master/python/pyarrow/types.pxi
+
+
+@pytest.mark.parametrize(
+    "pandas_dtype, c_string",
+    [
+        (np.dtype("bool"), "b"),
+        (np.dtype("int8"), "c"),
+        (np.dtype("uint8"), "C"),
+        (np.dtype("int16"), "s"),
+        (np.dtype("uint16"), "S"),
+        (np.dtype("int32"), "i"),
+        (np.dtype("uint32"), "I"),
+        (np.dtype("int64"), "l"),
+        (np.dtype("uint64"), "L"),
+        (np.dtype("float16"), "e"),
+        (np.dtype("float32"), "f"),
+        (np.dtype("float64"), "g"),
+        (pd.Series(["a"]).dtype, "u"),
+        (
+            pd.Series([0]).astype("datetime64[ns]").dtype,
+            "tsn:",
+        ),
+        (pd.CategoricalDtype(["a"]), "l"),
+        (np.dtype("O"), "u"),
+    ],
+)
+def test_dtype_to_arrow_c_fmt(pandas_dtype, c_string):  # PR01
+    """Test ``dtype_to_arrow_c_fmt`` utility function."""
+    assert dtype_to_arrow_c_fmt(pandas_dtype) == c_string
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index a5ba684a37edf..b30b27f5bae1a 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -140,7 +140,7 @@ def create_block(typestr, placement, item_shape=None, num_offset=0, maker=new_bl
         assert m is not None, f"incompatible typestr -> {typestr}"
         tz = m.groups()[0]
         assert num_items == 1, "must have only 1 num items for a tz-aware"
-        values = DatetimeIndex(np.arange(N) * 1e9, tz=tz)._data
+        values = DatetimeIndex(np.arange(N) * 10**9, tz=tz)._data
         values = ensure_block_shape(values, ndim=len(shape))
     elif typestr in ("timedelta", "td", "m8[ns]"):
         values = (mat * 1).astype("m8[ns]")
@@ -243,13 +243,12 @@ def create_mgr(descr, item_shape=None):
     )
 
 
-class TestBlock:
-    def setup_method(self, method):
-        self.fblock = create_block("float", [0, 2, 4])
-        self.cblock = create_block("complex", [7])
-        self.oblock = create_block("object", [1, 3])
-        self.bool_block = create_block("bool", [5])
+@pytest.fixture
+def fblock():
+    return create_block("float", [0, 2, 4])
+
 
+class TestBlock:
     def test_constructor(self):
         int32block = create_block("i4", [0])
         assert int32block.dtype == np.int32
@@ -267,47 +266,56 @@ def test_pickle(self, typ, data):
         blk = create_block(typ, data)
         assert_block_equal(tm.round_trip_pickle(blk), blk)
 
-    def test_mgr_locs(self):
-        assert isinstance(self.fblock.mgr_locs, BlockPlacement)
+    def test_mgr_locs(self, fblock):
+        assert isinstance(fblock.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(
-            self.fblock.mgr_locs.as_array, np.array([0, 2, 4], dtype=np.intp)
+            fblock.mgr_locs.as_array, np.array([0, 2, 4], dtype=np.intp)
         )
 
-    def test_attrs(self):
-        assert self.fblock.shape == self.fblock.values.shape
-        assert self.fblock.dtype == self.fblock.values.dtype
-        assert len(self.fblock) == len(self.fblock.values)
-
-    def test_copy(self):
-        cop = self.fblock.copy()
-        assert cop is not self.fblock
-        assert_block_equal(self.fblock, cop)
-
-    def test_delete(self):
-        newb = self.fblock.copy()
-        newb.delete(0)
-        assert isinstance(newb.mgr_locs, BlockPlacement)
+    def test_attrs(self, fblock):
+        assert fblock.shape == fblock.values.shape
+        assert fblock.dtype == fblock.values.dtype
+        assert len(fblock) == len(fblock.values)
+
+    def test_copy(self, fblock):
+        cop = fblock.copy()
+        assert cop is not fblock
+        assert_block_equal(fblock, cop)
+
+    def test_delete(self, fblock):
+        newb = fblock.copy()
+        locs = newb.mgr_locs
+        nb = newb.delete(0)
+        assert newb.mgr_locs is locs
+
+        assert nb is not newb
+
         tm.assert_numpy_array_equal(
-            newb.mgr_locs.as_array, np.array([2, 4], dtype=np.intp)
+            nb.mgr_locs.as_array, np.array([2, 4], dtype=np.intp)
         )
-        assert (newb.values[0] == 1).all()
+        assert not (newb.values[0] == 1).all()
+        assert (nb.values[0] == 1).all()
+
+        newb = fblock.copy()
+        locs = newb.mgr_locs
+        nb = newb.delete(1)
+        assert newb.mgr_locs is locs
 
-        newb = self.fblock.copy()
-        newb.delete(1)
-        assert isinstance(newb.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(
-            newb.mgr_locs.as_array, np.array([0, 4], dtype=np.intp)
+            nb.mgr_locs.as_array, np.array([0, 4], dtype=np.intp)
         )
-        assert (newb.values[1] == 2).all()
+        assert not (newb.values[1] == 2).all()
+        assert (nb.values[1] == 2).all()
 
-        newb = self.fblock.copy()
-        newb.delete(2)
+        newb = fblock.copy()
+        locs = newb.mgr_locs
+        nb = newb.delete(2)
         tm.assert_numpy_array_equal(
-            newb.mgr_locs.as_array, np.array([0, 2], dtype=np.intp)
+            nb.mgr_locs.as_array, np.array([0, 2], dtype=np.intp)
         )
-        assert (newb.values[1] == 1).all()
+        assert (nb.values[1] == 1).all()
 
-        newb = self.fblock.copy()
+        newb = fblock.copy()
 
         with pytest.raises(IndexError, match=None):
             newb.delete(3)
@@ -319,15 +327,15 @@ def test_delete_datetimelike(self):
         blk = df._mgr.blocks[0]
         assert isinstance(blk.values, TimedeltaArray)
 
-        blk.delete(1)
-        assert isinstance(blk.values, TimedeltaArray)
+        nb = blk.delete(1)
+        assert isinstance(nb.values, TimedeltaArray)
 
         df = DataFrame(arr.view("M8[ns]"))
         blk = df._mgr.blocks[0]
         assert isinstance(blk.values, DatetimeArray)
 
-        blk.delete([1, 3])
-        assert isinstance(blk.values, DatetimeArray)
+        nb = blk.delete([1, 3])
+        assert isinstance(nb.values, DatetimeArray)
 
     def test_split(self):
         # GH#37799
@@ -348,9 +356,9 @@ def test_split(self):
         for res, exp in zip(result, expected):
             assert_block_equal(res, exp)
 
-    def test_is_categorical_deprecated(self):
+    def test_is_categorical_deprecated(self, fblock):
         # GH#40571
-        blk = self.fblock
+        blk = fblock
         with tm.assert_produces_warning(DeprecationWarning):
             blk.is_categorical
 
@@ -540,9 +548,6 @@ def test_astype(self, t):
         # coerce all
         mgr = create_mgr("c: f4; d: f2; e: f8")
 
-        warn = FutureWarning if t == "int64" else None
-        # datetimelike.astype(int64) deprecated
-
         t = np.dtype(t)
         tmgr = mgr.astype(t)
         assert tmgr.iget(0).dtype.type == t
@@ -553,8 +558,7 @@ def test_astype(self, t):
         mgr = create_mgr("a,b: object; c: bool; d: datetime; e: f4; f: f2; g: f8")
 
         t = np.dtype(t)
-        with tm.assert_produces_warning(warn):
-            tmgr = mgr.astype(t, errors="ignore")
+        tmgr = mgr.astype(t, errors="ignore")
         assert tmgr.iget(2).dtype.type == t
         assert tmgr.iget(4).dtype.type == t
         assert tmgr.iget(5).dtype.type == t
@@ -722,7 +726,10 @@ def test_reindex_items(self):
         mgr = create_mgr("a: f8; b: i8; c: f8; d: i8; e: f8; f: bool; g: f8-2")
 
         reindexed = mgr.reindex_axis(["g", "c", "a", "d"], axis=0)
-        assert reindexed.nblocks == 2
+        # reindex_axis does not consolidate_inplace, as that risks failing to
+        #  invalidate _item_cache
+        assert not reindexed.is_consolidated()
+
         tm.assert_index_equal(reindexed.items, Index(["g", "c", "a", "d"]))
         tm.assert_almost_equal(
             mgr.iget(6).internal_values(), reindexed.iget(0).internal_values()
@@ -737,7 +744,7 @@ def test_reindex_items(self):
             mgr.iget(3).internal_values(), reindexed.iget(3).internal_values()
         )
 
-    def test_get_numeric_data(self):
+    def test_get_numeric_data(self, using_copy_on_write):
         mgr = create_mgr(
             "int: int; float: float; complex: complex;"
             "str: object; bool: bool; obj: object; dt: datetime",
@@ -758,10 +765,16 @@ def test_get_numeric_data(self):
             np.array([100.0, 200.0, 300.0]),
             inplace=True,
         )
-        tm.assert_almost_equal(
-            mgr.iget(mgr.items.get_loc("float")).internal_values(),
-            np.array([100.0, 200.0, 300.0]),
-        )
+        if using_copy_on_write:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([1.0, 1.0, 1.0]),
+            )
+        else:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([100.0, 200.0, 300.0]),
+            )
 
         numeric2 = mgr.get_numeric_data(copy=True)
         tm.assert_index_equal(numeric.items, Index(["int", "float", "complex", "bool"]))
@@ -770,12 +783,19 @@ def test_get_numeric_data(self):
             np.array([1000.0, 2000.0, 3000.0]),
             inplace=True,
         )
-        tm.assert_almost_equal(
-            mgr.iget(mgr.items.get_loc("float")).internal_values(),
-            np.array([100.0, 200.0, 300.0]),
-        )
+        if using_copy_on_write:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([1.0, 1.0, 1.0]),
+            )
+        else:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([100.0, 200.0, 300.0]),
+            )
 
-    def test_get_bool_data(self):
+    def test_get_bool_data(self, using_copy_on_write):
+        msg = "object-dtype columns with all-bool values"
         mgr = create_mgr(
             "int: int; float: float; complex: complex;"
             "str: object; bool: bool; obj: object; dt: datetime",
@@ -783,7 +803,8 @@ def test_get_bool_data(self):
         )
         mgr.iset(6, np.array([True, False, True], dtype=np.object_))
 
-        bools = mgr.get_bool_data()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            bools = mgr.get_bool_data()
         tm.assert_index_equal(bools.items, Index(["bool", "dt"]))
         tm.assert_almost_equal(
             mgr.iget(mgr.items.get_loc("bool")).internal_values(),
@@ -791,18 +812,31 @@ def test_get_bool_data(self):
         )
 
         bools.iset(0, np.array([True, False, True]), inplace=True)
-        tm.assert_numpy_array_equal(
-            mgr.iget(mgr.items.get_loc("bool")).internal_values(),
-            np.array([True, False, True]),
-        )
+        if using_copy_on_write:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, True, True]),
+            )
+        else:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, False, True]),
+            )
 
         # Check sharing
-        bools2 = mgr.get_bool_data(copy=True)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            bools2 = mgr.get_bool_data(copy=True)
         bools2.iset(0, np.array([False, True, False]))
-        tm.assert_numpy_array_equal(
-            mgr.iget(mgr.items.get_loc("bool")).internal_values(),
-            np.array([True, False, True]),
-        )
+        if using_copy_on_write:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, True, True]),
+            )
+        else:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, False, True]),
+            )
 
     def test_unicode_repr_doesnt_raise(self):
         repr(create_mgr("b,\u05d0: object"))
@@ -1338,10 +1372,7 @@ def check_frame_setitem(self, elem, index: Index, inplace: bool):
 
         if inplace:
             # assertion here implies setting was done inplace
-
-            # error: Item "ArrayManager" of "Union[ArrayManager, BlockManager]" has no
-            #  attribute "blocks"
-            assert df._mgr.blocks[0].values is arr  # type:ignore[union-attr]
+            assert df._mgr.arrays[0] is arr
         else:
             assert df.dtypes[0] == object
 
diff --git a/pandas/tests/io/conftest.py b/pandas/tests/io/conftest.py
index 86842f6a608d6..522d25205eeb0 100644
--- a/pandas/tests/io/conftest.py
+++ b/pandas/tests/io/conftest.py
@@ -6,6 +6,7 @@
 import pytest
 
 from pandas.compat import (
+    is_ci_environment,
     is_platform_arm,
     is_platform_mac,
     is_platform_windows,
@@ -42,7 +43,7 @@ def feather_file(datapath):
 
 @pytest.fixture
 def s3so(worker_id):
-    if os.environ.get("PANDAS_CI", "0") == "1":
+    if is_ci_environment():
         url = "http://localhost:5000/"
     else:
         worker_id = "5" if worker_id == "master" else worker_id.lstrip("gw")
@@ -66,11 +67,11 @@ def s3_base(worker_id):
         # see https://github.com/spulec/moto/issues/1924 & 1952
         os.environ.setdefault("AWS_ACCESS_KEY_ID", "foobar_key")
         os.environ.setdefault("AWS_SECRET_ACCESS_KEY", "foobar_secret")
-        if os.environ.get("PANDAS_CI", "0") == "1":
+        if is_ci_environment():
             if is_platform_arm() or is_platform_mac() or is_platform_windows():
                 # NOT RUN on Windows/MacOS/ARM, only Ubuntu
                 # - subprocess in CI can cause timeouts
-                # - Azure pipelines/Github Actions do not support
+                # - Github Actions do not support
                 #   container services for the above OSs
                 # - CircleCI will probably hit the Docker rate pull limit
                 pytest.skip(
@@ -114,7 +115,7 @@ def s3_base(worker_id):
                 proc.terminate()
 
 
-@pytest.fixture()
+@pytest.fixture
 def s3_resource(s3_base, tips_file, jsonl_file, feather_file):
     """
     Sets up S3 bucket with contents
diff --git a/pandas/tests/io/data/excel/df_header_oob.xlsx b/pandas/tests/io/data/excel/df_header_oob.xlsx
new file mode 100644
index 0000000000000..1e26091cd2ace
Binary files /dev/null and b/pandas/tests/io/data/excel/df_header_oob.xlsx differ
diff --git a/pandas/tests/io/data/excel/high_surrogate.xlsx b/pandas/tests/io/data/excel/high_surrogate.xlsx
deleted file mode 100644
index 1e29b6bee6586..0000000000000
Binary files a/pandas/tests/io/data/excel/high_surrogate.xlsx and /dev/null differ
diff --git a/pandas/tests/io/data/excel/ints_spelled_with_decimals.xlsx b/pandas/tests/io/data/excel/ints_spelled_with_decimals.xlsx
new file mode 100644
index 0000000000000..a667be86283b8
Binary files /dev/null and b/pandas/tests/io/data/excel/ints_spelled_with_decimals.xlsx differ
diff --git a/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx b/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx
new file mode 100755
index 0000000000000..3913ffce5befb
Binary files /dev/null and b/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx differ
diff --git a/pandas/tests/io/data/excel/test_newlines.ods b/pandas/tests/io/data/excel/test_newlines.ods
new file mode 100644
index 0000000000000..262529800351c
Binary files /dev/null and b/pandas/tests/io/data/excel/test_newlines.ods differ
diff --git a/pandas/tests/io/data/legacy_pickle/1.4.2/1.4.2_x86_64_linux_3.9.7.pickle b/pandas/tests/io/data/legacy_pickle/1.4.2/1.4.2_x86_64_linux_3.9.7.pickle
new file mode 100644
index 0000000000000..403ccf99c06d1
Binary files /dev/null and b/pandas/tests/io/data/legacy_pickle/1.4.2/1.4.2_x86_64_linux_3.9.7.pickle differ
diff --git a/pandas/tests/io/data/xml/doc_ch_utf.xml b/pandas/tests/io/data/xml/doc_ch_utf.xml
new file mode 100644
index 0000000000000..fde215b89646b
--- /dev/null
+++ b/pandas/tests/io/data/xml/doc_ch_utf.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE fragmentdoc [
+  <!ELEMENT qafragment (qa+)>
+  <!ELEMENT qa ( q, a )>
+  <!ELEMENT q ( #PCDATA | title | name)*>
+  <!ATTLIST q speaker CDATA #REQUIRED>
+  <!ELEMENT a ( #PCDATA | title | name)*>
+  <!ATTLIST a speaker CDATA #REQUIRED>
+  <!ELEMENT name (#PCDATA)>
+  <!ELEMENT title (#PCDATA)>
+  <!ENTITY C4-4F71 "Sorry, this is Big5 only">
+]>
+
+<qafragment>
+	<qa>
+		<問 speaker="Opponent">問  若箇是邪而言破邪 何者是正而道(Sorry, this is Big5 only)申正</問>
+		<答 speaker="吉藏">答  邪既無量 正亦多途  大略為言不出二種 謂有得與無得 有得是邪須破 無得是正須申
+		故<title>大品經</title> <name>善吉</name> 致問 何等是菩薩道 何等非菩薩道
+		<name>佛</name>答云  有所得非菩薩道 無所得是菩薩道</答>
+	</qa>
+	<qa>
+		<問 speaker="Opponent">問 既破有得申無得 亦應但破性執申假名以不</問>
+		<a speaker="吉藏">答 性執是有得 假名是無得  今破有得申無得 即是破性執申假名也</a>
+	</qa>
+	<qa>
+		<問 speaker="Opponent">問 既破性申假 亦應但破有申無 若有無兩洗 亦應性假雙破耶</問>
+		<答 speaker="吉藏">答  不例  有無皆是性 所以須雙破 既分性假異 故有破不破</答>
+	</qa>
+</qafragment>
diff --git a/pandas/tests/io/excel/__init__.py b/pandas/tests/io/excel/__init__.py
index c4343497ded48..e7a182ea63178 100644
--- a/pandas/tests/io/excel/__init__.py
+++ b/pandas/tests/io/excel/__init__.py
@@ -1,12 +1,5 @@
 import pytest
 
-from pandas.compat._optional import (
-    get_version,
-    import_optional_dependency,
-)
-
-from pandas.util.version import Version
-
 pytestmark = [
     pytest.mark.filterwarnings(
         # Looks like tree.getiterator is deprecated in favor of tree.iter
@@ -25,11 +18,3 @@
         "ignore:.*In xlrd >= 2.0, only the xls format is supported:FutureWarning"
     ),
 ]
-
-
-if import_optional_dependency("xlrd", errors="ignore") is None:
-    xlrd_version = None
-else:
-    import xlrd
-
-    xlrd_version = Version(get_version(xlrd))
diff --git a/pandas/tests/io/excel/conftest.py b/pandas/tests/io/excel/conftest.py
index 0455e0d61ad97..4ce06c01892d9 100644
--- a/pandas/tests/io/excel/conftest.py
+++ b/pandas/tests/io/excel/conftest.py
@@ -1,5 +1,6 @@
 import pytest
 
+from pandas.compat import is_platform_windows
 import pandas.util._test_decorators as td
 
 import pandas._testing as tm
@@ -43,7 +44,8 @@ def read_ext(request):
     return request.param
 
 
-@pytest.fixture(autouse=True)
+# Checking for file leaks can hang on Windows CI
+@pytest.fixture(autouse=not is_platform_windows())
 def check_for_file_leaks():
     """
     Fixture to run around every test to ensure that we are not leaking files.
diff --git a/pandas/tests/io/excel/test_odf.py b/pandas/tests/io/excel/test_odf.py
index ddc3c42710a61..25079b235d332 100644
--- a/pandas/tests/io/excel/test_odf.py
+++ b/pandas/tests/io/excel/test_odf.py
@@ -36,3 +36,15 @@ def test_read_writer_table():
     result = pd.read_excel("writertable.odt", sheet_name="Table1", index_col=0)
 
     tm.assert_frame_equal(result, expected)
+
+
+def test_read_newlines_between_xml_elements_table():
+    # GH#45598
+    expected = pd.DataFrame(
+        [[1.0, 4.0, 7], [np.nan, np.nan, 8], [3.0, 6.0, 9]],
+        columns=["Column 1", "Column 2", "Column 3"],
+    )
+
+    result = pd.read_excel("test_newlines.ods")
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/excel/test_odswriter.py b/pandas/tests/io/excel/test_odswriter.py
index 0e6d1dac55506..e9dad0c7fedc9 100644
--- a/pandas/tests/io/excel/test_odswriter.py
+++ b/pandas/tests/io/excel/test_odswriter.py
@@ -56,3 +56,13 @@ def test_engine_kwargs(ext, engine_kwargs):
         else:
             with ExcelWriter(f, engine="odf", engine_kwargs=engine_kwargs) as _:
                 pass
+
+
+def test_book_and_sheets_consistent(ext):
+    # GH#45687 - Ensure sheets is updated if user modifies book
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f) as writer:
+            assert writer.sheets == {}
+            table = odf.table.Table(name="test_name")
+            writer.book.spreadsheet.addElement(table)
+            assert writer.sheets == {"test_name": table}
diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index e0d4a0c12ecdf..3b122c8572751 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -1,3 +1,4 @@
+import contextlib
 from pathlib import Path
 import re
 
@@ -75,8 +76,8 @@ def test_write_cells_merge_styled(ext):
 
     with tm.ensure_clean(ext) as path:
         with _OpenpyxlWriter(path) as writer:
-            writer.write_cells(initial_cells, sheet_name=sheet_name)
-            writer.write_cells(merge_cells, sheet_name=sheet_name)
+            writer._write_cells(initial_cells, sheet_name=sheet_name)
+            writer._write_cells(merge_cells, sheet_name=sheet_name)
 
             wks = writer.sheets[sheet_name]
         xcell_b1 = wks["B1"]
@@ -159,12 +160,12 @@ def test_write_append_mode(ext, mode, expected):
         with ExcelWriter(f, engine="openpyxl", mode=mode) as writer:
             df.to_excel(writer, sheet_name="baz", index=False)
 
-        wb2 = openpyxl.load_workbook(f)
-        result = [sheet.title for sheet in wb2.worksheets]
-        assert result == expected
+        with contextlib.closing(openpyxl.load_workbook(f)) as wb2:
+            result = [sheet.title for sheet in wb2.worksheets]
+            assert result == expected
 
-        for index, cell_value in enumerate(expected):
-            assert wb2.worksheets[index]["A1"].value == cell_value
+            for index, cell_value in enumerate(expected):
+                assert wb2.worksheets[index]["A1"].value == cell_value
 
 
 @pytest.mark.parametrize(
@@ -187,15 +188,14 @@ def test_if_sheet_exists_append_modes(ext, if_sheet_exists, num_sheets, expected
         ) as writer:
             df2.to_excel(writer, sheet_name="foo", index=False)
 
-        wb = openpyxl.load_workbook(f)
-        assert len(wb.sheetnames) == num_sheets
-        assert wb.sheetnames[0] == "foo"
-        result = pd.read_excel(wb, "foo", engine="openpyxl")
-        assert list(result["fruit"]) == expected
-        if len(wb.sheetnames) == 2:
-            result = pd.read_excel(wb, wb.sheetnames[1], engine="openpyxl")
-            tm.assert_frame_equal(result, df2)
-        wb.close()
+        with contextlib.closing(openpyxl.load_workbook(f)) as wb:
+            assert len(wb.sheetnames) == num_sheets
+            assert wb.sheetnames[0] == "foo"
+            result = pd.read_excel(wb, "foo", engine="openpyxl")
+            assert list(result["fruit"]) == expected
+            if len(wb.sheetnames) == 2:
+                result = pd.read_excel(wb, wb.sheetnames[1], engine="openpyxl")
+                tm.assert_frame_equal(result, df2)
 
 
 @pytest.mark.parametrize(
@@ -279,9 +279,10 @@ def test_to_excel_with_openpyxl_engine(ext):
 def test_read_workbook(datapath, ext, read_only):
     # GH 39528
     filename = datapath("io", "data", "excel", "test1" + ext)
-    wb = openpyxl.load_workbook(filename, read_only=read_only)
-    result = pd.read_excel(wb, engine="openpyxl")
-    wb.close()
+    with contextlib.closing(
+        openpyxl.load_workbook(filename, read_only=read_only)
+    ) as wb:
+        result = pd.read_excel(wb, engine="openpyxl")
     expected = pd.read_excel(filename)
     tm.assert_frame_equal(result, expected)
 
@@ -306,16 +307,17 @@ def test_read_workbook(datapath, ext, read_only):
 # When read_only is None, use read_excel instead of a workbook
 @pytest.mark.parametrize("read_only", [True, False, None])
 def test_read_with_bad_dimension(
-    datapath, ext, header, expected_data, filename, read_only, request
+    datapath, ext, header, expected_data, filename, read_only
 ):
     # GH 38956, 39001 - no/incorrect dimension information
     path = datapath("io", "data", "excel", f"{filename}{ext}")
     if read_only is None:
         result = pd.read_excel(path, header=header)
     else:
-        wb = openpyxl.load_workbook(path, read_only=read_only)
-        result = pd.read_excel(wb, engine="openpyxl", header=header)
-        wb.close()
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl", header=header)
     expected = DataFrame(expected_data)
     tm.assert_frame_equal(result, expected)
 
@@ -343,15 +345,16 @@ def test_append_mode_file(ext):
 
 # When read_only is None, use read_excel instead of a workbook
 @pytest.mark.parametrize("read_only", [True, False, None])
-def test_read_with_empty_trailing_rows(datapath, ext, read_only, request):
+def test_read_with_empty_trailing_rows(datapath, ext, read_only):
     # GH 39181
     path = datapath("io", "data", "excel", f"empty_trailing_rows{ext}")
     if read_only is None:
         result = pd.read_excel(path)
     else:
-        wb = openpyxl.load_workbook(path, read_only=read_only)
-        result = pd.read_excel(wb, engine="openpyxl")
-        wb.close()
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl")
     expected = DataFrame(
         {
             "Title": [np.nan, "A", 1, 2, 3],
@@ -370,8 +373,40 @@ def test_read_empty_with_blank_row(datapath, ext, read_only):
     if read_only is None:
         result = pd.read_excel(path)
     else:
-        wb = openpyxl.load_workbook(path, read_only=read_only)
-        result = pd.read_excel(wb, engine="openpyxl")
-        wb.close()
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl")
     expected = DataFrame()
     tm.assert_frame_equal(result, expected)
+
+
+def test_book_and_sheets_consistent(ext):
+    # GH#45687 - Ensure sheets is updated if user modifies book
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f, engine="openpyxl") as writer:
+            assert writer.sheets == {}
+            sheet = writer.book.create_sheet("test_name", 0)
+            assert writer.sheets == {"test_name": sheet}
+
+
+def test_ints_spelled_with_decimals(datapath, ext):
+    # GH 46988 - openpyxl returns this sheet with floats
+    path = datapath("io", "data", "excel", f"ints_spelled_with_decimals{ext}")
+    result = pd.read_excel(path)
+    expected = DataFrame(range(2, 12), columns=[1])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_multiindex_header_no_index_names(datapath, ext):
+    # GH#47487
+    path = datapath("io", "data", "excel", f"multiindex_no_index_names{ext}")
+    result = pd.read_excel(path, index_col=[0, 1, 2], header=[0, 1, 2])
+    expected = DataFrame(
+        [[np.nan, "x", "x", "x"], ["x", np.nan, np.nan, np.nan]],
+        columns=pd.MultiIndex.from_tuples(
+            [("X", "Y", "A1"), ("X", "Y", "A2"), ("XX", "YY", "B1"), ("XX", "YY", "B2")]
+        ),
+        index=pd.MultiIndex.from_tuples([("A", "AA", "AAA"), ("A", "BB", "BBB")]),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index 7d18c2e63e74f..fa1d6bbfd5a7e 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -21,8 +21,6 @@
     Series,
 )
 import pandas._testing as tm
-from pandas.tests.io.excel import xlrd_version
-from pandas.util.version import Version
 
 read_ext_params = [".xls", ".xlsx", ".xlsm", ".xlsb", ".ods"]
 engine_params = [
@@ -69,12 +67,7 @@ def _is_valid_engine_ext_pair(engine, read_ext: str) -> bool:
         return False
     if read_ext == ".xlsb" and engine != "pyxlsb":
         return False
-    if (
-        engine == "xlrd"
-        and xlrd_version is not None
-        and xlrd_version >= Version("2")
-        and read_ext != ".xls"
-    ):
+    if engine == "xlrd" and read_ext != ".xls":
         return False
     return True
 
@@ -96,6 +89,7 @@ def _transfer_marks(engine, read_ext):
         for ext in read_ext_params
         if _is_valid_engine_ext_pair(eng, ext)
     ],
+    ids=str,
 )
 def engine_and_read_ext(request):
     """
@@ -150,9 +144,7 @@ def parser(self, *args, **kwargs):
             expected = expected_defaults[read_ext[1:]]
         assert result == expected
 
-    def test_usecols_int(self, read_ext, df_ref):
-        df_ref = df_ref.reindex(columns=["A", "B", "C"])
-
+    def test_usecols_int(self, read_ext):
         # usecols as int
         msg = "Passing an integer for `usecols`"
         with pytest.raises(ValueError, match=msg):
@@ -663,6 +655,7 @@ def test_read_excel_blank_with_header(self, read_ext):
         actual = pd.read_excel("blank_with_header" + read_ext, sheet_name="Sheet1")
         tm.assert_frame_equal(actual, expected)
 
+    @pytest.mark.filterwarnings("ignore:Cell A4 is marked:UserWarning:openpyxl")
     def test_date_conversion_overflow(self, request, engine, read_ext):
         # GH 10001 : pandas.ExcelFile ignore parse_dates=False
         if engine == "pyxlsb":
@@ -721,7 +714,7 @@ def test_excel_read_buffer(self, read_ext):
             actual = pd.read_excel(f, sheet_name="Sheet1", index_col=0)
             tm.assert_frame_equal(expected, actual)
 
-    def test_bad_engine_raises(self, read_ext):
+    def test_bad_engine_raises(self):
         bad_engine = "foo"
         with pytest.raises(ValueError, match="Unknown engine: foo"):
             pd.read_excel("", engine=bad_engine)
@@ -738,13 +731,12 @@ def test_bad_sheetname_raises(self, read_ext, sheet_name):
 
     def test_missing_file_raises(self, read_ext):
         bad_file = f"foo{read_ext}"
-        # CI tests with zh_CN.utf8, translates to "No such file or directory"
-        with pytest.raises(
-            FileNotFoundError, match=r"(No such file or directory|没有那个文件或目录)"
-        ):
+        # CI tests with other languages, translates to "No such file or directory"
+        match = r"(No such file or directory|没有那个文件或目录|File o directory non esistente)"
+        with pytest.raises(FileNotFoundError, match=match):
             pd.read_excel(bad_file)
 
-    def test_corrupt_bytes_raises(self, read_ext, engine):
+    def test_corrupt_bytes_raises(self, engine):
         bad_stream = b"foo"
         if engine is None:
             error = ValueError
@@ -766,10 +758,17 @@ def test_corrupt_bytes_raises(self, read_ext, engine):
         with pytest.raises(error, match=msg):
             pd.read_excel(bad_stream)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+            "pandas/tests/io/data/excel/test1.xlsx"
+        ),
+        check_before_test=True,
+    )
     def test_read_from_http_url(https://github.com/self,%20read_ext):
         url = (
-            "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
             "pandas/tests/io/data/excel/test1" + read_ext
         )
         url_table = pd.read_excel(url)
@@ -777,6 +776,7 @@ def test_read_from_http_url(https://github.com/self,%20read_ext):
         tm.assert_frame_equal(url_table, local_table)
 
     @td.skip_if_not_us_locale
+    @pytest.mark.single_cpu
     def test_read_from_s3_url(https://github.com/self,%20read_ext,%20s3_resource,%20s3so):
         # Bucket "pandas-test" created in tests/io/conftest.py
         with open("test1" + read_ext, "rb") as f:
@@ -788,6 +788,7 @@ def test_read_from_s3_url(https://github.com/self,%20read_ext,%20s3_resource,%20s3so):
         local_table = pd.read_excel("test1" + read_ext)
         tm.assert_frame_equal(url_table, local_table)
 
+    @pytest.mark.single_cpu
     def test_read_from_s3_object(self, read_ext, s3_resource, s3so):
         # GH 38788
         # Bucket "pandas-test" created in tests/io/conftest.py
@@ -1166,6 +1167,31 @@ def test_read_excel_skiprows(self, request, read_ext):
         )
         tm.assert_frame_equal(actual, expected)
 
+    def test_read_excel_skiprows_callable_not_in(self, request, read_ext):
+        # GH 4903
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        actual = pd.read_excel(
+            "testskiprows" + read_ext,
+            sheet_name="skiprows_list",
+            skiprows=lambda x: x not in [1, 3, 5],
+        )
+        expected = DataFrame(
+            [
+                [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                # [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                # [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=["a", "b", "c", "d"],
+        )
+        tm.assert_frame_equal(actual, expected)
+
     def test_read_excel_nrows(self, read_ext):
         # GH 16645
         num_rows_to_pull = 5
@@ -1188,6 +1214,42 @@ def test_read_excel_nrows_non_integer_parameter(self, read_ext):
         with pytest.raises(ValueError, match=msg):
             pd.read_excel("test1" + read_ext, nrows="5")
 
+    @pytest.mark.parametrize(
+        "filename,sheet_name,header,index_col,skiprows",
+        [
+            ("testmultiindex", "mi_column", [0, 1], 0, None),
+            ("testmultiindex", "mi_index", None, [0, 1], None),
+            ("testmultiindex", "both", [0, 1], [0, 1], None),
+            ("testmultiindex", "mi_column_name", [0, 1], 0, None),
+            ("testskiprows", "skiprows_list", None, None, [0, 2]),
+            ("testskiprows", "skiprows_list", None, None, lambda x: x == 0 or x == 2),
+        ],
+    )
+    def test_read_excel_nrows_params(
+        self, read_ext, filename, sheet_name, header, index_col, skiprows
+    ):
+        """
+        For various parameters, we should get the same result whether we
+        limit the rows during load (nrows=3) or after (df.iloc[:3]).
+        """
+        # GH 46894
+        expected = pd.read_excel(
+            filename + read_ext,
+            sheet_name=sheet_name,
+            header=header,
+            index_col=index_col,
+            skiprows=skiprows,
+        ).iloc[:3]
+        actual = pd.read_excel(
+            filename + read_ext,
+            sheet_name=sheet_name,
+            header=header,
+            index_col=index_col,
+            skiprows=skiprows,
+            nrows=3,
+        )
+        tm.assert_frame_equal(actual, expected)
+
     def test_read_excel_squeeze(self, read_ext):
         # GH 12157
         f = "test_squeeze" + read_ext
@@ -1288,7 +1350,7 @@ def test_ignore_chartsheets_by_int(self, request, engine, read_ext):
         ):
             pd.read_excel("chartsheet" + read_ext, sheet_name=1)
 
-    def test_euro_decimal_format(self, request, read_ext):
+    def test_euro_decimal_format(self, read_ext):
         # copied from read_csv
         result = pd.read_excel("test_decimal" + read_ext, decimal=",", skiprows=1)
         expected = DataFrame(
@@ -1312,7 +1374,7 @@ def cd_and_set_engine(self, engine, datapath, monkeypatch):
         monkeypatch.chdir(datapath("io", "data", "excel"))
         monkeypatch.setattr(pd, "ExcelFile", func)
 
-    def test_engine_used(self, read_ext, engine, monkeypatch):
+    def test_engine_used(self, read_ext, engine):
         expected_defaults = {
             "xlsx": "openpyxl",
             "xlsm": "openpyxl",
@@ -1496,17 +1558,11 @@ def test_excel_read_binary_via_read_excel(self, read_ext, engine):
         expected = pd.read_excel("test1" + read_ext, engine=engine)
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.skipif(
-        xlrd_version is not None and xlrd_version >= Version("2"),
-        reason="xlrd no longer supports xlsx",
-    )
-    def test_excel_high_surrogate(self):
-        # GH 23809
-        expected = DataFrame(["\udc88"], columns=["Column1"])
-
-        # should not produce a segmentation violation
-        actual = pd.read_excel("high_surrogate.xlsx", engine="xlrd")
-        tm.assert_frame_equal(expected, actual)
+    def test_read_excel_header_index_out_of_range(self, engine):
+        # GH#43143
+        with open("df_header_oob.xlsx", "rb") as f:
+            with pytest.raises(ValueError, match="exceeds maximum"):
+                pd.read_excel(f, header=[0, 1])
 
     @pytest.mark.parametrize("filename", ["df_empty.xlsx", "df_equals.xlsx"])
     def test_header_with_index_col(self, filename):
@@ -1565,7 +1621,7 @@ def test_corrupt_files_closed(self, engine, read_ext):
         # GH41778
         errors = (BadZipFile,)
         if engine is None:
-            pytest.skip()
+            pytest.skip(f"Invalid test for engine={engine}")
         elif engine == "xlrd":
             import xlrd
 
diff --git a/pandas/tests/io/excel/test_style.py b/pandas/tests/io/excel/test_style.py
index 8a142aebd719d..f26df440d263b 100644
--- a/pandas/tests/io/excel/test_style.py
+++ b/pandas/tests/io/excel/test_style.py
@@ -1,7 +1,15 @@
+import contextlib
+import time
+
 import numpy as np
 import pytest
 
-from pandas import DataFrame
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    read_excel,
+)
 import pandas._testing as tm
 
 from pandas.io.excel import ExcelWriter
@@ -37,13 +45,13 @@ def test_styler_to_excel_unstyled(engine):
             df.style.to_excel(writer, sheet_name="unstyled")
 
         openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
-        wb = openpyxl.load_workbook(path)
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
 
-        for col1, col2 in zip(wb["dataframe"].columns, wb["unstyled"].columns):
-            assert len(col1) == len(col2)
-            for cell1, cell2 in zip(col1, col2):
-                assert cell1.value == cell2.value
-                assert_equal_cell_styles(cell1, cell2)
+            for col1, col2 in zip(wb["dataframe"].columns, wb["unstyled"].columns):
+                assert len(col1) == len(col2)
+                for cell1, cell2 in zip(col1, col2):
+                    assert cell1.value == cell2.value
+                    assert_equal_cell_styles(cell1, cell2)
 
 
 shared_style_params = [
@@ -68,6 +76,51 @@ def test_styler_to_excel_unstyled(engine):
         ["alignment", "vertical"],
         {"xlsxwriter": None, "openpyxl": "bottom"},  # xlsxwriter Fails
     ),
+    ("vertical-align: middle;", ["alignment", "vertical"], "center"),
+    # Border widths
+    ("border-left: 2pt solid red", ["border", "left", "style"], "medium"),
+    ("border-left: 1pt dotted red", ["border", "left", "style"], "dotted"),
+    ("border-left: 2pt dotted red", ["border", "left", "style"], "mediumDashDotDot"),
+    ("border-left: 1pt dashed red", ["border", "left", "style"], "dashed"),
+    ("border-left: 2pt dashed red", ["border", "left", "style"], "mediumDashed"),
+    ("border-left: 1pt solid red", ["border", "left", "style"], "thin"),
+    ("border-left: 3pt solid red", ["border", "left", "style"], "thick"),
+    # Border expansion
+    (
+        "border-left: 2pt solid #111222",
+        ["border", "left", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "top", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "top", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "right", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "right", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "bottom", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "bottom", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "left", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "left", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    # Border styles
+    (
+        "border-left-style: hair; border-left-color: black",
+        ["border", "left", "style"],
+        "hair",
+    ),
 ]
 
 
@@ -87,13 +140,13 @@ def test_styler_to_excel_basic(engine, css, attrs, expected):
             styler.to_excel(writer, sheet_name="styled")
 
         openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
-        wb = openpyxl.load_workbook(path)
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
 
-        # test unstyled data cell does not have expected styles
-        # test styled cell has expected styles
-        u_cell, s_cell = wb["dataframe"].cell(2, 2), wb["styled"].cell(2, 2)
+            # test unstyled data cell does not have expected styles
+            # test styled cell has expected styles
+            u_cell, s_cell = wb["dataframe"].cell(2, 2), wb["styled"].cell(2, 2)
         for attr in attrs:
-            u_cell, s_cell = getattr(u_cell, attr), getattr(s_cell, attr)
+            u_cell, s_cell = getattr(u_cell, attr, None), getattr(s_cell, attr)
 
         if isinstance(expected, dict):
             assert u_cell is None or u_cell != expected[engine]
@@ -127,15 +180,15 @@ def test_styler_to_excel_basic_indexes(engine, css, attrs, expected):
             styler.to_excel(writer, sheet_name="styled")
 
         openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
-        wb = openpyxl.load_workbook(path)
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
 
-        # test null styled index cells does not have expected styles
-        # test styled cell has expected styles
-        ui_cell, si_cell = wb["null_styled"].cell(2, 1), wb["styled"].cell(2, 1)
-        uc_cell, sc_cell = wb["null_styled"].cell(1, 2), wb["styled"].cell(1, 2)
+            # test null styled index cells does not have expected styles
+            # test styled cell has expected styles
+            ui_cell, si_cell = wb["null_styled"].cell(2, 1), wb["styled"].cell(2, 1)
+            uc_cell, sc_cell = wb["null_styled"].cell(1, 2), wb["styled"].cell(1, 2)
         for attr in attrs:
-            ui_cell, si_cell = getattr(ui_cell, attr), getattr(si_cell, attr)
-            uc_cell, sc_cell = getattr(uc_cell, attr), getattr(sc_cell, attr)
+            ui_cell, si_cell = getattr(ui_cell, attr, None), getattr(si_cell, attr)
+            uc_cell, sc_cell = getattr(uc_cell, attr, None), getattr(sc_cell, attr)
 
         if isinstance(expected, dict):
             assert ui_cell is None or ui_cell != expected[engine]
@@ -149,6 +202,62 @@ def test_styler_to_excel_basic_indexes(engine, css, attrs, expected):
             assert sc_cell == expected
 
 
+# From https://openpyxl.readthedocs.io/en/stable/api/openpyxl.styles.borders.html
+# Note: Leaving behavior of "width"-type styles undefined; user should use border-width
+# instead
+excel_border_styles = [
+    # "thin",
+    "dashed",
+    "mediumDashDot",
+    "dashDotDot",
+    "hair",
+    "dotted",
+    "mediumDashDotDot",
+    # "medium",
+    "double",
+    "dashDot",
+    "slantDashDot",
+    # "thick",
+    "mediumDashed",
+]
+
+
+@pytest.mark.parametrize(
+    "engine",
+    ["xlsxwriter", "openpyxl"],
+)
+@pytest.mark.parametrize("border_style", excel_border_styles)
+def test_styler_to_excel_border_style(engine, border_style):
+    css = f"border-left: {border_style} black thin"
+    attrs = ["border", "left", "style"]
+    expected = border_style
+
+    pytest.importorskip(engine)
+    df = DataFrame(np.random.randn(1, 1))
+    styler = df.style.applymap(lambda x: css)
+
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine=engine) as writer:
+            df.to_excel(writer, sheet_name="dataframe")
+            styler.to_excel(writer, sheet_name="styled")
+
+        openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+
+            # test unstyled data cell does not have expected styles
+            # test styled cell has expected styles
+            u_cell, s_cell = wb["dataframe"].cell(2, 2), wb["styled"].cell(2, 2)
+        for attr in attrs:
+            u_cell, s_cell = getattr(u_cell, attr, None), getattr(s_cell, attr)
+
+        if isinstance(expected, dict):
+            assert u_cell is None or u_cell != expected[engine]
+            assert s_cell == expected[engine]
+        else:
+            assert u_cell is None or u_cell != expected
+            assert s_cell == expected
+
+
 def test_styler_custom_converter():
     openpyxl = pytest.importorskip("openpyxl")
 
@@ -163,5 +272,29 @@ def custom_converter(css):
                 writer, sheet_name="custom"
             )
 
-        wb = openpyxl.load_workbook(path)
-        assert wb["custom"].cell(2, 2).font.color.value == "00111222"
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            assert wb["custom"].cell(2, 2).font.color.value == "00111222"
+
+
+@pytest.mark.single_cpu
+@td.skip_if_not_us_locale
+def test_styler_to_s3(s3_resource, s3so):
+    # GH#46381
+
+    mock_bucket_name, target_file = "pandas-test", "test.xlsx"
+    df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
+    styler = df.style.set_sticky(axis="index")
+    styler.to_excel(f"s3://{mock_bucket_name}/{target_file}", storage_options=s3so)
+    timeout = 5
+    while True:
+        if target_file in (
+            obj.key for obj in s3_resource.Bucket("pandas-test").objects.all()
+        ):
+            break
+        time.sleep(0.1)
+        timeout -= 0.1
+        assert timeout > 0, "Timed out waiting for file to appear on moto"
+        result = read_excel(
+            f"s3://{mock_bucket_name}/{target_file}", index_col=0, storage_options=s3so
+        )
+        tm.assert_frame_equal(result, df)
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 0315783569c23..f6a77d3acb933 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -18,8 +18,7 @@
     DataFrame,
     Index,
     MultiIndex,
-    get_option,
-    set_option,
+    option_context,
 )
 import pandas._testing as tm
 
@@ -53,10 +52,8 @@ def set_engine(engine, ext):
     the test it rolls back said change to the global option.
     """
     option_name = f"io.excel.{ext.strip('.')}.writer"
-    prev_engine = get_option(option_name)
-    set_option(option_name, engine)
-    yield
-    set_option(option_name, prev_engine)  # Roll back option change
+    with option_context(option_name, engine):
+        yield
 
 
 @pytest.mark.parametrize(
@@ -338,8 +335,8 @@ class TestExcelWriter:
     def test_excel_sheet_size(self, path):
 
         # GH 26080
-        breaking_row_count = 2 ** 20 + 1
-        breaking_col_count = 2 ** 14 + 1
+        breaking_row_count = 2**20 + 1
+        breaking_col_count = 2**14 + 1
         # purposely using two arrays to prevent memory issues while testing
         row_arr = np.zeros(shape=(breaking_row_count, 1))
         col_arr = np.zeros(shape=(1, breaking_col_count))
@@ -353,7 +350,7 @@ def test_excel_sheet_size(self, path):
         with pytest.raises(ValueError, match=msg):
             col_df.to_excel(path)
 
-    def test_excel_sheet_by_name_raise(self, path, engine):
+    def test_excel_sheet_by_name_raise(self, path):
         gt = DataFrame(np.random.randn(10, 2))
         gt.to_excel(path)
 
@@ -499,15 +496,14 @@ def test_float_types(self, np_type, path):
 
         tm.assert_frame_equal(df, recons)
 
-    @pytest.mark.parametrize("np_type", [np.bool8, np.bool_])
-    def test_bool_types(self, np_type, path):
-        # Test np.bool8 and np.bool_ values read come back as float.
-        df = DataFrame([1, 0, True, False], dtype=np_type)
+    def test_bool_types(self, path):
+        # Test np.bool_ values read come back as float.
+        df = DataFrame([1, 0, True, False], dtype=np.bool_)
         df.to_excel(path, "test1")
 
         with ExcelFile(path) as reader:
             recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
-                np_type
+                np.bool_
             )
 
         tm.assert_frame_equal(df, recons)
@@ -652,7 +648,7 @@ def test_excel_roundtrip_datetime(self, merge_cells, tsframe, path):
 
         tm.assert_frame_equal(tsframe, recons)
 
-    def test_excel_date_datetime_format(self, engine, ext, path):
+    def test_excel_date_datetime_format(self, ext, path):
         # see gh-4133
         #
         # Excel output format strings
@@ -838,6 +834,19 @@ def test_to_excel_multiindex_no_write_index(self, path):
         # Test that it is the same as the initial frame.
         tm.assert_frame_equal(frame1, frame3)
 
+    def test_to_excel_empty_multiindex(self, path):
+        # GH 19543.
+        expected = DataFrame([], columns=[0, 1, 2])
+
+        df = DataFrame([], index=MultiIndex.from_tuples([], names=[0, 1]), columns=[2])
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            result = pd.read_excel(reader, sheet_name="test1")
+        tm.assert_frame_equal(
+            result, expected, check_index_type=False, check_dtype=False
+        )
+
     def test_to_excel_float_format(self, path):
         df = DataFrame(
             [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
@@ -865,11 +874,11 @@ def test_to_excel_output_encoding(self, ext):
         )
 
         with tm.ensure_clean("__tmp_to_excel_float_format__." + ext) as filename:
-            df.to_excel(filename, sheet_name="TestSheet", encoding="utf8")
+            df.to_excel(filename, sheet_name="TestSheet")
             result = pd.read_excel(filename, sheet_name="TestSheet", index_col=0)
             tm.assert_frame_equal(result, df)
 
-    def test_to_excel_unicode_filename(self, ext, path):
+    def test_to_excel_unicode_filename(self, ext):
         with tm.ensure_clean("\u0192u." + ext) as filename:
             try:
                 f = open(filename, "wb")
@@ -963,9 +972,12 @@ def test_duplicated_columns(self, path):
         tm.assert_frame_equal(result, expected)
 
         # Explicitly, we pass in the parameter.
-        result = pd.read_excel(
-            path, sheet_name="test1", index_col=0, mangle_dupe_cols=True
-        )
+        with tm.assert_produces_warning(
+            FutureWarning, match="the 'mangle_dupe_cols' keyword is deprecated"
+        ):
+            result = pd.read_excel(
+                path, sheet_name="test1", index_col=0, mangle_dupe_cols=True
+            )
         tm.assert_frame_equal(result, expected)
 
         # see gh-11007, gh-10970
@@ -986,8 +998,13 @@ def test_duplicated_columns(self, path):
         tm.assert_frame_equal(result, expected)
 
         msg = "Setting mangle_dupe_cols=False is not supported yet"
-        with pytest.raises(ValueError, match=msg):
-            pd.read_excel(path, sheet_name="test1", header=None, mangle_dupe_cols=False)
+        with tm.assert_produces_warning(
+            FutureWarning, match="the 'mangle_dupe_cols' keyword is deprecated"
+        ):
+            with pytest.raises(ValueError, match=msg):
+                pd.read_excel(
+                    path, sheet_name="test1", header=None, mangle_dupe_cols=False
+                )
 
     def test_swapped_columns(self, path):
         # Test for issue #5427.
@@ -1091,7 +1108,6 @@ def test_comment_empty_line(self, path):
         tm.assert_frame_equal(result, expected)
 
     def test_datetimes(self, path):
-
         # Test writing and reading datetimes. For issue #9139. (xref #9185)
         datetimes = [
             datetime(2013, 1, 13, 1, 2, 3),
@@ -1109,11 +1125,6 @@ def test_datetimes(self, path):
 
         write_frame = DataFrame({"A": datetimes})
         write_frame.to_excel(path, "Sheet1")
-        if path.endswith("xlsx") or path.endswith("xlsm"):
-            pytest.skip(
-                "Defaults to openpyxl and fails with floating point error on "
-                "datetimes; may be fixed on newer versions of openpyxl - GH #38644"
-            )
         read_frame = pd.read_excel(path, sheet_name="Sheet1", header=0)
 
         tm.assert_series_equal(write_frame["A"], read_frame["A"])
@@ -1192,7 +1203,7 @@ def test_path_local_path(self, engine, ext):
         result = tm.round_trip_localpath(writer, reader, path=f"foo{ext}")
         tm.assert_frame_equal(result, df)
 
-    def test_merged_cell_custom_objects(self, merge_cells, path):
+    def test_merged_cell_custom_objects(self, path):
         # see GH-27006
         mi = MultiIndex.from_tuples(
             [
@@ -1247,6 +1258,59 @@ def test_if_sheet_exists_raises(self, ext):
             with pytest.raises(ValueError, match=re.escape(msg)):
                 ExcelWriter(f, if_sheet_exists="replace")
 
+    def test_excel_writer_empty_frame(self, engine, ext):
+        # GH#45793
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path, engine=engine) as writer:
+                DataFrame().to_excel(writer)
+            result = pd.read_excel(path)
+            expected = DataFrame()
+            tm.assert_frame_equal(result, expected)
+
+    def test_to_excel_empty_frame(self, engine, ext):
+        # GH#45793
+        with tm.ensure_clean(ext) as path:
+            DataFrame().to_excel(path, engine=engine)
+            result = pd.read_excel(path)
+            expected = DataFrame()
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("attr", ["cur_sheet", "handles", "path"])
+    def test_deprecated_attr(self, engine, ext, attr):
+        # GH#45572
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path) as writer:
+                msg = f"{attr} is not part of the public API"
+                with tm.assert_produces_warning(FutureWarning, match=msg):
+                    getattr(writer, attr)
+                # Some engines raise if nothing is written
+                DataFrame().to_excel(writer)
+
+    @pytest.mark.filterwarnings("ignore:Calling close():UserWarning:xlsxwriter")
+    @pytest.mark.parametrize(
+        "attr, args", [("save", ()), ("write_cells", ([], "test"))]
+    )
+    def test_deprecated_method(self, engine, ext, attr, args):
+        # GH#45572
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path) as writer:
+                msg = f"{attr} is not part of the public API"
+                # Some engines raise if nothing is written
+                DataFrame().to_excel(writer)
+                with tm.assert_produces_warning(FutureWarning, match=msg):
+                    getattr(writer, attr)(*args)
+
+    def test_deprecated_book_setter(self, engine, ext):
+        # GH#48780
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path) as writer:
+                msg = "Setting the `book` attribute is not part of the public API"
+                # Some engines raise if nothing is written
+                DataFrame().to_excel(writer)
+                book = writer.book
+                with tm.assert_produces_warning(FutureWarning, match=msg):
+                    writer.book = book
+
 
 class TestExcelWriterEngineTests:
     @pytest.mark.parametrize(
@@ -1271,39 +1335,48 @@ def test_ExcelWriter_dispatch_raises(self):
             ExcelWriter("nothing")
 
     def test_register_writer(self):
-        # some awkward mocking to test out dispatch and such actually works
-        called_save = []
-        called_write_cells = []
-
         class DummyClass(ExcelWriter):
             called_save = False
             called_write_cells = False
-            supported_extensions = ["xlsx", "xls"]
-            engine = "dummy"
+            called_sheets = False
+            _supported_extensions = ("xlsx", "xls")
+            _engine = "dummy"
 
-            def save(self):
-                called_save.append(True)
+            def book(self):
+                pass
 
-            def write_cells(self, *args, **kwargs):
-                called_write_cells.append(True)
+            def _save(self):
+                type(self).called_save = True
 
-        def check_called(func):
-            func()
-            assert len(called_save) >= 1
-            assert len(called_write_cells) >= 1
-            del called_save[:]
-            del called_write_cells[:]
+            def _write_cells(self, *args, **kwargs):
+                type(self).called_write_cells = True
 
-        with pd.option_context("io.excel.xlsx.writer", "dummy"):
+            @property
+            def sheets(self):
+                type(self).called_sheets = True
+
+            @classmethod
+            def assert_called_and_reset(cls):
+                assert cls.called_save
+                assert cls.called_write_cells
+                assert not cls.called_sheets
+                cls.called_save = False
+                cls.called_write_cells = False
+
+        register_writer(DummyClass)
+
+        with option_context("io.excel.xlsx.writer", "dummy"):
             path = "something.xlsx"
             with tm.ensure_clean(path) as filepath:
-                register_writer(DummyClass)
                 with ExcelWriter(filepath) as writer:
                     assert isinstance(writer, DummyClass)
                 df = tm.makeCustomDataframe(1, 1)
-                check_called(lambda: df.to_excel(filepath))
-            with tm.ensure_clean("something.xls") as filepath:
-                check_called(lambda: df.to_excel(filepath, engine="dummy"))
+                df.to_excel(filepath)
+            DummyClass.assert_called_and_reset()
+
+        with tm.ensure_clean("something.xls") as filepath:
+            df.to_excel(filepath, engine="dummy")
+        DummyClass.assert_called_and_reset()
 
     @pytest.mark.parametrize(
         "ext",
diff --git a/pandas/tests/io/excel/test_xlrd.py b/pandas/tests/io/excel/test_xlrd.py
index 2309187b8e9af..86141f08f5f2d 100644
--- a/pandas/tests/io/excel/test_xlrd.py
+++ b/pandas/tests/io/excel/test_xlrd.py
@@ -6,8 +6,6 @@
 
 import pandas as pd
 import pandas._testing as tm
-from pandas.tests.io.excel import xlrd_version
-from pandas.util.version import Version
 
 from pandas.io.excel import ExcelFile
 from pandas.io.excel._base import inspect_excel_format
@@ -20,11 +18,7 @@
 )
 
 
-# error: Unsupported operand types for <= ("Version" and "None")
-if xlrd_version >= Version("2"):  # type: ignore[operator]
-    exts = [".xls"]
-else:
-    exts = [".xls", ".xlsx", ".xlsm"]
+exts = [".xls"]
 
 
 @pytest.fixture(params=exts)
@@ -45,13 +39,14 @@ def test_read_xlrd_book(read_ext_xlrd, frame):
 
     with tm.ensure_clean(read_ext_xlrd) as pth:
         df.to_excel(pth, sheet_name)
-        book = xlrd.open_workbook(pth)
-
-        with ExcelFile(book, engine=engine) as xl:
-            result = pd.read_excel(xl, sheet_name=sheet_name, index_col=0)
-            tm.assert_frame_equal(df, result)
-
-        result = pd.read_excel(book, sheet_name=sheet_name, engine=engine, index_col=0)
+        with xlrd.open_workbook(pth) as book:
+            with ExcelFile(book, engine=engine) as xl:
+                result = pd.read_excel(xl, sheet_name=sheet_name, index_col=0)
+                tm.assert_frame_equal(df, result)
+
+            result = pd.read_excel(
+                book, sheet_name=sheet_name, engine=engine, index_col=0
+            )
         tm.assert_frame_equal(df, result)
 
 
@@ -76,19 +71,11 @@ def test_read_excel_warning_with_xlsx_file(datapath):
     path = datapath("io", "data", "excel", "test1.xlsx")
     has_openpyxl = import_optional_dependency("openpyxl", errors="ignore") is not None
     if not has_openpyxl:
-        if xlrd_version >= Version("2"):
-            with pytest.raises(
-                ValueError,
-                match="Your version of xlrd is ",
-            ):
-                pd.read_excel(path, "Sheet1", engine=None)
-        else:
-            with tm.assert_produces_warning(
-                FutureWarning,
-                raise_on_extra_warnings=False,
-                match="The xlrd engine is no longer maintained",
-            ):
-                pd.read_excel(path, "Sheet1", engine=None)
+        with pytest.raises(
+            ValueError,
+            match="Your version of xlrd is ",
+        ):
+            pd.read_excel(path, "Sheet1", engine=None)
     else:
         with tm.assert_produces_warning(None):
             pd.read_excel(path, "Sheet1", engine=None)
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 79d2f55a9b8ff..82d47a13aefbc 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -1,3 +1,4 @@
+import contextlib
 import re
 import warnings
 
@@ -34,12 +35,12 @@ def test_column_format(ext):
             col_format = write_workbook.add_format({"num_format": num_format})
             write_worksheet.set_column("B:B", None, col_format)
 
-        read_workbook = openpyxl.load_workbook(path)
-        try:
-            read_worksheet = read_workbook["Sheet1"]
-        except TypeError:
-            # compat
-            read_worksheet = read_workbook.get_sheet_by_name(name="Sheet1")
+        with contextlib.closing(openpyxl.load_workbook(path)) as read_workbook:
+            try:
+                read_worksheet = read_workbook["Sheet1"]
+            except TypeError:
+                # compat
+                read_worksheet = read_workbook.get_sheet_by_name(name="Sheet1")
 
         # Get the number format from the cell.
         try:
@@ -82,3 +83,12 @@ def test_engine_kwargs(ext, nan_inf_to_errors):
     with tm.ensure_clean(ext) as f:
         with ExcelWriter(f, engine="xlsxwriter", engine_kwargs=engine_kwargs) as writer:
             assert writer.book.nan_inf_to_errors == nan_inf_to_errors
+
+
+def test_book_and_sheets_consistent(ext):
+    # GH#45687 - Ensure sheets is updated if user modifies book
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f, engine="xlsxwriter") as writer:
+            assert writer.sheets == {}
+            sheet = writer.book.add_worksheet("test_name")
+            assert writer.sheets == {"test_name": sheet}
diff --git a/pandas/tests/io/excel/test_xlwt.py b/pandas/tests/io/excel/test_xlwt.py
index ec333defd85ac..3aa405eb1e275 100644
--- a/pandas/tests/io/excel/test_xlwt.py
+++ b/pandas/tests/io/excel/test_xlwt.py
@@ -125,3 +125,22 @@ def test_engine_kwargs(ext, style_compression):
             assert writer.book._Workbook__styles.style_compression == style_compression
             # xlwt won't allow us to close without writing something
             DataFrame().to_excel(writer)
+
+
+def test_book_and_sheets_consistent(ext):
+    # GH#45687 - Ensure sheets is updated if user modifies book
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f) as writer:
+            assert writer.sheets == {}
+            sheet = writer.book.add_sheet("test_name")
+            assert writer.sheets == {"test_name": sheet}
+
+
+@pytest.mark.parametrize("attr", ["fm_date", "fm_datetime"])
+def test_deprecated_attr(ext, attr):
+    # GH#45572
+    with tm.ensure_clean(ext) as path:
+        with ExcelWriter(path, engine="xlwt") as writer:
+            msg = f"{attr} is not part of the public API"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                getattr(writer, attr)
diff --git a/pandas/tests/io/formats/style/test_deprecated.py b/pandas/tests/io/formats/style/test_deprecated.py
index 9c96e3cf1ba81..863c31ed3cccd 100644
--- a/pandas/tests/io/formats/style/test_deprecated.py
+++ b/pandas/tests/io/formats/style/test_deprecated.py
@@ -163,3 +163,8 @@ def test_precision(df):
 def test_render(df):
     with tm.assert_produces_warning(FutureWarning):
         df.style.render()
+
+
+def test_null_color(df):
+    with tm.assert_produces_warning(FutureWarning):
+        df.style.highlight_null(null_color="blue")
diff --git a/pandas/tests/io/formats/style/test_exceptions.py b/pandas/tests/io/formats/style/test_exceptions.py
new file mode 100644
index 0000000000000..d52e3a37e7693
--- /dev/null
+++ b/pandas/tests/io/formats/style/test_exceptions.py
@@ -0,0 +1,44 @@
+import pytest
+
+jinja2 = pytest.importorskip("jinja2")
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        data=[[0, -0.609], [1, -1.228]],
+        columns=["A", "B"],
+        index=["x", "y"],
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+def test_concat_bad_columns(styler):
+    msg = "`other.data` must have same columns as `Styler.data"
+    with pytest.raises(ValueError, match=msg):
+        styler.concat(DataFrame([[1, 2]]).style)
+
+
+def test_concat_bad_type(styler):
+    msg = "`other` must be of type `Styler`"
+    with pytest.raises(TypeError, match=msg):
+        styler.concat(DataFrame([[1, 2]]))
+
+
+def test_concat_bad_index_levels(styler, df):
+    df = df.copy()
+    df.index = MultiIndex.from_tuples([(0, 0), (1, 1)])
+    msg = "number of index levels must be same in `other`"
+    with pytest.raises(ValueError, match=msg):
+        styler.concat(df.style)
diff --git a/pandas/tests/io/formats/style/test_format.py b/pandas/tests/io/formats/style/test_format.py
index 5207be992d606..0b114ea128b0b 100644
--- a/pandas/tests/io/formats/style/test_format.py
+++ b/pandas/tests/io/formats/style/test_format.py
@@ -30,6 +30,20 @@ def styler(df):
     return Styler(df, uuid_len=0)
 
 
+@pytest.fixture
+def df_multi():
+    return DataFrame(
+        data=np.arange(16).reshape(4, 4),
+        columns=MultiIndex.from_product([["A", "B"], ["a", "b"]]),
+        index=MultiIndex.from_product([["X", "Y"], ["x", "y"]]),
+    )
+
+
+@pytest.fixture
+def styler_multi(df_multi):
+    return Styler(df_multi, uuid_len=0)
+
+
 def test_display_format(styler):
     ctx = styler.format("{:0.1f}")._translate(True, True)
     assert all(["display_value" in c for c in row] for row in ctx["body"])
@@ -434,3 +448,54 @@ def test_1level_multiindex():
     assert ctx["body"][0][0]["is_visible"] is True
     assert ctx["body"][1][0]["display_value"] == "2"
     assert ctx["body"][1][0]["is_visible"] is True
+
+
+def test_boolean_format():
+    # gh 46384: booleans do not collapse to integer representation on display
+    df = DataFrame([[True, False]])
+    ctx = df.style._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] is True
+    assert ctx["body"][0][2]["display_value"] is False
+
+
+@pytest.mark.parametrize(
+    "hide, labels",
+    [
+        (False, [1, 2]),
+        (True, [1, 2, 3, 4]),
+    ],
+)
+def test_relabel_raise_length(styler_multi, hide, labels):
+    if hide:
+        styler_multi.hide(axis=0, subset=[("X", "x"), ("Y", "y")])
+    with pytest.raises(ValueError, match="``labels`` must be of length equal"):
+        styler_multi.relabel_index(labels=labels)
+
+
+def test_relabel_index(styler_multi):
+    labels = [(1, 2), (3, 4)]
+    styler_multi.hide(axis=0, subset=[("X", "x"), ("Y", "y")])
+    styler_multi.relabel_index(labels=labels)
+    ctx = styler_multi._translate(True, True)
+    assert {"value": "X", "display_value": 1}.items() <= ctx["body"][0][0].items()
+    assert {"value": "y", "display_value": 2}.items() <= ctx["body"][0][1].items()
+    assert {"value": "Y", "display_value": 3}.items() <= ctx["body"][1][0].items()
+    assert {"value": "x", "display_value": 4}.items() <= ctx["body"][1][1].items()
+
+
+def test_relabel_columns(styler_multi):
+    labels = [(1, 2), (3, 4)]
+    styler_multi.hide(axis=1, subset=[("A", "a"), ("B", "b")])
+    styler_multi.relabel_index(axis=1, labels=labels)
+    ctx = styler_multi._translate(True, True)
+    assert {"value": "A", "display_value": 1}.items() <= ctx["head"][0][3].items()
+    assert {"value": "B", "display_value": 3}.items() <= ctx["head"][0][4].items()
+    assert {"value": "b", "display_value": 2}.items() <= ctx["head"][1][3].items()
+    assert {"value": "a", "display_value": 4}.items() <= ctx["head"][1][4].items()
+
+
+def test_relabel_roundtrip(styler):
+    styler.relabel_index(["{}", "{}"])
+    ctx = styler._translate(True, True)
+    assert {"value": "x", "display_value": "x"}.items() <= ctx["body"][0][0].items()
+    assert {"value": "y", "display_value": "y"}.items() <= ctx["body"][1][0].items()
diff --git a/pandas/tests/io/formats/style/test_highlight.py b/pandas/tests/io/formats/style/test_highlight.py
index 1b579a43370a2..3d59719010ee0 100644
--- a/pandas/tests/io/formats/style/test_highlight.py
+++ b/pandas/tests/io/formats/style/test_highlight.py
@@ -12,9 +12,12 @@
 from pandas.io.formats.style import Styler
 
 
-@pytest.fixture
-def df():
-    return DataFrame({"A": [0, np.nan, 10], "B": [1, None, 2]})
+@pytest.fixture(params=[(None, "float64"), (NA, "Int64")])
+def df(request):
+    # GH 45804
+    return DataFrame(
+        {"A": [0, np.nan, 10], "B": [1, request.param[0], 2]}, dtype=request.param[1]
+    )
 
 
 @pytest.fixture
@@ -34,8 +37,8 @@ def test_highlight_null(styler):
 def test_highlight_null_subset(styler):
     # GH 31345
     result = (
-        styler.highlight_null(null_color="red", subset=["A"])
-        .highlight_null(null_color="green", subset=["B"])
+        styler.highlight_null(color="red", subset=["A"])
+        .highlight_null(color="green", subset=["B"])
         ._compute()
         .ctx
     )
@@ -185,7 +188,6 @@ def test_highlight_quantile(styler, kwargs):
     assert result == expected
 
 
-@pytest.mark.skipif(np.__version__[:4] in ["1.16", "1.17"], reason="Numpy Issue #14831")
 @pytest.mark.parametrize(
     "f,kwargs",
     [
diff --git a/pandas/tests/io/formats/style/test_html.py b/pandas/tests/io/formats/style/test_html.py
index fad289d5e0d2c..4ae95645a075d 100644
--- a/pandas/tests/io/formats/style/test_html.py
+++ b/pandas/tests/io/formats/style/test_html.py
@@ -1,4 +1,7 @@
-from textwrap import dedent
+from textwrap import (
+    dedent,
+    indent,
+)
 
 import numpy as np
 import pytest
@@ -302,11 +305,11 @@ def test_sticky_basic(styler, index, columns, index_name):
         styler.set_sticky(axis=1)
 
     left_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  left: 0px;\n  z-index: {1};\n}}"
     )
     top_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  top: {1}px;\n  z-index: {2};\n{3}}}"
     )
 
@@ -338,11 +341,11 @@ def test_sticky_mi(styler_mi, index, columns):
         styler_mi.set_sticky(axis=1)
 
     left_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  left: {1}px;\n  min-width: 75px;\n  max-width: 75px;\n  z-index: {2};\n}}"
     )
     top_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  top: {1}px;\n  height: 25px;\n  z-index: {2};\n}}"
     )
 
@@ -374,11 +377,11 @@ def test_sticky_levels(styler_mi, index, columns, levels):
         styler_mi.set_sticky(axis=1, levels=levels)
 
     left_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  left: {1}px;\n  min-width: 75px;\n  max-width: 75px;\n  z-index: {2};\n}}"
     )
     top_css = (
-        "#T_ {0} {{\n  position: sticky;\n  background-color: white;\n"
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
         "  top: {1}px;\n  height: 25px;\n  z-index: {2};\n}}"
     )
 
@@ -469,7 +472,7 @@ def test_maximums(styler_mi, rows, cols):
     assert (">2</td>" in result) is not cols  # first trimmed horizontal element
 
 
-def test_replaced_css_class_names(styler_mi):
+def test_replaced_css_class_names():
     css = {
         "row_heading": "ROWHEAD",
         # "col_heading": "COLHEAD",
@@ -778,8 +781,20 @@ def test_hiding_index_columns_multiindex_trimming():
         ("no scheme, no top-level: www.web", False, "www.web"),
         ("https scheme: https://www.web.com", True, "https://www.web.com/"),
         ("ftp scheme: ftp://www.web", True, "ftp://www.web"),
+        ("ftps scheme: ftps://www.web", True, "ftps://www.web"),
         ("subdirectories: www.web.com/directory", True, "www.web.com/directory"),
         ("Multiple domains: www.1.2.3.4", True, "www.1.2.3.4"),
+        ("with port: http://web.com:80", True, "http://web.com/"),
+        (
+            "full net_loc scheme: http://user:pass@web.com",
+            True,
+            "http://user:pass@web.com/",
+        ),
+        (
+            "with valid special chars: http://web.com/,.':;~!@#$*()[]",
+            True,
+            "http://web.com/,.':;~!@#$*()[]",
+        ),
     ],
 )
 def test_rendered_links(type, text, exp, found):
@@ -804,3 +819,159 @@ def test_multiple_rendered_links():
     for link in links:
         assert href.format(link) in result
     assert href.format("text") not in result
+
+
+def test_concat(styler):
+    other = styler.data.agg(["mean"]).style
+    styler.concat(other).set_uuid("X")
+    result = styler.to_html()
+    fp = "foot0_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp}row0" class="{fp}row_heading level0 {fp}row0" >mean</th>
+      <td id="T_X_{fp}row0_col0" class="{fp}data {fp}row0 col0" >2.650000</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_recursion(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["mean"]), precision=3)
+    styler3 = Styler(df.agg(["mean"]), precision=4)
+    styler1.concat(styler2.concat(styler3)).set_uuid("X")
+    result = styler.to_html()
+    # notice that the second concat (last <tr> of the output html),
+    # there are two `foot_` in the id and class
+    fp1 = "foot0_"
+    fp2 = "foot0_foot0_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp1}row0" class="{fp1}row_heading level0 {fp1}row0" >mean</th>
+      <td id="T_X_{fp1}row0_col0" class="{fp1}data {fp1}row0 col0" >2.650</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp2}row0" class="{fp2}row_heading level0 {fp2}row0" >mean</th>
+      <td id="T_X_{fp2}row0_col0" class="{fp2}data {fp2}row0 col0" >2.6500</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_chain(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["mean"]), precision=3)
+    styler3 = Styler(df.agg(["mean"]), precision=4)
+    styler1.concat(styler2).concat(styler3).set_uuid("X")
+    result = styler.to_html()
+    fp1 = "foot0_"
+    fp2 = "foot1_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp1}row0" class="{fp1}row_heading level0 {fp1}row0" >mean</th>
+      <td id="T_X_{fp1}row0_col0" class="{fp1}data {fp1}row0 col0" >2.650</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp2}row0" class="{fp2}row_heading level0 {fp2}row0" >mean</th>
+      <td id="T_X_{fp2}row0_col0" class="{fp2}data {fp2}row0 col0" >2.6500</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_combined():
+    def html_lines(foot_prefix: str):
+        assert foot_prefix.endswith("_") or foot_prefix == ""
+        fp = foot_prefix
+        return indent(
+            dedent(
+                f"""\
+        <tr>
+          <th id="T_X_level0_{fp}row0" class="{fp}row_heading level0 {fp}row0" >a</th>
+          <td id="T_X_{fp}row0_col0" class="{fp}data {fp}row0 col0" >2.610000</td>
+        </tr>
+        <tr>
+          <th id="T_X_level0_{fp}row1" class="{fp}row_heading level0 {fp}row1" >b</th>
+          <td id="T_X_{fp}row1_col0" class="{fp}data {fp}row1 col0" >2.690000</td>
+        </tr>
+        """
+            ),
+            prefix=" " * 4,
+        )
+
+    df = DataFrame([[2.61], [2.69]], index=["a", "b"], columns=["A"])
+    s1 = df.style.highlight_max(color="red")
+    s2 = df.style.highlight_max(color="green")
+    s3 = df.style.highlight_max(color="blue")
+    s4 = df.style.highlight_max(color="yellow")
+
+    result = s1.concat(s2).concat(s3.concat(s4)).set_uuid("X").to_html()
+    expected_css = dedent(
+        """\
+        <style type="text/css">
+        #T_X_row1_col0 {
+          background-color: red;
+        }
+        #T_X_foot0_row1_col0 {
+          background-color: green;
+        }
+        #T_X_foot1_row1_col0 {
+          background-color: blue;
+        }
+        #T_X_foot1_foot0_row1_col0 {
+          background-color: yellow;
+        }
+        </style>
+        """
+    )
+    expected_table = (
+        dedent(
+            """\
+            <table id="T_X">
+              <thead>
+                <tr>
+                  <th class="blank level0" >&nbsp;</th>
+                  <th id="T_X_level0_col0" class="col_heading level0 col0" >A</th>
+                </tr>
+              </thead>
+              <tbody>
+            """
+        )
+        + html_lines("")
+        + html_lines("foot0_")
+        + html_lines("foot1_")
+        + html_lines("foot1_foot0_")
+        + dedent(
+            """\
+              </tbody>
+            </table>
+            """
+        )
+    )
+    assert expected_css + expected_table == result
diff --git a/pandas/tests/io/formats/style/test_matplotlib.py b/pandas/tests/io/formats/style/test_matplotlib.py
index a350b6fe7546d..52fd5355e3302 100644
--- a/pandas/tests/io/formats/style/test_matplotlib.py
+++ b/pandas/tests/io/formats/style/test_matplotlib.py
@@ -216,7 +216,7 @@ def test_background_gradient_gmap_array_raises(gmap, axis):
     ],
 )
 def test_background_gradient_gmap_dataframe_align(styler_blank, gmap, subset, exp_gmap):
-    # test gmap given as DataFrame that it aligns to the the data including subset
+    # test gmap given as DataFrame that it aligns to the data including subset
     expected = styler_blank.background_gradient(axis=None, gmap=exp_gmap, subset=subset)
     result = styler_blank.background_gradient(axis=None, gmap=gmap, subset=subset)
     assert expected._compute().ctx == result._compute().ctx
@@ -232,7 +232,7 @@ def test_background_gradient_gmap_dataframe_align(styler_blank, gmap, subset, ex
     ],
 )
 def test_background_gradient_gmap_series_align(styler_blank, gmap, axis, exp_gmap):
-    # test gmap given as Series that it aligns to the the data including subset
+    # test gmap given as Series that it aligns to the data including subset
     expected = styler_blank.background_gradient(axis=None, gmap=exp_gmap)._compute()
     result = styler_blank.background_gradient(axis=axis, gmap=gmap)._compute()
     assert expected.ctx == result.ctx
@@ -284,3 +284,17 @@ def test_bar_color_raises(df):
     msg = "`color` and `cmap` cannot both be given"
     with pytest.raises(ValueError, match=msg):
         df.style.bar(color="something", cmap="something else").to_html()
+
+
+@pytest.mark.parametrize(
+    "plot_method",
+    ["scatter", "hexbin"],
+)
+def test_pass_colormap_instance(df, plot_method):
+    # https://github.com/pandas-dev/pandas/issues/49374
+    cmap = mpl.colors.ListedColormap([[1, 1, 1], [0, 0, 0]])
+    df["c"] = df.A + df.B
+    kwargs = dict(x="A", y="B", c="c", colormap=cmap)
+    if plot_method == "hexbin":
+        kwargs["C"] = kwargs.pop("c")
+    getattr(df.plot, plot_method)(**kwargs)
diff --git a/pandas/tests/io/formats/style/test_style.py b/pandas/tests/io/formats/style/test_style.py
index fa054ff7ca6c0..192fec048a930 100644
--- a/pandas/tests/io/formats/style/test_style.py
+++ b/pandas/tests/io/formats/style/test_style.py
@@ -5,10 +5,12 @@
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import (
     DataFrame,
+    IndexSlice,
     MultiIndex,
+    Series,
+    option_context,
 )
 import pandas._testing as tm
 
@@ -53,6 +55,9 @@ def mi_styler_comp(mi_styler):
     mi_styler.hide(axis="index")
     mi_styler.hide([("i0", "i1_a")], axis="index", names=True)
     mi_styler.set_table_attributes('class="box"')
+    other = mi_styler.data.agg(["mean"])
+    other.index = MultiIndex.from_product([[""], other.index])
+    mi_styler.concat(other.style)
     mi_styler.format(na_rep="MISSING", precision=3)
     mi_styler.format_index(precision=2, axis=0)
     mi_styler.format_index(precision=4, axis=1)
@@ -74,6 +79,25 @@ def mi_styler_comp(mi_styler):
     return mi_styler
 
 
+@pytest.fixture
+def blank_value():
+    return "&nbsp;"
+
+
+@pytest.fixture
+def df():
+    np.random.seed(24)
+    df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
+    return df
+
+
+@pytest.fixture
+def styler(df):
+    np.random.seed(24)
+    df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
+    return Styler(df)
+
+
 @pytest.mark.parametrize(
     "sparse_columns, exp_cols",
     [
@@ -137,16 +161,16 @@ def test_mi_styler_sparsify_index(mi_styler, sparse_index, exp_rows):
 
 
 def test_mi_styler_sparsify_options(mi_styler):
-    with pd.option_context("styler.sparse.index", False):
+    with option_context("styler.sparse.index", False):
         html1 = mi_styler.to_html()
-    with pd.option_context("styler.sparse.index", True):
+    with option_context("styler.sparse.index", True):
         html2 = mi_styler.to_html()
 
     assert html1 != html2
 
-    with pd.option_context("styler.sparse.columns", False):
+    with option_context("styler.sparse.columns", False):
         html1 = mi_styler.to_html()
-    with pd.option_context("styler.sparse.columns", True):
+    with option_context("styler.sparse.columns", True):
         html2 = mi_styler.to_html()
 
     assert html1 != html2
@@ -180,7 +204,7 @@ def test_trimming_maximum(rn, cn, max_els, max_rows, max_cols, exp_rn, exp_cn):
 def test_render_trimming_rows(option, val):
     # test auto and specific trimming of rows
     df = DataFrame(np.arange(120).reshape(60, 2))
-    with pd.option_context(option, val):
+    with option_context(option, val):
         ctx = df.style._translate(True, True)
     assert len(ctx["head"][0]) == 3  # index + 2 data cols
     assert len(ctx["body"]) == 4  # 3 data rows + trimming row
@@ -197,7 +221,7 @@ def test_render_trimming_rows(option, val):
 def test_render_trimming_cols(option, val):
     # test auto and specific trimming of cols
     df = DataFrame(np.arange(30).reshape(3, 10))
-    with pd.option_context(option, val):
+    with option_context(option, val):
         ctx = df.style._translate(True, True)
     assert len(ctx["head"][0]) == 4  # index + 2 data cols + trimming col
     assert len(ctx["body"]) == 3  # 3 data rows
@@ -207,7 +231,7 @@ def test_render_trimming_cols(option, val):
 def test_render_trimming_mi():
     midx = MultiIndex.from_product([[1, 2], [1, 2, 3]])
     df = DataFrame(np.arange(36).reshape(6, 6), columns=midx, index=midx)
-    with pd.option_context("styler.render.max_elements", 4):
+    with option_context("styler.render.max_elements", 4):
         ctx = df.style._translate(True, True)
 
     assert len(ctx["body"][0]) == 5  # 2 indexes + 2 data cols + trimming row
@@ -438,70 +462,49 @@ def test_apply_map_header_raises(mi_styler):
 
 
 class TestStyler:
-    def setup_method(self, method):
-        np.random.seed(24)
-        self.s = DataFrame({"A": np.random.permutation(range(6))})
-        self.df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
-        self.f = lambda x: x
-        self.g = lambda x: x
-
-        def h(x, foo="bar"):
-            return pd.Series(f"color: {foo}", index=x.index, name=x.name)
-
-        self.h = h
-        self.styler = Styler(self.df)
-        self.attrs = DataFrame({"A": ["color: red", "color: blue"]})
-        self.dataframes = [
-            self.df,
-            DataFrame(
-                {"f": [1.0, 2.0], "o": ["a", "b"], "c": pd.Categorical(["a", "b"])}
-            ),
-        ]
-        self.blank_value = "&nbsp;"
-
     def test_init_non_pandas(self):
         msg = "``data`` must be a Series or DataFrame"
         with pytest.raises(TypeError, match=msg):
             Styler([1, 2, 3])
 
     def test_init_series(self):
-        result = Styler(pd.Series([1, 2]))
+        result = Styler(Series([1, 2]))
         assert result.data.ndim == 2
 
-    def test_repr_html_ok(self):
-        self.styler._repr_html_()
+    def test_repr_html_ok(self, styler):
+        styler._repr_html_()
 
-    def test_repr_html_mathjax(self):
+    def test_repr_html_mathjax(self, styler):
         # gh-19824 / 41395
-        assert "tex2jax_ignore" not in self.styler._repr_html_()
+        assert "tex2jax_ignore" not in styler._repr_html_()
 
-        with pd.option_context("styler.html.mathjax", False):
-            assert "tex2jax_ignore" in self.styler._repr_html_()
+        with option_context("styler.html.mathjax", False):
+            assert "tex2jax_ignore" in styler._repr_html_()
 
-    def test_update_ctx(self):
-        self.styler._update_ctx(self.attrs)
+    def test_update_ctx(self, styler):
+        styler._update_ctx(DataFrame({"A": ["color: red", "color: blue"]}))
         expected = {(0, 0): [("color", "red")], (1, 0): [("color", "blue")]}
-        assert self.styler.ctx == expected
+        assert styler.ctx == expected
 
-    def test_update_ctx_flatten_multi_and_trailing_semi(self):
+    def test_update_ctx_flatten_multi_and_trailing_semi(self, styler):
         attrs = DataFrame({"A": ["color: red; foo: bar", "color:blue ; foo: baz;"]})
-        self.styler._update_ctx(attrs)
+        styler._update_ctx(attrs)
         expected = {
             (0, 0): [("color", "red"), ("foo", "bar")],
             (1, 0): [("color", "blue"), ("foo", "baz")],
         }
-        assert self.styler.ctx == expected
+        assert styler.ctx == expected
 
     def test_render(self):
         df = DataFrame({"A": [0, 1]})
-        style = lambda x: pd.Series(["color: red", "color: blue"], name=x.name)
+        style = lambda x: Series(["color: red", "color: blue"], name=x.name)
         s = Styler(df, uuid="AB").apply(style)
         s.to_html()
         # it worked?
 
-    def test_multiple_render(self):
+    def test_multiple_render(self, df):
         # GH 39396
-        s = Styler(self.df, uuid_len=0).applymap(lambda x: "color: red;", subset=["A"])
+        s = Styler(df, uuid_len=0).applymap(lambda x: "color: red;", subset=["A"])
         s.to_html()  # do 2 renders to ensure css styles not duplicated
         assert (
             '<style type="text/css">\n#T__row0_col0, #T__row1_col0 {\n'
@@ -520,7 +523,7 @@ def test_render_empty_dfs(self):
 
     def test_render_double(self):
         df = DataFrame({"A": [0, 1]})
-        style = lambda x: pd.Series(
+        style = lambda x: Series(
             ["color: red; border: 1px", "color: blue; border: 2px"], name=x.name
         )
         s = Styler(df, uuid="AB").apply(style)
@@ -540,14 +543,14 @@ def test_set_properties(self):
     def test_set_properties_subset(self):
         df = DataFrame({"A": [0, 1]})
         result = (
-            df.style.set_properties(subset=pd.IndexSlice[0, "A"], color="white")
+            df.style.set_properties(subset=IndexSlice[0, "A"], color="white")
             ._compute()
             .ctx
         )
         expected = {(0, 0): [("color", "white")]}
         assert result == expected
 
-    def test_empty_index_name_doesnt_display(self):
+    def test_empty_index_name_doesnt_display(self, blank_value):
         # https://github.com/pandas-dev/pandas/pull/12090#issuecomment-180695902
         df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
         result = df.style._translate(True, True)
@@ -555,9 +558,9 @@ def test_empty_index_name_doesnt_display(self):
         expected = {
             "class": "blank level0",
             "type": "th",
-            "value": self.blank_value,
+            "value": blank_value,
             "is_visible": True,
-            "display_value": self.blank_value,
+            "display_value": blank_value,
         }
         assert expected.items() <= result["head"][0][0].items()
 
@@ -614,13 +617,13 @@ def test_apply_series_return(self, axis):
         df = DataFrame([[1, 2], [3, 4]], index=["X", "Y"], columns=["X", "Y"])
 
         # test Series return where len(Series) < df.index or df.columns but labels OK
-        func = lambda s: pd.Series(["color: red;"], index=["Y"])
+        func = lambda s: Series(["color: red;"], index=["Y"])
         result = df.style.apply(func, axis=axis)._compute().ctx
         assert result[(1, 1)] == [("color", "red")]
         assert result[(1 - axis, axis)] == [("color", "red")]
 
         # test Series return where labels align but different order
-        func = lambda s: pd.Series(["color: red;", "color: blue;"], index=["Y", "X"])
+        func = lambda s: Series(["color: red;", "color: blue;"], index=["Y", "X"])
         result = df.style.apply(func, axis=axis)._compute().ctx
         assert result[(0, 0)] == [("color", "blue")]
         assert result[(1, 1)] == [("color", "red")]
@@ -645,61 +648,58 @@ def test_apply_dataframe_return(self, index, columns):
     @pytest.mark.parametrize(
         "slice_",
         [
-            pd.IndexSlice[:],
-            pd.IndexSlice[:, ["A"]],
-            pd.IndexSlice[[1], :],
-            pd.IndexSlice[[1], ["A"]],
-            pd.IndexSlice[:2, ["A", "B"]],
+            IndexSlice[:],
+            IndexSlice[:, ["A"]],
+            IndexSlice[[1], :],
+            IndexSlice[[1], ["A"]],
+            IndexSlice[:2, ["A", "B"]],
         ],
     )
     @pytest.mark.parametrize("axis", [0, 1])
-    def test_apply_subset(self, slice_, axis):
-        result = (
-            self.df.style.apply(self.h, axis=axis, subset=slice_, foo="baz")
-            ._compute()
-            .ctx
-        )
+    def test_apply_subset(self, slice_, axis, df):
+        def h(x, foo="bar"):
+            return Series(f"color: {foo}", index=x.index, name=x.name)
+
+        result = df.style.apply(h, axis=axis, subset=slice_, foo="baz")._compute().ctx
         expected = {
             (r, c): [("color", "baz")]
-            for r, row in enumerate(self.df.index)
-            for c, col in enumerate(self.df.columns)
-            if row in self.df.loc[slice_].index and col in self.df.loc[slice_].columns
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
         }
         assert result == expected
 
     @pytest.mark.parametrize(
         "slice_",
         [
-            pd.IndexSlice[:],
-            pd.IndexSlice[:, ["A"]],
-            pd.IndexSlice[[1], :],
-            pd.IndexSlice[[1], ["A"]],
-            pd.IndexSlice[:2, ["A", "B"]],
+            IndexSlice[:],
+            IndexSlice[:, ["A"]],
+            IndexSlice[[1], :],
+            IndexSlice[[1], ["A"]],
+            IndexSlice[:2, ["A", "B"]],
         ],
     )
-    def test_applymap_subset(self, slice_):
-        result = (
-            self.df.style.applymap(lambda x: "color:baz;", subset=slice_)._compute().ctx
-        )
+    def test_applymap_subset(self, slice_, df):
+        result = df.style.applymap(lambda x: "color:baz;", subset=slice_)._compute().ctx
         expected = {
             (r, c): [("color", "baz")]
-            for r, row in enumerate(self.df.index)
-            for c, col in enumerate(self.df.columns)
-            if row in self.df.loc[slice_].index and col in self.df.loc[slice_].columns
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
         }
         assert result == expected
 
     @pytest.mark.parametrize(
         "slice_",
         [
-            pd.IndexSlice[:, pd.IndexSlice["x", "A"]],
-            pd.IndexSlice[:, pd.IndexSlice[:, "A"]],
-            pd.IndexSlice[:, pd.IndexSlice[:, ["A", "C"]]],  # missing col element
-            pd.IndexSlice[pd.IndexSlice["a", 1], :],
-            pd.IndexSlice[pd.IndexSlice[:, 1], :],
-            pd.IndexSlice[pd.IndexSlice[:, [1, 3]], :],  # missing row element
-            pd.IndexSlice[:, ("x", "A")],
-            pd.IndexSlice[("a", 1), :],
+            IndexSlice[:, IndexSlice["x", "A"]],
+            IndexSlice[:, IndexSlice[:, "A"]],
+            IndexSlice[:, IndexSlice[:, ["A", "C"]]],  # missing col element
+            IndexSlice[IndexSlice["a", 1], :],
+            IndexSlice[IndexSlice[:, 1], :],
+            IndexSlice[IndexSlice[:, [1, 3]], :],  # missing row element
+            IndexSlice[:, ("x", "A")],
+            IndexSlice[("a", 1), :],
         ],
     )
     def test_applymap_subset_multiindex(self, slice_):
@@ -737,7 +737,7 @@ def test_applymap_subset_multiindex_code(self):
         df = DataFrame(
             [[1, -1, 1, 1], [-1, 1, 1, 1]], index=["hello", "world"], columns=columns
         )
-        pct_subset = pd.IndexSlice[:, pd.IndexSlice[:, "%":"%"]]
+        pct_subset = IndexSlice[:, IndexSlice[:, "%":"%"]]
 
         def color_negative_red(val):
             color = "red" if val < 0 else "black"
@@ -746,6 +746,22 @@ def color_negative_red(val):
         df.loc[pct_subset]
         df.style.applymap(color_negative_red, subset=pct_subset)
 
+    @pytest.mark.parametrize(
+        "stylefunc", ["background_gradient", "bar", "text_gradient"]
+    )
+    def test_subset_for_boolean_cols(self, stylefunc):
+        # GH47838
+        df = DataFrame(
+            [
+                [1, 2],
+                [3, 4],
+            ],
+            columns=[False, True],
+        )
+        styled = getattr(df.style, stylefunc)()
+        styled._compute()
+        assert set(styled.ctx) == {(0, 0), (0, 1), (1, 0), (1, 1)}
+
     def test_empty(self):
         df = DataFrame({"A": [1, 0]})
         s = df.style
@@ -777,22 +793,22 @@ def test_init_with_na_rep(self):
         assert ctx["body"][0][1]["display_value"] == "NA"
         assert ctx["body"][0][2]["display_value"] == "NA"
 
-    def test_caption(self):
-        styler = Styler(self.df, caption="foo")
+    def test_caption(self, df):
+        styler = Styler(df, caption="foo")
         result = styler.to_html()
         assert all(["caption" in result, "foo" in result])
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_caption("baz")
         assert styler is result
         assert styler.caption == "baz"
 
-    def test_uuid(self):
-        styler = Styler(self.df, uuid="abc123")
+    def test_uuid(self, df):
+        styler = Styler(df, uuid="abc123")
         result = styler.to_html()
         assert "abc123" in result
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_uuid("aaa")
         assert result is styler
         assert result.uuid == "aaa"
@@ -805,25 +821,25 @@ def test_unique_id(self):
         ids = re.findall('id="(.*?)"', result)
         assert np.unique(ids).size == len(ids)
 
-    def test_table_styles(self):
+    def test_table_styles(self, df):
         style = [{"selector": "th", "props": [("foo", "bar")]}]  # default format
-        styler = Styler(self.df, table_styles=style)
+        styler = Styler(df, table_styles=style)
         result = " ".join(styler.to_html().split())
         assert "th { foo: bar; }" in result
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_table_styles(style)
         assert styler is result
         assert styler.table_styles == style
 
         # GH 39563
         style = [{"selector": "th", "props": "foo:bar;"}]  # css string format
-        styler = self.df.style.set_table_styles(style)
+        styler = df.style.set_table_styles(style)
         result = " ".join(styler.to_html().split())
         assert "th { foo: bar; }" in result
 
-    def test_table_styles_multiple(self):
-        ctx = self.df.style.set_table_styles(
+    def test_table_styles_multiple(self, df):
+        ctx = df.style.set_table_styles(
             [
                 {"selector": "th,td", "props": "color:red;"},
                 {"selector": "tr", "props": "color:green;"},
@@ -835,15 +851,19 @@ def test_table_styles_multiple(self):
             {"selector": "tr", "props": [("color", "green")]},
         ]
 
-    def test_table_styles_dict_multiple_selectors(self):
+    def test_table_styles_dict_multiple_selectors(self, df):
         # GH 44011
-        result = self.df.style.set_table_styles(
-            [{"selector": "th,td", "props": [("border-left", "2px solid black")]}]
+        result = df.style.set_table_styles(
+            {
+                "B": [
+                    {"selector": "th,td", "props": [("border-left", "2px solid black")]}
+                ]
+            }
         )._translate(True, True)["table_styles"]
 
         expected = [
-            {"selector": "th", "props": [("border-left", "2px solid black")]},
-            {"selector": "td", "props": [("border-left", "2px solid black")]},
+            {"selector": "th.col1", "props": [("border-left", "2px solid black")]},
+            {"selector": "td.col1", "props": [("border-left", "2px solid black")]},
         ]
 
         assert result == expected
@@ -860,13 +880,13 @@ def test_maybe_convert_css_to_tuples_err(self):
         with pytest.raises(ValueError, match=msg):
             maybe_convert_css_to_tuples("err")
 
-    def test_table_attributes(self):
+    def test_table_attributes(self, df):
         attributes = 'class="foo" data-bar'
-        styler = Styler(self.df, table_attributes=attributes)
+        styler = Styler(df, table_attributes=attributes)
         result = styler.to_html()
         assert 'class="foo" data-bar' in result
 
-        result = self.df.style.set_table_attributes(attributes).to_html()
+        result = df.style.set_table_attributes(attributes).to_html()
         assert 'class="foo" data-bar' in result
 
     def test_apply_none(self):
@@ -880,20 +900,20 @@ def f(x):
         result = DataFrame([[1, 2], [3, 4]]).style.apply(f, axis=None)._compute().ctx
         assert result[(1, 1)] == [("color", "red")]
 
-    def test_trim(self):
-        result = self.df.style.to_html()  # trim=True
+    def test_trim(self, df):
+        result = df.style.to_html()  # trim=True
         assert result.count("#") == 0
 
-        result = self.df.style.highlight_max().to_html()
-        assert result.count("#") == len(self.df.columns)
+        result = df.style.highlight_max().to_html()
+        assert result.count("#") == len(df.columns)
 
-    def test_export(self):
+    def test_export(self, df, styler):
         f = lambda x: "color: red" if x > 0 else "color: blue"
         g = lambda x, z: f"color: {z}" if x > 0 else f"color: {z}"
-        style1 = self.styler
+        style1 = styler
         style1.applymap(f).applymap(g, z="b").highlight_max()._compute()  # = render
         result = style1.export()
-        style2 = self.df.style
+        style2 = df.style
         style2.use(result)
         assert style1._todo == style2._todo
         style2.to_html()
@@ -913,13 +933,13 @@ def test_bad_apply_shape(self):
             df.style._apply(lambda x: ["", "", "", ""])
 
         with pytest.raises(ValueError, match=msg.format("index")):
-            df.style._apply(lambda x: pd.Series(["a:v;", ""], index=["A", "C"]), axis=0)
+            df.style._apply(lambda x: Series(["a:v;", ""], index=["A", "C"]), axis=0)
 
         with pytest.raises(ValueError, match=msg.format("columns")):
             df.style._apply(lambda x: ["", "", ""], axis=1)
 
         with pytest.raises(ValueError, match=msg.format("columns")):
-            df.style._apply(lambda x: pd.Series(["a:v;", ""], index=["X", "Z"]), axis=1)
+            df.style._apply(lambda x: Series(["a:v;", ""], index=["X", "Z"]), axis=1)
 
         msg = "returned ndarray with wrong shape"
         with pytest.raises(ValueError, match=msg):
@@ -1006,7 +1026,7 @@ def test_get_level_lengths_un_sorted(self):
         result = _get_level_lengths(index, sparsify=False, max_index=100)
         tm.assert_dict_equal(result, expected)
 
-    def test_mi_sparse_index_names(self):
+    def test_mi_sparse_index_names(self, blank_value):
         # Test the class names and displayed value are correct on rendering MI names
         df = DataFrame(
             {"A": [1, 2]},
@@ -1029,14 +1049,14 @@ def test_mi_sparse_index_names(self):
             },
             {
                 "class": "blank col0",
-                "display_value": self.blank_value,
+                "display_value": blank_value,
                 "is_visible": True,
             },
         ]
         for i, expected_dict in enumerate(expected):
             assert expected_dict.items() <= head[i].items()
 
-    def test_mi_sparse_column_names(self):
+    def test_mi_sparse_column_names(self, blank_value):
         df = DataFrame(
             np.arange(16).reshape(4, 4),
             index=MultiIndex.from_arrays(
@@ -1054,7 +1074,7 @@ def test_mi_sparse_column_names(self):
             expected = [
                 {
                     "class": "blank",
-                    "display_value": self.blank_value,
+                    "display_value": blank_value,
                     "is_visible": True,
                 },
                 {
@@ -1066,32 +1086,32 @@ def test_mi_sparse_column_names(self):
             for i, expected_dict in enumerate(expected):
                 assert expected_dict.items() <= head[i].items()
 
-    def test_hide_column_headers(self):
-        ctx = self.styler.hide(axis="columns")._translate(True, True)
+    def test_hide_column_headers(self, df, styler):
+        ctx = styler.hide(axis="columns")._translate(True, True)
         assert len(ctx["head"]) == 0  # no header entries with an unnamed index
 
-        self.df.index.name = "some_name"
-        ctx = self.df.style.hide(axis="columns")._translate(True, True)
+        df.index.name = "some_name"
+        ctx = df.style.hide(axis="columns")._translate(True, True)
         assert len(ctx["head"]) == 1
         # index names still visible, changed in #42101, reverted in 43404
 
-    def test_hide_single_index(self):
+    def test_hide_single_index(self, df):
         # GH 14194
         # single unnamed index
-        ctx = self.df.style._translate(True, True)
+        ctx = df.style._translate(True, True)
         assert ctx["body"][0][0]["is_visible"]
         assert ctx["head"][0][0]["is_visible"]
-        ctx2 = self.df.style.hide(axis="index")._translate(True, True)
+        ctx2 = df.style.hide(axis="index")._translate(True, True)
         assert not ctx2["body"][0][0]["is_visible"]
         assert not ctx2["head"][0][0]["is_visible"]
 
         # single named index
-        ctx3 = self.df.set_index("A").style._translate(True, True)
+        ctx3 = df.set_index("A").style._translate(True, True)
         assert ctx3["body"][0][0]["is_visible"]
         assert len(ctx3["head"]) == 2  # 2 header levels
         assert ctx3["head"][0][0]["is_visible"]
 
-        ctx4 = self.df.set_index("A").style.hide(axis="index")._translate(True, True)
+        ctx4 = df.set_index("A").style.hide(axis="index")._translate(True, True)
         assert not ctx4["body"][0][0]["is_visible"]
         assert len(ctx4["head"]) == 1  # only 1 header levels
         assert not ctx4["head"][0][0]["is_visible"]
@@ -1119,10 +1139,10 @@ def test_hide_multiindex(self):
         assert len(ctx2["head"][0]) == 3  # one hidden (col name) and two data columns
         assert not ctx2["head"][0][0]["is_visible"]
 
-    def test_hide_columns_single_level(self):
+    def test_hide_columns_single_level(self, df):
         # GH 14194
         # test hiding single column
-        ctx = self.df.style._translate(True, True)
+        ctx = df.style._translate(True, True)
         assert ctx["head"][0][1]["is_visible"]
         assert ctx["head"][0][1]["display_value"] == "A"
         assert ctx["head"][0][2]["is_visible"]
@@ -1130,13 +1150,13 @@ def test_hide_columns_single_level(self):
         assert ctx["body"][0][1]["is_visible"]  # col A, row 1
         assert ctx["body"][1][2]["is_visible"]  # col B, row 1
 
-        ctx = self.df.style.hide("A", axis="columns")._translate(True, True)
+        ctx = df.style.hide("A", axis="columns")._translate(True, True)
         assert not ctx["head"][0][1]["is_visible"]
         assert not ctx["body"][0][1]["is_visible"]  # col A, row 1
         assert ctx["body"][1][2]["is_visible"]  # col B, row 1
 
         # test hiding mulitiple columns
-        ctx = self.df.style.hide(["A", "B"], axis="columns")._translate(True, True)
+        ctx = df.style.hide(["A", "B"], axis="columns")._translate(True, True)
         assert not ctx["head"][0][1]["is_visible"]
         assert not ctx["head"][0][2]["is_visible"]
         assert not ctx["body"][0][1]["is_visible"]  # col A, row 1
@@ -1202,18 +1222,18 @@ def test_hide_columns_index_mult_levels(self):
             assert "row1" in ctx["body"][0][i]["class"]  # row0 not included in body
             assert ctx["body"][0][i]["is_visible"]
 
-    def test_pipe(self):
+    def test_pipe(self, df):
         def set_caption_from_template(styler, a, b):
             return styler.set_caption(f"Dataframe with a = {a} and b = {b}")
 
-        styler = self.df.style.pipe(set_caption_from_template, "A", b="B")
+        styler = df.style.pipe(set_caption_from_template, "A", b="B")
         assert "Dataframe with a = A and b = B" in styler.to_html()
 
         # Test with an argument that is a (callable, keyword_name) pair.
         def f(a, b, styler):
             return (a, b, styler)
 
-        styler = self.df.style
+        styler = df.style
         result = styler.pipe((f, "styler"), a=1, b=2)
         assert result == (1, 2, styler)
 
@@ -1315,18 +1335,18 @@ def test_uuid_len_raises(self, len_):
     @pytest.mark.parametrize(
         "slc",
         [
-            pd.IndexSlice[:, :],
-            pd.IndexSlice[:, 1],
-            pd.IndexSlice[1, :],
-            pd.IndexSlice[[1], [1]],
-            pd.IndexSlice[1, [1]],
-            pd.IndexSlice[[1], 1],
-            pd.IndexSlice[1],
-            pd.IndexSlice[1, 1],
+            IndexSlice[:, :],
+            IndexSlice[:, 1],
+            IndexSlice[1, :],
+            IndexSlice[[1], [1]],
+            IndexSlice[1, [1]],
+            IndexSlice[[1], 1],
+            IndexSlice[1],
+            IndexSlice[1, 1],
             slice(None, None, None),
             [0, 1],
             np.array([0, 1]),
-            pd.Series([0, 1]),
+            Series([0, 1]),
         ],
     )
     def test_non_reducing_slice(self, slc):
@@ -1335,13 +1355,13 @@ def test_non_reducing_slice(self, slc):
         tslice_ = non_reducing_slice(slc)
         assert isinstance(df.loc[tslice_], DataFrame)
 
-    @pytest.mark.parametrize("box", [list, pd.Series, np.array])
+    @pytest.mark.parametrize("box", [list, Series, np.array])
     def test_list_slice(self, box):
         # like dataframe getitem
         subset = box(["A"])
 
         df = DataFrame({"A": [1, 2], "B": [3, 4]}, index=["A", "B"])
-        expected = pd.IndexSlice[:, ["A"]]
+        expected = IndexSlice[:, ["A"]]
 
         result = non_reducing_slice(subset)
         tm.assert_frame_equal(df.loc[result], df.loc[expected])
@@ -1355,7 +1375,7 @@ def test_non_reducing_slice_on_multiindex(self):
             ("b", "d"): [4, 1],
         }
         df = DataFrame(dic, index=[0, 1])
-        idx = pd.IndexSlice
+        idx = IndexSlice
         slice_ = idx[:, idx["b", "d"]]
         tslice_ = non_reducing_slice(slice_)
 
@@ -1366,27 +1386,27 @@ def test_non_reducing_slice_on_multiindex(self):
     @pytest.mark.parametrize(
         "slice_",
         [
-            pd.IndexSlice[:, :],
+            IndexSlice[:, :],
             # check cols
-            pd.IndexSlice[:, pd.IndexSlice[["a"]]],  # inferred deeper need list
-            pd.IndexSlice[:, pd.IndexSlice[["a"], ["c"]]],  # inferred deeper need list
-            pd.IndexSlice[:, pd.IndexSlice["a", "c", :]],
-            pd.IndexSlice[:, pd.IndexSlice["a", :, "e"]],
-            pd.IndexSlice[:, pd.IndexSlice[:, "c", "e"]],
-            pd.IndexSlice[:, pd.IndexSlice["a", ["c", "d"], :]],  # check list
-            pd.IndexSlice[:, pd.IndexSlice["a", ["c", "d", "-"], :]],  # allow missing
-            pd.IndexSlice[:, pd.IndexSlice["a", ["c", "d", "-"], "e"]],  # no slice
+            IndexSlice[:, IndexSlice[["a"]]],  # inferred deeper need list
+            IndexSlice[:, IndexSlice[["a"], ["c"]]],  # inferred deeper need list
+            IndexSlice[:, IndexSlice["a", "c", :]],
+            IndexSlice[:, IndexSlice["a", :, "e"]],
+            IndexSlice[:, IndexSlice[:, "c", "e"]],
+            IndexSlice[:, IndexSlice["a", ["c", "d"], :]],  # check list
+            IndexSlice[:, IndexSlice["a", ["c", "d", "-"], :]],  # allow missing
+            IndexSlice[:, IndexSlice["a", ["c", "d", "-"], "e"]],  # no slice
             # check rows
-            pd.IndexSlice[pd.IndexSlice[["U"]], :],  # inferred deeper need list
-            pd.IndexSlice[pd.IndexSlice[["U"], ["W"]], :],  # inferred deeper need list
-            pd.IndexSlice[pd.IndexSlice["U", "W", :], :],
-            pd.IndexSlice[pd.IndexSlice["U", :, "Y"], :],
-            pd.IndexSlice[pd.IndexSlice[:, "W", "Y"], :],
-            pd.IndexSlice[pd.IndexSlice[:, "W", ["Y", "Z"]], :],  # check list
-            pd.IndexSlice[pd.IndexSlice[:, "W", ["Y", "Z", "-"]], :],  # allow missing
-            pd.IndexSlice[pd.IndexSlice["U", "W", ["Y", "Z", "-"]], :],  # no slice
+            IndexSlice[IndexSlice[["U"]], :],  # inferred deeper need list
+            IndexSlice[IndexSlice[["U"], ["W"]], :],  # inferred deeper need list
+            IndexSlice[IndexSlice["U", "W", :], :],
+            IndexSlice[IndexSlice["U", :, "Y"], :],
+            IndexSlice[IndexSlice[:, "W", "Y"], :],
+            IndexSlice[IndexSlice[:, "W", ["Y", "Z"]], :],  # check list
+            IndexSlice[IndexSlice[:, "W", ["Y", "Z", "-"]], :],  # allow missing
+            IndexSlice[IndexSlice["U", "W", ["Y", "Z", "-"]], :],  # no slice
             # check simultaneous
-            pd.IndexSlice[pd.IndexSlice[:, "W", "Y"], pd.IndexSlice["a", "c", :]],
+            IndexSlice[IndexSlice[:, "W", "Y"], IndexSlice["a", "c", :]],
         ],
     )
     def test_non_reducing_multi_slice_on_multiindex(self, slice_):
@@ -1505,7 +1525,7 @@ def test_get_level_lengths_mi_hidden():
 def test_row_trimming_hide_index():
     # gh 43703
     df = DataFrame([[1], [2], [3], [4], [5]])
-    with pd.option_context("styler.render.max_rows", 2):
+    with option_context("styler.render.max_rows", 2):
         ctx = df.style.hide([0, 1], axis="index")._translate(True, True)
     assert len(ctx["body"]) == 3
     for r, val in enumerate(["3", "4", "..."]):
@@ -1516,7 +1536,7 @@ def test_row_trimming_hide_index_mi():
     # gh 44247
     df = DataFrame([[1], [2], [3], [4], [5]])
     df.index = MultiIndex.from_product([[0], [0, 1, 2, 3, 4]])
-    with pd.option_context("styler.render.max_rows", 2):
+    with option_context("styler.render.max_rows", 2):
         ctx = df.style.hide([(0, 0), (0, 1)], axis="index")._translate(True, True)
     assert len(ctx["body"]) == 3
 
@@ -1538,7 +1558,7 @@ def test_row_trimming_hide_index_mi():
 def test_col_trimming_hide_columns():
     # gh 44272
     df = DataFrame([[1, 2, 3, 4, 5]])
-    with pd.option_context("styler.render.max_columns", 2):
+    with option_context("styler.render.max_columns", 2):
         ctx = df.style.hide([0, 1], axis="columns")._translate(True, True)
 
     assert len(ctx["head"][0]) == 6  # blank, [0, 1 (hidden)], [2 ,3 (visible)], + trim
@@ -1547,3 +1567,16 @@ def test_col_trimming_hide_columns():
         assert ctx["head"][0][c + 2]["is_visible"] == vals[1]
 
     assert len(ctx["body"][0]) == 6  # index + 2 hidden + 2 visible + trimming col
+
+
+def test_no_empty_apply(mi_styler):
+    # 45313
+    mi_styler.apply(lambda s: ["a:v;"] * 2, subset=[False, False])
+    mi_styler._compute()
+
+
+@pytest.mark.parametrize("format", ["html", "latex", "string"])
+def test_output_buffer(mi_styler, format):
+    # gh 47053
+    with tm.ensure_clean(f"delete_me.{format}") as f:
+        getattr(mi_styler, f"to_{format}")(f)
diff --git a/pandas/tests/io/formats/style/test_to_latex.py b/pandas/tests/io/formats/style/test_to_latex.py
index 9c61357286167..1c67d125664f8 100644
--- a/pandas/tests/io/formats/style/test_to_latex.py
+++ b/pandas/tests/io/formats/style/test_to_latex.py
@@ -876,3 +876,212 @@ def test_apply_index_hidden_levels():
         """
     )
     assert result == expected
+
+
+@pytest.mark.parametrize("clines", ["bad", "index", "skip-last", "all", "data"])
+def test_clines_validation(clines, styler):
+    msg = f"`clines` value of {clines} is invalid."
+    with pytest.raises(ValueError, match=msg):
+        styler.to_latex(clines=clines)
+
+
+@pytest.mark.parametrize(
+    "clines, exp",
+    [
+        ("all;index", "\n\\cline{1-1}"),
+        ("all;data", "\n\\cline{1-2}"),
+        ("skip-last;index", ""),
+        ("skip-last;data", ""),
+        (None, ""),
+    ],
+)
+@pytest.mark.parametrize("env", ["table", "longtable"])
+def test_clines_index(clines, exp, env):
+    df = DataFrame([[1], [2], [3], [4]])
+    result = df.style.to_latex(clines=clines, environment=env)
+    expected = f"""\
+0 & 1 \\\\{exp}
+1 & 2 \\\\{exp}
+2 & 3 \\\\{exp}
+3 & 4 \\\\{exp}
+"""
+    assert expected in result
+
+
+@pytest.mark.parametrize(
+    "clines, expected",
+    [
+        (
+            None,
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            """
+            ),
+        ),
+        (
+            "skip-last;index",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\cline{1-2}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            \\cline{1-2}
+            """
+            ),
+        ),
+        (
+            "skip-last;data",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\cline{1-3}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            \\cline{1-3}
+            """
+            ),
+        ),
+        (
+            "all;index",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+            \\cline{2-2}
+             & Y & 2 \\\\
+            \\cline{1-2} \\cline{2-2}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+            \\cline{2-2}
+             & Y & 4 \\\\
+            \\cline{1-2} \\cline{2-2}
+            """
+            ),
+        ),
+        (
+            "all;data",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+            \\cline{2-3}
+             & Y & 2 \\\\
+            \\cline{1-3} \\cline{2-3}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+            \\cline{2-3}
+             & Y & 4 \\\\
+            \\cline{1-3} \\cline{2-3}
+            """
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize("env", ["table"])
+def test_clines_multiindex(clines, expected, env):
+    # also tests simultaneously with hidden rows and a hidden multiindex level
+    midx = MultiIndex.from_product([["A", "-", "B"], [0], ["X", "Y"]])
+    df = DataFrame([[1], [2], [99], [99], [3], [4]], index=midx)
+    styler = df.style
+    styler.hide([("-", 0, "X"), ("-", 0, "Y")])
+    styler.hide(level=1)
+    result = styler.to_latex(clines=clines, environment=env)
+    assert expected in result
+
+
+def test_col_format_len(styler):
+    # gh 46037
+    result = styler.to_latex(environment="longtable", column_format="lrr{10cm}")
+    expected = r"\multicolumn{4}{r}{Continued on next page} \\"
+    assert expected in result
+
+
+def test_concat(styler):
+    result = styler.concat(styler.data.agg(["sum"]).style).to_latex()
+    expected = dedent(
+        """\
+    \\begin{tabular}{lrrl}
+     & A & B & C \\\\
+    0 & 0 & -0.61 & ab \\\\
+    1 & 1 & -1.22 & cd \\\\
+    sum & 1 & -1.830000 & abcd \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+def test_concat_recursion():
+    # tests hidden row recursion and applied styles
+    styler1 = DataFrame([[1], [9]]).style.hide([1]).highlight_min(color="red")
+    styler2 = DataFrame([[9], [2]]).style.hide([0]).highlight_min(color="green")
+    styler3 = DataFrame([[3], [9]]).style.hide([1]).highlight_min(color="blue")
+
+    result = styler1.concat(styler2.concat(styler3)).to_latex(convert_css=True)
+    expected = dedent(
+        """\
+    \\begin{tabular}{lr}
+     & 0 \\\\
+    0 & {\\cellcolor{red}} 1 \\\\
+    1 & {\\cellcolor{green}} 2 \\\\
+    0 & {\\cellcolor{blue}} 3 \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+def test_concat_chain():
+    # tests hidden row recursion and applied styles
+    styler1 = DataFrame([[1], [9]]).style.hide([1]).highlight_min(color="red")
+    styler2 = DataFrame([[9], [2]]).style.hide([0]).highlight_min(color="green")
+    styler3 = DataFrame([[3], [9]]).style.hide([1]).highlight_min(color="blue")
+
+    result = styler1.concat(styler2).concat(styler3).to_latex(convert_css=True)
+    expected = dedent(
+        """\
+    \\begin{tabular}{lr}
+     & 0 \\\\
+    0 & {\\cellcolor{red}} 1 \\\\
+    1 & {\\cellcolor{green}} 2 \\\\
+    0 & {\\cellcolor{blue}} 3 \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "df, expected",
+    [
+        (
+            DataFrame(),
+            dedent(
+                """\
+            \\begin{tabular}{l}
+            \\end{tabular}
+            """
+            ),
+        ),
+        (
+            DataFrame(columns=["a", "b", "c"]),
+            dedent(
+                """\
+            \\begin{tabular}{llll}
+             & a & b & c \\\\
+            \\end{tabular}
+            """
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "clines", [None, "all;data", "all;index", "skip-last;data", "skip-last;index"]
+)
+def test_empty_clines(df: DataFrame, expected: str, clines: str):
+    # GH 47203
+    result = df.style.to_latex(clines=clines)
+    assert result == expected
diff --git a/pandas/tests/io/formats/style/test_to_string.py b/pandas/tests/io/formats/style/test_to_string.py
new file mode 100644
index 0000000000000..913857396446c
--- /dev/null
+++ b/pandas/tests/io/formats/style/test_to_string.py
@@ -0,0 +1,91 @@
+from textwrap import dedent
+
+import pytest
+
+from pandas import DataFrame
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame({"A": [0, 1], "B": [-0.61, -1.22], "C": ["ab", "cd"]})
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0, precision=2)
+
+
+def test_basic_string(styler):
+    result = styler.to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    """
+    )
+    assert result == expected
+
+
+def test_string_delimiter(styler):
+    result = styler.to_string(delimiter=";")
+    expected = dedent(
+        """\
+    ;A;B;C
+    0;0;-0.61;ab
+    1;1;-1.22;cd
+    """
+    )
+    assert result == expected
+
+
+def test_concat(styler):
+    result = styler.concat(styler.data.agg(["sum"]).style).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830000 abcd
+    """
+    )
+    assert result == expected
+
+
+def test_concat_recursion(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["sum"]), uuid_len=0, precision=3)
+    styler3 = Styler(df.agg(["sum"]), uuid_len=0, precision=4)
+    result = styler1.concat(styler2.concat(styler3)).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830 abcd
+    sum 1 -1.8300 abcd
+    """
+    )
+    assert result == expected
+
+
+def test_concat_chain(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["sum"]), uuid_len=0, precision=3)
+    styler3 = Styler(df.agg(["sum"]), uuid_len=0, precision=4)
+    result = styler1.concat(styler2).concat(styler3).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830 abcd
+    sum 1 -1.8300 abcd
+    """
+    )
+    assert result == expected
diff --git a/pandas/tests/io/formats/test_console.py b/pandas/tests/io/formats/test_console.py
index 5bd73e6045e32..dd7b57df9baed 100644
--- a/pandas/tests/io/formats/test_console.py
+++ b/pandas/tests/io/formats/test_console.py
@@ -12,7 +12,7 @@ class MockEncoding:
     side effect should be an exception that will be raised.
     """
 
-    def __init__(self, encoding):
+    def __init__(self, encoding) -> None:
         super().__init__()
         self.val = encoding
 
diff --git a/pandas/tests/io/formats/test_css.py b/pandas/tests/io/formats/test_css.py
index 8465d116805c7..70c91dd02751a 100644
--- a/pandas/tests/io/formats/test_css.py
+++ b/pandas/tests/io/formats/test_css.py
@@ -1,11 +1,10 @@
 import pytest
 
+from pandas.errors import CSSWarning
+
 import pandas._testing as tm
 
-from pandas.io.formats.css import (
-    CSSResolver,
-    CSSWarning,
-)
+from pandas.io.formats.css import CSSResolver
 
 
 def assert_resolves(css, props, inherited=None):
@@ -57,6 +56,8 @@ def test_css_parse_normalisation(name, norm, abnorm):
         ("font-size: 1unknownunit", "font-size: 1em"),
         ("font-size: 10", "font-size: 1em"),
         ("font-size: 10 pt", "font-size: 1em"),
+        # Too many args
+        ("border-top: 1pt solid red green", "border-top: 1pt solid green"),
     ],
 )
 def test_css_parse_invalid(invalid_css, remainder):
@@ -123,6 +124,65 @@ def test_css_side_shorthands(shorthand, expansions):
         assert_resolves(f"{shorthand}: 1pt 1pt 1pt 1pt 1pt", {})
 
 
+@pytest.mark.parametrize(
+    "shorthand,sides",
+    [
+        ("border-top", ["top"]),
+        ("border-right", ["right"]),
+        ("border-bottom", ["bottom"]),
+        ("border-left", ["left"]),
+        ("border", ["top", "right", "bottom", "left"]),
+    ],
+)
+def test_css_border_shorthand_sides(shorthand, sides):
+    def create_border_dict(sides, color=None, style=None, width=None):
+        resolved = {}
+        for side in sides:
+            if color:
+                resolved[f"border-{side}-color"] = color
+            if style:
+                resolved[f"border-{side}-style"] = style
+            if width:
+                resolved[f"border-{side}-width"] = width
+        return resolved
+
+    assert_resolves(
+        f"{shorthand}: 1pt red solid", create_border_dict(sides, "red", "solid", "1pt")
+    )
+
+
+@pytest.mark.parametrize(
+    "prop, expected",
+    [
+        ("1pt red solid", ("red", "solid", "1pt")),
+        ("red 1pt solid", ("red", "solid", "1pt")),
+        ("red solid 1pt", ("red", "solid", "1pt")),
+        ("solid 1pt red", ("red", "solid", "1pt")),
+        ("red solid", ("red", "solid", "1.500000pt")),
+        # Note: color=black is not CSS conforming
+        # (See https://drafts.csswg.org/css-backgrounds/#border-shorthands)
+        ("1pt solid", ("black", "solid", "1pt")),
+        ("1pt red", ("red", "none", "1pt")),
+        ("red", ("red", "none", "1.500000pt")),
+        ("1pt", ("black", "none", "1pt")),
+        ("solid", ("black", "solid", "1.500000pt")),
+        # Sizes
+        ("1em", ("black", "none", "12pt")),
+    ],
+)
+def test_css_border_shorthands(prop, expected):
+    color, style, width = expected
+
+    assert_resolves(
+        f"border-left: {prop}",
+        {
+            "border-left-color": color,
+            "border-left-style": style,
+            "border-left-width": width,
+        },
+    )
+
+
 @pytest.mark.parametrize(
     "style,inherited,equiv",
     [
diff --git a/pandas/tests/io/formats/test_eng_formatting.py b/pandas/tests/io/formats/test_eng_formatting.py
index b8e3122cac5c4..2f18623559557 100644
--- a/pandas/tests/io/formats/test_eng_formatting.py
+++ b/pandas/tests/io/formats/test_eng_formatting.py
@@ -56,57 +56,57 @@ def test_exponents_with_eng_prefix(self):
         formatter = fmt.EngFormatter(accuracy=3, use_eng_prefix=True)
         f = np.sqrt(2)
         in_out = [
-            (f * 10 ** -24, " 1.414y"),
-            (f * 10 ** -23, " 14.142y"),
-            (f * 10 ** -22, " 141.421y"),
-            (f * 10 ** -21, " 1.414z"),
-            (f * 10 ** -20, " 14.142z"),
-            (f * 10 ** -19, " 141.421z"),
-            (f * 10 ** -18, " 1.414a"),
-            (f * 10 ** -17, " 14.142a"),
-            (f * 10 ** -16, " 141.421a"),
-            (f * 10 ** -15, " 1.414f"),
-            (f * 10 ** -14, " 14.142f"),
-            (f * 10 ** -13, " 141.421f"),
-            (f * 10 ** -12, " 1.414p"),
-            (f * 10 ** -11, " 14.142p"),
-            (f * 10 ** -10, " 141.421p"),
-            (f * 10 ** -9, " 1.414n"),
-            (f * 10 ** -8, " 14.142n"),
-            (f * 10 ** -7, " 141.421n"),
-            (f * 10 ** -6, " 1.414u"),
-            (f * 10 ** -5, " 14.142u"),
-            (f * 10 ** -4, " 141.421u"),
-            (f * 10 ** -3, " 1.414m"),
-            (f * 10 ** -2, " 14.142m"),
-            (f * 10 ** -1, " 141.421m"),
-            (f * 10 ** 0, " 1.414"),
-            (f * 10 ** 1, " 14.142"),
-            (f * 10 ** 2, " 141.421"),
-            (f * 10 ** 3, " 1.414k"),
-            (f * 10 ** 4, " 14.142k"),
-            (f * 10 ** 5, " 141.421k"),
-            (f * 10 ** 6, " 1.414M"),
-            (f * 10 ** 7, " 14.142M"),
-            (f * 10 ** 8, " 141.421M"),
-            (f * 10 ** 9, " 1.414G"),
-            (f * 10 ** 10, " 14.142G"),
-            (f * 10 ** 11, " 141.421G"),
-            (f * 10 ** 12, " 1.414T"),
-            (f * 10 ** 13, " 14.142T"),
-            (f * 10 ** 14, " 141.421T"),
-            (f * 10 ** 15, " 1.414P"),
-            (f * 10 ** 16, " 14.142P"),
-            (f * 10 ** 17, " 141.421P"),
-            (f * 10 ** 18, " 1.414E"),
-            (f * 10 ** 19, " 14.142E"),
-            (f * 10 ** 20, " 141.421E"),
-            (f * 10 ** 21, " 1.414Z"),
-            (f * 10 ** 22, " 14.142Z"),
-            (f * 10 ** 23, " 141.421Z"),
-            (f * 10 ** 24, " 1.414Y"),
-            (f * 10 ** 25, " 14.142Y"),
-            (f * 10 ** 26, " 141.421Y"),
+            (f * 10**-24, " 1.414y"),
+            (f * 10**-23, " 14.142y"),
+            (f * 10**-22, " 141.421y"),
+            (f * 10**-21, " 1.414z"),
+            (f * 10**-20, " 14.142z"),
+            (f * 10**-19, " 141.421z"),
+            (f * 10**-18, " 1.414a"),
+            (f * 10**-17, " 14.142a"),
+            (f * 10**-16, " 141.421a"),
+            (f * 10**-15, " 1.414f"),
+            (f * 10**-14, " 14.142f"),
+            (f * 10**-13, " 141.421f"),
+            (f * 10**-12, " 1.414p"),
+            (f * 10**-11, " 14.142p"),
+            (f * 10**-10, " 141.421p"),
+            (f * 10**-9, " 1.414n"),
+            (f * 10**-8, " 14.142n"),
+            (f * 10**-7, " 141.421n"),
+            (f * 10**-6, " 1.414u"),
+            (f * 10**-5, " 14.142u"),
+            (f * 10**-4, " 141.421u"),
+            (f * 10**-3, " 1.414m"),
+            (f * 10**-2, " 14.142m"),
+            (f * 10**-1, " 141.421m"),
+            (f * 10**0, " 1.414"),
+            (f * 10**1, " 14.142"),
+            (f * 10**2, " 141.421"),
+            (f * 10**3, " 1.414k"),
+            (f * 10**4, " 14.142k"),
+            (f * 10**5, " 141.421k"),
+            (f * 10**6, " 1.414M"),
+            (f * 10**7, " 14.142M"),
+            (f * 10**8, " 141.421M"),
+            (f * 10**9, " 1.414G"),
+            (f * 10**10, " 14.142G"),
+            (f * 10**11, " 141.421G"),
+            (f * 10**12, " 1.414T"),
+            (f * 10**13, " 14.142T"),
+            (f * 10**14, " 141.421T"),
+            (f * 10**15, " 1.414P"),
+            (f * 10**16, " 14.142P"),
+            (f * 10**17, " 141.421P"),
+            (f * 10**18, " 1.414E"),
+            (f * 10**19, " 14.142E"),
+            (f * 10**20, " 141.421E"),
+            (f * 10**21, " 1.414Z"),
+            (f * 10**22, " 14.142Z"),
+            (f * 10**23, " 141.421Z"),
+            (f * 10**24, " 1.414Y"),
+            (f * 10**25, " 14.142Y"),
+            (f * 10**26, " 141.421Y"),
         ]
         self.compare_all(formatter, in_out)
 
@@ -114,57 +114,57 @@ def test_exponents_without_eng_prefix(self):
         formatter = fmt.EngFormatter(accuracy=4, use_eng_prefix=False)
         f = np.pi
         in_out = [
-            (f * 10 ** -24, " 3.1416E-24"),
-            (f * 10 ** -23, " 31.4159E-24"),
-            (f * 10 ** -22, " 314.1593E-24"),
-            (f * 10 ** -21, " 3.1416E-21"),
-            (f * 10 ** -20, " 31.4159E-21"),
-            (f * 10 ** -19, " 314.1593E-21"),
-            (f * 10 ** -18, " 3.1416E-18"),
-            (f * 10 ** -17, " 31.4159E-18"),
-            (f * 10 ** -16, " 314.1593E-18"),
-            (f * 10 ** -15, " 3.1416E-15"),
-            (f * 10 ** -14, " 31.4159E-15"),
-            (f * 10 ** -13, " 314.1593E-15"),
-            (f * 10 ** -12, " 3.1416E-12"),
-            (f * 10 ** -11, " 31.4159E-12"),
-            (f * 10 ** -10, " 314.1593E-12"),
-            (f * 10 ** -9, " 3.1416E-09"),
-            (f * 10 ** -8, " 31.4159E-09"),
-            (f * 10 ** -7, " 314.1593E-09"),
-            (f * 10 ** -6, " 3.1416E-06"),
-            (f * 10 ** -5, " 31.4159E-06"),
-            (f * 10 ** -4, " 314.1593E-06"),
-            (f * 10 ** -3, " 3.1416E-03"),
-            (f * 10 ** -2, " 31.4159E-03"),
-            (f * 10 ** -1, " 314.1593E-03"),
-            (f * 10 ** 0, " 3.1416E+00"),
-            (f * 10 ** 1, " 31.4159E+00"),
-            (f * 10 ** 2, " 314.1593E+00"),
-            (f * 10 ** 3, " 3.1416E+03"),
-            (f * 10 ** 4, " 31.4159E+03"),
-            (f * 10 ** 5, " 314.1593E+03"),
-            (f * 10 ** 6, " 3.1416E+06"),
-            (f * 10 ** 7, " 31.4159E+06"),
-            (f * 10 ** 8, " 314.1593E+06"),
-            (f * 10 ** 9, " 3.1416E+09"),
-            (f * 10 ** 10, " 31.4159E+09"),
-            (f * 10 ** 11, " 314.1593E+09"),
-            (f * 10 ** 12, " 3.1416E+12"),
-            (f * 10 ** 13, " 31.4159E+12"),
-            (f * 10 ** 14, " 314.1593E+12"),
-            (f * 10 ** 15, " 3.1416E+15"),
-            (f * 10 ** 16, " 31.4159E+15"),
-            (f * 10 ** 17, " 314.1593E+15"),
-            (f * 10 ** 18, " 3.1416E+18"),
-            (f * 10 ** 19, " 31.4159E+18"),
-            (f * 10 ** 20, " 314.1593E+18"),
-            (f * 10 ** 21, " 3.1416E+21"),
-            (f * 10 ** 22, " 31.4159E+21"),
-            (f * 10 ** 23, " 314.1593E+21"),
-            (f * 10 ** 24, " 3.1416E+24"),
-            (f * 10 ** 25, " 31.4159E+24"),
-            (f * 10 ** 26, " 314.1593E+24"),
+            (f * 10**-24, " 3.1416E-24"),
+            (f * 10**-23, " 31.4159E-24"),
+            (f * 10**-22, " 314.1593E-24"),
+            (f * 10**-21, " 3.1416E-21"),
+            (f * 10**-20, " 31.4159E-21"),
+            (f * 10**-19, " 314.1593E-21"),
+            (f * 10**-18, " 3.1416E-18"),
+            (f * 10**-17, " 31.4159E-18"),
+            (f * 10**-16, " 314.1593E-18"),
+            (f * 10**-15, " 3.1416E-15"),
+            (f * 10**-14, " 31.4159E-15"),
+            (f * 10**-13, " 314.1593E-15"),
+            (f * 10**-12, " 3.1416E-12"),
+            (f * 10**-11, " 31.4159E-12"),
+            (f * 10**-10, " 314.1593E-12"),
+            (f * 10**-9, " 3.1416E-09"),
+            (f * 10**-8, " 31.4159E-09"),
+            (f * 10**-7, " 314.1593E-09"),
+            (f * 10**-6, " 3.1416E-06"),
+            (f * 10**-5, " 31.4159E-06"),
+            (f * 10**-4, " 314.1593E-06"),
+            (f * 10**-3, " 3.1416E-03"),
+            (f * 10**-2, " 31.4159E-03"),
+            (f * 10**-1, " 314.1593E-03"),
+            (f * 10**0, " 3.1416E+00"),
+            (f * 10**1, " 31.4159E+00"),
+            (f * 10**2, " 314.1593E+00"),
+            (f * 10**3, " 3.1416E+03"),
+            (f * 10**4, " 31.4159E+03"),
+            (f * 10**5, " 314.1593E+03"),
+            (f * 10**6, " 3.1416E+06"),
+            (f * 10**7, " 31.4159E+06"),
+            (f * 10**8, " 314.1593E+06"),
+            (f * 10**9, " 3.1416E+09"),
+            (f * 10**10, " 31.4159E+09"),
+            (f * 10**11, " 314.1593E+09"),
+            (f * 10**12, " 3.1416E+12"),
+            (f * 10**13, " 31.4159E+12"),
+            (f * 10**14, " 314.1593E+12"),
+            (f * 10**15, " 3.1416E+15"),
+            (f * 10**16, " 31.4159E+15"),
+            (f * 10**17, " 314.1593E+15"),
+            (f * 10**18, " 3.1416E+18"),
+            (f * 10**19, " 31.4159E+18"),
+            (f * 10**20, " 314.1593E+18"),
+            (f * 10**21, " 3.1416E+21"),
+            (f * 10**22, " 31.4159E+21"),
+            (f * 10**23, " 314.1593E+21"),
+            (f * 10**24, " 3.1416E+24"),
+            (f * 10**25, " 31.4159E+24"),
+            (f * 10**26, " 314.1593E+24"),
         ]
         self.compare_all(formatter, in_out)
 
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index bf0a10fa702a5..a7c9c86b3d9a5 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1,7 +1,6 @@
 """
 Test output formatting for Series/DataFrame, including to_string & reprs
 """
-
 from datetime import datetime
 from io import StringIO
 import itertools
@@ -951,36 +950,35 @@ def test_to_string_with_column_specific_col_space(self):
         result = df.to_string(col_space=[10, 11, 12])
         assert len(result.split("\n")[1]) == (3 + 1 + 10 + 11 + 12)
 
-    def test_to_string_truncate_indices(self):
-        for index in [
+    @pytest.mark.parametrize(
+        "index",
+        [
             tm.makeStringIndex,
-            tm.makeUnicodeIndex,
             tm.makeIntIndex,
             tm.makeDateIndex,
             tm.makePeriodIndex,
-        ]:
-            for column in [tm.makeStringIndex]:
-                for h in [10, 20]:
-                    for w in [10, 20]:
-                        with option_context("display.expand_frame_repr", False):
-                            df = DataFrame(index=index(h), columns=column(w))
-                            with option_context("display.max_rows", 15):
-                                if h == 20:
-                                    assert has_vertically_truncated_repr(df)
-                                else:
-                                    assert not has_vertically_truncated_repr(df)
-                            with option_context("display.max_columns", 15):
-                                if w == 20:
-                                    assert has_horizontally_truncated_repr(df)
-                                else:
-                                    assert not (has_horizontally_truncated_repr(df))
-                            with option_context(
-                                "display.max_rows", 15, "display.max_columns", 15
-                            ):
-                                if h == 20 and w == 20:
-                                    assert has_doubly_truncated_repr(df)
-                                else:
-                                    assert not has_doubly_truncated_repr(df)
+        ],
+    )
+    @pytest.mark.parametrize("h", [10, 20])
+    @pytest.mark.parametrize("w", [10, 20])
+    def test_to_string_truncate_indices(self, index, h, w):
+        with option_context("display.expand_frame_repr", False):
+            df = DataFrame(index=index(h), columns=tm.makeStringIndex(w))
+            with option_context("display.max_rows", 15):
+                if h == 20:
+                    assert has_vertically_truncated_repr(df)
+                else:
+                    assert not has_vertically_truncated_repr(df)
+            with option_context("display.max_columns", 15):
+                if w == 20:
+                    assert has_horizontally_truncated_repr(df)
+                else:
+                    assert not (has_horizontally_truncated_repr(df))
+            with option_context("display.max_rows", 15, "display.max_columns", 15):
+                if h == 20 and w == 20:
+                    assert has_doubly_truncated_repr(df)
+                else:
+                    assert not has_doubly_truncated_repr(df)
 
     def test_to_string_truncate_multilevel(self):
         arrays = [
@@ -1146,20 +1144,18 @@ def test_wide_repr(self):
         ):
             max_cols = get_option("display.max_columns")
             df = DataFrame(tm.rands_array(25, size=(10, max_cols - 1)))
-            set_option("display.expand_frame_repr", False)
-            rep_str = repr(df)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
 
             assert f"10 rows x {max_cols - 1} columns" in rep_str
-            set_option("display.expand_frame_repr", True)
-            wide_repr = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
             assert rep_str != wide_repr
 
             with option_context("display.width", 120):
                 wider_repr = repr(df)
                 assert len(wider_repr) < len(wide_repr)
 
-        reset_option("display.expand_frame_repr")
-
     def test_wide_repr_wide_columns(self):
         with option_context("mode.sim_interactive", True, "display.max_columns", 20):
             df = DataFrame(
@@ -1174,11 +1170,10 @@ def test_wide_repr_named(self):
             max_cols = get_option("display.max_columns")
             df = DataFrame(tm.rands_array(25, size=(10, max_cols - 1)))
             df.index.name = "DataFrame Index"
-            set_option("display.expand_frame_repr", False)
-
-            rep_str = repr(df)
-            set_option("display.expand_frame_repr", True)
-            wide_repr = repr(df)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
             assert rep_str != wide_repr
 
             with option_context("display.width", 150):
@@ -1188,18 +1183,16 @@ def test_wide_repr_named(self):
             for line in wide_repr.splitlines()[1::13]:
                 assert "DataFrame Index" in line
 
-        reset_option("display.expand_frame_repr")
-
     def test_wide_repr_multiindex(self):
         with option_context("mode.sim_interactive", True, "display.max_columns", 20):
             midx = MultiIndex.from_arrays(tm.rands_array(5, size=(2, 10)))
             max_cols = get_option("display.max_columns")
             df = DataFrame(tm.rands_array(25, size=(10, max_cols - 1)), index=midx)
             df.index.names = ["Level 0", "Level 1"]
-            set_option("display.expand_frame_repr", False)
-            rep_str = repr(df)
-            set_option("display.expand_frame_repr", True)
-            wide_repr = repr(df)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
             assert rep_str != wide_repr
 
             with option_context("display.width", 150):
@@ -1209,8 +1202,6 @@ def test_wide_repr_multiindex(self):
             for line in wide_repr.splitlines()[1::13]:
                 assert "Level 0 Level 1" in line
 
-        reset_option("display.expand_frame_repr")
-
     def test_wide_repr_multiindex_cols(self):
         with option_context("mode.sim_interactive", True, "display.max_columns", 20):
             max_cols = get_option("display.max_columns")
@@ -1220,34 +1211,30 @@ def test_wide_repr_multiindex_cols(self):
                 tm.rands_array(25, (10, max_cols - 1)), index=midx, columns=mcols
             )
             df.index.names = ["Level 0", "Level 1"]
-            set_option("display.expand_frame_repr", False)
-            rep_str = repr(df)
-            set_option("display.expand_frame_repr", True)
-            wide_repr = repr(df)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
             assert rep_str != wide_repr
 
         with option_context("display.width", 150, "display.max_columns", 20):
             wider_repr = repr(df)
             assert len(wider_repr) < len(wide_repr)
 
-        reset_option("display.expand_frame_repr")
-
     def test_wide_repr_unicode(self):
         with option_context("mode.sim_interactive", True, "display.max_columns", 20):
             max_cols = 20
             df = DataFrame(tm.rands_array(25, size=(10, max_cols - 1)))
-            set_option("display.expand_frame_repr", False)
-            rep_str = repr(df)
-            set_option("display.expand_frame_repr", True)
-            wide_repr = repr(df)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
             assert rep_str != wide_repr
 
             with option_context("display.width", 150):
                 wider_repr = repr(df)
                 assert len(wider_repr) < len(wide_repr)
 
-        reset_option("display.expand_frame_repr")
-
     def test_wide_repr_wide_long_columns(self):
         with option_context("mode.sim_interactive", True):
             df = DataFrame({"a": ["a" * 30, "b" * 30], "b": ["c" * 70, "d" * 80]})
@@ -1455,8 +1442,6 @@ def test_to_string_float_formatting(self):
         fmt.set_option(
             "display.precision",
             5,
-            "display.column_space",
-            12,
             "display.notebook_repr_html",
             False,
         )
@@ -2122,9 +2107,6 @@ def gen_series_formatting():
 
 
 class TestSeriesFormatting:
-    def setup_method(self, method):
-        self.ts = tm.makeTimeSeries()
-
     def test_repr_unicode(self):
         s = Series(["\u03c3"] * 10)
         repr(s)
@@ -2134,30 +2116,31 @@ def test_repr_unicode(self):
         repr(a)
 
     def test_to_string(self):
+        ts = tm.makeTimeSeries()
         buf = StringIO()
 
-        s = self.ts.to_string()
+        s = ts.to_string()
 
-        retval = self.ts.to_string(buf=buf)
+        retval = ts.to_string(buf=buf)
         assert retval is None
         assert buf.getvalue().strip() == s
 
         # pass float_format
         format = "%.4f".__mod__
-        result = self.ts.to_string(float_format=format)
+        result = ts.to_string(float_format=format)
         result = [x.split()[1] for x in result.split("\n")[:-1]]
-        expected = [format(x) for x in self.ts]
+        expected = [format(x) for x in ts]
         assert result == expected
 
         # empty string
-        result = self.ts[:0].to_string()
+        result = ts[:0].to_string()
         assert result == "Series([], Freq: B)"
 
-        result = self.ts[:0].to_string(length=0)
+        result = ts[:0].to_string(length=0)
         assert result == "Series([], Freq: B)"
 
         # name and length
-        cp = self.ts.copy()
+        cp = ts.copy()
         cp.name = "foo"
         result = cp.to_string(length=True, name=True, dtype=True)
         last_line = result.split("\n")[-1].strip()
@@ -2874,6 +2857,25 @@ def test_output_display_precision_trailing_zeroes(self):
             expected_output = "0     840\n1    4200\ndtype: float64"
             assert str(s) == expected_output
 
+    @pytest.mark.parametrize(
+        "value,expected",
+        [
+            ([9.4444], "   0\n0  9"),
+            ([0.49], "       0\n0  5e-01"),
+            ([10.9999], "    0\n0  11"),
+            ([9.5444, 9.6], "    0\n0  10\n1  10"),
+            ([0.46, 0.78, -9.9999], "       0\n0  5e-01\n1  8e-01\n2 -1e+01"),
+        ],
+    )
+    def test_set_option_precision(self, value, expected):
+        # Issue #30122
+        # Precision was incorrectly shown
+
+        with option_context("display.precision", 0):
+
+            df_value = DataFrame(value)
+            assert str(df_value) == expected
+
     def test_output_significant_digits(self):
         # Issue #9764
 
@@ -3159,6 +3161,65 @@ def test_str(self):
         assert str(NaT) == "NaT"
 
 
+class TestPeriodIndexFormat:
+    def test_period_format_and_strftime_default(self):
+        per = pd.PeriodIndex([datetime(2003, 1, 1, 12), None], freq="H")
+
+        # Default formatting
+        formatted = per.format()
+        assert formatted[0] == "2003-01-01 12:00"  # default: minutes not shown
+        assert formatted[1] == "NaT"
+        # format is equivalent to strftime(None)...
+        assert formatted[0] == per.strftime(None)[0]
+        assert per.strftime(None)[1] is np.nan  # ...except for NaTs
+
+        # Same test with nanoseconds freq
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+        formatted = per.format()
+        assert (formatted == per.strftime(None)).all()
+        assert formatted[0] == "2003-01-01 12:01:01.123456789"
+        assert formatted[1] == "2003-01-01 12:01:01.123456790"
+
+    def test_period_custom(self):
+        # GH#46252 custom formatting directives %l (ms) and %u (us)
+
+        # 3 digits
+        per = pd.period_range("2003-01-01 12:01:01.123", periods=2, freq="l")
+        formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123000 ns=123000000)"
+        assert formatted[1] == "03 12:01:01 (ms=124 us=124000 ns=124000000)"
+
+        # 6 digits
+        per = pd.period_range("2003-01-01 12:01:01.123456", periods=2, freq="u")
+        formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456000)"
+        assert formatted[1] == "03 12:01:01 (ms=123 us=123457 ns=123457000)"
+
+        # 9 digits
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+        formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456789)"
+        assert formatted[1] == "03 12:01:01 (ms=123 us=123456 ns=123456790)"
+
+    def test_period_tz(self):
+        # Formatting periods created from a datetime with timezone.
+
+        # This timestamp is in 2013 in Europe/Paris but is 2012 in UTC
+        dt = pd.to_datetime(["2013-01-01 00:00:00+01:00"], utc=True)
+
+        # Converting to a period looses the timezone information
+        # Since tz is currently set as utc, we'll see 2012
+        with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+            per = dt.to_period(freq="H")
+        assert per.format()[0] == "2012-12-31 23:00"
+
+        # If tz is currently set as paris before conversion, we'll see 2013
+        dt = dt.tz_convert("Europe/Paris")
+        with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+            per = dt.to_period(freq="H")
+        assert per.format()[0] == "2013-01-01 00:00"
+
+
 class TestDatetimeIndexFormat:
     def test_datetime(self):
         formatted = pd.to_datetime([datetime(2003, 1, 1, 12), NaT]).format()
@@ -3339,3 +3400,9 @@ def test_filepath_or_buffer_bad_arg_raises(float_frame, method):
     msg = "buf is not a file name and it has no write method"
     with pytest.raises(TypeError, match=msg):
         getattr(float_frame, method)(buf=object())
+
+
+def test_col_space_deprecated():
+    # GH 7576
+    with tm.assert_produces_warning(FutureWarning, match="column_space is"):
+        set_option("display.column_space", 11)
diff --git a/pandas/tests/io/formats/test_info.py b/pandas/tests/io/formats/test_info.py
index 5522631d222e1..1657327dd7344 100644
--- a/pandas/tests/io/formats/test_info.py
+++ b/pandas/tests/io/formats/test_info.py
@@ -20,6 +20,7 @@
     date_range,
     option_context,
 )
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -29,6 +30,7 @@ def duplicate_columns_frame():
 
 
 def test_info_empty():
+    # GH #45494
     df = DataFrame()
     buf = StringIO()
     df.info(buf=buf)
@@ -37,7 +39,7 @@ def test_info_empty():
         """\
         <class 'pandas.core.frame.DataFrame'>
         Index: 0 entries
-        Empty DataFrame"""
+        Empty DataFrame\n"""
     )
     assert result == expected
 
@@ -387,7 +389,7 @@ def test_info_memory_usage_deep_not_pypy():
     assert df_object.memory_usage(deep=True).sum() > df_object.memory_usage().sum()
 
 
-@pytest.mark.skipif(not PYPY, reason="on PyPy deep=True does not change result")
+@pytest.mark.xfail(not PYPY, reason="on PyPy deep=True does not change result")
 def test_info_memory_usage_deep_pypy():
     df_with_object_index = DataFrame({"a": [1]}, index=["foo"])
     assert (
@@ -490,3 +492,12 @@ def test_info_int_columns():
         """
     )
     assert result == expected
+
+
+def test_memory_usage_empty_no_warning():
+    # GH#50066
+    df = DataFrame(index=["a", "b"])
+    with tm.assert_produces_warning(None):
+        result = df.memory_usage()
+    expected = Series(16 if IS64 else 8, index=["Index"])
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/io/formats/test_series_info.py b/pandas/tests/io/formats/test_series_info.py
index fc83b6c3d23ea..761dd07dbef51 100644
--- a/pandas/tests/io/formats/test_series_info.py
+++ b/pandas/tests/io/formats/test_series_info.py
@@ -116,7 +116,7 @@ def test_info_shows_dtypes():
         assert name in res
 
 
-@pytest.mark.skipif(PYPY, reason="on PyPy deep=True doesn't change result")
+@pytest.mark.xfail(PYPY, reason="on PyPy deep=True doesn't change result")
 def test_info_memory_usage_deep_not_pypy():
     s_with_object_index = Series({"a": [1]}, index=["foo"])
     assert s_with_object_index.memory_usage(
@@ -127,7 +127,7 @@ def test_info_memory_usage_deep_not_pypy():
     assert s_object.memory_usage(deep=True) > s_object.memory_usage()
 
 
-@pytest.mark.skipif(not PYPY, reason="on PyPy deep=True does not change result")
+@pytest.mark.xfail(not PYPY, reason="on PyPy deep=True does not change result")
 def test_info_memory_usage_deep_pypy():
     s_with_object_index = Series({"a": [1]}, index=["foo"])
     assert s_with_object_index.memory_usage(
diff --git a/pandas/tests/io/formats/test_to_csv.py b/pandas/tests/io/formats/test_to_csv.py
index e039ff263ca3a..b5096934af4cb 100644
--- a/pandas/tests/io/formats/test_to_csv.py
+++ b/pandas/tests/io/formats/test_to_csv.py
@@ -13,8 +13,7 @@
     compat,
 )
 import pandas._testing as tm
-
-import pandas.io.common as icom
+from pandas.tests.io.test_compression import _compression_to_extension
 
 
 class TestToCSV:
@@ -46,7 +45,7 @@ def test_to_csv_with_single_column(self):
             with open(path) as f:
                 assert f.read() == expected2
 
-    def test_to_csv_defualt_encoding(self):
+    def test_to_csv_default_encoding(self):
         # GH17097
         df = DataFrame({"col": ["AAAAA", "ÄÄÄÄÄ", "ßßßßß", "聞聞聞聞聞"]})
 
@@ -315,6 +314,26 @@ def test_to_csv_date_format_in_categorical(self):
         ser = ser.astype("category")
         assert ser.to_csv(index=False, date_format="%Y-%m-%d") == expected
 
+    def test_to_csv_float_ea_float_format(self):
+        # GH#45991
+        df = DataFrame({"a": [1.1, 2.02, pd.NA, 6.000006], "b": "c"})
+        df["a"] = df["a"].astype("Float64")
+        result = df.to_csv(index=False, float_format="%.5f")
+        expected = tm.convert_rows_list_to_csv_str(
+            ["a,b", "1.10000,c", "2.02000,c", ",c", "6.00001,c"]
+        )
+        assert result == expected
+
+    def test_to_csv_float_ea_no_float_format(self):
+        # GH#45991
+        df = DataFrame({"a": [1.1, 2.02, pd.NA, 6.000006], "b": "c"})
+        df["a"] = df["a"].astype("Float64")
+        result = df.to_csv(index=False)
+        expected = tm.convert_rows_list_to_csv_str(
+            ["a,b", "1.1,c", "2.02,c", ",c", "6.000006,c"]
+        )
+        assert result == expected
+
     def test_to_csv_multi_index(self):
         # see gh-6618
         df = DataFrame([1], columns=pd.MultiIndex.from_arrays([[1], [2]]))
@@ -369,9 +388,11 @@ def test_to_csv_multi_index(self):
     @pytest.mark.parametrize("klass", [DataFrame, pd.Series])
     def test_to_csv_single_level_multi_index(self, ind, expected, klass):
         # see gh-19589
-        result = klass(pd.Series([1], ind, name="data")).to_csv(
-            line_terminator="\n", header=True
-        )
+        obj = klass(pd.Series([1], ind, name="data"))
+
+        with tm.assert_produces_warning(FutureWarning, match="lineterminator"):
+            # GH#9568 standardize on lineterminator matching stdlib
+            result = obj.to_csv(line_terminator="\n", header=True)
         assert result == expected
 
     def test_to_csv_string_array_ascii(self):
@@ -425,14 +446,14 @@ def test_to_csv_string_with_lf(self):
         with tm.ensure_clean("lf_test.csv") as path:
             # case 2: LF as line terminator
             expected_lf = b'int,str_lf\n1,abc\n2,"d\nef"\n3,"g\nh\n\ni"\n'
-            df.to_csv(path, line_terminator="\n", index=False)
+            df.to_csv(path, lineterminator="\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_lf
         with tm.ensure_clean("lf_test.csv") as path:
             # case 3: CRLF as line terminator
-            # 'line_terminator' should not change inner element
+            # 'lineterminator' should not change inner element
             expected_crlf = b'int,str_lf\r\n1,abc\r\n2,"d\nef"\r\n3,"g\nh\n\ni"\r\n'
-            df.to_csv(path, line_terminator="\r\n", index=False)
+            df.to_csv(path, lineterminator="\r\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_crlf
 
@@ -459,19 +480,19 @@ def test_to_csv_string_with_crlf(self):
         with tm.ensure_clean("crlf_test.csv") as path:
             # case 2: LF as line terminator
             expected_lf = b'int,str_crlf\n1,abc\n2,"d\r\nef"\n3,"g\r\nh\r\n\r\ni"\n'
-            df.to_csv(path, line_terminator="\n", index=False)
+            df.to_csv(path, lineterminator="\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_lf
         with tm.ensure_clean("crlf_test.csv") as path:
             # case 3: CRLF as line terminator
-            # 'line_terminator' should not change inner element
+            # 'lineterminator' should not change inner element
             expected_crlf = (
                 b"int,str_crlf\r\n"
                 b"1,abc\r\n"
                 b'2,"d\r\nef"\r\n'
                 b'3,"g\r\nh\r\n\r\ni"\r\n'
             )
-            df.to_csv(path, line_terminator="\r\n", index=False)
+            df.to_csv(path, lineterminator="\r\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_crlf
 
@@ -533,7 +554,7 @@ def test_to_csv_compression(self, compression_only, read_infer, to_infer):
 
         # We'll complete file extension subsequently.
         filename = "test."
-        filename += icom._compression_to_extension[compression]
+        filename += _compression_to_extension[compression]
 
         df = DataFrame({"A": [1]})
 
diff --git a/pandas/tests/io/formats/test_to_excel.py b/pandas/tests/io/formats/test_to_excel.py
index 968ad63eaceef..2a0f9f59972ef 100644
--- a/pandas/tests/io/formats/test_to_excel.py
+++ b/pandas/tests/io/formats/test_to_excel.py
@@ -6,12 +6,15 @@
 
 import pytest
 
+from pandas.errors import CSSWarning
 import pandas.util._test_decorators as td
 
 import pandas._testing as tm
 
-from pandas.io.formats.css import CSSWarning
-from pandas.io.formats.excel import CSSToExcelConverter
+from pandas.io.formats.excel import (
+    CssExcelCell,
+    CSSToExcelConverter,
+)
 
 
 @pytest.mark.parametrize(
@@ -187,6 +190,10 @@
             "border-top-style: solid; border-top-color: #06c",
             {"border": {"top": {"style": "medium", "color": "0066CC"}}},
         ),
+        (
+            "border-top-color: blue",
+            {"border": {"top": {"color": "0000FF", "style": "none"}}},
+        ),
         # ALIGNMENT
         # - horizontal
         ("text-align: center", {"alignment": {"horizontal": "center"}}),
@@ -206,6 +213,10 @@
         ("white-space: normal", {"alignment": {"wrap_text": True}}),
         # NUMBER FORMAT
         ("number-format: 0%", {"number_format": {"format_code": "0%"}}),
+        (
+            "number-format: 0§[Red](0)§-§@;",
+            {"number_format": {"format_code": "0;[red](0);-;@"}},  # GH 46152
+        ),
     ],
 )
 def test_css_to_excel(css, expected):
@@ -288,7 +299,8 @@ def test_css_to_excel_good_colors(input_color, output_color):
     expected["font"] = {"color": output_color}
 
     expected["border"] = {
-        k: {"color": output_color} for k in ("top", "right", "bottom", "left")
+        k: {"color": output_color, "style": "none"}
+        for k in ("top", "right", "bottom", "left")
     }
 
     with tm.assert_produces_warning(None):
@@ -331,3 +343,89 @@ def test_css_named_colors_from_mpl_present():
     pd_colors = CSSToExcelConverter.NAMED_COLORS
     for name, color in mpl_colors.items():
         assert name in pd_colors and pd_colors[name] == color[1:]
+
+
+@pytest.mark.parametrize(
+    "styles,expected",
+    [
+        ([("color", "green"), ("color", "red")], "color: red;"),
+        ([("font-weight", "bold"), ("font-weight", "normal")], "font-weight: normal;"),
+        ([("text-align", "center"), ("TEXT-ALIGN", "right")], "text-align: right;"),
+    ],
+)
+def test_css_excel_cell_precedence(styles, expected):
+    """It applies favors latter declarations over former declarations"""
+    # See GH 47371
+    converter = CSSToExcelConverter()
+    converter._call_cached.cache_clear()
+    css_styles = {(0, 0): styles}
+    cell = CssExcelCell(
+        row=0,
+        col=0,
+        val="",
+        style=None,
+        css_styles=css_styles,
+        css_row=0,
+        css_col=0,
+        css_converter=converter,
+    )
+    converter._call_cached.cache_clear()
+
+    assert cell.style == converter(expected)
+
+
+@pytest.mark.parametrize(
+    "styles,cache_hits,cache_misses",
+    [
+        ([[("color", "green"), ("color", "red"), ("color", "green")]], 0, 1),
+        (
+            [
+                [("font-weight", "bold")],
+                [("font-weight", "normal"), ("font-weight", "bold")],
+            ],
+            1,
+            1,
+        ),
+        ([[("text-align", "center")], [("TEXT-ALIGN", "center")]], 1, 1),
+        (
+            [
+                [("font-weight", "bold"), ("text-align", "center")],
+                [("font-weight", "bold"), ("text-align", "left")],
+            ],
+            0,
+            2,
+        ),
+        (
+            [
+                [("font-weight", "bold"), ("text-align", "center")],
+                [("font-weight", "bold"), ("text-align", "left")],
+                [("font-weight", "bold"), ("text-align", "center")],
+            ],
+            1,
+            2,
+        ),
+    ],
+)
+def test_css_excel_cell_cache(styles, cache_hits, cache_misses):
+    """It caches unique cell styles"""
+    # See GH 47371
+    converter = CSSToExcelConverter()
+    converter._call_cached.cache_clear()
+
+    css_styles = {(0, i): _style for i, _style in enumerate(styles)}
+    for css_row, css_col in css_styles:
+        CssExcelCell(
+            row=0,
+            col=0,
+            val="",
+            style=None,
+            css_styles=css_styles,
+            css_row=css_row,
+            css_col=css_col,
+            css_converter=converter,
+        )
+    cache_info = converter._call_cached.cache_info()
+    converter._call_cached.cache_clear()
+
+    assert cache_info.hits == cache_hits
+    assert cache_info.misses == cache_misses
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index aa8508d8e8942..3059efef09095 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -342,9 +342,9 @@ def test_to_html_truncate_multi_index(sparsify, expected, datapath):
     "option,result,expected",
     [
         (None, lambda df: df.to_html(), "1"),
-        (None, lambda df: df.to_html(border=0), "0"),
-        (0, lambda df: df.to_html(), "0"),
-        (0, lambda df: df._repr_html_(), "0"),
+        (None, lambda df: df.to_html(border=2), "2"),
+        (2, lambda df: df.to_html(), "2"),
+        (2, lambda df: df._repr_html_(), "2"),
     ],
 )
 def test_to_html_border(option, result, expected):
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index 01bc94bf594d9..f8015851c9a83 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -282,7 +282,7 @@ def test_to_latex_longtable_without_index(self):
     )
     def test_to_latex_longtable_continued_on_next_page(self, df, expected_number):
         result = df.to_latex(index=False, longtable=True)
-        assert fr"\multicolumn{{{expected_number}}}" in result
+        assert rf"\multicolumn{{{expected_number}}}" in result
 
 
 class TestToLatexHeader:
@@ -1006,7 +1006,7 @@ def test_to_latex_na_rep_and_float_format(self, na_rep):
         )
         result = df.to_latex(na_rep=na_rep, float_format="{:.2f}".format)
         expected = _dedent(
-            fr"""
+            rf"""
             \begin{{tabular}}{{llr}}
             \toprule
             {{}} & Group &  Data \\
diff --git a/pandas/tests/io/formats/test_to_markdown.py b/pandas/tests/io/formats/test_to_markdown.py
index 2bd0d11888163..55ec9c83601f9 100644
--- a/pandas/tests/io/formats/test_to_markdown.py
+++ b/pandas/tests/io/formats/test_to_markdown.py
@@ -59,7 +59,7 @@ def test_series():
     )
 
 
-def test_no_buf(capsys):
+def test_no_buf():
     df = pd.DataFrame([1, 2, 3])
     result = df.to_markdown()
     assert (
diff --git a/pandas/tests/io/generate_legacy_storage_files.py b/pandas/tests/io/generate_legacy_storage_files.py
index dede9127821fd..8f03655ec27cc 100644
--- a/pandas/tests/io/generate_legacy_storage_files.py
+++ b/pandas/tests/io/generate_legacy_storage_files.py
@@ -23,7 +23,7 @@
 generate a pickle file. We will then check this file into a current
 branch, and test using test_pickle.py. This will load the *older*
 pickles and test versus the current data that is generated
-(with master). These are then compared.
+(with main). These are then compared.
 
 If we have cases where we changed the signature (e.g. we renamed
 offset -> freq in Timestamp). Then we have to conditionally execute
diff --git a/pandas/tests/io/json/data/teams.csv b/pandas/tests/io/json/data/teams.csv
new file mode 100644
index 0000000000000..fe509fb7d7c31
--- /dev/null
+++ b/pandas/tests/io/json/data/teams.csv
@@ -0,0 +1,2716 @@
+yearID,lgID,teamID,franchID,divID,Rank,G,Ghome,W,L,DivWin,WCWin,LgWin,WSWin,R,AB,H,2B,3B,HR,BB,SO,SB,CS,HBP,SF,RA,ER,ERA,CG,SHO,SV,IPouts,HA,HRA,BBA,SOA,E,DP,FP,name,park,attendance,BPF,PPF,teamIDBR,teamIDlahman45,teamIDretro
+1871,NA,BS1,BNA,,3,31,,20,10,,,N,,401,1372,426,70,37,3,60,19,73,,,,303,109,3.5500000000,22,1,3,828,367,2,42,23,225,,0.83,Boston Red Stockings,South End Grounds I,,103,98,BOS,BS1,BS1
+1871,NA,CH1,CNA,,2,28,,19,9,,,N,,302,1196,323,52,21,10,60,22,69,,,,241,77,2.7600000000,25,0,1,753,308,6,28,22,218,,0.82,Chicago White Stockings,Union Base-Ball Grounds,,104,102,CHI,CH1,CH1
+1871,NA,CL1,CFC,,8,29,,10,19,,,N,,249,1186,328,35,40,7,26,25,18,,,,341,116,4.1100000000,23,0,0,762,346,13,53,34,223,,0.81,Cleveland Forest Citys,National Association Grounds,,96,100,CLE,CL1,CL1
+1871,NA,FW1,KEK,,7,19,,7,12,,,N,,137,746,178,19,8,2,33,9,16,,,,243,97,5.1700000000,19,1,0,507,261,5,21,17,163,,0.80,Fort Wayne Kekiongas,Hamilton Field,,101,107,KEK,FW1,FW1
+1871,NA,NY2,NNA,,5,33,,16,17,,,N,,302,1404,403,43,21,1,33,15,46,,,,313,121,3.7200000000,32,1,0,879,373,7,42,22,227,,0.83,New York Mutuals,Union Grounds (Brooklyn),,90,88,NYU,NY2,NY2
+1871,NA,PH1,PNA,,1,28,,21,7,,,Y,,376,1281,410,66,27,9,46,23,56,,,,266,137,4.9500000000,27,0,0,747,329,3,53,16,194,,0.84,Philadelphia Athletics,Jefferson Street Grounds,,102,98,ATH,PH1,PH1
+1871,NA,RC1,ROK,,9,25,,4,21,,,N,,231,1036,274,44,25,3,38,30,53,,,,287,108,4.3000000000,23,1,0,678,315,3,34,16,220,,0.82,Rockford Forest Citys,Agricultural Society Fair Grounds,,97,99,ROK,RC1,RC1
+1871,NA,TRO,TRO,,6,29,,13,15,,,N,,351,1248,384,51,34,6,49,19,62,,,,362,153,5.5100000000,28,0,0,750,431,4,75,12,198,,0.84,Troy Haymakers,Haymakers' Grounds,,101,100,TRO,TRO,TRO
+1871,NA,WS3,OLY,,4,32,,15,15,,,N,,310,1353,375,54,26,6,48,13,48,,,,303,137,4.3700000000,32,0,0,846,371,4,45,13,217,,0.85,Washington Olympics,Olympics Grounds,,94,98,OLY,WS3,WS3
+1872,NA,BL1,BLC,,2,58,,35,19,,,N,,617,2576,747,94,35,14,27,28,35,15,,,434,173,3.0200000000,48,1,1,1545,566,3,63,0,432,,0.82,Baltimore Canaries,Newington Park,,106,102,BAL,BL1,BL1
+1872,NA,BR1,ECK,,9,29,,3,26,,,N,,152,1075,235,26,6,0,14,29,8,4,,,413,165,5.7300000000,28,0,0,777,503,6,24,0,278,,0.79,Brooklyn Eckfords,Union Grounds,,87,96,ECK,BR1,BR1
+1872,NA,BR2,BRA,,6,37,,9,28,,,N,,237,1466,370,46,10,0,19,24,17,14,,,473,189,5.0600000000,37,0,0,1008,561,6,19,0,358,,0.81,Brooklyn Atlantics,Capitoline Grounds,,115,122,BRA,BR2,BR2
+1872,NA,BS1,BNA,,1,48,,39,8,,,Y,,521,2137,677,114,31,7,28,26,47,14,,,236,95,1.9900000000,41,3,1,1290,438,0,27,0,263,,0.87,Boston Red Stockings,South End Grounds I,,105,100,BOS,BS1,BS1
+1872,NA,CL1,CFC,,7,22,,6,16,,,N,,174,935,272,37,6,0,17,13,12,3,,,254,101,4.5700000000,15,0,0,597,289,6,24,0,168,,0.82,Cleveland Forest Citys,National Association Grounds,,96,100,CLE,CL1,CL1
+1872,NA,MID,MAN,,8,24,,5,19,,,N,,220,1014,305,31,8,1,5,12,5,3,,,348,140,5.9700000000,22,0,0,633,368,5,13,0,224,,0.80,Middletown Mansfields,Mansfield Club Grounds,,98,103,MAN,MID,MID
+1872,NA,NY2,NNA,,3,56,,34,20,,,N,,523,2423,668,86,13,4,55,52,56,21,,,362,145,2.5500000000,54,3,0,1536,618,2,32,0,326,,0.86,New York Mutuals,Union Grounds (Brooklyn),,93,92,NYU,NY2,NY2
+1872,NA,PH1,PNA,,4,47,,30,14,,,N,,539,2140,678,77,23,4,69,47,58,32,,,349,140,3.0100000000,47,1,0,1257,513,3,26,0,298,,0.85,Philadelphia Athletics,Jefferson Street Grounds,,102,100,ATH,PH1,PH1
+1872,NA,TRO,TRO,,5,25,,15,10,,,N,,273,1124,329,56,11,5,7,14,9,7,,,191,77,3.0800000000,17,2,0,675,282,2,10,0,144,,0.86,Troy Haymakers,Haymakers' Grounds,,101,100,TRO,TRO,TRO
+1872,NA,WS3,OLY,,10,9,,2,7,,,N,,54,363,93,12,3,0,4,4,0,3,,,140,56,6.3800000000,9,0,0,237,147,0,5,0,96,,0.78,Washington Olympics,Olympics Grounds,,94,98,OLY,WS3,WS3
+1872,NA,WS4,NAT,,11,11,,0,11,,,N,,80,460,105,3,2,0,1,3,0,0,,,190,76,6.9100000000,11,0,0,297,194,2,3,0,100,,0.76,Washington Nationals,Nationals Grounds,,129,141,NAT,WS4,WS4
+1873,NA,BL1,BLC,,3,57,,34,22,,,N,,644,2563,810,119,39,12,40,25,21,10,,,451,170,3.0100000000,55,1,0,1524,680,4,42,34,366,,0.85,Baltimore Canaries,Newington Park,,101,102,BAL,BL1,BL1
+1873,NA,BL4,MAR,,9,6,,0,6,,,N,,26,211,33,5,0,0,0,0,0,0,,,152,48,8.0000000000,6,0,0,162,144,4,0,0,70,,0.76,Baltimore Marylands,Newington Park,,77,99,MAR,BL4,BL4
+1873,NA,BR2,BRA,,6,55,,17,37,,,N,,366,2210,588,60,27,6,53,43,18,9,,,549,221,3.9800000000,52,1,0,1500,737,8,42,15,505,,0.82,Brooklyn Atlantics,Union Grounds,,90,94,BRA,BR2,BR2
+1873,NA,BS1,BNA,,1,60,,43,16,,,Y,,739,2755,930,137,46,13,62,24,39,27,,,460,154,2.5900000000,48,1,3,1608,708,5,35,31,434,,0.83,Boston Red Stockings,South End Grounds I,,106,100,BOS,BS1,BS1
+1873,NA,ELI,RES,,8,23,,2,21,,,N,,98,868,204,21,8,0,8,22,2,1,,,299,74,3.2200000000,22,0,0,621,342,7,9,8,247,,0.78,Elizabeth Resolutes,Waverly Fairgrounds,,92,103,RES,ELI,ELI
+1873,NA,NY2,NNA,,4,53,,29,24,,,N,,424,2214,622,67,41,5,42,22,15,5,,,385,139,2.6200000000,48,2,0,1431,539,5,69,76,419,,0.82,New York Mutuals,Union Grounds (Brooklyn),,98,96,NYU,NY2,NY2
+1873,NA,PH1,PNA,,5,52,,28,23,,,N,,474,2266,683,76,22,4,35,32,29,24,,,403,160,3.0300000000,44,3,1,1425,553,4,58,41,383,,0.84,Philadelphia Athletics,Jefferson Street Grounds,,108,105,ATH,PH1,PH1
+1873,NA,PH2,PWS,,2,53,,36,17,,,N,,526,2325,645,83,20,8,62,39,44,14,,,396,148,2.7700000000,50,0,0,1443,627,3,44,28,361,,0.84,Philadelphia Whites,Jefferson Street Grounds,,103,101,PHI,PH2,PH2
+1873,NA,WS5,WBL,,7,39,,8,31,,,N,,283,1563,408,45,25,3,19,33,5,5,,,485,181,4.7100000000,39,0,0,1038,593,11,22,7,240,,0.84,Washington Blue Legs,Olympics Grounds,,96,102,WAS,WS5,WS5
+1874,NA,BL1,BLC,,8,47,,9,38,,,N,,227,1781,435,53,8,1,24,0,,,,,505,201,4.3100000000,43,0,0,1260,643,4,37,0,355,,0.81,Baltimore Canaries,Newington Park,,102,104,BAL,BL1,BL1
+1874,NA,BR2,BRA,,6,56,,22,33,,,N,,301,2165,497,50,11,1,32,0,,,,,449,180,3.2000000000,56,1,0,1518,621,16,13,0,500,,0.82,Brooklyn Atlantics,Union Grounds,,89,94,BRA,BR2,BR2
+1874,NA,BS1,BNA,,1,71,,52,18,,,Y,,735,3122,981,130,57,18,32,0,,,,,415,166,2.3600000000,65,4,3,1899,777,1,27,0,457,,0.85,Boston Red Stockings,South End Grounds I,,105,98,BOS,BS1,BS1
+1874,NA,CH2,CNA,,5,59,,28,31,,,N,,418,2457,690,89,3,3,34,0,,,,,480,192,3.2400000000,58,3,0,1599,696,7,48,0,446,,0.83,Chicago White Stockings,23rd Street Grounds,,101,102,CHI,CH2,CH2
+1874,NA,HR1,HNA,,7,53,,16,37,,,N,,371,2140,587,92,19,2,26,0,,,,,471,189,3.5400000000,45,0,1,1443,660,2,23,0,501,,0.80,Hartford Dark Blues,Hartford Ball Club Grounds,,106,106,HAR,HR1,HR1
+1874,NA,NY2,NNA,,2,65,,42,23,,,N,,500,2719,709,100,31,8,38,0,,,,,377,150,2.3000000000,62,4,0,1758,658,3,40,0,438,,0.84,New York Mutuals,Union Grounds (Brooklyn),,103,102,NYU,NY2,NY2
+1874,NA,PH1,PNA,,3,55,,33,22,,,N,,441,2260,646,87,17,6,24,0,,,,,344,138,2.5500000000,55,0,0,1461,514,5,29,0,396,,0.83,Philadelphia Athletics,Jefferson Street Grounds,,108,105,ATH,PH1,PH1
+1874,NA,PH2,PWS,,4,58,,29,29,,,N,,476,2432,690,74,51,3,28,0,,,,,428,172,2.9500000000,56,3,0,1572,666,4,21,0,518,,0.80,Philadelphia Whites,Jefferson Street Grounds,,103,101,PHI,PH2,PH2
+1875,NA,BR2,BRA,,11,44,,2,42,,,N,,132,1547,304,32,9,2,10,0,,,,,438,174,3.9500000000,31,0,0,1188,531,9,22,0,426,,0.80,Brooklyn Atlantics,Union Grounds,,88,94,BRA,BR2,BR2
+1875,NA,BS1,BNA,,1,82,,71,8,,,Y,,831,3516,1124,157,54,14,31,0,,,,,343,138,1.7000000000,60,10,17,2196,751,2,29,0,464,,0.86,Boston Red Stockings,South End Grounds I,,103,96,BOS,BS1,BS1
+1875,NA,CH2,CNA,,6,69,,30,37,,,N,,379,2658,697,85,13,0,24,0,,,,,416,167,2.4000000000,65,7,0,1875,652,0,28,0,385,,0.86,Chicago White Stockings,23rd Street Grounds,,101,102,CHI,CH2,CH2
+1875,NA,HR1,HNA,,3,86,,54,28,,,N,,557,3342,873,98,34,2,40,0,,,,,343,138,1.6100000000,83,13,0,2313,706,4,16,0,432,,0.88,Hartford Dark Blues,Hartford Ball Club Grounds,,107,105,HAR,HR1,HR1
+1875,NA,KEO,WES,,13,13,,1,12,,,N,,45,449,81,9,6,0,1,0,,,,,88,35,2.8100000000,13,0,0,336,110,0,14,0,68,,0.85,Keokuk Westerns,Perry Park,,105,109,WES,KEO,KEO
+1875,NA,NH1,NHV,,8,47,,7,40,,,N,,170,1708,374,42,12,2,13,0,,,,,397,158,3.3400000000,40,0,0,1278,500,5,22,0,437,,0.81,New Haven Elm Citys,Hamilton Park,,87,93,NHV,NH1,NH1
+1875,NA,NY2,NNA,,6,71,,30,38,,,N,,328,2683,626,84,24,7,21,0,,,,,425,170,2.4000000000,70,2,0,1911,716,3,24,0,526,,0.83,New York Mutuals,Union Grounds (Brooklyn),,99,100,NYU,NY2,NY2
+1875,NA,PH1,PNA,,2,77,,53,20,,,N,,699,3245,940,126,61,10,40,0,,,,,402,161,2.1100000000,75,6,0,2061,775,4,40,0,418,,0.87,Philadelphia Athletics,Jefferson Street Grounds,,107,106,ATH,PH1,PH1
+1875,NA,PH2,PWS,,5,70,,37,31,,,N,,470,2717,681,65,28,5,22,0,,,,,376,150,2.1500000000,64,5,0,1881,650,6,30,0,475,,0.84,Philadelphia Whites,Jefferson Street Grounds,,104,102,PHI,PH2,PH2
+1875,NA,PH3,CEN,,11,14,,2,12,,,N,,70,529,126,19,3,0,8,0,,,,,138,55,3.9300000000,14,0,0,378,170,0,3,0,164,,0.76,Philadelphia Centennials,Centennial Grounds,,92,98,CEN,PH3,PH3
+1875,NA,SL1,SLR,,10,19,,4,15,,,N,,60,688,138,20,1,0,14,0,,,,,161,64,3.3700000000,16,2,0,513,207,0,3,0,150,,0.83,St. Louis Red Stockings,Red Stocking Baseball Park,,90,98,SLR,SL1,SL1
+1875,NA,SL2,SNA,,4,70,,39,29,,,N,,386,2679,641,84,27,0,33,0,,,,,369,148,2.1100000000,67,5,1,1890,634,3,20,0,424,,0.86,St. Louis Brown Stockings,Grand Avenue Park,,89,86,STL,SL2,SL2
+1875,NA,WS6,WNT,,9,28,,5,23,,,N,,107,997,194,12,11,0,5,0,,,,,338,135,4.8600000000,23,0,0,750,397,6,11,0,263,,0.79,Washington Nationals,Olympics Grounds,,96,106,WAS,WS6,WS6
+1876,NL,BSN,ATL,,4,70,,39,31,,,N,,471,2722,723,96,24,9,58,98,,,,,450,176,2.5100000000,49,3,7,1896,732,7,104,77,422,42,0.86,Boston Red Caps,South End Grounds I,,102,98,BSN,BSN,BSN
+1876,NL,CHN,CHC,,1,66,,52,14,,,Y,,624,2748,926,131,32,8,70,45,,,,,257,116,1.7600000000,59,9,4,1776,608,6,29,51,282,33,0.89,Chicago White Stockings,23rd Street Grounds,,112,106,CHC,CHN,CHN
+1876,NL,CN1,CNR,,8,65,,9,56,,,N,,238,2372,555,51,12,4,41,136,,,,,579,238,3.6200000000,57,0,0,1773,850,9,34,60,469,45,0.84,Cincinnati Reds,Avenue Grounds,,86,95,CIN,CN1,CN1
+1876,NL,HAR,HAR,,2,69,,47,21,,,N,,429,2664,711,96,22,2,39,78,,,,,261,116,1.6700000000,69,11,0,1872,570,2,27,114,337,27,0.88,Hartford Dark Blues,Hartford Ball Club Grounds,,110,106,HAR,HAR,HAR
+1876,NL,LS1,LGR,,5,69,,30,36,,,N,,280,2570,641,68,14,6,24,98,,,,,344,121,1.6900000000,67,5,0,1929,605,3,38,125,396,44,0.87,Louisville Grays,Louisville Baseball Park,,117,117,LOU,LS1,LS1
+1876,NL,NY3,NYU,,6,57,,21,35,,,N,,260,2180,494,39,15,2,18,35,,,,,412,173,2.9400000000,56,2,0,1590,718,8,24,37,475,18,0.82,New York Mutuals,Union Grounds (Brooklyn),,96,100,NYU,NY3,NY3
+1876,NL,PHN,ATH,,7,60,,14,45,,,N,,378,2387,646,79,35,7,27,36,,,,,534,197,3.2200000000,53,1,2,1650,783,2,41,22,456,32,0.83,Philadelphia Athletics,Jefferson Street Grounds,,104,104,ATH,PHN,PHN
+1876,NL,SL3,SBS,,3,64,,45,19,,,N,,386,2478,642,73,27,2,59,63,,,,,229,78,1.2200000000,63,16,0,1731,472,3,39,103,268,33,0.90,St. Louis Brown Stockings,Sportsman's Park I,,93,92,STL,SL3,SL3
+1877,NL,BSN,ATL,,1,61,,42,18,,,Y,,419,2368,700,91,37,4,65,121,,,,,263,131,2.1500000000,61,7,0,1644,557,5,38,177,289,36,0.88,Boston Red Caps,South End Grounds I,,104,100,BSN,BSN,BSN
+1877,NL,CHN,CHC,,5,60,,26,33,,,N,,366,2273,633,79,30,0,57,111,,,,,375,200,3.3700000000,45,3,3,1602,630,7,58,92,313,43,0.88,Chicago White Stockings,23rd Street Grounds,,112,106,CHC,CHN,CHN
+1877,NL,CN1,CNR,,6,58,,15,42,,,N,,291,2135,545,72,34,6,78,110,,,,,485,240,4.1900000000,48,1,1,1545,747,4,61,85,393,33,0.85,Cincinnati Reds,Avenue Grounds,,89,94,CIN,CN1,CN1
+1877,NL,HAR,HAR,,3,60,,31,27,,,N,,341,2358,637,63,31,4,30,97,,,,,311,140,2.3200000000,59,4,0,1632,572,2,56,99,313,32,0.88,Hartford Dark Blues,Union Grounds (Brooklyn),,90,87,HAR,HAR,HAR
+1877,NL,LS1,LGR,,2,61,,35,25,,,N,,339,2355,659,75,36,9,58,140,,,,,288,140,2.2500000000,61,4,0,1677,617,4,41,141,267,37,0.90,Louisville Grays,Louisville Baseball Park,,117,117,LOU,LS1,LS1
+1877,NL,SL3,SBS,,4,60,,28,32,,,N,,284,2178,531,51,36,1,57,147,,,,,318,160,2.6600000000,52,1,0,1623,582,2,92,132,281,29,0.89,St. Louis Brown Stockings,Sportsman's Park I,,95,93,STL,SL3,SL3
+1878,NL,BSN,ATL,,1,60,,41,19,,,Y,,298,2220,535,75,25,2,35,154,,,,,241,140,2.3200000000,58,9,0,1632,595,6,38,184,228,48,0.91,Boston Red Caps,South End Grounds I,,108,102,BSN,BSN,BSN
+1878,NL,CHN,CHC,,4,61,,30,30,,,N,,371,2333,677,91,20,3,88,157,,,,,331,145,2.3700000000,61,1,0,1653,577,4,35,175,304,37,0.89,Chicago White Stockings,Lake Front Park I,,106,105,CHC,CHN,CHN
+1878,NL,CN1,CNR,,2,61,,37,23,,,N,,333,2281,629,67,22,5,58,141,,,,,281,112,1.8400000000,61,6,0,1644,546,2,63,220,254,37,0.90,Cincinnati Reds,Avenue Grounds,,91,92,CIN,CN1,CN1
+1878,NL,IN1,IBL,,5,63,,24,36,,,N,,293,2300,542,76,15,3,64,197,,,,,328,149,2.3200000000,59,2,1,1734,621,3,87,182,290,37,0.89,Indianapolis Blues,South Street Park,,87,89,IND,IN1,IN1
+1878,NL,ML2,MLG,,6,61,,15,45,,,N,,256,2212,552,65,20,2,69,214,,,,,386,158,2.6000000000,54,1,0,1641,589,3,55,147,376,32,0.86,Milwaukee Grays,Eclipse Park II,,106,113,MLG,ML2,ML2
+1878,NL,PRO,PRO,,3,62,,33,27,,,N,,353,2298,604,107,30,8,50,218,,,,,337,147,2.3800000000,59,6,0,1668,609,5,86,173,311,42,0.89,Providence Grays,Messer Street Grounds,,100,96,PRO,PRO,PRO
+1879,NL,BFN,BUF,,3,79,,46,32,,,N,,394,2906,733,105,54,2,78,314,,,,,365,185,2.3400000000,78,8,0,2139,698,3,47,198,331,62,0.90,Buffalo Bisons,Riverside Park,,102,105,BUF,BFN,BFN
+1879,NL,BSN,ATL,,2,84,,54,30,,,N,,562,3217,883,138,51,20,90,222,,,,,348,183,2.1900000000,80,13,0,2259,757,9,46,230,319,58,0.91,Boston Red Caps,South End Grounds I,,102,100,BSN,BSN,BSN
+1879,NL,CHN,CHC,,4,83,,46,33,,,N,,437,3116,808,167,32,3,73,294,,,,,411,203,2.4600000000,82,6,0,2232,762,5,57,211,381,52,0.90,Chicago White Stockings,Lake Front Park I,,106,103,CHC,CHN,CHN
+1879,NL,CL2,CBL,,6,82,,27,55,,,N,,322,2987,666,116,29,4,37,214,,,,,461,218,2.6500000000,79,3,0,2223,818,4,116,287,405,42,0.88,Cleveland Blues,Kennard Street Park,,99,100,CLV,CL2,CL2
+1879,NL,CN1,CNR,,5,81,,43,37,,,N,,485,3085,813,127,53,8,66,207,,,,,464,185,2.2900000000,79,4,0,2178,756,11,81,246,426,48,0.87,Cincinnati Reds,Avenue Grounds,,95,94,CIN,CN1,CN1
+1879,NL,PRO,PRO,,1,85,,59,25,,,Y,,612,3392,1003,142,55,12,91,172,,,,,355,188,2.1800000000,73,3,2,2328,765,9,62,329,382,41,0.90,Providence Grays,Messer Street Grounds,,99,95,PRO,PRO,PRO
+1879,NL,SR1,SYR,,7,71,,22,48,,,N,,276,2611,592,61,19,5,28,238,,,,,462,230,3.1900000000,64,5,0,1947,775,4,52,132,398,37,0.87,Syracuse Stars,Newell Park,,89,95,SYR,SR1,SR1
+1879,NL,TRN,TRT,,8,77,,19,56,,,N,,321,2841,673,102,24,4,45,182,,,,,543,216,2.8000000000,75,3,0,2085,840,13,47,210,460,44,0.87,Troy Trojans,Putnam Grounds,,93,100,TRO,TRN,TRN
+1880,NL,BFN,BUF,,7,85,,24,58,,,N,,331,2962,669,104,37,3,90,327,,,,,502,254,3.0900000000,72,6,1,2217,879,10,78,186,403,55,0.89,Buffalo Bisons,Riverside Park,,102,103,BUF,BFN,BFN
+1880,NL,BSN,ATL,,6,86,,40,44,,,N,,416,3080,779,134,41,20,105,221,,,,,456,255,3.0800000000,70,4,0,2232,840,2,86,187,368,54,0.90,Boston Red Caps,South End Grounds I,,97,96,BSN,BSN,BSN
+1880,NL,CHN,CHC,,1,86,,67,17,,,Y,,538,3135,876,164,39,4,104,217,,,,,317,166,1.9300000000,80,8,3,2325,622,8,129,367,329,41,0.91,Chicago White Stockings,Lake Front Park I,,106,102,CHC,CHN,CHN
+1880,NL,CL2,CBL,,3,85,,47,37,,,N,,387,3002,726,130,52,7,76,237,,,,,337,160,1.9000000000,83,7,1,2277,685,4,98,289,330,52,0.91,Cleveland Blues,Kennard Street Park,,98,99,CLV,CL2,CL2
+1880,NL,CN1,CNR,,8,83,,21,59,,,N,,296,2895,649,91,36,7,75,267,,,,,472,193,2.4400000000,79,3,0,2139,785,10,88,208,427,49,0.87,Cincinnati Reds,Bank Street Grounds,,98,104,CIN,CN1,CN1
+1880,NL,PRO,PRO,,2,87,,52,32,,,N,,419,3196,793,114,34,8,89,186,,,,,299,146,1.6400000000,75,13,2,2397,663,7,51,286,357,53,0.91,Providence Grays,Messer Street Grounds,,97,93,PRO,PRO,PRO
+1880,NL,TRN,TRT,,4,83,,41,42,,,N,,392,3007,755,114,37,5,120,260,,,,,438,225,2.7400000000,81,4,0,2214,763,8,113,173,366,58,0.90,Troy Trojans,Haymakers' Grounds,,105,106,TRO,TRN,TRN
+1880,NL,WOR,WOR,,5,85,,40,43,,,N,,412,3024,699,129,52,8,81,278,,,,,370,192,2.2700000000,68,7,5,2286,709,13,97,297,355,49,0.90,Worcester Ruby Legs,Worcester Driving Park Grounds,,108,109,WOR,WOR,WOR
+1881,NL,BFN,BUF,,3,83,,45,38,,,N,,440,3019,797,157,50,12,108,270,,,,,447,234,2.8400000000,72,5,0,2226,881,9,89,185,408,48,0.89,Buffalo Bisons,Riverside Park,,99,100,BUF,BFN,BFN
+1881,NL,BSN,ATL,,6,83,,38,45,,,N,,349,2916,733,121,27,5,110,193,,,,,410,220,2.7100000000,72,6,3,2190,763,9,143,199,293,54,0.91,Boston Red Caps,South End Grounds I,,96,96,BSN,BSN,BSN
+1881,NL,CHN,CHC,,1,84,,56,28,,,Y,,550,3114,918,157,36,12,140,224,,,,,379,201,2.4300000000,81,9,0,2232,722,14,122,228,309,54,0.91,Chicago White Stockings,Lake Front Park I,,105,99,CHC,CHN,CHN
+1881,NL,CL2,CBL,,7,85,,36,48,,,N,,392,3117,796,120,39,7,132,224,,,,,414,226,2.6800000000,82,2,0,2280,737,9,126,240,348,68,0.90,Cleveland Blues,Kennard Street Park,,95,95,CLV,CL2,CL2
+1881,NL,DTN,DTN,,4,84,,41,43,,,N,,439,2995,780,131,53,17,136,250,,,,,429,219,2.6500000000,83,10,0,2232,785,8,137,265,338,80,0.90,Detroit Wolverines,Recreation Park,,104,105,DTN,DTN,DTN
+1881,NL,PRO,PRO,,2,85,,47,37,,,N,,447,3077,780,144,37,11,146,214,,,,,426,202,2.4000000000,76,7,0,2271,756,5,138,264,389,66,0.89,Providence Grays,Messer Street Grounds,,98,96,PRO,PRO,PRO
+1881,NL,TRN,TRT,,5,85,,39,45,,,N,,399,3046,754,124,31,5,140,240,,,,,429,254,2.9700000000,85,8,0,2310,813,11,159,207,311,70,0.91,Troy Trojans,Haymakers' Grounds,,105,106,TRO,TRN,TRN
+1881,NL,WOR,WOR,,8,83,,32,50,,,N,,410,3093,781,114,31,7,121,169,,,,,492,290,3.5400000000,80,5,0,2211,882,11,120,196,353,50,0.90,Worcester Ruby Legs,Worcester Driving Park Grounds,,105,108,WOR,WOR,WOR
+1882,AA,BL2,BLO,,6,74,,19,54,,,N,,273,2583,535,60,24,4,72,215,,,,,515,278,3.8700000000,64,1,0,1938,760,15,108,113,488,41,0.85,Baltimore Orioles,Newington Park,,90,100,BAL,BL2,BL2
+1882,AA,CN2,CIN,,1,80,,55,25,,,Y,,489,3007,795,95,47,5,102,204,,,,,268,132,1.6500000000,77,11,0,2163,609,7,125,165,322,41,0.90,Cincinnati Red Stockings,Bank Street Grounds,,106,99,CIN,CN2,CN2
+1882,AA,LS2,LOU,,2,80,,42,38,,,N,,443,2806,728,110,28,9,128,193,,,,,352,156,2.0300000000,73,6,0,2079,637,6,112,240,385,37,0.89,Louisville Eclipse,Eclipse Park I,,95,93,LOU,LS2,LS2
+1882,AA,PH4,PHA,,3,75,,41,34,,,N,,406,2707,660,89,21,5,125,164,,,,,389,219,2.9700000000,72,2,0,1989,682,13,99,190,361,36,0.89,Philadelphia Athletics,Oakdale Park,,110,110,PHA,PH4,PH4
+1882,AA,PT1,PIT,,4,79,,39,39,,,N,,428,2904,730,110,59,18,90,183,,,,,418,216,2.7900000000,77,2,0,2088,694,4,82,252,397,40,0.88,Pittsburg Alleghenys,Exposition Park I,,100,99,PIT,PT1,PT1
+1882,AA,SL4,STL,,5,80,,37,43,,,N,,399,2865,663,87,41,11,112,226,,,,,496,223,2.9200000000,75,3,1,2064,729,7,103,225,446,41,0.87,St. Louis Brown Stockings,Sportsman's Park I,,104,104,STL,SL4,SL4
+1882,NL,BFN,BUF,,3,84,,45,39,,,N,,500,3128,858,146,47,18,116,228,,,,,461,266,3.2500000000,79,3,0,2211,778,16,114,287,315,42,0.91,Buffalo Bisons,Riverside Park,,102,101,BUF,BFN,BFN
+1882,NL,BSN,ATL,,3,85,,45,39,,,N,,472,3118,823,114,50,15,134,244,,,,,414,233,2.8000000000,81,4,0,2247,738,10,77,352,295,37,0.91,Boston Red Caps,South End Grounds I,,100,98,BSN,BSN,BSN
+1882,NL,CHN,CHC,,1,84,,55,29,,,Y,,604,3225,892,209,54,15,142,262,,,,,353,188,2.2200000000,83,7,0,2289,667,13,102,279,376,54,0.89,Chicago White Stockings,Lake Front Park I/Lake Front Park II,,105,99,CHC,CHN,CHN
+1882,NL,CL2,CBL,,5,84,,42,40,,,N,,402,3009,716,139,40,20,122,261,,,,,411,229,2.7400000000,81,4,0,2253,743,22,132,232,355,71,0.90,Cleveland Blues,Kennard Street Park,,97,97,CLV,CL2,CL2
+1882,NL,DTN,DTN,,5,86,,42,41,,,N,,407,3144,724,117,44,19,122,308,,,,,488,263,2.9800000000,82,7,0,2379,808,19,129,354,377,44,0.89,Detroit Wolverines,Recreation Park,,100,101,DTN,DTN,DTN
+1882,NL,PRO,PRO,,2,84,,52,32,,,N,,463,3104,776,121,53,11,102,255,,,,,356,190,2.2700000000,80,10,1,2256,690,12,87,273,371,67,0.90,Providence Grays,Messer Street Grounds,,100,98,PRO,PRO,PRO
+1882,NL,TRN,TRT,,7,85,,35,48,,,N,,430,3057,747,116,59,12,109,298,,,,,522,259,3.0800000000,81,6,0,2271,837,13,168,189,432,70,0.88,Troy Trojans,Troy Ball Club Grounds,,95,98,TRO,TRN,TRN
+1882,NL,WOR,WOR,,8,84,,18,66,,,N,,379,2984,689,109,57,16,113,303,,,,,652,308,3.7600000000,75,0,0,2214,964,21,151,195,469,66,0.87,Worcester Ruby Legs,Worcester Driving Park Grounds,,102,107,WOR,WOR,WOR
+1883,AA,BL2,BLO,,8,96,,28,68,,,N,,471,3534,870,125,49,5,162,331,,,,,742,383,4.0800000000,86,1,0,2532,943,12,190,290,624,,0.85,Baltimore Orioles,Oriole Park,,103,105,BAL,BL2,BL2
+1883,AA,CL5,CBK,,6,97,,32,65,,,N,,476,3553,854,101,79,15,134,410,,,,,659,370,3.9600000000,90,4,0,2520,980,16,211,222,535,,0.87,Columbus Buckeyes,Recreation Park I,,92,93,COL,CL5,CL5
+1883,AA,CN2,CIN,,3,98,,61,37,,,N,,662,3669,961,122,74,34,139,261,,,,,413,217,2.2600000000,96,8,0,2598,766,17,168,215,360,,0.90,Cincinnati Red Stockings,Bank Street Grounds,,106,99,CIN,CN2,CN2
+1883,AA,LS2,LOU,,5,98,,52,45,,,N,,564,3553,891,114,64,14,140,305,,,,,562,340,3.5100000000,96,7,0,2619,987,7,110,269,471,,0.88,Louisville Eclipse,Eclipse Park I,,93,91,LOU,LS2,LS2
+1883,AA,NY4,NYP,,4,97,,54,42,,,N,,498,3534,883,111,58,6,142,259,,,,,405,282,2.9000000000,97,6,0,2622,749,12,123,480,391,,0.90,New York Metropolitans,Polo Grounds I West Diamond,,109,106,NYP,NY4,NY4
+1883,AA,PH4,PHA,,1,98,,66,32,,,Y,,720,3714,972,149,50,20,194,268,,,,,547,279,2.8800000000,92,1,0,2619,921,22,95,347,584,,0.86,Philadelphia Athletics,Jefferson Street Grounds,,108,105,PHA,PH4,PH4
+1883,AA,PT1,PIT,,7,98,,31,67,,,N,,525,3609,892,120,58,13,162,345,,,,,728,445,4.6200000000,82,1,1,2601,1140,21,151,271,506,,0.88,Pittsburg Alleghenys,Exposition Park I,,94,98,PIT,PT1,PT1
+1883,AA,SL4,STL,,2,98,,65,33,,,N,,549,3495,892,118,46,7,125,240,,,,,409,218,2.2300000000,93,9,1,2637,729,7,150,325,388,,0.90,St. Louis Browns,Sportsman's Park I,,106,106,STL,SL4,SL4
+1883,NL,BFN,BUF,,5,98,,52,45,,,N,,614,3729,1058,184,59,8,147,342,,,,,576,317,3.3200000000,90,5,2,2577,971,12,101,362,445,,0.89,Buffalo Bisons,Riverside Park,,102,101,BUF,BFN,BFN
+1883,NL,BSN,ATL,,1,98,,63,35,,,Y,,669,3657,1010,209,86,34,123,423,,,,,456,244,2.5500000000,89,6,3,2580,853,11,90,538,382,,0.90,Boston Beaneaters,South End Grounds I,,102,98,BSN,BSN,BSN
+1883,NL,CHN,CHC,,2,98,,59,39,,,N,,679,3658,1000,277,61,13,129,399,,,,,540,266,2.7800000000,91,5,1,2586,942,21,123,299,543,,0.87,Chicago White Stockings,Lake Front Park II,,108,105,CHC,CHN,CHN
+1883,NL,CL2,CBL,,4,100,,55,42,,,N,,476,3457,852,184,38,8,139,374,,,,,443,217,2.2200000000,92,5,2,2637,818,7,217,402,389,,0.90,Cleveland Blues,Kennard Street Park,,99,100,CLV,CL2,CL2
+1883,NL,DTN,DTN,,7,101,,40,58,,,N,,524,3726,931,164,48,13,166,378,,,,,650,356,3.5800000000,89,5,2,2682,1026,22,184,324,444,,0.89,Detroit Wolverines,Recreation Park,,95,99,DTN,DTN,DTN
+1883,NL,NY1,SFG,,6,98,,46,50,,,N,,530,3524,900,139,69,24,127,297,,,,,577,283,2.9400000000,87,5,0,2598,907,19,170,323,468,,0.88,New York Gothams,Polo Grounds I,,99,99,NYG,NY1,NY1
+1883,NL,PHI,PHI,,8,99,,17,81,,,N,,437,3576,859,181,48,3,141,355,,,,,887,513,5.3400000000,91,3,0,2592,1267,20,125,253,639,,0.85,Philadelphia Quakers,Recreation Park,,91,98,PHI,PHI,PHI
+1883,NL,PRO,PRO,,3,98,,58,40,,,N,,636,3685,1001,189,59,21,149,309,,,,,436,229,2.3700000000,88,4,1,2613,827,12,111,376,419,,0.90,Providence Grays,Messer Street Grounds,,103,99,PRO,PRO,PRO
+1884,AA,BL2,BLO,,6,108,,63,43,,,N,N,636,3845,896,133,84,32,211,545,,,,,515,288,2.7100000000,105,8,1,2865,869,16,219,635,461,,0.89,Baltimore Orioles,Oriole Park,,104,107,BAL,BL2,BL2
+1884,AA,BR3,LAD,,9,109,,40,64,,,N,N,476,3763,845,112,47,16,179,417,,,,,644,399,3.7900000000,105,6,0,2844,996,20,163,378,508,,0.88,Brooklyn Atlantics,Washington Park I,,100,102,BRO,BR3,BR3
+1884,AA,CL5,CBK,,2,110,,69,39,,,N,N,585,3759,901,107,96,40,196,404,,,,,459,286,2.6800000000,102,8,1,2886,815,22,172,526,433,,0.90,Columbus Buckeyes,Recreation Park I,,92,93,COL,CL5,CL5
+1884,AA,CN2,CIN,,5,112,,68,41,,,N,N,754,4090,1037,109,96,36,154,404,,,,,512,364,3.3300000000,111,11,0,2949,956,27,181,308,412,,0.91,Cincinnati Red Stockings,League Park I in Cincinnati,,104,102,CIN,CN2,CN2
+1884,AA,IN2,IHO,,12,110,,29,78,,,N,N,462,3813,890,129,62,20,125,560,,,,,755,437,4.2000000000,107,2,0,2811,1001,30,199,479,515,,0.88,Indianapolis Hoosiers,Seventh Street Park,,97,100,IND,IN2,IN2
+1884,AA,LS2,LOU,,3,110,,68,40,,,N,N,573,3957,1004,152,69,17,146,408,,,,,425,238,2.1700000000,101,6,0,2967,836,9,97,470,426,,0.91,Louisville Eclipse,Eclipse Park I,,95,95,LOU,LS2,LS2
+1884,AA,NY4,NYP,,1,112,,75,32,,,Y,N,734,4012,1052,155,64,22,203,315,,,,,423,269,2.4600000000,111,9,0,2952,800,15,119,611,441,,0.90,New York Metropolitans,Polo Grounds I West Diamond,,100,96,NYP,NY4,NY4
+1884,AA,PH4,PHA,,7,108,,61,46,,,N,N,700,3959,1057,167,100,26,153,425,,,,,546,360,3.4200000000,105,5,0,2844,920,16,127,530,458,,0.90,Philadelphia Athletics,Jefferson Street Grounds,,107,104,PHA,PH4,PH4
+1884,AA,PT1,PIT,,11,110,,30,78,,,N,N,406,3689,777,105,50,2,143,411,,,,,725,456,4.3500000000,108,4,0,2829,1059,25,216,338,523,,0.88,Pittsburg Alleghenys,Recreation Park,,97,101,PIT,PT1,PT1
+1884,AA,RIC,RIC,,10,46,,12,30,,,N,N,194,1469,325,40,33,7,53,284,,,,,294,186,4.5200000000,45,1,0,1110,402,14,52,167,238,,0.87,Richmond Virginians,Allen Pasture,,99,102,RIC,RIC,RIC
+1884,AA,SL4,STL,,4,110,,67,40,,,N,N,658,3952,986,151,60,11,174,339,,,,,539,293,2.6700000000,99,8,0,2961,881,16,172,477,489,,0.90,St. Louis Browns,Sportsman's Park I,,104,101,STL,SL4,SL4
+1884,AA,TL1,TOL,,8,110,,46,58,,,N,N,463,3712,859,153,48,8,157,541,,,,,571,322,3.0600000000,103,9,1,2838,885,12,169,501,469,,0.90,Toledo Blue Stockings,League Park,,103,105,TOL,TL1,TL1
+1884,AA,WS7,WST,,13,63,,12,51,,,N,N,248,2166,434,61,24,6,102,377,,,,,481,242,4.0100000000,62,3,0,1629,643,21,110,235,399,,0.85,Washington Nationals,Athletic Park,,88,93,WAS,WS7,WS7
+1884,NL,BFN,BUF,,3,115,,64,47,,,N,N,700,4197,1099,163,69,39,215,458,,,,,626,328,2.9500000000,108,14,1,3003,1041,46,189,534,463,,0.90,Buffalo Bisons,Olympic Park I,,103,105,BUF,BFN,BFN
+1884,NL,BSN,ATL,,2,116,,73,38,,,N,N,684,4189,1063,179,60,36,207,660,,,,,468,285,2.4700000000,109,14,2,3111,932,30,135,742,374,,0.92,Boston Beaneaters,South End Grounds I,,99,97,BSN,BSN,BSN
+1884,NL,CHN,CHC,,5,113,,62,50,,,N,N,834,4182,1176,162,50,142,264,469,,,,,647,336,3.0300000000,106,9,0,2991,1028,83,231,472,595,,0.88,Chicago White Stockings,Lake Front Park II,,108,105,CHC,CHN,CHN
+1884,NL,CL2,CBL,,7,113,,35,77,,,N,N,458,3934,934,147,49,16,170,576,,,,,716,379,3.4300000000,107,7,0,2982,1046,35,269,482,512,,0.89,Cleveland Blues,Kennard Street Park,,103,106,CLV,CL2,CL2
+1884,NL,DTN,DTN,,8,114,,28,84,,,N,N,445,3970,825,114,47,31,207,699,,,,,736,370,3.3800000000,109,3,0,2952,1097,36,245,488,514,,0.89,Detroit Wolverines,Recreation Park,,94,97,DTN,DTN,DTN
+1884,NL,NY1,SFG,,4,116,,62,50,,,N,N,693,4124,1053,149,67,23,249,492,,,,,623,352,3.1200000000,111,4,0,3042,1011,28,326,567,514,,0.89,New York Gothams,Polo Grounds I,,105,102,NYG,NY1,NY1
+1884,NL,PHI,PHI,,6,113,,39,73,,,N,N,549,3998,934,149,39,14,209,512,,,,,824,428,3.9300000000,106,3,1,2943,1090,38,254,411,536,,0.88,Philadelphia Quakers,Recreation Park,,94,99,PHI,PHI,PHI
+1884,NL,PRO,PRO,,1,114,,84,28,,,Y,Y,665,4093,987,153,43,21,300,469,,,,,388,185,1.6100000000,107,16,2,3108,825,26,172,639,398,,0.91,Providence Grays,Messer Street Grounds,,99,96,PRO,PRO,PRO
+1884,UA,ALT,ALT,,10,25,,6,19,,,N,,90,899,223,30,6,2,22,130,,,,,216,114,4.6800000000,20,0,0,657,292,3,52,93,156,,0.86,Altoona Mountain City,,,101,109,ALT,ALT,ALT
+1884,UA,BLU,BLU,,4,106,,58,47,,,N,,662,3883,952,150,26,17,144,652,,,,,627,316,3.0100000000,92,4,0,2838,1002,24,177,628,610,,0.87,Baltimore Monumentals,,,109,109,BLU,BLU,BLU
+1884,UA,BSU,BRD,,5,111,,58,51,,,N,,636,3940,928,168,32,19,128,787,,,,,558,286,2.7000000000,100,5,1,2859,885,17,110,753,633,,0.86,Boston Reds,,,99,98,BOS,BSU,BSU
+1884,UA,CHU,CPI,,6,93,,41,50,,,N,,438,3212,742,127,26,10,119,505,,,,,482,243,2.7200000000,86,6,0,2409,743,12,137,679,459,,0.88,Chicago/Pittsburgh (Union League),,,98,99,CPI,CHU,CHU
+1884,UA,CNU,COR,,3,105,,69,36,,,N,,703,3786,1027,118,63,26,147,482,,,,,466,242,2.3800000000,95,11,1,2742,831,17,90,503,532,,0.88,Cincinnati Outlaw Reds,,,111,107,COR,CNU,CNU
+1884,UA,KCU,KCU,,11,82,,16,63,,,N,,311,2802,557,104,15,6,123,529,,,,,618,317,4.0600000000,70,0,0,2106,862,14,127,334,520,,0.86,Kansas City Cowboys,,,87,92,KCC,KCU,KCU
+1884,UA,MLU,MLU,,2,12,,8,4,,,N,,53,395,88,25,0,0,20,70,,,,,34,26,2.2500000000,12,3,0,312,49,1,13,139,53,,0.89,Milwaukee Brewers,,,60,60,MIL,MLU,MLU
+1884,UA,PHU,PHK,,8,67,,21,46,,,N,,414,2518,618,108,35,7,103,405,,,,,545,305,4.6300000000,64,1,0,1779,726,7,105,310,501,,0.84,Philadelphia Keystones,,,91,94,PHK,PHU,PHU
+1884,UA,SLU,SLM,,1,114,,94,19,,,Y,,887,4285,1251,259,41,32,181,542,,,,,429,216,1.9600000000,104,8,6,2979,838,9,110,550,554,,0.88,St. Louis Maroons,,,99,98,SLM,SLU,SLU
+1884,UA,SPU,STP,,9,9,,2,6,,,N,,24,272,49,13,1,0,7,47,,,,,57,25,3.1700000000,7,1,0,213,72,1,27,44,47,,0.87,St. Paul White Caps,,,60,60,STP,SPU,SPU
+1884,UA,WIL,WIL,,12,18,,2,16,,,N,,35,521,91,8,8,2,22,123,,,,,114,48,3.0400000000,15,0,0,426,165,4,18,113,104,,0.85,Wilmington Quicksteps,,,103,109,WIL,WIL,WIL
+1884,UA,WSU,WNA,,7,114,,47,65,,,N,,572,3926,931,120,26,4,118,558,,,,,679,364,3.4400000000,94,5,0,2859,992,16,168,684,550,,0.87,Washington Nationals,,,96,98,WHS,WSU,WSU
+1885,AA,BL2,BLO,,8,110,,41,68,,,N,N,541,3820,837,124,59,17,279,529,,,,,683,421,3.9000000000,103,2,4,2913,1059,12,222,395,419,,0.90,Baltimore Orioles,Oriole Park,,99,100,BAL,BL2,BL2
+1885,AA,BR3,LAD,,5,112,,53,59,,,N,N,624,3943,966,121,65,14,238,324,,,,,650,381,3.4600000000,110,3,1,2973,955,27,211,436,436,,0.91,Brooklyn Grays,Washington Park I,,100,102,BRO,BR3,BR3
+1885,AA,CN2,CIN,,2,112,,63,49,,,N,N,642,4050,1046,108,77,26,153,420,,,,,575,362,3.2600000000,102,7,1,2997,998,24,250,330,417,,0.91,Cincinnati Red Stockings,League Park I in Cincinnati,,102,100,CIN,CN2,CN2
+1885,AA,LS2,LOU,,6,112,,53,59,,,N,N,564,3969,986,126,83,19,152,448,,,,,598,298,2.6800000000,109,3,1,3006,927,13,217,462,460,,0.90,Louisville Colonels,Eclipse Park I,,100,100,LOU,LS2,LS2
+1885,AA,NY4,NYP,,7,108,,44,64,,,N,N,526,3731,921,123,57,21,217,428,,,,,688,432,4.1500000000,103,2,0,2811,1015,36,204,408,453,,0.90,New York Metropolitans,Polo Grounds I West Diamond,,84,86,NYP,NY4,NY4
+1885,AA,PH4,PHA,,4,113,,55,57,,,N,N,764,4142,1099,169,76,30,223,410,,,,,691,360,3.2300000000,105,5,0,3009,1038,11,212,506,482,,0.90,Philadelphia Athletics,Jefferson Street Grounds,,106,106,PHA,PH4,PH4
+1885,AA,PT1,PIT,,3,111,,56,55,,,N,N,547,3975,955,123,79,5,189,537,,,,,539,328,2.9200000000,104,8,0,3033,918,14,201,454,422,,0.91,Pittsburg Alleghenys,Recreation Park,,100,99,PIT,PT1,PT1
+1885,AA,SL4,STL,,1,112,,79,33,,,Y,N,677,3972,979,132,57,17,234,282,,,,,461,272,2.4400000000,111,11,0,3006,879,12,168,378,381,,0.92,St. Louis Browns,Sportsman's Park I,,105,101,STL,SL4,SL4
+1885,NL,BFN,BUF,,7,112,,38,74,,,N,N,495,3900,980,149,50,23,179,380,,,,,761,456,4.2900000000,107,4,1,2868,1175,31,234,320,464,,0.90,Buffalo Bisons,Olympic Park I,,103,105,BUF,BFN,BFN
+1885,NL,BSN,ATL,,5,113,,46,66,,,N,N,528,3950,915,144,53,22,190,522,,,,,589,330,3.0300000000,111,10,0,2943,1045,26,188,480,445,,0.90,Boston Beaneaters,South End Grounds I,,96,95,BSN,BSN,BSN
+1885,NL,CHN,CHC,,1,113,,87,25,,,Y,N,834,4093,1079,184,75,54,340,429,,,,,470,251,2.2300000000,108,14,4,3045,868,37,202,458,497,,0.90,Chicago White Stockings,West Side Park I,,114,107,CHC,CHN,CHN
+1885,NL,DTN,DTN,,6,108,,41,67,,,N,N,514,3773,917,149,66,25,216,451,,,,,582,305,2.8800000000,105,6,1,2862,966,18,224,475,445,,0.90,Detroit Wolverines,Recreation Park,,100,101,DTN,DTN,DTN
+1885,NL,NY1,SFG,,2,112,,85,27,,,N,N,691,4029,1085,150,82,16,221,312,,,,,370,190,1.7200000000,109,16,1,2982,758,11,265,516,331,,0.92,New York Giants,Polo Grounds I,,101,97,NYG,NY1,NY1
+1885,NL,PHI,PHI,,3,111,,56,54,,,N,N,513,3893,891,156,35,20,220,401,,,,,511,259,2.3900000000,108,10,0,2928,860,18,218,378,447,,0.90,Philadelphia Quakers,Recreation Park,,97,98,PHI,PHI,PHI
+1885,NL,PRO,PRO,,4,110,,53,57,,,N,N,442,3727,820,114,30,6,265,430,,,,,531,289,2.7100000000,108,8,0,2880,912,18,235,371,459,,0.90,Providence Grays,Messer Street Grounds,,97,95,PRO,PRO,PRO
+1885,NL,SL5,SLM,,8,111,,36,72,,,N,N,390,3758,829,121,21,8,214,412,,,,,593,361,3.3700000000,107,4,0,2895,935,15,278,337,398,,0.91,St. Louis Maroons,Sportsman's Park I,,97,98,SLM,SL5,SL5
+1886,AA,BL2,BLO,,8,139,,48,83,,,N,N,625,4639,945,124,51,8,379,603,269,,,,878,547,4.0800000000,134,5,0,3618,1197,25,403,805,524,,0.90,Baltimore Orioles,Oriole Park,,98,99,BAL,BL2,BL2
+1886,AA,BR3,LAD,,3,141,,76,61,,,N,N,832,5053,1261,196,80,16,433,523,248,,,,832,469,3.4200000000,138,6,0,3702,1202,17,464,540,610,,0.90,Brooklyn Grays,Washington Park I,,100,100,BRO,BR3,BR3
+1886,AA,CN2,CIN,,5,141,,65,73,,,N,N,883,4915,1225,145,95,45,374,633,185,,,,865,579,4.1800000000,129,3,0,3741,1267,25,481,495,580,,0.90,Cincinnati Red Stockings,League Park I in Cincinnati,,103,102,CIN,CN2,CN2
+1886,AA,LS2,LOU,,4,138,,66,70,,,N,N,833,4921,1294,182,88,20,410,558,202,,,,805,412,3.0700000000,131,5,2,3627,1109,16,432,720,593,,0.90,Louisville Colonels,Eclipse Park I,,106,106,LOU,LS2,LS2
+1886,AA,NY4,NYP,,7,137,,53,82,,,N,N,628,4683,1047,108,72,18,330,578,120,,,,766,461,3.5000000000,134,5,0,3558,1148,23,386,559,545,,0.90,New York Metropolitans,St. George Cricket Grounds,,96,100,NYP,NY4,NY4
+1886,AA,PH4,PHA,,6,139,,63,72,,,N,N,772,4856,1142,192,82,21,378,697,284,,,,942,537,3.9700000000,134,4,0,3654,1308,35,388,513,637,,0.89,Philadelphia Athletics,Jefferson Street Grounds,,101,102,PHA,PH4,PH4
+1886,AA,PT1,PIT,,2,140,,80,57,,,N,N,810,4854,1171,186,96,16,478,713,260,,,,647,386,2.8300000000,137,15,1,3678,1130,10,299,515,487,,0.91,Pittsburg Alleghenys,Recreation Park,,98,97,PIT,PT1,PT1
+1886,AA,SL4,STL,,1,139,,93,46,,,Y,Y,944,5009,1365,206,85,20,400,425,336,,,,592,340,2.4900000000,134,14,2,3687,1087,13,329,583,494,,0.91,St. Louis Browns,Sportsman's Park I,,105,100,STL,SL4,SL4
+1886,NL,BSN,ATL,,5,118,,56,61,,,N,N,657,4180,1085,151,59,24,250,537,156,,,,661,370,3.2400000000,116,3,0,3087,1049,33,298,511,465,,0.90,Boston Beaneaters,South End Grounds I,,97,97,BSN,BSN,BSN
+1886,NL,CHN,CHC,,1,126,,90,34,,,Y,N,900,4378,1223,198,87,53,460,513,213,,,,555,310,2.5400000000,116,8,3,3291,988,49,262,647,475,,0.91,Chicago White Stockings,West Side Park I,,114,109,CHC,CHN,CHN
+1886,NL,DTN,DTN,,2,126,,87,36,,,N,N,829,4501,1260,176,81,53,374,426,194,,,,538,349,2.8500000000,122,8,0,3309,995,20,270,592,373,,0.92,Detroit Wolverines,Recreation Park,,103,100,DTN,DTN,DTN
+1886,NL,KCN,KCN,,7,126,,30,91,,,N,N,494,4236,967,177,48,19,269,608,96,,,,872,573,4.8400000000,117,4,0,3198,1345,27,246,442,455,,0.90,Kansas City Cowboys,Association Park,,106,114,KCN,KCN,KCN
+1886,NL,NY1,SFG,,3,124,,75,44,,,N,N,692,4298,1156,175,68,21,237,410,155,,,,558,337,2.8600000000,119,3,1,3186,1029,23,280,588,359,,0.92,New York Giants,Polo Grounds I,,103,99,NYG,NY1,NY1
+1886,NL,PHI,PHI,,4,119,,71,43,,,N,N,621,4072,976,145,66,26,282,516,226,,,,498,284,2.4500000000,110,10,2,3135,923,29,264,540,393,,0.92,Philadelphia Quakers,Recreation Park,,100,99,PHI,PHI,PHI
+1886,NL,SL5,SLM,,6,126,,43,79,,,N,N,547,4250,1001,183,46,30,235,656,156,,,,712,388,3.2400000000,118,6,0,3231,1050,34,392,501,452,,0.91,St. Louis Maroons,Sportsman's Park I,,94,97,SLM,SL5,SL5
+1886,NL,WS8,WNL,,8,125,,28,92,,,N,N,445,4082,856,135,51,23,265,582,143,,,,791,497,4.3000000000,116,4,0,3123,1147,34,379,500,458,,0.91,Washington Nationals,Swampdoodle Grounds,,94,99,WHS,WS8,WS8
+1887,AA,BL2,BLO,,3,141,,77,58,,,N,N,975,4825,1337,202,100,31,469,334,545,,,,861,525,3.8700000000,132,8,0,3660,1288,16,418,470,549,,0.90,Baltimore Orioles,Oriole Park,,94,95,BAL,BL2,BL2
+1887,AA,BR3,LAD,,6,138,,60,74,,,N,N,904,4913,1281,200,82,25,456,365,409,,,,918,589,4.4700000000,132,3,3,3555,1348,27,454,332,562,,0.90,Brooklyn Grays,Washington Park I,,101,100,BRO,BR3,BR3
+1887,AA,CL3,CLV,,8,133,,39,92,,,N,N,729,4649,1170,178,77,14,375,463,355,,,,1112,630,4.9900000000,127,2,1,3408,1472,34,533,332,576,,0.89,Cleveland Blues,National League Park II,,97,101,CLE,CL3,CL3
+1887,AA,CN2,CIN,,2,136,,81,54,,,N,N,892,4797,1285,179,102,37,382,366,527,,,,745,470,3.5800000000,129,11,1,3546,1202,28,396,330,484,,0.91,Cincinnati Red Stockings,League Park I in Cincinnati,,102,101,CIN,CN2,CN2
+1887,AA,LS2,LOU,,4,139,,76,60,,,N,N,956,4916,1420,194,98,27,436,356,466,,,,854,511,3.8200000000,133,3,1,3615,1274,31,357,544,574,,0.90,Louisville Colonels,Eclipse Park I,,102,102,LOU,LS2,LS2
+1887,AA,NY4,NYP,,7,138,,44,89,,,N,N,754,4820,1197,193,66,21,439,463,305,,,,1093,692,5.2800000000,132,1,0,3540,1545,39,406,316,628,,0.89,New York Metropolitans,St. George Cricket Grounds,,96,100,NYP,NY4,NY4
+1887,AA,PH4,PHA,,5,137,,64,69,,,N,N,893,4954,1370,231,84,29,321,388,476,,,,890,605,4.5900000000,131,5,1,3558,1227,29,433,417,528,,0.90,Philadelphia Athletics,Jefferson Street Grounds,,100,100,PHA,PH4,PH4
+1887,AA,SL4,STL,,1,138,,95,40,,,Y,N,1131,5048,1550,261,78,39,442,340,581,,,,761,502,3.7700000000,132,7,2,3597,1254,19,323,334,481,,0.91,St. Louis Browns,Sportsman's Park I,,111,106,STL,SL4,SL4
+1887,NL,BSN,ATL,,5,127,,61,60,,,N,N,831,4531,1255,185,94,53,340,392,373,,,,792,539,4.4100000000,123,4,1,3300,1226,55,396,254,522,,0.90,Boston Beaneaters,South End Grounds I,,98,97,BSN,BSN,BSN
+1887,NL,CHN,CHC,,3,127,,71,50,,,N,N,813,4350,1177,178,98,80,407,400,382,,,,716,433,3.4600000000,117,4,3,3378,1156,55,338,510,472,,0.91,Chicago White Stockings,West Side Park I,,113,110,CHC,CHN,CHN
+1887,NL,DTN,DTN,,1,127,,79,45,,,Y,Y,969,4689,1404,213,126,55,352,258,267,,,,714,490,3.9500000000,122,3,1,3348,1172,52,344,337,384,,0.92,Detroit Wolverines,Recreation Park,,104,100,DTN,DTN,DTN
+1887,NL,IN3,IND,,8,127,,37,89,,,N,N,628,4368,1080,162,70,33,300,379,334,,,,965,633,5.2400000000,118,4,1,3264,1289,60,431,245,479,,0.91,Indianapolis Hoosiers,Athletic Park I,,96,102,IND,IN3,IN3
+1887,NL,NY1,SFG,,4,129,,68,55,,,N,N,816,4516,1259,167,93,48,361,326,415,,,,723,441,3.5700000000,123,5,1,3339,1096,27,373,415,430,,0.92,New York Giants,Polo Grounds I,,96,93,NYG,NY1,NY1
+1887,NL,PHI,PHI,,2,128,,75,48,,,N,N,901,4630,1269,213,89,47,385,346,355,,,,702,436,3.4700000000,119,7,1,3396,1173,48,305,435,471,,0.91,Philadelphia Quakers,Philadelphia Baseball Grounds,,106,104,PHI,PHI,PHI
+1887,NL,PIT,PIT,,6,125,,55,69,,,N,N,621,4414,1141,183,78,20,319,381,221,,,,750,507,4.1200000000,123,3,0,3324,1287,39,246,248,425,,0.92,Pittsburg Alleghenys,Recreation Park,,93,93,PIT,PIT,PIT
+1887,NL,WS8,WNL,,7,126,,46,76,,,N,N,601,4314,1039,149,63,47,269,339,334,,,,818,507,4.1900000000,124,4,0,3270,1216,47,299,396,469,,0.91,Washington Nationals,Swampdoodle Grounds,,95,100,WHS,WS8,WS8
+1888,AA,BL2,BLO,,5,137,,57,80,,,N,N,653,4656,1068,162,70,19,298,479,326,,,,779,504,3.7800000000,130,3,0,3600,1162,23,419,525,461,,0.92,Baltimore Orioles,Oriole Park,,98,98,BAL,BL2,BL2
+1888,AA,BR3,LAD,,2,143,,88,52,,,N,N,758,4871,1177,172,70,25,353,439,334,,,,584,333,2.3300000000,138,9,0,3858,1059,15,285,577,502,,0.91,Brooklyn Bridegrooms,Washington Park I,,101,100,BRO,BR3,BR3
+1888,AA,CL3,CLV,,6,135,,50,82,,,N,N,651,4603,1076,128,59,12,315,559,353,,,,839,484,3.7200000000,131,6,1,3513,1235,38,389,500,480,,0.91,Cleveland Blues,National League Park II,,97,101,CLE,CL3,CL3
+1888,AA,CN2,CIN,,4,137,,80,54,,,N,N,745,4801,1161,132,82,32,345,555,469,,,,628,375,2.7300000000,132,10,2,3711,1103,19,310,539,456,,0.92,Cincinnati Red Stockings,League Park I in Cincinnati,,105,104,CIN,CN2,CN2
+1888,AA,KC2,KCC,,8,132,,43,89,,,N,N,579,4588,1000,142,61,19,288,604,257,,,,896,552,4.2900000000,128,4,0,3471,1306,32,401,381,507,,0.91,Kansas City Cowboys,Association Park I,,106,112,KCC,KC2,KC2
+1888,AA,LS2,LOU,,7,139,,48,87,,,N,N,689,4881,1177,183,67,14,322,604,318,,,,870,445,3.2500000000,133,6,0,3693,1264,28,281,599,609,,0.90,Louisville Colonels,Eclipse Park I,,98,100,LOU,LS2,LS2
+1888,AA,PH4,PHA,,3,136,,81,52,,,N,N,827,4828,1209,183,89,31,303,473,434,,,,594,323,2.4100000000,133,13,0,3624,988,14,324,596,475,,0.91,Philadelphia Athletics,Jefferson Street Grounds,,100,98,PHA,PH4,PH4
+1888,AA,SL4,STL,,1,137,,92,43,,,Y,N,789,4755,1189,149,47,36,410,521,468,,,,501,281,2.0900000000,132,12,0,3636,939,19,225,517,430,,0.92,St. Louis Browns,Sportsman's Park I,,111,106,STL,SL4,SL4
+1888,NL,BSN,ATL,,4,137,,70,64,,,N,N,669,4834,1183,167,89,56,282,524,293,,,,619,355,2.6100000000,134,7,0,3675,1104,36,269,484,494,,0.91,Boston Beaneaters,South End Grounds II,,104,102,BSN,BSN,BSN
+1888,NL,CHN,CHC,,2,136,,77,58,,,N,N,734,4616,1201,147,95,77,290,563,287,,,,659,390,2.9600000000,123,13,1,3558,1139,63,308,588,417,,0.92,Chicago White Stockings,West Side Park I,,107,106,CHC,CHN,CHN
+1888,NL,DTN,DTN,,5,134,,68,63,,,N,N,721,4849,1275,177,72,51,307,396,193,,,,629,365,2.7400000000,130,10,1,3597,1115,44,183,522,463,,0.91,Detroit Wolverines,Recreation Park,,100,97,DTN,DTN,DTN
+1888,NL,IN3,IND,,7,136,,50,85,,,N,N,603,4623,1100,180,33,34,236,492,350,,,,731,502,3.8100000000,132,6,0,3561,1260,64,308,388,449,,0.92,Indianapolis Hoosiers,Athletic Park II,,102,104,IND,IN3,IN3
+1888,NL,NY1,SFG,,1,138,,84,47,,,Y,Y,659,4747,1149,130,76,55,270,456,314,,,,479,263,1.9600000000,133,20,1,3624,907,27,307,726,430,,0.92,New York Giants,Polo Grounds I,,99,96,NYG,NY1,NY1
+1888,NL,PHI,PHI,,3,132,,69,61,,,N,N,535,4528,1021,151,46,16,268,485,246,,,,509,309,2.3800000000,125,16,3,3501,1072,26,196,519,424,,0.92,Philadelphia Quakers,Philadelphia Baseball Grounds,,105,104,PHI,PHI,PHI
+1888,NL,PIT,PIT,,6,139,,66,68,,,N,N,534,4713,1070,150,49,14,194,583,287,,,,580,357,2.6700000000,135,13,0,3609,1190,23,223,367,416,,0.92,Pittsburg Alleghenys,Recreation Park,,92,93,PIT,PIT,PIT
+1888,NL,WS8,WNL,,8,136,,48,86,,,N,N,482,4546,944,98,49,30,246,499,331,,,,731,464,3.5400000000,133,6,0,3537,1157,50,298,406,474,,0.91,Washington Nationals,Swampdoodle Grounds,,94,98,WHS,WS8,WS8
+1889,AA,BL2,BLO,,5,139,,70,65,,,N,N,791,4756,1209,155,68,20,418,536,311,,,,795,472,3.5600000000,128,10,1,3576,1168,27,424,540,536,,0.90,Baltimore Orioles,Oriole Park,,98,99,BAL,BL2,BL2
+1889,AA,BR3,LAD,,1,140,,93,44,,,Y,N,995,4815,1265,188,79,47,550,401,389,,,,706,486,3.6100000000,120,10,1,3636,1205,33,400,471,421,,0.92,Brooklyn Bridegrooms,Washington Park I,,95,91,BRO,BR3,BR3
+1889,AA,CL6,CLS,,6,140,,60,78,,,N,N,779,4816,1247,171,95,36,507,609,304,,,,924,585,4.3900000000,114,9,4,3597,1274,33,551,610,488,,0.91,Columbus Solons,Recreation Park II,,95,94,COL,CL6,CL6
+1889,AA,CN2,CIN,,4,141,,76,63,,,N,N,897,4844,1307,197,96,52,452,511,462,,,,769,483,3.5000000000,114,3,8,3729,1270,35,475,562,440,,0.92,Cincinnati Red Stockings,League Park I in Cincinnati,,105,103,CIN,CN2,CN2
+1889,AA,KC2,KCC,,7,139,,55,82,,,N,N,852,4947,1256,162,76,18,430,626,472,,,,1031,583,4.3600000000,128,0,2,3612,1373,51,457,447,611,,0.89,Kansas City Cowboys,Exposition Park,,105,108,KCC,KC2,KC2
+1889,AA,LS2,LOU,,8,140,,27,111,,,N,N,632,4955,1249,170,75,22,320,521,203,,,,1091,655,4.8100000000,127,2,1,3678,1529,43,475,451,584,,0.90,Louisville Colonels,Eclipse Park I,,98,100,LOU,LS2,LS2
+1889,AA,PH4,PHA,,3,138,,75,58,,,N,N,880,4868,1339,239,65,43,534,496,252,,,,787,470,3.5300000000,130,9,1,3597,1200,35,509,479,465,,0.92,Philadelphia Athletics,Jefferson Street Grounds,,98,99,PHA,PH4,PH4
+1889,AA,SL4,STL,,2,141,,90,45,,,N,N,957,4939,1312,211,64,58,493,477,336,,,,680,412,3.0000000000,121,7,3,3711,1166,39,413,617,438,,0.92,St. Louis Browns,Sportsman's Park I,,113,110,STL,SL4,SL4
+1889,NL,BSN,ATL,,2,133,,83,45,,,N,N,826,4628,1251,196,54,42,471,450,331,,,,626,435,3.3600000000,121,10,4,3498,1152,41,413,497,413,,0.92,Boston Beaneaters,South End Grounds II,,106,104,BSN,BSN,BSN
+1889,NL,CHN,CHC,,3,136,,67,65,,,N,N,867,4849,1274,184,66,79,518,516,243,,,,814,513,3.7300000000,123,6,2,3711,1313,71,408,434,463,,0.92,Chicago White Stockings,West Side Park I,,105,103,CHC,CHN,CHN
+1889,NL,CL4,CLV,,6,136,,61,72,,,N,N,656,4673,1167,131,59,25,429,417,237,,,,720,484,3.6600000000,132,6,1,3573,1182,36,519,435,365,,0.93,Cleveland Spiders,National League Park,,104,105,CLV,CL4,CL4
+1889,NL,IN3,IND,,7,135,,59,75,,,N,N,819,4879,1356,228,35,62,377,447,252,,,,894,633,4.8500000000,109,3,2,3522,1365,73,420,408,419,,0.92,Indianapolis Hoosiers,Athletic Park II,,102,104,IND,IN3,IN3
+1889,NL,NY1,SFG,,1,131,,83,43,,,Y,Y,935,4671,1319,208,77,52,538,386,292,,,,708,444,3.4700000000,118,6,3,3453,1073,38,523,558,436,,0.92,New York Giants,Polo Grounds II,,104,101,NYG,NY1,NY1
+1889,NL,PHI,PHI,,4,130,,63,64,,,N,N,742,4695,1248,215,52,44,393,353,269,,,,748,512,4.0000000000,106,4,2,3459,1288,33,428,443,466,,0.91,Philadelphia Quakers,Philadelphia Baseball Grounds,,109,108,PHI,PHI,PHI
+1889,NL,PIT,PIT,,5,134,,61,71,,,N,N,726,4748,1202,209,65,42,420,467,231,,,,801,566,4.5100000000,125,5,1,3390,1296,42,374,345,384,,0.93,Pittsburg Alleghenys,Recreation Park,,91,93,PIT,PIT,PIT
+1889,NL,WS8,WNL,,8,127,,41,83,,,N,N,632,4395,1105,151,57,25,466,456,232,,,,892,574,4.6800000000,113,1,0,3309,1261,37,527,388,519,,0.90,Washington Nationals,Swampdoodle Grounds,,94,98,WHS,WS8,WS8
+1890,AA,BL3,BLO,,6,38,,15,19,,,N,N,182,1213,278,34,16,2,125,152,101,,,,192,140,4.0000000000,36,1,0,945,307,3,123,134,109,,0.92,Baltimore Orioles,Oriole Park,,109,110,BAL,BL3,BL3
+1890,AA,BR4,BRG,,9,100,,26,73,,,N,N,492,3475,769,116,47,13,328,456,182,,,,733,460,4.7100000000,96,0,0,2637,1011,21,421,230,394,,0.91,Brooklyn Gladiators,Ridgewood Park,,97,101,BRG,BR4,BR4
+1890,AA,CL6,CLS,,2,140,,79,55,,,N,N,831,4741,1225,159,77,16,545,557,353,,,,617,403,2.9900000000,120,14,3,3642,976,20,471,624,393,,0.93,Columbus Solons,Recreation Park II,,93,93,COL,CL6,CL6
+1890,AA,LS2,LOU,,1,136,,88,44,,,Y,N,819,4687,1310,156,65,15,410,460,341,,,,588,344,2.5700000000,114,13,7,3618,1120,18,293,587,380,,0.93,Louisville Colonels,Eclipse Park I,,98,99,LOU,LS2,LS2
+1890,AA,PH4,PHA,,8,132,,54,78,,,N,N,702,4490,1057,181,51,24,475,540,305,,,,945,657,5.2200000000,119,3,2,3396,1405,17,514,461,453,,0.91,Philadelphia Athletics,Jefferson Street Grounds,,98,99,PHA,PH4,PH4
+1890,AA,RC2,ROC,,5,133,,63,63,,,N,N,709,4553,1088,131,64,31,446,538,310,,,,711,459,3.5600000000,122,5,2,3483,1115,19,530,477,416,,0.92,Rochester Broncos,Culver Field I,,93,92,ROC,RC2,RC2
+1890,AA,SL4,STL,,3,139,,78,58,,,N,N,870,4800,1308,178,73,48,474,490,307,,,,736,487,3.6700000000,118,4,1,3585,1127,38,447,733,472,,0.91,St. Louis Browns,Sportsman's Park I,,114,111,STL,SL4,SL4
+1890,AA,SR2,SYS,,7,128,,55,72,,,N,N,698,4469,1158,151,59,14,457,482,292,,,,831,603,4.9800000000,115,5,0,3267,1158,28,518,454,391,,0.92,Syracuse Stars,Star Park II,,90,91,SYR,SR2,SR2
+1890,AA,TL2,TLM,,4,134,,68,64,,,N,N,739,4575,1152,152,108,24,486,558,421,,,,689,458,3.5600000000,122,4,2,3477,1122,23,429,533,419,,0.92,Toledo Maumees,Speranza Park,,103,102,TOL,TL2,TL2
+1890,NL,BRO,LAD,,1,129,,86,43,,,Y,N,884,4419,1166,184,75,43,517,361,349,,,,620,389,3.0600000000,115,6,2,3435,1102,27,401,403,319,,0.94,Brooklyn Bridegrooms,Washington Park II,121412,101,97,BRO,BRO,BRO
+1890,NL,BSN,ATL,,5,134,,76,57,,,N,N,763,4722,1220,175,62,31,530,515,285,,,,593,386,2.9300000000,132,13,1,3561,1132,27,354,506,358,,0.93,Boston Beaneaters,South End Grounds II,147539,108,105,BSN,BSN,BSN
+1890,NL,CHN,CHC,,2,139,,83,53,,,N,N,847,4891,1271,147,59,67,516,514,329,,,,692,445,3.2400000000,126,6,3,3711,1103,41,481,504,347,,0.93,Chicago Colts,West Side Park I,102536,104,102,CHC,CHN,CHN
+1890,NL,CIN,CIN,,4,134,,77,55,,,N,N,753,4644,1204,150,120,27,433,377,312,,,,633,369,2.7900000000,124,9,1,3570,1097,41,407,488,381,,0.93,Cincinnati Reds,League Park I in Cincinnati,131980,101,101,CIN,CIN,CIN
+1890,NL,CL4,CLV,,7,136,,44,88,,,N,N,630,4633,1073,132,59,21,497,474,152,,,,832,543,4.1300000000,129,2,0,3552,1322,33,462,306,405,,0.92,Cleveland Spiders,National League Park,47478,94,97,CLV,CL4,CL4
+1890,NL,NY1,SFG,,6,135,,63,68,,,N,N,713,4832,1250,208,89,25,350,479,289,,,,698,400,3.0600000000,115,6,1,3531,1029,14,607,612,440,,0.92,New York Giants,Polo Grounds II,60667,95,95,NYG,NY1,NY1
+1890,NL,PHI,PHI,,3,133,,78,53,,,N,N,823,4707,1267,220,78,23,522,403,335,,,,707,440,3.3200000000,122,9,2,3582,1210,22,486,507,396,,0.92,Philadelphia Phillies,Philadelphia Baseball Grounds,148366,103,102,PHI,PHI,PHI
+1890,NL,PIT,PIT,,8,138,,23,113,,,N,N,597,4739,1088,160,43,20,408,458,208,,,,1235,780,5.9700000000,119,3,0,3528,1520,52,573,381,607,,0.89,Pittsburg Alleghenys,Recreation Park,16064,88,92,PIT,PIT,PIT
+1890,PL,BFP,BFB,,8,134,,36,96,,,N,,793,4795,1249,180,64,20,541,367,160,,,,1199,775,6.1100000000,125,2,0,3423,1499,67,673,351,491,,0.91,Buffalo Bisons,,,92,97,BUF,BFP,BFP
+1890,PL,BRP,BWW,,2,133,,76,56,,,N,,964,4887,1354,186,93,34,502,369,272,,,,893,520,3.9500000000,111,4,7,3552,1334,26,570,377,531,,0.90,Brooklyn Ward's Wonders,,,106,105,BWW,BRP,BRP
+1890,PL,BSP,BRS,,1,130,,81,48,,,Y,,992,4626,1306,223,76,54,652,435,412,,,,767,479,3.7900000000,105,6,2,3411,1291,49,467,345,459,,0.91,Boston Reds,,,103,99,BOS,BSP,BSP
+1890,PL,CHP,CHP,,4,138,,75,62,,,N,,886,4968,1311,200,95,31,492,410,276,,,,770,459,3.3900000000,124,5,2,3657,1238,27,503,460,492,,0.91,Chicago Pirates,,,104,103,CHI,CHP,CHP
+1890,PL,CLP,CLI,,7,131,,55,75,,,N,,849,4804,1373,213,94,27,509,345,180,,,,1027,537,4.2300000000,115,1,0,3429,1386,45,571,325,532,,0.90,Cleveland Infants,,,92,94,CLE,CLP,CLP
+1890,PL,NYP,NYI,,3,132,,74,57,,,N,,1018,4913,1393,204,97,66,486,364,231,,,,875,543,4.1700000000,111,3,6,3516,1219,37,569,449,449,,0.92,New York Giants,,,108,107,NYI,NYP,NYP
+1890,PL,PHP,PHQ,,5,132,,68,63,,,N,,941,4855,1348,187,113,49,431,321,203,,,,855,519,4.0500000000,118,4,2,3462,1292,33,495,361,510,,0.91,Philadelphia Athletics,,,103,101,PHQ,PHP,PHP
+1890,PL,PTP,PBB,,6,128,,60,68,,,N,,835,4577,1192,168,113,35,569,375,249,,,,892,523,4.2200000000,121,7,0,3348,1267,32,334,318,512,,0.90,Pittsburgh Burghers,,,92,92,PBB,PTP,PTP
+1891,AA,BL3,BLO,,4,139,,71,64,,,N,,850,4771,1217,142,99,30,551,553,342,,,,798,464,3.4300000000,118,6,2,3651,1238,33,472,408,503,,0.91,Baltimore Orioles,Union Park,,101,100,BAL,BL3,BL3
+1891,AA,BS2,BRS,,1,139,,93,42,,,Y,,1028,4889,1341,163,100,52,651,499,447,,,,675,410,3.0300000000,108,9,7,3657,1158,42,497,524,392,,0.93,Boston Reds,Congress Street Grounds,,103,99,BOS,BS2,BS2
+1891,AA,CL6,CLS,,6,138,,61,76,,,N,,702,4697,1113,154,61,20,529,530,280,,,,777,505,3.7500000000,118,6,0,3639,1141,29,588,502,379,,0.93,Columbus Solons,Recreation Park II,,95,93,COL,CL6,CL6
+1891,AA,CN3,CKK,,7,102,,43,57,,,N,,549,3574,838,105,58,28,428,385,164,,,,643,344,3.4300000000,86,2,1,2706,921,20,446,331,389,,0.91,Cincinnati Kelly's Killers,East End Park,,108,110,CKK,CN3,CN3
+1891,AA,LS2,LOU,,8,141,,54,83,,,N,,713,4833,1247,130,69,17,443,473,230,,,,890,582,4.2700000000,128,9,1,3678,1353,33,464,485,458,,0.92,Louisville Colonels,Eclipse Park I,,97,97,LOU,LS2,LS2
+1891,AA,ML3,MLA,,3,36,,21,15,,,N,,227,1271,332,58,15,13,107,114,47,,,,156,86,2.5000000000,35,3,0,927,291,6,120,137,116,,0.92,Milwaukee Brewers,Athletic Field,,120,118,MIL,ML3,ML3
+1891,AA,PH4,PHQ,,5,143,,73,66,,,N,,817,5039,1301,182,123,55,447,548,149,,,,794,549,4.0100000000,135,3,0,3699,1274,35,520,533,389,,0.93,Philadelphia Athletics,Athletic Park,,103,103,PHA,PH4,PH4
+1891,AA,SL4,STL,,2,141,,85,51,,,N,,976,5005,1330,169,51,58,625,440,283,,,,753,444,3.2700000000,103,8,5,3666,1106,50,576,621,466,,0.92,St. Louis Browns,Sportsman's Park I,,108,108,STL,SL4,SL4
+1891,AA,WS9,WAS,,9,139,,44,91,,,N,,691,4715,1183,147,84,19,468,485,219,,,,1067,634,4.8300000000,123,2,2,3543,1420,44,566,486,589,,0.90,Washington Statesmen,Boundary Field,,95,100,WAS,WS9,WS9
+1891,NL,BRO,LAD,,6,137,,61,76,,,N,,765,4748,1233,200,69,23,464,435,337,,,,820,516,3.8600000000,121,8,3,3612,1272,40,459,407,432,,0.92,Brooklyn Grooms,Eastern Park,181477,99,99,BRO,BRO,BRO
+1891,NL,BSN,ATL,,1,140,,87,51,,,Y,,847,4956,1264,181,80,54,532,538,289,,,,658,381,2.7600000000,126,9,6,3723,1223,51,364,525,358,,0.93,Boston Beaneaters,South End Grounds II,184472,112,109,BSN,BSN,BSN
+1891,NL,CHN,CHC,,2,137,,82,53,,,N,,832,4873,1233,159,88,60,526,457,238,,,,730,470,3.4700000000,114,6,3,3660,1207,53,475,477,397,,0.93,Chicago Colts,South Side Park I,181431,106,105,CHC,CHN,CHN
+1891,NL,CIN,CIN,,7,138,,56,81,,,N,,646,4791,1158,148,90,40,414,439,244,,,,790,480,3.5500000000,125,6,1,3654,1234,40,465,393,409,,0.93,Cincinnati Reds,League Park I in Cincinnati,97500,101,101,CIN,CIN,CIN
+1891,NL,CL4,CLV,,5,141,,65,74,,,N,,835,5074,1294,183,88,22,519,464,242,,,,888,484,3.5000000000,118,1,3,3732,1371,24,466,400,485,,0.92,Cleveland Spiders,League Park I,132000,104,103,CLV,CL4,CL4
+1891,NL,NY1,SFG,,3,136,,71,61,,,N,,754,4833,1271,189,72,46,438,394,224,,,,711,400,2.9900000000,117,11,3,3612,1098,27,593,651,384,,0.93,New York Giants,Polo Grounds III,210568,96,96,NYG,NY1,NY1
+1891,NL,PHI,PHI,,4,138,,68,69,,,N,,756,4929,1244,180,51,21,482,412,232,,,,773,509,3.7300000000,105,3,5,3687,1280,29,505,343,443,,0.92,Philadelphia Phillies,Philadelphia Baseball Grounds,217282,103,102,PHI,PHI,PHI
+1891,NL,PIT,PIT,,8,137,,55,80,,,N,,679,4794,1148,148,71,29,427,503,205,,,,744,384,2.8900000000,122,7,2,3591,1160,31,465,446,475,,0.91,Pittsburgh Pirates,Exposition Park,128000,97,98,PIT,PIT,PIT
+1892,NL,BLN,BLO,,12,152,,46,101,,,N,,779,5296,1342,160,111,30,499,480,227,,,,1020,617,4.2800000000,131,2,2,3894,1537,51,536,437,584,,0.91,Baltimore Orioles,Union Park,93589,103,104,BLN,BLN,BLN
+1892,NL,BRO,LAD,,3,158,,95,59,,,N,,935,5485,1439,183,105,30,629,506,409,,,,733,507,3.2500000000,132,12,5,4215,1285,26,600,597,398,,0.94,Brooklyn Grooms,Eastern Park,183727,96,96,BRO,BRO,BRO
+1892,NL,BSN,ATL,,1,152,,102,48,,,Y,,862,5301,1324,203,51,34,526,488,338,,,,649,425,2.8600000000,142,15,1,4008,1156,41,460,509,454,,0.92,Boston Beaneaters,South End Grounds II,146421,109,107,BSN,BSN,BSN
+1892,NL,CHN,CHC,,7,147,,70,76,,,N,,635,5063,1188,149,92,26,427,482,233,,,,735,456,3.1600000000,133,6,1,3894,1269,35,424,518,424,,0.93,Chicago Colts,South Side Park I,109067,94,94,CHC,CHN,CHN
+1892,NL,CIN,CIN,,5,155,,82,68,,,N,,766,5349,1288,155,75,44,503,474,270,,,,731,485,3.1700000000,130,8,2,4131,1327,39,535,437,402,,0.93,Cincinnati Reds,League Park I in Cincinnati,196473,99,99,CIN,CIN,CIN
+1892,NL,CL4,CLV,,2,153,,93,56,,,N,,855,5412,1375,196,96,26,552,536,225,,,,613,358,2.4100000000,140,11,2,4008,1178,28,413,472,406,,0.93,Cleveland Spiders,League Park I,139928,104,103,CLV,CL4,CL4
+1892,NL,LS3,LOU,,9,154,,63,89,,,N,,649,5334,1208,133,61,18,433,508,275,,,,804,500,3.3400000000,147,9,0,4038,1358,26,447,430,469,,0.92,Louisville Colonels,Eclipse Park I,131159,91,93,LOU,LS3,LS3
+1892,NL,NY1,SFG,,8,153,,71,80,,,N,,811,5291,1326,173,85,39,510,469,301,,,,826,483,3.2900000000,139,5,1,3966,1165,32,635,641,565,,0.91,New York Giants,Polo Grounds III,130566,99,98,NYG,NY1,NY1
+1892,NL,PHI,PHI,,4,155,,87,66,,,N,,860,5413,1420,225,95,50,528,515,216,,,,690,449,2.9300000000,131,10,5,4137,1297,24,492,502,393,,0.93,Philadelphia Phillies,Philadelphia Baseball Grounds,193731,100,99,PHI,PHI,PHI
+1892,NL,PIT,PIT,,6,155,,80,73,,,N,,802,5469,1288,143,108,38,435,453,222,,,,796,464,3.1000000000,130,3,1,4041,1300,28,537,455,480,,0.92,Pittsburgh Pirates,Exposition Park,177205,100,100,PIT,PIT,PIT
+1892,NL,SLN,STL,,11,155,,56,94,,,N,,703,5259,1187,138,53,45,607,491,209,,,,922,627,4.2000000000,139,4,1,4032,1466,47,543,478,453,,0.92,St. Louis Browns,Sportsman's Park I,192442,105,104,STL,SLN,SLN
+1892,NL,WAS,WAS,,10,153,,58,93,,,N,,731,5204,1245,149,78,37,529,553,276,,,,869,506,3.4600000000,129,5,3,3945,1293,40,556,479,547,,0.91,Washington Senators,Boundary Field,128279,97,99,WHS,WSN,WSN
+1893,NL,BLN,BLO,,8,130,,60,70,,,N,,820,4651,1281,164,86,27,537,323,233,,,,893,620,4.9700000000,104,1,2,3369,1325,29,534,275,384,,0.92,Baltimore Orioles,Union Park,143000,102,102,BLN,BLN,BLN
+1893,NL,BRO,LAD,,7,130,,65,63,,,N,,775,4511,1200,173,83,45,473,296,213,,,,845,583,4.5500000000,109,3,3,3462,1262,41,547,297,385,,0.93,Brooklyn Grooms,Eastern Park,235000,95,95,BRO,BRO,BRO
+1893,NL,BSN,ATL,,1,131,,86,43,,,Y,,1008,4678,1358,178,50,65,561,292,243,,,,795,572,4.4300000000,114,2,2,3489,1314,66,402,253,353,,0.93,Boston Beaneaters,South End Grounds II,193300,108,106,BSN,BSN,BSN
+1893,NL,CHN,CHC,,9,128,,56,71,,,N,,829,4664,1299,186,93,32,465,262,255,,,,874,597,4.8100000000,101,4,5,3351,1278,26,553,273,421,,0.92,Chicago Colts,South Side Park I,223500,103,104,CHC,CHN,CHN
+1893,NL,CIN,CIN,,6,131,,65,63,,,N,,759,4617,1195,161,65,29,532,256,238,,,,814,593,4.5500000000,97,4,5,3516,1305,38,549,258,321,,0.94,Cincinnati Reds,League Park I in Cincinnati,194250,102,103,CIN,CIN,CIN
+1893,NL,CL4,CLV,,3,129,,73,55,,,N,,976,4747,1425,222,98,32,532,229,252,,,,839,532,4.2000000000,110,2,2,3420,1361,35,356,242,389,,0.93,Cleveland Spiders,League Park I,130000,106,105,CLV,CL4,CL4
+1893,NL,LS3,LOU,,11,126,,50,75,,,N,,759,4566,1185,177,73,19,485,306,203,,,,942,708,5.9000000000,113,4,1,3240,1431,38,479,190,328,,0.93,Louisville Colonels,Eclipse Park II,53683,92,94,LOU,LS3,LS3
+1893,NL,NY1,SFG,,5,136,,68,64,,,N,,941,4858,1424,182,101,61,504,279,299,,,,845,577,4.2900000000,111,6,4,3633,1271,36,581,395,432,,0.92,New York Giants,Polo Grounds III,290000,101,100,NYG,NY1,NY1
+1893,NL,PHI,PHI,,4,133,,72,57,,,N,,1011,5151,1553,246,90,80,468,335,202,,,,841,618,4.6800000000,107,4,2,3567,1359,30,521,283,318,,0.94,Philadelphia Phillies,Philadelphia Baseball Grounds,293019,102,101,PHI,PHI,PHI
+1893,NL,PIT,PIT,,2,131,,81,48,,,N,,970,4834,1447,176,127,37,537,273,210,,,,766,529,4.0800000000,104,8,2,3501,1232,29,504,280,346,,0.93,Pittsburgh Pirates,Exposition Park,184000,98,98,PIT,PIT,PIT
+1893,NL,SLN,STL,,10,135,,57,75,,,N,,745,4879,1288,152,98,10,524,251,250,,,,829,544,4.0600000000,114,3,4,3621,1292,38,542,301,398,,0.93,St. Louis Browns,Robison Field,195000,100,101,STL,SLN,SLN
+1893,NL,WAS,WAS,,12,130,,40,89,,,N,,722,4742,1260,180,83,23,524,237,154,,,,1032,704,5.5600000000,110,2,0,3417,1485,54,574,292,497,,0.91,Washington Senators,Boundary Field,90000,97,99,WHS,WSN,WSN
+1894,NL,BLN,BLO,,1,129,,89,39,,,Y,,1171,4799,1647,271,150,33,516,200,324,,,,819,620,5.0000000000,97,1,11,3348,1371,31,472,275,293,,0.94,Baltimore Orioles,Union Park,328000,104,103,BLN,BLN,BLN
+1894,NL,BRO,LAD,,5,134,,70,61,,,N,,1021,4816,1507,228,130,42,466,294,282,,,,1007,711,5.5100000000,105,3,5,3486,1447,41,555,285,390,,0.92,Brooklyn Grooms,Eastern Park,214000,93,93,BRO,BRO,BRO
+1894,NL,BSN,ATL,,3,133,,83,49,,,N,,1220,5011,1658,272,94,103,535,261,241,,,,1002,701,5.4100000000,108,3,1,3498,1529,89,411,262,415,,0.92,Boston Beaneaters,South End Grounds II / Congress Street Grounds / South End Grounds III,152800,113,111,BSN,BSN,BSN
+1894,NL,CHN,CHC,,8,135,,57,75,,,N,,1041,4960,1555,265,86,65,496,298,327,,,,1066,725,5.6800000000,117,0,0,3444,1561,43,557,281,452,,0.91,Chicago Colts,West Side Park II,239000,106,106,CHC,CHN,CHN
+1894,NL,CIN,CIN,,10,132,,55,75,,,N,,910,4671,1374,224,67,61,508,252,215,,,,1085,763,5.9900000000,110,4,3,3441,1585,85,491,219,420,,0.92,Cincinnati Reds,League Park II in Cincinnati,158000,103,104,CIN,CIN,CIN
+1894,NL,CL4,CLV,,6,130,,68,61,,,N,,932,4764,1442,241,90,37,471,301,220,,,,896,621,4.9700000000,106,6,1,3372,1390,54,435,254,344,,0.93,Cleveland Spiders,League Park I,82000,104,103,CLV,CL4,CL4
+1894,NL,LS3,LOU,,12,130,,36,94,,,N,,692,4482,1206,173,88,42,350,364,217,,,,1001,664,5.4500000000,113,2,1,3288,1462,39,475,258,428,,0.92,Louisville Colonels,Eclipse Park II,75000,93,96,LOU,LS3,LS3
+1894,NL,NY1,SFG,,2,137,,88,44,,,N,,940,4806,1446,197,96,43,476,217,319,,,,789,516,3.8300000000,111,5,5,3636,1292,37,539,395,443,,0.92,New York Giants,Polo Grounds III,387000,99,99,NYG,NY1,NY1
+1894,NL,PHI,PHI,,4,129,,71,57,,,N,,1143,4967,1732,252,131,40,496,245,273,,,,966,704,5.6300000000,102,3,4,3375,1482,62,469,262,338,,0.93,Philadelphia Phillies,Philadelphia Baseball Grounds,352773,96,94,PHI,PHI,PHI
+1894,NL,PIT,PIT,,7,132,,65,65,,,N,,955,4676,1458,222,124,48,434,208,256,,,,972,724,5.6000000000,106,2,0,3492,1552,39,457,304,354,,0.93,Pittsburgh Pirates,Exposition Park,159000,99,98,PIT,PIT,PIT
+1894,NL,SLN,STL,,9,133,,56,76,,,N,,771,4610,1320,171,113,54,442,289,190,,,,953,682,5.2900000000,114,2,0,3483,1418,48,500,319,426,,0.92,St. Louis Browns,Robison Field,155000,100,102,STL,SLN,SLN
+1894,NL,WAS,WAS,,11,132,,45,87,,,N,,882,4581,1317,218,118,59,617,375,249,,,,1122,678,5.5100000000,101,0,4,3321,1573,59,446,190,499,,0.90,Washington Senators,Boundary Field,125000,97,99,WHS,WSN,WSN
+1895,NL,BLN,BLO,,1,132,,87,43,,,Y,,1009,4725,1530,235,89,25,355,243,310,,,,646,479,3.8000000000,104,10,4,3402,1216,31,430,244,288,,0.94,Baltimore Orioles,Union Park,293000,103,100,BLN,BLN,BLN
+1895,NL,BRO,LAD,,5,133,,71,60,,,N,,867,4717,1330,189,77,39,397,318,183,,,,834,631,4.9400000000,103,5,6,3450,1360,41,395,216,325,,0.94,Brooklyn Grooms,Eastern Park,230000,92,92,BRO,BRO,BRO
+1895,NL,BSN,ATL,,6,132,,71,60,,,N,,907,4715,1369,197,57,54,500,236,199,,,,826,557,4.2700000000,116,4,4,3525,1364,56,363,370,364,,0.93,Boston Beaneaters,South End Grounds III,242000,105,104,BSN,BSN,BSN
+1895,NL,CHN,CHC,,4,133,,72,58,,,N,,866,4708,1401,171,85,55,422,344,260,,,,854,597,4.6700000000,119,3,1,3450,1422,38,432,297,401,,0.92,Chicago Colts,West Side Park II,382300,107,107,CHC,CHN,CHN
+1895,NL,CIN,CIN,,8,132,,66,64,,,N,,903,4684,1395,235,105,36,414,249,326,,,,854,613,4.8100000000,97,2,6,3441,1451,39,362,245,377,,0.93,Cincinnati Reds,League Park II in Cincinnati,281000,104,104,CIN,CIN,CIN
+1895,NL,CL4,CLV,,2,131,,84,46,,,N,,917,4658,1423,194,67,29,472,361,187,,,,720,497,3.9100000000,108,6,3,3429,1272,33,346,326,348,,0.93,Cleveland Spiders,League Park I,143000,106,104,CLV,CL4,CL4
+1895,NL,LS3,LOU,,12,133,,35,96,,,N,,698,4724,1320,171,73,34,346,323,156,,,,1090,732,5.9000000000,104,3,1,3351,1520,40,470,245,477,,0.91,Louisville Colonels,Eclipse Park II,92000,94,97,LOU,LS3,LS3
+1895,NL,NY1,SFG,,9,132,,66,65,,,N,,852,4605,1324,191,90,32,454,292,292,,,,834,575,4.5100000000,115,6,1,3441,1359,34,415,409,438,,0.92,New York Giants,Polo Grounds III,240000,98,97,NYG,NY1,NY1
+1895,NL,PHI,PHI,,3,133,,78,53,,,N,,1068,5037,1664,272,73,61,463,262,276,,,,957,706,5.4700000000,106,2,7,3483,1467,36,485,330,369,,0.93,Philadelphia Phillies,Baker Bowl,474971,100,100,PHI,PHI,PHI
+1895,NL,PIT,PIT,,7,134,,71,61,,,N,,811,4645,1349,190,89,26,376,299,257,,,,787,527,4.0500000000,106,4,6,3513,1263,17,500,382,392,,0.93,Pittsburgh Pirates,Exposition Park,188000,95,95,PIT,PIT,PIT
+1895,NL,SLN,STL,,11,135,,39,92,,,N,,747,4781,1344,155,88,38,384,279,205,,,,1032,737,5.7600000000,105,1,1,3456,1562,64,439,280,380,,0.93,St. Louis Browns,Robison Field,170000,99,101,STL,SLN,SLN
+1895,NL,WAS,WAS,,10,132,,43,85,,,N,,837,4577,1314,207,101,55,518,396,237,,,,1048,646,5.2800000000,99,0,5,3303,1507,55,465,258,444,,0.91,Washington Senators,Boundary Field,153000,99,101,WHS,WSN,WSN
+1896,NL,BLN,BLO,,1,132,,90,39,,,Y,,995,4719,1548,207,100,23,386,201,441,,,,662,476,3.6700000000,115,9,1,3504,1281,22,339,302,296,,0.94,Baltimore Orioles,Union Park,249448,102,98,BLN,BLN,BLN
+1896,NL,BRO,LAD,,10,133,,58,73,,,N,,692,4548,1292,174,87,28,344,269,198,,,,764,540,4.2500000000,97,3,1,3432,1353,39,400,259,297,,0.94,Brooklyn Bridegrooms,Eastern Park,201000,94,95,BRO,BRO,BRO
+1896,NL,BSN,ATL,,4,132,,74,57,,,N,,860,4717,1416,175,74,36,414,274,241,,,,761,485,3.7800000000,110,6,3,3465,1254,57,397,277,368,,0.93,Boston Beaneaters,South End Grounds III,240000,106,104,BSN,BSN,BSN
+1896,NL,CHN,CHC,,5,132,,71,57,,,N,,815,4582,1311,182,97,34,409,290,332,,,,799,569,4.4100000000,118,2,1,3483,1302,30,467,353,367,,0.93,Chicago Colts,West Side Park II,317500,104,104,CHC,CHN,CHN
+1896,NL,CIN,CIN,,3,128,,77,50,,,N,,783,4360,1283,204,73,20,382,226,350,,,,620,452,3.6700000000,105,12,4,3324,1240,27,310,219,252,,0.95,Cincinnati Reds,League Park II in Cincinnati,373000,107,106,CIN,CIN,CIN
+1896,NL,CL4,CLV,,2,135,,80,48,,,N,,840,4856,1463,207,72,28,436,316,175,,,,650,459,3.4600000000,113,9,5,3585,1363,27,280,336,280,,0.95,Cleveland Spiders,League Park I,152000,106,104,CLV,CL4,CL4
+1896,NL,LS3,LOU,,12,134,,38,93,,,N,,653,4588,1197,142,80,37,371,427,195,,,,997,653,5.1200000000,108,1,4,3444,1398,48,541,288,475,,0.91,Louisville Colonels,Eclipse Park II,133000,96,99,LOU,LS3,LS3
+1896,NL,NY1,SFG,,7,133,,64,67,,,N,,829,4661,1383,159,87,40,439,271,274,,,,821,573,4.5400000000,104,1,2,3408,1303,33,403,312,365,,0.93,New York Giants,Polo Grounds III,274000,97,96,NYG,NY1,NY1
+1896,NL,PHI,PHI,,8,130,,62,68,,,N,,890,4680,1382,234,84,49,438,297,191,,,,891,645,5.2000000000,107,3,2,3351,1473,39,387,243,313,,0.94,Philadelphia Phillies,Baker Bowl,357025,99,99,PHI,PHI,PHI
+1896,NL,PIT,PIT,,6,131,,66,63,,,N,,787,4701,1371,169,94,27,387,286,217,,,,741,554,4.3000000000,108,8,1,3477,1286,18,439,362,317,,0.94,Pittsburgh Pirates,Exposition Park,197000,96,96,PIT,PIT,PIT
+1896,NL,SLN,STL,,11,131,,40,90,,,N,,593,4520,1162,134,78,37,332,300,185,,,,929,669,5.3300000000,115,1,1,3390,1448,40,456,279,345,,0.93,St. Louis Browns,Robison Field,184000,96,100,STL,SLN,SLN
+1896,NL,WAS,WAS,,9,133,,58,73,,,N,,818,4639,1328,179,79,45,516,365,258,,,,920,582,4.6100000000,106,2,3,3408,1435,24,435,292,398,,0.92,Washington Senators,Boundary Field,223000,100,101,WHS,WSN,WSN
+1897,NL,BLN,BLO,,2,136,,90,40,,,N,,964,4872,1584,243,66,19,437,256,401,,,,674,472,3.5500000000,118,3,0,3591,1296,18,382,361,277,,0.95,Baltimore Orioles,Union Park,273046,100,97,BLN,BLN,BLN
+1897,NL,BRO,LAD,,7,136,,61,71,,,N,,802,4810,1343,202,72,24,351,255,187,,,,845,610,4.6000000000,114,4,2,3582,1417,34,410,256,364,,0.93,Brooklyn Bridegrooms,Eastern Park,220831,94,95,BRO,BRO,BRO
+1897,NL,BSN,ATL,,1,135,,93,39,,,Y,,1025,4937,1574,230,83,45,423,262,233,,,,665,484,3.6500000000,115,8,7,3582,1273,39,393,329,272,,0.95,Boston Beaneaters,South End Grounds III,334800,106,104,BSN,BSN,BSN
+1897,NL,CHN,CHC,,9,138,,59,73,,,N,,832,4803,1356,189,97,38,430,317,264,,,,894,602,4.5300000000,131,2,1,3591,1485,30,433,361,394,,0.93,Chicago Colts,West Side Park II,327160,104,104,CHC,CHN,CHN
+1897,NL,CIN,CIN,,4,134,,76,56,,,N,,763,4524,1311,219,69,22,380,218,194,,,,705,525,4.0900000000,100,4,2,3468,1375,18,329,270,273,,0.94,Cincinnati Reds,League Park II in Cincinnati,336800,107,106,CIN,CIN,CIN
+1897,NL,CL4,CLV,,5,132,,69,62,,,N,,773,4604,1374,192,88,16,435,344,181,,,,680,491,3.9500000000,111,6,0,3357,1297,32,289,277,257,,0.95,Cleveland Spiders,League Park I,115250,110,109,CLV,CL4,CL4
+1897,NL,LS3,LOU,,11,134,,52,78,,,N,,669,4520,1197,160,70,40,370,453,195,,,,859,559,4.4200000000,114,2,0,3414,1363,39,459,267,395,,0.92,Louisville Colonels,Eclipse Park II,145210,97,99,LOU,LS3,LS3
+1897,NL,NY1,SFG,,3,137,,83,48,,,N,,895,4844,1449,188,84,31,404,327,328,,,,695,458,3.4700000000,118,8,3,3561,1214,26,486,456,397,,0.93,New York Giants,Polo Grounds III,390340,97,96,NYG,NY1,NY1
+1897,NL,PHI,PHI,,10,134,,55,77,,,N,,752,4756,1392,213,83,40,399,299,163,,,,792,590,4.6000000000,115,4,2,3465,1415,28,364,253,296,,0.94,Philadelphia Phillies,Baker Bowl,290027,97,97,PHI,PHI,PHI
+1897,NL,PIT,PIT,,8,135,,60,71,,,N,,676,4590,1266,140,108,25,359,334,170,,,,835,598,4.6700000000,112,2,2,3459,1397,22,318,342,346,,0.93,Pittsburgh Pirates,Exposition Park,165950,96,97,PIT,PIT,PIT
+1897,NL,SLN,STL,,12,132,,29,102,,,N,,588,4642,1277,149,67,31,354,314,172,,,,1083,778,6.2100000000,109,1,1,3381,1584,54,453,207,375,,0.93,St. Louis Browns,Robison Field,136400,98,102,STL,SLN,SLN
+1897,NL,WAS,WAS,,6,135,,61,71,,,N,,781,4636,1376,194,77,36,374,348,208,,,,793,511,4.0100000000,102,7,6,3444,1383,27,400,348,369,,0.93,Washington Senators,Boundary Field,151028,99,101,WHS,WSN,WSN
+1898,NL,BLN,BLO,,2,154,,96,53,,,N,,933,5242,1584,154,77,12,519,316,250,,,,623,426,2.9000000000,138,12,0,3969,1236,17,400,422,326,,0.94,Baltimore Orioles,Union Park,123416,102,99,BLN,BLN,BLN
+1898,NL,BRO,LAD,,10,149,,54,91,,,N,,638,5126,1314,156,66,17,328,314,130,,,,811,578,4.0100000000,134,1,0,3894,1446,34,476,294,334,,0.94,Brooklyn Bridegrooms,Washington Park III,122514,100,99,BRO,BRO,BRO
+1898,NL,BSN,ATL,,1,152,,102,47,,,Y,,872,5276,1531,190,55,53,405,303,172,,,,614,444,2.9800000000,127,9,8,4020,1186,37,470,432,299,,0.95,Boston Beaneaters,South End Grounds III,229275,105,102,BSN,BSN,BSN
+1898,NL,CHN,CHC,,4,152,,85,65,,,N,,828,5219,1431,175,84,18,476,394,220,,,,679,422,2.8300000000,137,13,0,4026,1357,17,364,323,412,,0.93,Chicago Orphans,West Side Park II,424352,100,99,CHC,CHN,CHN
+1898,NL,CIN,CIN,,3,157,,92,60,,,N,,831,5334,1448,207,101,19,455,300,165,,,,740,539,3.5000000000,131,10,2,4155,1484,16,449,294,325,,0.95,Cincinnati Reds,League Park II in Cincinnati,336378,107,106,CIN,CIN,CIN
+1898,NL,CL4,CLV,,5,156,,81,68,,,N,,730,5246,1379,162,56,18,545,306,93,,,,683,474,3.2000000000,142,9,0,4002,1429,26,309,339,296,,0.95,Cleveland Spiders,League Park I,70496,96,95,CLV,CL4,CL4
+1898,NL,LS3,LOU,,9,154,,70,81,,,N,,728,5193,1389,150,71,32,375,429,235,,,,833,628,4.2400000000,137,4,0,4002,1457,33,470,271,382,,0.93,Louisville Colonels,Eclipse Park II,128980,99,99,LOU,LS3,LS3
+1898,NL,NY1,SFG,,7,157,,77,73,,,N,,837,5349,1422,190,86,34,428,372,214,,,,800,517,3.4400000000,141,9,1,4059,1359,21,587,558,447,,0.93,New York Giants,Polo Grounds III,265414,97,96,NYG,NY1,NY1
+1898,NL,PHI,PHI,,6,150,,78,71,,,N,,823,5118,1431,238,81,33,472,382,182,,,,784,532,3.7200000000,129,10,0,3864,1440,23,399,325,379,,0.93,Philadelphia Phillies,Baker Bowl,265414,96,95,PHI,PHI,PHI
+1898,NL,PIT,PIT,,8,152,,72,76,,,N,,634,5087,1313,140,88,14,336,343,107,,,,694,501,3.4100000000,131,10,3,3969,1400,14,346,330,340,,0.94,Pittsburgh Pirates,Exposition Park,150900,98,99,PIT,PIT,PIT
+1898,NL,SLN,STL,,12,154,,39,111,,,N,,571,5214,1290,149,55,13,383,402,104,,,,929,666,4.5300000000,133,0,2,3972,1584,32,372,288,388,,0.93,St. Louis Browns,Robison Field,151700,102,105,STL,SLN,SLN
+1898,NL,WAS,WAS,,11,155,,51,101,,,N,,704,5257,1423,177,80,36,370,386,197,,,,939,656,4.5200000000,129,0,1,3921,1577,29,450,371,442,,0.92,Washington Senators,Boundary Field,103250,100,101,WHS,WSN,WSN
+1899,NL,BLN,BLO,,4,152,,86,62,,,N,,827,5073,1509,204,71,17,418,383,364,,,,691,480,3.3100000000,132,10,4,3912,1403,13,349,294,308,,0.94,Baltimore Orioles,Union Park,121935,105,103,BLN,BLN,BLN
+1899,NL,BRO,LAD,,1,150,,101,47,,,Y,,892,4937,1436,178,97,27,477,263,271,,,,658,458,3.2500000000,121,9,9,3807,1320,32,463,331,314,,0.94,Brooklyn Superbas,Washington Park III,269641,102,102,BRO,BRO,BRO
+1899,NL,BSN,ATL,,2,153,,95,57,,,N,,858,5290,1517,178,90,39,431,269,185,,,,645,488,3.2600000000,138,13,4,4044,1273,44,432,385,295,,0.95,Boston Beaneaters,South End Grounds III,200384,109,108,BSN,BSN,BSN
+1899,NL,CHN,CHC,,8,152,,75,73,,,N,,812,5148,1428,173,82,27,406,342,247,,,,763,498,3.3700000000,147,8,1,3993,1433,20,330,313,428,,0.93,Chicago Orphans,West Side Park II,352130,97,97,CHC,CHN,CHN
+1899,NL,CIN,CIN,,6,156,,83,67,,,N,,856,5225,1439,194,105,13,485,295,228,,,,770,560,3.7000000000,130,8,5,4083,1484,26,370,360,339,,0.94,Cincinnati Reds,League Park II in Cincinnati,259536,102,102,CIN,CIN,CIN
+1899,NL,CL4,CLV,,12,154,,20,134,,,N,,529,5279,1333,142,50,12,289,280,127,,,,1252,895,6.3700000000,138,0,0,3792,1844,43,527,215,388,,0.93,Cleveland Spiders,League Park I,6088,89,96,CLV,CL4,CL4
+1899,NL,LS3,LOU,,9,155,,75,77,,,N,,827,5307,1484,192,68,40,436,375,233,,,,775,518,3.4500000000,134,5,2,4053,1509,33,323,287,382,,0.93,Louisville Colonels,Eclipse Park II,109319,100,100,LOU,LS3,LS3
+1899,NL,NY1,SFG,,10,152,,60,90,,,N,,734,5092,1431,161,65,23,387,360,234,,,,863,609,4.2900000000,138,4,0,3834,1454,19,628,397,433,,0.93,New York Giants,Polo Grounds III,121384,97,97,NYG,NY1,NY1
+1899,NL,PHI,PHI,,3,154,,94,58,,,N,,916,5353,1613,241,83,31,441,341,212,,,,743,514,3.4700000000,129,15,2,3999,1398,17,370,281,379,,0.94,Philadelphia Phillies,Baker Bowl,388933,97,96,PHI,PHI,PHI
+1899,NL,PIT,PIT,,7,154,,76,73,,,N,,834,5450,1574,196,122,27,384,345,179,,,,765,546,3.6000000000,117,9,4,4092,1464,27,437,334,361,,0.94,Pittsburgh Pirates,Exposition Park,251834,100,99,PIT,PIT,PIT
+1899,NL,SLN,STL,,5,155,,84,67,,,N,,819,5304,1514,172,88,47,468,262,210,,,,739,500,3.3600000000,134,7,1,4020,1476,41,321,331,399,,0.93,St. Louis Perfectos,Robison Field,373909,102,103,STL,SLN,SLN
+1899,NL,WAS,WAS,,11,155,,54,98,,,N,,743,5256,1429,162,87,47,350,341,176,,,,983,712,4.9300000000,131,3,0,3900,1649,35,422,328,403,,0.93,Washington Senators,Boundary Field,86392,99,101,WHS,WSN,WSN
+1900,NL,BRO,LAD,,1,142,,82,54,,,Y,,816,4860,1423,199,81,26,421,272,274,,,,722,529,3.8900000000,104,8,4,3675,1370,30,405,300,303,102,0.94,Brooklyn Superbas,Washington Park III,183000,106,104,BRO,BRO,BRO
+1900,NL,BSN,ATL,,4,142,,66,72,,,N,,778,4952,1403,163,68,48,395,278,182,,,,739,513,3.7200000000,116,8,2,3720,1263,59,463,340,271,86,0.95,Boston Beaneaters,South End Grounds III,202000,112,111,BSN,BSN,BSN
+1900,NL,CHN,CHC,,6,146,,65,75,,,N,,635,4907,1276,202,51,33,343,383,189,,,,751,456,3.2300000000,137,9,1,3813,1375,21,324,357,418,98,0.93,Chicago Orphans,West Side Park II,248577,96,98,CHC,CHN,CHN
+1900,NL,CIN,CIN,,7,144,,62,77,,,N,,703,5026,1335,178,83,33,333,408,183,,,,745,542,3.8300000000,118,9,1,3822,1383,28,404,399,341,120,0.94,Cincinnati Reds,League Park II in Cincinnati,170000,98,99,CIN,CIN,CIN
+1900,NL,NY1,SFG,,8,141,,60,78,,,N,,713,4724,1317,177,61,23,369,343,236,,,,823,531,3.9600000000,113,4,0,3621,1423,26,442,277,439,124,0.92,New York Giants,Polo Grounds III,190000,95,98,NYG,NY1,NY1
+1900,NL,PHI,PHI,,3,141,,75,63,,,N,,810,4969,1439,187,82,29,440,374,205,,,,792,571,4.1200000000,116,7,3,3744,1506,29,402,284,330,125,0.94,Philadelphia Phillies,Baker Bowl,301913,99,98,PHI,PHI,PHI
+1900,NL,PIT,PIT,,2,140,,79,60,,,N,,733,4817,1312,185,100,26,327,321,174,,,,612,418,3.0600000000,114,11,1,3687,1232,24,295,415,322,106,0.94,Pittsburgh Pirates,Exposition Park,264000,101,98,PIT,PIT,PIT
+1900,NL,SLN,STL,,5,142,,65,75,,,N,,744,4877,1420,141,81,36,406,318,243,,,,748,507,3.7500000000,117,12,0,3651,1373,37,299,325,331,73,0.94,St. Louis Cardinals,Robison Field,270000,99,98,STL,SLN,SLN
+1901,AL,BLA,NYY,,5,135,66,68,65,,,N,,760,4589,1348,179,111,24,369,377,207,,,,750,480,3.7300000000,115,4,3,3474,1313,21,344,271,401,76,0.92,Baltimore Orioles,Oriole Park,141952,104,105,BLA,BLA,BLA
+1901,AL,BOS,BOS,,2,138,69,79,57,,,N,,759,4866,1353,183,104,37,331,282,157,,,,608,411,3.0400000000,123,7,1,3651,1178,33,294,396,329,104,0.94,Boston Americans,Huntington Avenue Grounds,289448,98,96,BOS,BOS,BOS
+1901,AL,CHA,CHW,,1,137,71,83,53,,,Y,,819,4725,1303,173,89,32,475,337,280,,,,631,403,2.9800000000,110,11,2,3654,1250,27,312,394,345,100,0.94,Chicago White Sox,South Side Park II,354350,97,95,CHW,CHA,CHA
+1901,AL,CLE,CLE,,7,138,69,54,82,,,N,,667,4833,1311,197,68,12,243,326,125,,,,831,541,4.1200000000,122,7,4,3546,1365,22,464,334,329,99,0.94,Cleveland Blues,League Park I,131380,96,97,CLE,CLE,CLE
+1901,AL,DET,DET,,3,136,70,74,61,,,N,,741,4676,1303,180,80,29,380,346,204,,,,694,436,3.3000000000,118,8,2,3564,1328,22,313,307,410,127,0.93,Detroit Tigers,Bennett Park,259430,105,105,DET,DET,DET
+1901,AL,MLA,BAL,,8,139,70,48,89,,,N,,641,4795,1250,192,66,26,325,384,176,,,,828,549,4.0600000000,107,3,4,3654,1383,32,395,376,393,106,0.93,Milwaukee Brewers,Lloyd Street Grounds,139034,95,98,MLA,MLA,MLA
+1901,AL,PHA,OAK,,4,137,66,74,62,,,N,,805,4882,1409,239,87,35,301,344,173,,,,761,533,4.0000000000,124,6,1,3600,1346,20,374,350,331,93,0.94,Philadelphia Athletics,Columbia Park,206329,104,103,PHA,PHA,PHA
+1901,AL,WS1,MIN,,6,138,68,61,72,,,N,,682,4772,1282,191,83,33,356,340,127,,,,771,538,4.0900000000,118,8,2,3549,1396,51,284,308,323,97,0.94,Washington Senators,American League Park I,161661,98,100,WSH,WS1,WS1
+1901,NL,BRO,LAD,,3,137,68,79,57,,,N,,744,4879,1399,206,93,32,312,449,178,,,,600,423,3.1400000000,111,7,5,3639,1244,18,435,583,281,99,0.95,Brooklyn Superbas,Washington Park III,198200,103,101,BRO,BRO,BRO
+1901,NL,BSN,ATL,,5,140,70,69,69,,,N,,531,4746,1180,135,36,28,303,519,158,,,,556,407,2.9000000000,128,11,0,3789,1196,29,349,558,279,89,0.95,Boston Beaneaters,South End Grounds III,146502,109,109,BSN,BSN,BSN
+1901,NL,CHN,CHC,,6,140,70,53,86,,,N,,578,4844,1250,153,61,18,314,532,204,,,,699,459,3.3300000000,131,2,0,3723,1348,27,324,586,336,87,0.94,Chicago Orphans,West Side Park II,205071,96,98,CHC,CHN,CHN
+1901,NL,CIN,CIN,,8,142,72,52,87,,,N,,561,4914,1232,173,70,38,323,584,137,,,,818,586,4.1700000000,126,4,0,3795,1469,51,365,542,355,102,0.94,Cincinnati Reds,League Park II in Cincinnati,205728,94,96,CIN,CIN,CIN
+1901,NL,NY1,SFG,,7,141,71,52,85,,,N,,544,4839,1225,167,46,19,303,575,133,,,,755,530,3.8700000000,118,11,1,3696,1389,24,377,542,343,81,0.94,New York Giants,Polo Grounds III,297650,96,100,NYG,NY1,NY1
+1901,NL,PHI,PHI,,2,140,69,83,57,,,N,,668,4793,1275,194,58,24,430,549,199,,,,543,397,2.8700000000,125,15,2,3738,1221,19,259,480,262,65,0.95,Philadelphia Phillies,Baker Bowl,234937,102,102,PHI,PHI,PHI
+1901,NL,PIT,PIT,,1,140,69,90,49,,,Y,,776,4913,1407,182,92,29,386,493,203,,,,534,357,2.5800000000,119,15,4,3732,1198,20,244,505,285,97,0.95,Pittsburgh Pirates,Exposition Park,251955,103,98,PIT,PIT,PIT
+1901,NL,SLN,STL,,4,142,72,76,64,,,N,,792,5039,1430,187,94,39,314,540,190,,,,689,519,3.6800000000,118,5,5,3807,1333,39,332,445,305,108,0.94,St. Louis Cardinals,Robison Field,379988,95,96,STL,SLN,SLN
+1902,AL,BLA,NYY,,8,141,64,50,88,,,N,,715,4760,1318,202,107,33,417,429,189,,,,848,582,4.3300000000,119,3,1,3630,1531,30,354,258,347,109,0.93,Baltimore Orioles,Oriole Park,174606,104,105,BLA,BLA,BLA
+1902,AL,BOS,BOS,,3,138,71,77,60,,,N,,664,4875,1356,195,95,42,275,375,132,,,,600,415,3.0200000000,123,6,1,3714,1217,27,326,431,255,101,0.95,Boston Americans,Huntington Avenue Grounds,348567,103,100,BOS,BOS,BOS
+1902,AL,CHA,CHW,,4,138,72,74,60,,,N,,675,4654,1248,170,50,14,411,381,265,,,,602,463,3.4100000000,116,11,0,3663,1269,30,331,346,259,125,0.95,Chicago White Sox,South Side Park II,337898,96,95,CHW,CHA,CHA
+1902,AL,CLE,CLE,,5,137,65,69,67,,,N,,686,4840,1401,248,68,33,308,356,140,,,,667,439,3.2800000000,116,16,3,3612,1199,26,411,361,287,96,0.95,Cleveland Bronchos,League Park I,275395,96,96,CLE,CLE,CLE
+1902,AL,DET,DET,,7,137,67,52,83,,,N,,566,4644,1167,141,55,22,359,287,130,,,,657,471,3.5600000000,116,9,3,3570,1267,20,370,245,332,111,0.94,Detroit Tigers,Bennett Park,189469,105,105,DET,DET,DET
+1902,AL,PHA,OAK,,1,137,73,83,53,,,Y,,775,4762,1369,235,67,38,343,293,201,,,,636,445,3.2900000000,114,5,2,3648,1292,33,368,455,266,75,0.95,Philadelphia Athletics,Columbia Park,420078,104,103,PHA,PHA,PHA
+1902,AL,SLA,BAL,,2,140,73,78,58,,,N,,619,4736,1254,208,61,29,373,327,137,,,,607,462,3.3400000000,120,7,2,3732,1273,36,343,348,274,122,0.95,St. Louis Browns,Sportsman's Park III,272283,99,99,SLB,SLA,SLA
+1902,AL,WS1,MIN,,6,138,68,61,75,,,N,,707,4734,1338,262,66,47,329,296,121,,,,790,585,4.3600000000,130,2,1,3621,1403,56,312,300,316,70,0.94,Washington Senators,American League Park I,188158,101,104,WSH,WS1,WS1
+1902,NL,BRO,LAD,,2,141,69,75,63,,,N,,564,4845,1242,147,49,19,319,489,145,,,,519,375,2.6900000000,132,14,3,3768,1113,10,363,536,275,79,0.95,Brooklyn Superbas,Washington Park III,199868,101,99,BRO,BRO,BRO
+1902,NL,BSN,ATL,,3,142,72,73,64,,,N,,572,4728,1178,142,39,14,398,481,189,,,,516,365,2.6100000000,124,14,4,3777,1233,16,372,523,236,90,0.95,Boston Beaneaters,South End Grounds III,116960,101,102,BSN,BSN,BSN
+1902,NL,CHN,CHC,,5,141,70,68,69,,,N,,530,4802,1200,131,40,6,353,565,222,,,,501,313,2.2100000000,132,17,2,3825,1235,9,279,437,311,111,0.94,Chicago Orphans,West Side Park II,263700,97,97,CHC,CHN,CHN
+1902,NL,CIN,CIN,,4,141,70,70,70,,,N,,633,4908,1383,188,77,18,297,465,131,,,,566,368,2.6700000000,130,9,1,3717,1228,15,352,430,322,118,0.94,Cincinnati Reds,Palace of the Fans,217300,109,108,CIN,CIN,CIN
+1902,NL,NY1,SFG,,8,139,71,48,88,,,N,,401,4571,1088,147,34,8,252,530,187,,,,590,384,2.8200000000,118,11,1,3678,1193,16,332,501,330,104,0.94,New York Giants,Polo Grounds III,302875,99,101,NYG,NY1,NY1
+1902,NL,PHI,PHI,,7,138,69,56,81,,,N,,484,4615,1139,110,43,5,356,481,108,,,,649,471,3.5000000000,118,8,3,3633,1323,12,334,504,305,81,0.94,Philadelphia Phillies,Baker Bowl,112066,104,105,PHI,PHI,PHI
+1902,NL,PIT,PIT,,1,142,71,103,36,,,Y,,775,4926,1410,189,95,18,372,446,222,,,,440,323,2.3000000000,131,21,3,3792,1142,4,250,564,247,87,0.95,Pittsburgh Pirates,Exposition Park,243826,104,99,PIT,PIT,PIT
+1902,NL,SLN,STL,,6,140,70,56,78,,,N,,517,4751,1226,116,37,10,273,438,158,,,,695,473,3.4700000000,112,7,4,3681,1399,16,338,400,323,107,0.94,St. Louis Cardinals,Robison Field,226417,96,99,STL,SLN,SLN
+1903,AL,BOS,BOS,,1,141,70,91,47,,,Y,Y,708,4919,1336,222,113,48,262,561,141,,,,504,358,2.5700000000,123,20,4,3765,1142,23,269,579,235,86,0.95,Boston Americans,Huntington Avenue Grounds,379338,105,102,BOS,BOS,BOS
+1903,AL,CHA,CHW,,7,138,70,60,77,,,N,N,516,4670,1152,176,49,14,325,537,180,,,,613,414,3.0200000000,114,9,4,3705,1233,23,287,391,297,85,0.94,Chicago White Sox,South Side Park II,286183,96,95,CHW,CHA,CHA
+1903,AL,CLE,CLE,,3,140,74,77,63,,,N,N,639,4773,1265,231,95,31,259,595,175,,,,579,377,2.7300000000,125,20,1,3729,1161,16,271,521,322,99,0.94,Cleveland Naps,League Park I,311280,98,96,CLE,CLE,CLE
+1903,AL,DET,DET,,5,137,65,65,71,,,N,N,567,4582,1229,162,91,12,292,526,128,,,,539,365,2.7500000000,123,15,2,3588,1169,19,336,554,281,82,0.95,Detroit Tigers,Bennett Park,224523,96,97,DET,DET,DET
+1903,AL,NYA,NYY,,4,136,67,72,62,,,N,N,579,4565,1136,193,62,18,332,465,160,,,,573,411,3.0800000000,111,7,2,3603,1171,19,245,463,264,87,0.95,New York Highlanders,Hilltop Park,211808,106,105,NYY,NYA,NYA
+1903,AL,PHA,OAK,,2,137,67,75,60,,,N,N,597,4673,1236,227,68,32,268,513,157,,,,519,400,2.9800000000,112,10,1,3621,1124,20,315,728,217,66,0.96,Philadelphia Athletics,Columbia Park,422473,105,103,PHA,PHA,PHA
+1903,AL,SLA,BAL,,6,139,70,65,74,,,N,N,500,4639,1133,166,68,12,271,539,101,,,,525,376,2.7700000000,124,12,3,3666,1220,26,237,511,268,94,0.95,St. Louis Browns,Sportsman's Park III,380405,97,98,SLB,SLA,SLA
+1903,AL,WS1,MIN,,8,140,71,43,94,,,N,N,437,4613,1066,172,72,17,257,463,131,,,,691,519,3.8200000000,122,6,3,3669,1333,38,306,452,262,86,0.95,Washington Senators,American League Park I,128878,102,105,WSH,WS1,WS1
+1903,NL,BRO,LAD,,5,139,73,70,66,,,N,N,667,4534,1201,177,56,15,522,,273,,,,682,467,3.4400000000,118,11,4,3663,1276,18,377,438,284,98,0.95,Brooklyn Superbas,Washington Park III,224670,97,98,BRO,BRO,BRO
+1903,NL,BSN,ATL,,6,140,68,58,80,,,N,N,578,4682,1145,176,47,25,398,,159,,,,699,456,3.3400000000,125,8,1,3684,1310,30,460,516,351,89,0.93,Boston Beaneaters,South End Grounds III,143155,96,98,BSN,BSN,BSN
+1903,NL,CHN,CHC,,3,139,73,82,56,,,N,N,695,4733,1300,191,62,9,422,,259,,,,599,382,2.7700000000,117,6,6,3720,1182,14,354,451,314,78,0.94,Chicago Cubs,West Side Park II,386205,97,96,CHC,CHN,CHN
+1903,NL,CIN,CIN,,4,141,76,74,65,,,N,N,765,4857,1399,228,92,28,403,,144,,,,656,420,3.0700000000,126,11,1,3690,1277,14,378,480,312,84,0.94,Cincinnati Reds,Palace of the Fans,351680,111,109,CIN,CIN,CIN
+1903,NL,NY1,SFG,,2,142,70,84,55,,,N,N,729,4741,1290,181,49,20,379,,264,,,,567,414,2.9500000000,115,8,8,3786,1257,20,371,628,287,87,0.95,New York Giants,Polo Grounds III,579530,104,102,NYG,NY1,NY1
+1903,NL,PHI,PHI,,7,139,61,49,86,,,N,N,617,4781,1283,186,62,12,338,,120,,,,738,533,3.9600000000,126,5,3,3636,1347,21,425,381,299,76,0.94,Philadelphia Phillies,Baker Bowl,151729,92,95,PHI,PHI,PHI
+1903,NL,PIT,PIT,,1,141,70,91,49,,,Y,N,793,4988,1429,208,110,34,364,,172,,,,613,404,2.9100000000,117,16,5,3753,1215,9,384,454,289,100,0.95,Pittsburgh Pirates,Exposition Park,326855,103,99,PIT,PIT,PIT
+1903,NL,SLN,STL,,8,139,69,43,94,,,N,N,505,4689,1176,138,65,8,277,,171,,,,795,494,3.6700000000,111,4,2,3636,1353,25,430,419,321,111,0.94,St. Louis Cardinals,Robison Field,226538,97,100,STL,SLN,SLN
+1904,AL,BOS,BOS,,1,157,81,95,59,,,Y,,608,5231,1294,194,105,26,347,570,101,,,,466,331,2.1200000000,148,21,1,4218,1208,31,233,612,236,83,0.96,Boston Americans,Huntington Avenue Grounds,623295,106,103,BOS,BOS,BOS
+1904,AL,CHA,CHW,,3,156,78,89,65,,,N,,600,5027,1217,193,68,14,373,586,216,,,,482,353,2.3000000000,134,26,3,4140,1161,13,303,550,238,95,0.96,Chicago White Sox,South Side Park II,557123,96,95,CHW,CHA,CHA
+1904,AL,CLE,CLE,,4,154,78,86,65,,,N,,647,5152,1340,225,90,27,307,714,178,,,,482,334,2.2200000000,141,20,0,4068,1273,10,285,627,255,86,0.95,Cleveland Naps,League Park I,264749,99,98,CLE,CLE,CLE
+1904,AL,DET,DET,,7,162,79,62,90,,,N,,505,5321,1231,154,69,11,344,635,112,,,,627,440,2.7700000000,143,15,2,4290,1345,16,433,556,273,92,0.95,Detroit Tigers,Bennett Park,177796,97,98,DET,DET,DET
+1904,AL,NYA,NYY,,2,155,75,92,59,,,N,,598,5220,1354,195,91,27,312,548,163,,,,526,394,2.5700000000,123,15,1,4140,1180,29,311,684,275,90,0.95,New York Highlanders,Hilltop Park,438919,105,104,NYY,NYA,NYA
+1904,AL,PHA,OAK,,5,155,79,81,70,,,N,,557,5088,1266,197,77,31,313,605,137,,,,503,355,2.3500000000,136,26,0,4083,1149,13,366,887,250,67,0.95,Philadelphia Athletics,Columbia Park,512294,105,103,PHA,PHA,PHA
+1904,AL,SLA,BAL,,6,156,78,65,87,,,N,,481,5291,1266,153,53,10,332,609,150,,,,604,443,2.8300000000,135,13,1,4230,1335,25,333,577,267,78,0.96,St. Louis Browns,Sportsman's Park III,318108,94,96,SLB,SLA,SLA
+1904,AL,WS1,MIN,,8,157,78,38,113,,,N,,437,5149,1170,171,57,10,283,759,150,,,,743,547,3.6200000000,137,7,4,4077,1487,19,347,533,313,97,0.95,Washington Senators,American League Park II,131744,98,102,WSH,WS1,WS1
+1904,NL,BRO,LAD,,6,154,76,56,97,,,N,,497,4917,1142,159,53,15,411,,205,,,,614,401,2.7000000000,135,12,2,4011,1281,27,414,453,343,87,0.94,Brooklyn Superbas,Washington Park III,214600,97,100,BRO,BRO,BRO
+1904,NL,BSN,ATL,,7,155,79,55,98,,,N,,491,5135,1217,153,50,24,316,,143,,,,749,514,3.4300000000,136,13,0,4044,1405,25,500,544,338,91,0.94,Boston Beaneaters,South End Grounds III,140694,96,101,BSN,BSN,BSN
+1904,NL,CHN,CHC,,2,156,78,93,60,,,N,,599,5210,1294,157,62,22,298,,227,,,,517,353,2.3000000000,139,18,6,4149,1150,16,402,618,282,89,0.95,Chicago Cubs,West Side Park II,439100,100,98,CHC,CHN,CHN
+1904,NL,CIN,CIN,,3,157,79,88,65,,,N,,695,5231,1332,189,92,21,399,,179,,,,547,362,2.3400000000,142,12,2,4176,1256,13,343,502,301,81,0.95,Cincinnati Reds,Palace of the Fans,391915,109,107,CIN,CIN,CIN
+1904,NL,NY1,SFG,,1,158,84,106,47,,,Y,,744,5150,1347,202,65,31,434,,283,,,,476,337,2.1700000000,127,21,15,4188,1151,36,349,707,289,93,0.95,New York Giants,Polo Grounds III,609826,104,100,NYG,NY1,NY1
+1904,NL,PHI,PHI,,8,155,73,52,100,,,N,,571,5103,1268,170,54,23,377,,159,,,,784,504,3.3900000000,131,10,2,4017,1418,22,425,469,401,93,0.93,Philadelphia Phillies,Baker Bowl,140771,99,100,PHI,PHI,PHI
+1904,NL,PIT,PIT,,4,156,78,87,66,,,N,,675,5160,1333,164,102,15,391,,178,,,,592,433,2.8900000000,133,15,1,4044,1273,13,379,455,291,93,0.95,Pittsburgh Pirates,Exposition Park,340615,103,100,PIT,PIT,PIT
+1904,NL,SLN,STL,,5,155,76,75,79,,,N,,602,5104,1292,175,66,24,343,,199,,,,595,401,2.6400000000,146,7,2,4104,1286,23,319,529,307,83,0.95,St. Louis Cardinals,Robison Field,386750,96,99,STL,SLN,SLN
+1905,AL,BOS,BOS,,4,153,77,78,74,,,N,N,579,5049,1179,165,69,29,486,,131,,,,564,428,2.8400000000,124,14,1,4068,1198,33,292,652,290,75,0.95,Boston Americans,Huntington Avenue Grounds,468828,101,102,BOS,BOS,BOS
+1905,AL,CHA,CHW,,2,158,82,92,60,,,N,N,612,5114,1213,200,55,11,439,,194,,,,451,316,1.9900000000,131,15,0,4281,1163,11,329,613,217,64,0.96,Chicago White Sox,South Side Park II,687419,96,93,CHW,CHA,CHA
+1905,AL,CLE,CLE,,5,155,77,76,78,,,N,N,567,5166,1318,211,72,18,286,,188,,,,587,432,2.8500000000,140,16,0,4089,1251,23,334,555,233,84,0.96,Cleveland Naps,League Park I,316306,101,99,CLE,CLE,CLE
+1905,AL,DET,DET,,3,154,76,79,74,,,N,N,512,4971,1209,190,54,13,375,,129,,,,602,424,2.8300000000,124,17,1,4044,1226,11,474,578,264,80,0.95,Detroit Tigers,Bennett Park,193384,101,103,DET,DET,DET
+1905,AL,NYA,NYY,,6,152,75,71,78,,,N,N,586,4957,1228,163,61,23,360,,200,,,,622,440,2.9300000000,88,16,4,4059,1235,26,396,642,293,88,0.95,New York Highlanders,Hilltop Park,309100,111,110,NYY,NYA,NYA
+1905,AL,PHA,OAK,,1,152,74,92,56,,,Y,N,623,5146,1310,256,51,24,376,,190,,,,492,337,2.1900000000,117,19,0,4149,1137,21,409,895,265,95,0.95,Philadelphia Athletics,Columbia Park,554576,102,100,PHA,PHA,PHA
+1905,AL,SLA,BAL,,8,156,79,54,99,,,N,N,511,5204,1205,153,49,16,362,,130,,,,608,421,2.7400000000,134,10,2,4152,1245,19,389,633,284,78,0.95,St. Louis Browns,Sportsman's Park III,339112,95,96,SLB,SLA,SLA
+1905,AL,WS1,MIN,,7,154,77,64,87,,,N,N,559,5015,1121,193,68,22,298,,169,,,,623,434,2.8700000000,118,12,1,4086,1250,12,385,539,319,76,0.95,Washington Senators,American League Park II,252027,96,100,WSH,WS1,WS1
+1905,NL,BRO,LAD,,8,155,77,48,104,,,N,N,506,5100,1255,154,60,29,327,,186,,,,807,563,3.7600000000,125,7,3,4041,1416,24,476,556,408,101,0.93,Brooklyn Superbas,Washington Park III,227924,93,96,BRO,BRO,BRO
+1905,NL,BSN,ATL,,7,156,76,51,103,,,N,N,468,5190,1217,148,52,17,302,,132,,,,733,541,3.5200000000,139,14,0,4149,1390,36,433,533,311,89,0.95,Boston Beaneaters,South End Grounds III,150003,98,103,BSN,BSN,BSN
+1905,NL,CHN,CHC,,3,155,81,92,61,,,N,N,667,5108,1249,157,82,12,448,,267,,,,442,319,2.0400000000,133,23,2,4221,1135,14,385,627,246,99,0.96,Chicago Cubs,West Side Park II,509900,104,99,CHC,CHN,CHN
+1905,NL,CIN,CIN,,5,155,79,79,74,,,N,N,735,5205,1401,160,101,27,434,,181,,,,698,457,3.0100000000,119,10,2,4095,1409,22,439,547,310,122,0.95,Cincinnati Reds,Palace of the Fans,313927,111,110,CIN,CIN,CIN
+1905,NL,NY1,SFG,,1,155,76,105,48,,,Y,Y,780,5094,1392,191,88,39,517,,291,,,,505,364,2.3900000000,117,18,15,4110,1160,25,364,760,253,93,0.96,New York Giants,Polo Grounds III,552700,102,98,NYG,NY1,NY1
+1905,NL,PHI,PHI,,4,155,76,83,69,,,N,N,708,5243,1362,187,82,16,406,,180,,,,602,436,2.8100000000,119,12,5,4194,1303,21,411,516,275,99,0.95,Philadelphia Phillies,Baker Bowl,317932,96,97,PHI,PHI,PHI
+1905,NL,PIT,PIT,,2,155,78,96,57,,,N,N,692,5213,1385,190,91,22,382,,202,,,,570,439,2.8600000000,113,12,6,4146,1270,12,389,512,255,112,0.96,Pittsburgh Pirates,Exposition Park,369124,103,100,PIT,PIT,PIT
+1905,NL,SLN,STL,,6,154,77,58,96,,,N,N,535,5066,1254,140,85,20,391,,162,,,,734,537,3.5900000000,135,10,2,4041,1431,28,367,411,274,83,0.95,St. Louis Cardinals,Robison Field,292800,97,99,STL,SLN,SLN
+1906,AL,BOS,BOS,,8,155,77,49,105,,,N,N,463,5168,1223,160,75,13,298,,99,,,,706,524,3.4100000000,124,6,6,4146,1360,37,285,549,333,84,0.94,Boston Americans,Huntington Avenue Grounds,410209,100,102,BOS,BOS,BOS
+1906,AL,CHA,CHW,,1,154,79,93,58,,,Y,Y,570,4925,1133,152,52,7,453,,214,,,,460,325,2.1300000000,117,32,3,4125,1212,11,255,543,243,80,0.96,Chicago White Sox,South Side Park II,585202,98,95,CHW,CHA,CHA
+1906,AL,CLE,CLE,,3,157,79,89,64,,,N,N,663,5426,1516,240,73,12,330,,203,,,,482,328,2.0900000000,133,27,4,4236,1197,16,365,530,217,111,0.96,Cleveland Naps,League Park I,325733,99,97,CLE,CLE,CLE
+1906,AL,DET,DET,,6,151,78,71,78,,,N,N,518,4930,1195,154,64,10,333,,206,,,,599,454,3.0600000000,128,7,4,4002,1398,14,389,469,259,86,0.95,Detroit Tigers,Bennett Park,174043,103,103,DET,DET,DET
+1906,AL,NYA,NYY,,2,155,76,90,61,,,N,N,644,5095,1354,166,77,17,331,,192,,,,543,419,2.7800000000,99,18,5,4071,1236,21,351,605,272,69,0.95,New York Highlanders,Hilltop Park,434700,110,110,NYY,NYA,NYA
+1906,AL,PHA,OAK,,4,149,73,78,67,,,N,N,561,4883,1206,213,49,32,385,,165,,,,543,382,2.6000000000,107,19,4,3966,1135,9,425,749,267,86,0.95,Philadelphia Athletics,Columbia Park,489129,103,101,PHA,PHA,PHA
+1906,AL,SLA,BAL,,5,154,76,76,73,,,N,N,558,5030,1244,145,60,20,366,,221,,,,498,336,2.2300000000,133,17,5,4071,1132,14,314,558,289,80,0.95,St. Louis Browns,Sportsman's Park III,389157,96,96,SLB,SLA,SLA
+1906,AL,WS1,MIN,,7,151,75,55,95,,,N,N,518,4956,1180,144,65,26,306,,233,,,,664,477,3.2500000000,115,13,1,3966,1331,15,451,558,273,78,0.95,Washington Senators,American League Park II,129903,95,98,WSH,WS1,WS1
+1906,NL,BRO,LAD,,5,153,76,66,86,,,N,N,496,4897,1156,141,68,25,388,,175,,,,625,469,3.1300000000,119,22,11,4044,1255,15,453,476,283,73,0.95,Brooklyn Superbas,Washington Park III,277400,92,96,BRO,BRO,BRO
+1906,NL,BSN,ATL,,8,152,76,49,102,,,N,N,408,4925,1115,136,43,16,356,,93,,,,649,465,3.1400000000,137,10,0,4002,1291,24,436,562,337,102,0.94,Boston Beaneaters,South End Grounds III,143280,97,102,BSN,BSN,BSN
+1906,NL,CHN,CHC,,1,155,79,116,36,,,Y,N,705,5018,1316,181,71,20,448,,283,,,,381,270,1.7500000000,125,30,10,4164,1018,12,446,702,190,100,0.97,Chicago Cubs,West Side Park II,654300,106,100,CHC,CHN,CHN
+1906,NL,CIN,CIN,,6,155,78,64,87,,,N,N,533,5025,1198,140,71,16,395,,170,,,,582,409,2.6900000000,126,12,5,4107,1248,14,470,567,260,97,0.95,Cincinnati Reds,Palace of the Fans,330056,104,104,CIN,CIN,CIN
+1906,NL,NY1,SFG,,2,153,75,96,56,,,N,N,625,4768,1217,162,53,15,563,,288,,,,510,369,2.4900000000,105,19,18,4002,1207,13,394,639,228,84,0.96,New York Giants,Polo Grounds III,402850,102,99,NYG,NY1,NY1
+1906,NL,PHI,PHI,,4,154,77,71,82,,,N,N,528,4911,1183,197,47,12,432,,180,,,,564,388,2.5800000000,108,21,5,4062,1201,18,436,500,271,83,0.95,Philadelphia Phillies,Baker Bowl,294680,100,99,PHI,PHI,PHI
+1906,NL,PIT,PIT,,3,154,77,93,60,,,N,N,623,5030,1313,164,67,12,424,,162,,,,470,333,2.2100000000,116,27,2,4074,1234,13,309,532,220,109,0.96,Pittsburgh Pirates,Exposition Park,394877,104,102,PIT,PIT,PIT
+1906,NL,SLN,STL,,7,154,77,52,98,,,N,N,470,5075,1195,137,69,10,361,,110,,,,607,457,3.0400000000,118,4,2,4062,1246,17,479,559,272,92,0.95,St. Louis Cardinals,Robison Field,283770,96,100,STL,SLN,SLN
+1907,AL,BOS,BOS,,7,155,78,59,90,,,N,N,464,5235,1224,154,48,18,305,,125,,,,558,385,2.4500000000,100,17,7,4242,1222,22,337,517,269,103,0.95,Boston Americans,Huntington Avenue Grounds,436777,99,101,BOS,BOS,BOS
+1907,AL,CHA,CHW,,3,157,79,87,64,,,N,N,588,5070,1205,149,33,5,421,,175,,,,474,347,2.2200000000,112,17,9,4218,1279,13,305,604,232,101,0.96,Chicago White Sox,South Side Park II,666307,97,95,CHW,CHA,CHA
+1907,AL,CLE,CLE,,4,158,82,85,67,,,N,N,530,5068,1221,182,68,11,335,,193,,,,525,350,2.2600000000,127,20,5,4176,1253,8,362,513,264,137,0.96,Cleveland Naps,League Park I,382046,101,99,CLE,CLE,CLE
+1907,AL,DET,DET,,1,153,79,92,58,,,Y,N,694,5204,1383,179,75,11,315,,192,,,,532,355,2.3300000000,120,15,7,4110,1281,8,380,512,264,79,0.95,Detroit Tigers,Bennett Park,297079,103,102,DET,DET,DET
+1907,AL,NYA,NYY,,5,152,75,70,78,,,N,N,605,5044,1258,150,67,15,304,,206,,,,665,449,3.0300000000,93,10,5,3999,1327,13,428,511,336,79,0.94,New York Highlanders,Hilltop Park,350020,108,110,NYY,NYA,NYA
+1907,AL,PHA,OAK,,2,150,73,88,57,,,N,N,582,5008,1274,223,43,22,384,,137,,,,511,354,2.3500000000,106,27,6,4062,1106,13,378,789,263,67,0.95,Philadelphia Athletics,Columbia Park,625581,102,102,PHA,PHA,PHA
+1907,AL,SLA,BAL,,6,155,76,69,83,,,N,N,542,5224,1324,154,63,10,370,,144,,,,555,400,2.6100000000,129,15,9,4143,1254,17,352,463,266,97,0.95,St. Louis Browns,Sportsman's Park III,419025,100,99,SLB,SLA,SLA
+1907,AL,WS1,MIN,,8,154,75,49,102,,,N,N,506,5112,1243,134,58,12,390,,223,,,,691,467,3.1100000000,106,12,5,4053,1383,10,344,570,309,69,0.95,Washington Senators,American League Park II,221929,92,95,WSH,WS1,WS1
+1907,NL,BRO,LAD,,5,153,77,65,83,,,N,N,446,4895,1135,142,63,18,336,,121,,,,522,359,2.3800000000,125,20,1,4068,1218,16,463,479,262,94,0.95,Brooklyn Superbas,Washington Park III,312500,92,95,BRO,BRO,BRO
+1907,NL,BSN,ATL,,7,152,74,58,90,,,N,N,502,5020,1222,142,61,22,413,,118,,,,652,495,3.3300000000,121,9,2,4014,1324,28,458,426,249,128,0.96,Boston Doves,South End Grounds III,203221,100,103,BSN,BSN,BSN
+1907,NL,CHN,CHC,,1,155,76,107,45,,,Y,Y,574,4892,1224,162,48,13,435,,235,,,,390,264,1.7300000000,114,32,8,4119,1054,11,402,586,211,110,0.96,Chicago Cubs,West Side Park II,422550,106,101,CHC,CHN,CHN
+1907,NL,CIN,CIN,,6,156,81,66,87,,,N,N,526,4966,1226,126,90,15,372,,158,,,,519,362,2.4100000000,118,10,2,4053,1223,16,444,481,227,118,0.96,Cincinnati Reds,Palace of the Fans,317500,104,105,CIN,CIN,CIN
+1907,NL,NY1,SFG,,4,155,77,82,71,,,N,N,574,4874,1222,160,48,23,516,,205,,,,510,373,2.4500000000,109,22,13,4113,1219,25,369,655,230,75,0.96,New York Giants,Polo Grounds III,538350,103,100,NYG,NY1,NY1
+1907,NL,PHI,PHI,,3,149,75,83,64,,,N,N,512,4725,1113,162,65,12,424,,154,,,,476,351,2.4300000000,110,21,4,3897,1095,13,422,499,256,104,0.95,Philadelphia Phillies,Baker Bowl,341216,99,98,PHI,PHI,PHI
+1907,NL,PIT,PIT,,2,157,77,91,63,,,N,N,634,4957,1261,133,78,19,469,,264,,,,510,348,2.3000000000,111,24,5,4089,1207,12,368,497,253,75,0.95,Pittsburgh Pirates,Exposition Park,319506,102,99,PIT,PIT,PIT
+1907,NL,SLN,STL,,8,155,79,52,101,,,N,N,419,5008,1163,121,51,19,312,,125,,,,608,410,2.7000000000,127,19,2,4095,1212,20,500,594,350,105,0.94,St. Louis Cardinals,Robison Field,185377,97,101,STL,SLN,SLN
+1908,AL,BOS,BOS,,5,155,77,75,79,,,N,N,564,5048,1239,117,88,14,289,,167,,,,513,350,2.2800000000,102,12,7,4140,1200,18,364,624,296,71,0.95,Boston Red Sox,Huntington Avenue Grounds,473048,103,103,BOS,BOS,BOS
+1908,AL,CHA,CHW,,3,156,78,88,64,,,N,N,537,5027,1127,145,41,3,463,,209,,,,470,349,2.2200000000,107,23,10,4242,1170,11,284,623,233,82,0.96,Chicago White Sox,South Side Park II,636096,98,97,CHW,CHA,CHA
+1908,AL,CLE,CLE,,2,157,78,90,64,,,N,N,568,5108,1221,188,58,18,364,,177,,,,457,320,2.0200000000,108,18,5,4272,1172,16,328,548,257,95,0.96,Cleveland Naps,League Park I,422262,101,100,CLE,CLE,CLE
+1908,AL,DET,DET,,1,154,78,90,63,,,Y,N,647,5115,1347,199,86,19,320,,165,,,,547,366,2.4000000000,119,15,5,4122,1313,12,318,553,298,95,0.95,Detroit Tigers,Bennett Park,436199,104,101,DET,DET,DET
+1908,AL,NYA,NYY,,8,155,77,51,103,,,N,N,459,5046,1190,142,50,13,288,,231,,,,713,480,3.1600000000,90,11,3,4098,1288,26,458,585,338,78,0.94,New York Highlanders,Hilltop Park,305500,101,103,NYY,NYA,NYA
+1908,AL,PHA,OAK,,6,157,78,68,85,,,N,N,486,5065,1131,183,50,21,368,,116,,,,562,398,2.5600000000,102,23,4,4200,1194,10,410,741,272,68,0.95,Philadelphia Athletics,Columbia Park,455062,107,107,PHA,PHA,PHA
+1908,AL,SLA,BAL,,4,155,78,83,69,,,N,N,544,5151,1261,173,52,20,343,,126,,,,483,334,2.1500000000,107,15,5,4191,1151,7,387,607,237,97,0.96,St. Louis Browns,Sportsman's Park III,618947,101,100,SLB,SLA,SLA
+1908,AL,WS1,MIN,,7,155,78,67,85,,,N,N,479,5041,1186,132,74,8,368,,170,,,,539,362,2.3400000000,106,15,7,4173,1236,16,348,649,276,89,0.95,Washington Senators,American League Park II,264252,92,96,WSH,WS1,WS1
+1908,NL,BRO,LAD,,7,154,77,53,101,,,N,N,377,4897,1044,110,60,28,323,,113,,,,516,376,2.4700000000,118,20,4,4107,1165,17,444,535,241,66,0.96,Brooklyn Superbas,Washington Park III,275600,96,99,BRO,BRO,BRO
+1908,NL,BSN,ATL,,6,156,78,63,91,,,N,N,537,5131,1228,137,43,17,414,,134,,,,622,435,2.7900000000,92,14,1,4212,1262,29,423,416,252,90,0.96,Boston Doves,South End Grounds III,253750,98,102,BSN,BSN,BSN
+1908,NL,CHN,CHC,,1,158,78,99,55,,,Y,Y,624,5085,1267,196,56,19,418,,212,,,,461,341,2.1400000000,108,29,12,4299,1137,20,437,668,206,76,0.96,Chicago Cubs,West Side Park II,665325,104,100,CHC,CHN,CHN
+1908,NL,CIN,CIN,,5,155,77,73,81,,,N,N,489,4879,1108,129,77,14,372,,196,,,,544,364,2.3700000000,110,17,8,4152,1218,19,415,433,255,72,0.95,Cincinnati Reds,Palace of the Fans,399200,97,98,CIN,CIN,CIN
+1908,NL,NY1,SFG,,2,157,80,98,56,,,N,N,652,5006,1339,182,43,20,494,,181,,,,456,336,2.1400000000,95,25,18,4233,1214,26,288,656,248,79,0.96,New York Giants,Polo Grounds III,910000,105,102,NYG,NY1,NY1
+1908,NL,PHI,PHI,,4,155,78,83,71,,,N,N,504,5012,1223,194,68,11,334,,200,,,,445,325,2.1000000000,116,22,6,4179,1167,8,379,476,238,75,0.96,Philadelphia Phillies,Baker Bowl,420660,103,102,PHI,PHI,PHI
+1908,NL,PIT,PIT,,2,155,77,98,56,,,N,N,585,5109,1263,162,98,25,420,,186,,,,469,330,2.1200000000,100,24,9,4206,1142,16,406,468,225,74,0.96,Pittsburgh Pirates,Exposition Park,382444,100,98,PIT,PIT,PIT
+1908,NL,SLN,STL,,8,154,77,49,105,,,N,N,371,4959,1105,134,57,17,282,,150,,,,626,401,2.6400000000,97,13,4,4104,1217,16,430,528,349,68,0.94,St. Louis Cardinals,Robison Field,205129,95,100,STL,SLN,SLN
+1909,AL,BOS,BOS,,3,152,75,88,63,,,N,N,597,4979,1307,151,69,20,348,,215,,,,550,391,2.5900000000,75,11,15,4080,1214,18,384,555,291,95,0.95,Boston Red Sox,Huntington Avenue Grounds,668965,102,101,BOS,BOS,BOS
+1909,AL,CHA,CHW,,4,159,81,78,74,,,N,N,492,5017,1110,145,56,4,441,,211,,,,463,326,2.0500000000,115,26,4,4290,1182,8,340,669,247,101,0.96,Chicago White Sox,South Side Park II,478400,96,95,CHW,CHA,CHA
+1909,AL,CLE,CLE,,6,155,77,71,82,,,N,N,493,5048,1216,173,81,10,283,,174,,,,532,363,2.4000000000,110,15,3,4083,1212,9,348,568,277,110,0.95,Cleveland Naps,League Park I,354627,104,103,CLE,CLE,CLE
+1909,AL,DET,DET,,1,158,78,98,54,,,Y,N,666,5095,1360,209,58,19,397,,280,,,,493,357,2.2600000000,117,17,12,4260,1254,16,359,528,268,87,0.96,Detroit Tigers,Bennett Park,490490,104,102,DET,DET,DET
+1909,AL,NYA,NYY,,5,153,77,74,77,,,N,N,590,4981,1234,143,61,16,407,,187,,,,587,398,2.6500000000,94,18,7,4050,1223,21,422,597,328,94,0.94,New York Highlanders,Hilltop Park,501000,101,102,NYY,NYA,NYA
+1909,AL,PHA,OAK,,2,153,76,95,58,,,N,N,605,4905,1257,186,88,21,403,,205,,,,408,296,1.9300000000,110,27,3,4134,1069,9,386,728,245,92,0.96,Philadelphia Athletics,Shibe Park,674915,102,97,PHA,PHA,PHA
+1909,AL,SLA,BAL,,7,154,79,61,89,,,N,N,441,4964,1151,116,45,10,331,,136,,,,575,433,2.8800000000,105,21,4,4062,1287,16,383,620,267,107,0.95,St. Louis Browns,Sportsman's Park IV,366274,93,98,SLB,SLA,SLA
+1909,AL,WS1,MIN,,8,156,77,42,110,,,N,N,380,4983,1112,149,41,9,321,,136,,,,656,464,3.0400000000,99,11,2,4122,1288,12,424,653,280,100,0.95,Washington Senators,American League Park II,205199,95,98,WSH,WS1,WS1
+1909,NL,BRO,LAD,,6,155,79,55,98,,,N,N,444,5056,1157,176,59,16,330,,141,,,,627,477,3.1000000000,126,18,3,4152,1277,32,528,594,276,86,0.95,Brooklyn Superbas,Washington Park III,321300,96,100,BRO,BRO,BRO
+1909,NL,BSN,ATL,,8,155,76,45,108,,,N,N,435,5017,1121,124,43,15,400,,135,,,,683,487,3.2000000000,98,13,6,4110,1329,23,543,414,340,101,0.94,Boston Doves,South End Grounds III,195188,104,108,BSN,BSN,BSN
+1909,NL,CHN,CHC,,2,155,77,104,49,,,N,N,635,4999,1227,203,60,20,420,,187,,,,390,272,1.7500000000,111,32,11,4197,1094,6,364,680,244,95,0.96,Chicago Cubs,West Side Park II,633480,103,98,CHC,CHN,CHN
+1909,NL,CIN,CIN,,4,157,80,77,76,,,N,N,606,5088,1273,159,72,22,478,,280,,,,599,394,2.5200000000,91,10,8,4221,1233,5,510,477,309,120,0.95,Cincinnati Reds,Palace of the Fans,424643,99,100,CIN,CIN,CIN
+1909,NL,NY1,SFG,,3,158,77,92,61,,,N,N,623,5218,1327,173,68,26,530,,234,,,,546,363,2.2700000000,105,17,15,4320,1248,28,397,735,305,99,0.95,New York Giants,Polo Grounds III,783700,102,98,NYG,NY1,NY1
+1909,NL,PHI,PHI,,5,154,77,74,79,,,N,N,516,5034,1228,185,53,12,369,,185,,,,518,377,2.4400000000,89,17,6,4173,1190,23,472,612,241,97,0.96,Philadelphia Phillies,Baker Bowl,303177,101,100,PHI,PHI,PHI
+1909,NL,PIT,PIT,,1,154,78,110,42,,,Y,Y,699,5129,1332,218,92,25,479,,185,,,,447,322,2.0700000000,93,21,11,4203,1174,12,320,490,222,100,0.96,Pittsburgh Pirates,Exposition Park/Forbes Field,534950,105,99,PIT,PIT,PIT
+1909,NL,SLN,STL,,7,154,76,54,98,,,N,N,583,5108,1242,148,56,15,568,,161,,,,731,522,3.4100000000,84,5,4,4137,1368,22,483,435,321,90,0.95,St. Louis Cardinals,Robison Field,299982,94,97,STL,SLN,SLN
+1910,AL,BOS,BOS,,4,158,80,81,72,,,N,N,638,5204,1350,175,87,43,430,,194,,,,564,389,2.4500000000,100,12,6,4290,1236,30,414,670,308,80,0.95,Boston Red Sox,Huntington Avenue Grounds,584619,102,101,BOS,BOS,BOS
+1910,AL,CHA,CHW,,6,156,79,68,85,,,N,N,457,5024,1058,115,58,7,403,,183,,,,479,321,2.0300000000,103,23,7,4263,1130,16,381,785,314,100,0.95,Chicago White Sox,South Side Park II/Comiskey Park,552084,95,95,CHW,CHA,CHA
+1910,AL,CLE,CLE,,5,161,80,71,81,,,N,N,548,5385,1316,188,64,9,366,,189,,,,657,469,2.8800000000,92,13,5,4401,1392,10,488,617,246,112,0.96,Cleveland Naps,League Park II,293456,101,103,CLE,CLE,CLE
+1910,AL,DET,DET,,3,155,78,86,68,,,N,N,679,5039,1317,190,72,28,459,,249,,,,582,432,2.8200000000,108,17,5,4140,1257,34,460,532,281,79,0.95,Detroit Tigers,Bennett Park,391288,107,104,DET,DET,DET
+1910,AL,NYA,NYY,,2,156,77,88,63,,,N,N,626,5051,1254,164,75,20,464,,288,,,,557,406,2.6100000000,110,14,8,4197,1238,16,364,654,286,95,0.95,New York Highlanders,Hilltop Park,355857,106,105,NYY,NYA,NYA
+1910,AL,PHA,OAK,,1,155,78,102,48,,,Y,Y,673,5156,1373,191,105,19,409,,207,,,,441,283,1.7900000000,123,24,5,4263,1103,8,450,789,230,117,0.96,Philadelphia Athletics,Shibe Park,588905,99,94,PHA,PHA,PHA
+1910,AL,SLA,BAL,,8,158,79,47,107,,,N,N,451,5077,1105,131,60,12,415,,169,,,,743,478,3.0900000000,101,9,3,4173,1356,14,532,557,385,113,0.94,St. Louis Browns,Sportsman's Park IV,249889,94,98,SLB,SLA,SLA
+1910,AL,WS1,MIN,,7,157,77,66,85,,,N,N,501,4989,1175,145,46,9,449,,192,,,,550,375,2.4600000000,119,19,3,4119,1215,19,375,674,264,99,0.95,Washington Senators,American League Park II,254591,95,99,WSH,WS1,WS1
+1910,NL,BRO,LAD,,6,156,80,64,90,,,N,N,497,5125,1174,166,73,25,434,706,151,,,,623,484,3.0700000000,103,15,5,4260,1331,17,545,555,234,125,0.96,Brooklyn Superbas,Washington Park III,279321,97,100,BRO,BRO,BRO
+1910,NL,BSN,ATL,,8,157,78,53,100,,,N,N,495,5123,1260,173,49,31,359,540,152,,,,701,497,3.2200000000,72,12,9,4170,1328,36,599,531,305,137,0.95,Boston Doves,South End Grounds III,149027,103,109,BSN,BSN,BSN
+1910,NL,CHN,CHC,,1,154,77,104,50,,,Y,N,712,4977,1333,219,84,34,542,501,173,,,,499,384,2.5100000000,100,25,13,4134,1171,18,474,609,229,110,0.96,Chicago Cubs,West Side Park II,526152,99,95,CHC,CHN,CHN
+1910,NL,CIN,CIN,,5,156,77,75,79,,,N,N,620,5121,1326,150,79,23,529,515,310,,,,684,474,3.0800000000,86,16,11,4158,1334,27,528,497,291,103,0.95,Cincinnati Reds,Palace of the Fans,380622,96,97,CIN,CIN,CIN
+1910,NL,NY1,SFG,,2,155,79,91,63,,,N,N,715,5061,1391,204,83,31,562,489,282,,,,567,414,2.6800000000,96,9,10,4173,1290,30,397,717,282,117,0.95,New York Giants,Polo Grounds III,511785,100,98,NYG,NY1,NY1
+1910,NL,PHI,PHI,,4,157,78,78,75,,,N,N,674,5171,1319,223,71,22,506,559,199,,,,639,478,3.0500000000,84,17,9,4233,1297,36,547,657,258,132,0.96,Philadelphia Phillies,Baker Bowl,296597,103,103,PHI,PHI,PHI
+1910,NL,PIT,PIT,,3,154,76,86,67,,,N,N,655,5125,1364,214,83,33,437,524,148,,,,576,433,2.8300000000,73,13,12,4128,1254,20,392,479,245,102,0.96,Pittsburgh Pirates,Forbes Field,436586,107,104,PIT,PIT,PIT
+1910,NL,SLN,STL,,7,153,76,63,90,,,N,N,639,4912,1217,167,70,15,655,581,179,,,,718,562,3.7800000000,81,4,14,4011,1396,30,541,466,257,109,0.95,St. Louis Cardinals,Robison Field,355668,96,98,STL,SLN,SLN
+1911,AL,BOS,BOS,,4,153,76,78,75,,,N,N,680,5014,1379,203,66,35,506,,190,,,,643,411,2.7400000000,87,10,8,4053,1309,21,473,711,322,93,0.94,Boston Red Sox,Huntington Avenue Grounds,503961,99,98,BOS,BOS,BOS
+1911,AL,CHA,CHW,,5,154,78,77,74,,,N,N,719,5213,1401,179,92,20,385,,201,,,,624,457,2.9700000000,85,17,11,4158,1349,22,384,752,255,98,0.96,Chicago White Sox,Comiskey Park,583208,98,97,CHW,CHA,CHA
+1911,AL,CLE,CLE,,3,156,77,80,73,,,N,N,691,5321,1501,238,81,20,354,,209,,,,712,519,3.3600000000,93,6,6,4170,1382,17,552,675,302,108,0.95,Cleveland Naps,League Park II,406296,101,102,CLE,CLE,CLE
+1911,AL,DET,DET,,2,154,76,89,65,,,N,N,831,5294,1544,230,96,30,471,,276,,,,776,575,3.7300000000,108,8,3,4161,1514,28,460,538,312,78,0.95,Detroit Tigers,Bennett Park,484988,105,104,DET,DET,DET
+1911,AL,NYA,NYY,,6,153,77,76,76,,,N,N,684,5052,1374,190,96,25,493,,269,,,,724,535,3.5400000000,91,5,3,4080,1404,26,406,667,320,99,0.94,New York Highlanders,Hilltop Park,302444,106,107,NYY,NYA,NYA
+1911,AL,PHA,OAK,,1,152,75,101,50,,,Y,Y,861,5199,1540,237,93,35,424,,226,,,,601,460,3.0100000000,97,13,13,4125,1343,17,487,739,228,100,0.96,Philadelphia Athletics,Shibe Park,605749,98,95,PHA,PHA,PHA
+1911,AL,SLA,BAL,,8,152,78,45,107,,,N,N,567,4996,1192,187,63,17,460,,125,,,,812,571,3.8600000000,92,8,1,3996,1465,28,463,383,358,104,0.94,St. Louis Browns,Sportsman's Park IV,207984,96,101,SLB,SLA,SLA
+1911,AL,WS1,MIN,,7,154,77,64,90,,,N,N,625,5065,1308,159,54,16,466,,215,,,,766,529,3.5200000000,106,13,3,4059,1471,39,410,628,306,90,0.95,Washington Senators,Griffith Stadium I,244884,98,98,WSH,WS1,WS1
+1911,NL,BRO,LAD,,7,154,74,64,86,,,N,N,539,5059,1198,151,71,28,425,683,184,,,,659,516,3.3900000000,81,13,10,4113,1310,27,566,533,243,112,0.96,Brooklyn Dodgers,Washington Park III,269000,96,98,BRO,BRO,BRO
+1911,NL,BSN,ATL,,8,156,75,44,107,,,N,N,699,5308,1417,249,54,37,554,577,169,,,,1021,776,5.0800000000,73,5,7,4122,1570,76,672,486,347,110,0.94,Boston Rustlers,South End Grounds III,116000,107,111,BSN,BSN,BSN
+1911,NL,CHN,CHC,,2,157,84,92,62,,,N,N,757,5130,1335,218,101,54,585,617,214,,,,607,455,2.9000000000,85,12,16,4233,1270,26,525,582,260,114,0.96,Chicago Cubs,West Side Park II,576000,100,97,CHC,CHN,CHN
+1911,NL,CIN,CIN,,6,159,82,70,83,,,N,N,682,5291,1379,180,105,21,578,594,289,,,,706,516,3.2600000000,77,4,12,4275,1410,36,476,557,297,108,0.95,Cincinnati Reds,Palace of the Fans,300000,97,98,CIN,CIN,CIN
+1911,NL,NY1,SFG,,1,154,75,99,54,,,Y,N,756,5006,1399,225,103,41,530,506,347,,,,542,409,2.6900000000,95,19,13,4104,1267,33,369,771,251,86,0.96,New York Giants,Polo Grounds III/Polo Grounds IV,675000,103,99,NYG,NY1,NY1
+1911,NL,PHI,PHI,,4,153,76,79,73,,,N,N,658,5044,1307,214,56,60,490,588,153,,,,669,503,3.3000000000,90,20,10,4119,1285,43,598,697,231,113,0.96,Philadelphia Phillies,Baker Bowl,416000,101,101,PHI,PHI,PHI
+1911,NL,PIT,PIT,,3,155,78,85,69,,,N,N,744,5137,1345,206,106,49,525,583,160,,,,557,435,2.8400000000,91,13,11,4140,1249,36,375,605,231,131,0.96,Pittsburgh Pirates,Forbes Field,432000,104,101,PIT,PIT,PIT
+1911,NL,SLN,STL,,5,158,79,75,74,,,N,N,671,5132,1295,199,86,26,592,650,175,,,,745,573,3.6800000000,88,6,10,4206,1296,39,701,561,262,106,0.95,St. Louis Cardinals,Robison Field,447768,97,99,STL,SLN,SLN
+1912,AL,BOS,BOS,,1,154,78,105,47,,,Y,Y,799,5071,1404,269,84,29,565,,185,,,,544,418,2.7600000000,108,18,6,4086,1243,18,385,712,266,88,0.95,Boston Red Sox,Fenway Park I,597096,105,102,BOS,BOS,BOS
+1912,AL,CHA,CHW,,4,158,78,78,76,,,N,N,639,5182,1321,174,80,17,423,,205,,,,648,480,3.0600000000,85,14,16,4239,1398,26,426,698,289,102,0.95,Chicago White Sox,Comiskey Park,602241,97,97,CHW,CHA,CHA
+1912,AL,CLE,CLE,,5,155,77,75,78,,,N,N,677,5133,1403,219,77,12,407,,194,,,,681,496,3.3000000000,94,7,7,4056,1367,15,523,622,286,124,0.95,Cleveland Naps,League Park II,336844,103,103,CLE,CLE,CLE
+1912,AL,DET,DET,,6,154,76,69,84,,,N,N,720,5143,1376,189,86,19,530,,270,,,,777,573,3.7700000000,107,7,5,4101,1438,16,521,512,330,91,0.95,Detroit Tigers,Navin Field,402870,97,98,DET,DET,DET
+1912,AL,NYA,NYY,,8,153,76,50,102,,,N,N,630,5092,1320,168,79,18,463,,247,,,,842,613,4.1300000000,105,5,3,4005,1448,28,436,637,376,77,0.94,New York Highlanders,Hilltop Park,242194,106,108,NYY,NYA,NYA
+1912,AL,PHA,OAK,,3,153,77,90,62,,,N,N,779,5111,1442,204,108,22,485,,258,,,,658,501,3.3200000000,95,11,9,4071,1273,12,518,601,263,115,0.95,Philadelphia Athletics,Shibe Park,517653,97,93,PHA,PHA,PHA
+1912,AL,SLA,BAL,,7,157,79,53,101,,,N,N,552,5080,1262,166,71,19,449,,176,,,,764,564,3.7100000000,85,8,5,4107,1433,17,442,547,340,127,0.94,St. Louis Browns,Sportsman's Park IV,214070,96,100,SLB,SLA,SLA
+1912,AL,WS1,MIN,,2,154,78,91,61,,,N,N,699,5075,1298,202,86,20,472,,274,,,,581,411,2.6900000000,98,11,7,4128,1219,24,525,828,297,92,0.95,Washington Senators,Griffith Stadium I,350663,101,101,WSH,WS1,WS1
+1912,NL,BRO,LAD,,7,153,76,58,95,,,N,N,651,5141,1377,220,73,32,490,584,179,,,,754,549,3.6400000000,71,10,8,4071,1399,45,510,553,255,96,0.95,Brooklyn Dodgers,Washington Park III,243000,96,98,BRO,BRO,BRO
+1912,NL,BSN,ATL,,8,155,79,52,101,,,N,N,693,5361,1465,227,68,35,454,690,137,,,,861,644,4.1700000000,88,5,5,4170,1544,43,521,542,295,129,0.95,Boston Braves,South End Grounds III,121000,100,104,BSN,BSN,BSN
+1912,NL,CHN,CHC,,3,152,78,91,59,,,N,N,756,5048,1398,245,90,43,560,615,164,,,,668,516,3.4200000000,80,15,9,4074,1307,33,493,554,249,125,0.96,Chicago Cubs,West Side Park II,514000,100,97,CHC,CHN,CHN
+1912,NL,CIN,CIN,,4,155,77,75,78,,,N,N,656,5115,1310,183,89,21,479,492,248,,,,722,523,3.4200000000,86,13,10,4131,1455,28,452,561,247,102,0.96,Cincinnati Reds,Crosley Field,344000,97,99,CIN,CIN,CIN
+1912,NL,NY1,SFG,,1,154,76,103,48,,,Y,N,823,5067,1451,231,89,47,514,497,319,,,,571,392,2.5800000000,93,8,15,4107,1352,36,338,652,280,123,0.95,New York Giants,Polo Grounds IV,638000,104,100,NYG,NY1,NY1
+1912,NL,PHI,PHI,,5,152,75,73,79,,,N,N,670,5077,1354,244,68,43,464,615,159,,,,688,489,3.2500000000,81,10,9,4065,1381,43,515,616,231,98,0.96,Philadelphia Phillies,Baker Bowl,250000,106,106,PHI,PHI,PHI
+1912,NL,PIT,PIT,,2,152,75,93,58,,,N,N,751,5252,1493,222,129,39,420,514,177,,,,565,439,2.8500000000,94,18,7,4155,1268,28,497,664,169,125,0.97,Pittsburgh Pirates,Forbes Field,384000,99,96,PIT,PIT,PIT
+1912,NL,SLN,STL,,6,153,77,63,90,,,N,N,659,5092,1366,190,77,27,508,620,193,,,,830,579,3.8500000000,61,6,12,4059,1466,31,560,487,272,113,0.95,St. Louis Cardinals,Robison Field,241759,98,101,STL,SLN,SLN
+1913,AL,BOS,BOS,,4,151,75,79,71,,,N,N,631,4965,1334,220,101,17,466,534,189,,,,610,444,2.9400000000,83,12,10,4074,1323,6,442,710,238,84,0.96,Boston Red Sox,Fenway Park I,437194,103,100,BOS,BOS,BOS
+1913,AL,CHA,CHW,,5,153,77,78,74,,,N,N,488,4822,1139,157,66,24,398,550,156,,,,498,352,2.3300000000,84,17,8,4080,1190,10,438,602,255,104,0.96,Chicago White Sox,Comiskey Park,644501,99,100,CHW,CHA,CHA
+1913,AL,CLE,CLE,,3,155,80,86,66,,,N,N,633,5031,1349,206,74,16,420,557,191,,,,536,391,2.5400000000,93,18,5,4158,1278,19,502,689,242,124,0.96,Cleveland Naps,League Park II,541000,103,103,CLE,CLE,CLE
+1913,AL,DET,DET,,6,153,76,66,87,,,N,N,624,5064,1344,180,101,24,496,501,218,,,,716,511,3.3800000000,90,4,7,4080,1359,13,504,468,297,105,0.95,Detroit Tigers,Navin Field,398502,99,99,DET,DET,DET
+1913,AL,NYA,NYY,,7,153,75,57,94,,,N,N,529,4880,1157,155,45,8,534,617,203,,,,668,488,3.2700000000,75,8,7,4032,1318,31,455,530,286,94,0.95,New York Yankees,Polo Grounds IV,357551,100,102,NYY,NYA,NYA
+1913,AL,PHA,OAK,,1,153,76,96,57,,,Y,Y,794,5044,1412,223,80,33,534,547,221,,,,592,479,3.1900000000,69,17,22,4053,1200,24,532,630,212,108,0.96,Philadelphia Athletics,Shibe Park,571896,98,94,PHA,PHA,PHA
+1913,AL,SLA,BAL,,8,155,77,57,96,,,N,N,528,5031,1193,179,73,18,455,769,209,,,,642,470,3.0600000000,104,14,5,4146,1369,21,454,476,301,125,0.95,St. Louis Browns,Sportsman's Park IV,250330,97,100,SLB,SLA,SLA
+1913,AL,WS1,MIN,,2,155,78,90,64,,,N,N,596,5074,1281,156,81,19,440,595,287,,,,561,423,2.7300000000,78,23,20,4188,1177,35,465,758,262,122,0.96,Washington Senators,Griffith Stadium I,325831,102,101,WSH,WS1,WS1
+1913,NL,BRO,LAD,,6,152,77,65,84,,,N,N,595,5165,1394,193,86,39,361,555,188,,,,613,477,3.1300000000,71,9,7,4119,1287,33,439,548,243,125,0.96,Brooklyn Superbas,Ebbets Field,347000,103,103,BRO,BRO,BRO
+1913,NL,BSN,ATL,,5,154,77,69,82,,,N,N,641,5145,1318,191,60,32,488,640,177,,,,690,487,3.1900000000,105,13,3,4119,1343,37,419,597,273,82,0.95,Boston Braves,South End Grounds III,208000,100,102,BSN,BSN,BSN
+1913,NL,CHN,CHC,,3,155,76,88,65,,,N,N,720,5022,1289,195,96,59,554,634,181,,,,630,477,3.1300000000,89,12,15,4116,1330,39,478,556,260,106,0.95,Chicago Cubs,West Side Park II,419000,100,99,CHC,CHN,CHN
+1913,NL,CIN,CIN,,7,156,78,64,89,,,N,N,607,5132,1339,170,96,27,458,579,226,,,,717,531,3.4600000000,71,10,10,4140,1398,40,456,522,251,104,0.96,Cincinnati Reds,Crosley Field,258000,100,101,CIN,CIN,CIN
+1913,NL,NY1,SFG,,1,156,81,101,51,,,Y,N,684,5218,1427,226,71,30,444,501,296,,,,515,382,2.4200000000,82,12,17,4266,1276,38,315,651,252,107,0.96,New York Giants,Polo Grounds IV,630000,101,98,NYG,NY1,NY1
+1913,NL,PHI,PHI,,2,159,78,88,63,,,N,N,693,5400,1433,257,78,73,383,578,156,,,,636,509,3.1500000000,77,20,11,4365,1407,40,512,667,213,112,0.96,Philadelphia Phillies,Baker Bowl,470000,104,104,PHI,PHI,PHI
+1913,NL,PIT,PIT,,4,155,79,78,71,,,N,N,673,5252,1383,210,86,35,391,545,181,,,,585,451,2.9000000000,74,9,7,4200,1344,26,434,590,226,94,0.96,Pittsburgh Pirates,Forbes Field,296000,96,94,PIT,PIT,PIT
+1913,NL,SLN,STL,,8,153,74,51,99,,,N,N,528,4967,1229,152,72,15,451,573,171,,,,755,635,4.2300000000,74,6,11,4053,1426,57,477,465,219,113,0.96,St. Louis Cardinals,Robison Field,203531,98,101,STL,SLN,SLN
+1914,AL,BOS,BOS,,2,159,79,91,62,,,N,N,589,5117,1278,226,85,18,490,549,177,176,,,510,374,2.3600000000,88,24,8,4281,1207,18,393,602,242,99,0.96,Boston Red Sox,Fenway Park I,481359,100,98,BOS,BOS,BOS
+1914,AL,CHA,CHW,,6,157,81,70,84,,,N,N,487,5040,1205,161,71,19,408,609,167,152,,,560,385,2.4800000000,74,17,11,4194,1207,15,401,660,288,90,0.95,Chicago White Sox,Comiskey Park,469290,99,98,CHW,CHA,CHA
+1914,AL,CLE,CLE,,8,157,79,51,102,,,N,N,538,5157,1262,178,70,10,450,685,167,157,,,709,496,3.2100000000,69,9,3,4173,1365,10,666,688,298,119,0.95,Cleveland Naps,League Park II,185997,104,105,CLE,CLE,CLE
+1914,AL,DET,DET,,4,157,78,80,73,,,N,N,615,5102,1318,195,84,25,557,537,211,154,,,618,449,2.8600000000,81,14,12,4236,1285,17,498,567,285,101,0.95,Detroit Tigers,Navin Field,416225,103,102,DET,DET,DET
+1914,AL,NYA,NYY,,6,157,78,70,84,,,N,N,537,4992,1144,149,52,12,577,711,251,191,,,550,436,2.8100000000,98,9,5,4191,1277,30,390,563,223,93,0.96,New York Yankees,Polo Grounds IV,359477,100,101,NYY,NYA,NYA
+1914,AL,PHA,OAK,,1,158,78,99,53,,,Y,N,749,5126,1392,165,80,29,545,517,231,188,,,529,434,2.7800000000,89,24,17,4212,1264,18,521,720,213,116,0.96,Philadelphia Athletics,Shibe Park,346641,96,95,PHA,PHA,PHA
+1914,AL,SLA,BAL,,5,159,81,71,82,,,N,N,523,5101,1241,185,75,17,423,863,233,189,,,615,446,2.8500000000,81,15,11,4230,1309,20,540,553,317,114,0.95,St. Louis Browns,Sportsman's Park IV,244714,96,99,SLB,SLA,SLA
+1914,AL,WS1,MIN,,3,158,77,81,73,,,N,N,572,5108,1245,176,81,18,470,640,220,163,,,519,401,2.5400000000,75,25,20,4260,1170,20,520,784,252,116,0.96,Washington Senators,Griffith Stadium I,243888,104,103,WSH,WS1,WS1
+1914,FL,BLF,BLT,,3,160,,84,70,,,N,,645,5120,1374,222,67,32,487,589,152,,,,628,484,3.1300000000,88,15,13,4176,1389,34,392,732,259,105,0.96,Baltimore Terrapins,,,103,105,BAL,BLF,BLF
+1914,FL,BRF,BTT,,5,157,,77,77,,,N,,662,5221,1402,225,85,42,404,665,220,,,,677,512,3.3300000000,91,11,9,4155,1375,31,559,636,282,120,0.95,Brooklyn Tip-Tops,,,99,100,BTT,BRF,BRF
+1914,FL,BUF,BFL,,4,155,,80,71,,,N,,620,5064,1264,177,74,38,430,761,228,,,,602,487,3.1600000000,89,15,16,4161,1249,45,505,662,242,109,0.96,Buffalo Buffeds,,,102,103,BUF,BUF,BUF
+1914,FL,CHF,CHH,,2,157,,87,67,,,N,,621,5098,1314,227,50,52,520,645,171,,,,517,385,2.4400000000,93,17,8,4260,1204,43,393,650,249,113,0.96,Chicago Chi-Feds,Wrigley Field,,94,92,CHI,CHF,CHF
+1914,FL,IND,NEW,,1,157,,88,65,,,Y,,762,5176,1474,230,90,33,470,641,273,,,,622,475,3.0600000000,104,15,9,4191,1352,29,476,664,275,113,0.95,Indianapolis Hoosiers,,,111,108,IND,IND,IND
+1914,FL,KCF,KCP,,6,154,,67,84,,,N,,644,5127,1369,226,77,39,399,621,171,,,,683,516,3.4100000000,82,10,12,4083,1387,37,445,600,279,135,0.95,Kansas City Packers,,,97,97,KCP,KCF,KCF
+1914,FL,PTF,PBS,,7,154,,64,86,,,N,,605,5114,1339,180,90,34,410,575,153,,,,698,542,3.5600000000,97,9,6,4110,1416,39,444,510,253,92,0.96,Pittsburgh Rebels,,,99,99,PBS,PTF,PTF
+1914,FL,SLF,SLI,,8,154,,62,89,,,N,,565,5078,1254,193,65,26,503,662,113,,,,697,545,3.5900000000,97,9,6,4101,1418,38,409,661,269,94,0.95,St. Louis Terriers,,,105,105,SLM,SLF,SLF
+1914,NL,BRO,LAD,,5,154,79,75,79,,,N,N,622,5152,1386,172,90,31,376,559,173,,,,618,429,2.8200000000,80,11,11,4104,1282,36,466,605,248,112,0.96,Brooklyn Robins,Ebbets Field,122671,102,102,BRO,BRO,BRO
+1914,NL,BSN,ATL,,1,158,79,94,59,,,Y,Y,657,5206,1307,213,60,35,502,617,139,,,,548,433,2.7400000000,104,19,6,4263,1272,38,477,606,237,143,0.96,Boston Braves,South End Grounds III,382913,104,102,BSN,BSN,BSN
+1914,NL,CHN,CHC,,4,156,76,78,76,,,N,N,605,5050,1229,199,74,42,501,577,164,,,,638,418,2.7100000000,70,14,11,4167,1169,37,528,651,310,87,0.95,Chicago Cubs,West Side Park II,202516,100,100,CHC,CHN,CHN
+1914,NL,CIN,CIN,,8,157,77,60,94,,,N,N,530,4991,1178,142,64,16,441,627,224,,,,651,453,2.9400000000,74,15,15,4161,1259,30,489,607,314,113,0.95,Cincinnati Reds,Crosley Field,100791,103,105,CIN,CIN,CIN
+1914,NL,NY1,SFG,,2,156,80,84,70,,,N,N,672,5146,1363,222,59,30,447,479,239,,,,576,454,2.9400000000,88,20,9,4170,1298,47,367,563,253,119,0.96,New York Giants,Polo Grounds IV,364313,97,95,NYG,NY1,NY1
+1914,NL,PHI,PHI,,6,154,78,74,80,,,N,N,651,5110,1345,211,52,62,472,570,145,,,,687,469,3.0600000000,85,14,7,4137,1403,26,452,650,324,81,0.95,Philadelphia Phillies,Baker Bowl,138474,106,105,PHI,PHI,PHI
+1914,NL,PIT,PIT,,7,158,77,69,85,,,N,N,503,5145,1197,148,79,18,416,608,147,,,,540,422,2.7000000000,86,10,11,4215,1272,27,392,488,223,96,0.96,Pittsburgh Pirates,Forbes Field,139620,96,95,PIT,PIT,PIT
+1914,NL,SLN,STL,,3,157,79,81,72,,,N,N,558,5046,1249,203,65,33,445,618,204,,,,540,377,2.3800000000,84,16,12,4272,1279,26,422,531,239,109,0.96,St. Louis Cardinals,Robison Field,256099,99,100,STL,SLN,SLN
+1915,AL,BOS,BOS,,1,155,76,101,50,,,Y,Y,669,5024,1308,202,76,14,527,476,118,117,,,499,371,2.3900000000,81,19,15,4191,1164,18,446,634,226,95,0.96,Boston Red Sox,Fenway Park I,539885,97,95,BOS,BOS,BOS
+1915,AL,CHA,CHW,,3,155,79,93,61,,,N,N,717,4914,1269,163,102,25,583,575,233,183,,,509,378,2.4300000000,91,16,9,4203,1242,14,350,635,222,95,0.96,Chicago White Sox,Comiskey Park,539461,103,102,CHW,CHA,CHA
+1915,AL,CLE,CLE,,7,154,77,57,95,,,N,N,539,5034,1210,169,79,20,490,681,138,117,,,670,477,3.1300000000,62,11,10,4116,1287,18,518,610,272,82,0.95,Cleveland Indians,League Park II,159285,102,104,CLE,CLE,CLE
+1915,AL,DET,DET,,2,156,77,100,54,,,N,N,778,5128,1372,207,94,23,681,527,241,146,,,597,449,2.8600000000,86,10,19,4239,1259,14,492,550,258,107,0.96,Detroit Tigers,Navin Field,476105,105,103,DET,DET,DET
+1915,AL,NYA,NYY,,5,154,82,69,83,,,N,N,584,4982,1162,167,50,31,570,669,198,133,,,588,470,3.0600000000,101,12,2,4146,1272,41,517,559,215,118,0.96,New York Yankees,Polo Grounds IV,256035,100,100,NYY,NYA,NYA
+1915,AL,PHA,OAK,,8,154,74,43,109,,,N,N,545,5081,1204,183,72,16,436,634,127,89,,,888,643,4.2900000000,78,6,2,4044,1358,22,827,588,338,118,0.94,Philadelphia Athletics,Shibe Park,146223,96,99,PHA,PHA,PHA
+1915,AL,SLA,BAL,,6,159,76,63,91,,,N,N,521,5112,1255,166,65,19,472,765,202,160,,,680,474,3.0400000000,76,6,7,4209,1256,21,612,566,336,144,0.94,St. Louis Browns,Sportsman's Park IV,150358,96,98,SLB,SLA,SLA
+1915,AL,WS1,MIN,,4,155,80,85,68,,,N,N,569,5029,1225,152,79,12,458,541,186,106,,,491,358,2.3100000000,87,21,13,4179,1161,12,455,715,230,101,0.96,Washington Senators,Griffith Stadium I,167332,102,101,WSH,WS1,WS1
+1915,FL,BLF,BLT,,8,154,,47,107,,,N,,550,5060,1235,196,53,36,470,641,128,,,,760,598,3.9600000000,85,5,7,4080,1455,52,466,570,273,140,0.95,Baltimore Terrapins,,,103,105,BAL,BLF,BLF
+1915,FL,BRF,BTT,,7,153,,70,82,,,N,,647,5035,1348,205,75,36,473,654,249,,,,673,507,3.3700000000,78,10,16,4065,1299,27,536,467,285,103,0.95,Brooklyn Tip-Tops,,,99,100,BTT,BRF,BRF
+1915,FL,BUF,BFL,,6,153,,74,78,,,N,,574,5065,1261,193,68,40,420,587,184,,,,634,511,3.3800000000,79,14,11,4080,1271,35,553,594,232,112,0.96,Buffalo Blues,,,102,103,BUF,BUF,BUF
+1915,FL,CHF,CHH,,2,155,,86,66,,,Y,,640,5133,1320,185,77,50,444,590,161,,,,538,410,2.6400000000,97,21,10,4191,1232,33,402,576,227,102,0.96,Chicago Whales,Wrigley Field,,94,92,CHI,CHF,CHF
+1915,FL,KCF,KCP,,4,153,,81,72,,,N,,547,4937,1206,200,66,28,368,503,144,,,,551,426,2.8200000000,95,16,11,4077,1210,29,390,526,246,96,0.96,Kansas City Packers,,,97,97,KCP,KCF,KCF
+1915,FL,NEW,NEW,,5,155,,80,72,,,N,,585,5097,1283,210,80,17,438,550,184,,,,562,406,2.6000000000,100,16,7,4218,1308,15,453,581,239,124,0.96,Newark Pepper,,,94,94,NEW,NEW,NEW
+1915,FL,PTF,PBS,,3,156,,86,67,,,N,,592,5040,1318,180,80,20,448,561,224,,,,524,428,2.7900000000,88,16,12,4146,1273,37,441,517,174,98,0.97,Pittsburgh Rebels,,,99,99,PBS,PTF,PTF
+1915,FL,SLF,SLI,,1,159,,87,67,,,N,,634,5145,1344,199,81,23,576,502,195,,,,527,433,2.7300000000,94,24,9,4278,1267,22,396,698,207,111,0.96,St. Louis Terriers,,,105,105,SLM,SLF,SLF
+1915,NL,BRO,LAD,,3,154,78,80,72,,,N,N,536,5120,1268,165,75,14,313,496,131,126,,,560,411,2.6600000000,87,16,8,4167,1252,29,473,499,238,96,0.96,Brooklyn Robins,Ebbets Field,297766,102,101,BRO,BRO,BRO
+1915,NL,BSN,ATL,,2,157,78,83,69,,,N,N,582,5070,1219,231,57,17,549,620,121,98,,,545,401,2.5700000000,95,17,13,4215,1257,23,366,630,213,115,0.96,Boston Braves,Fenway Park I / Braves Field,376283,98,97,BSN,BSN,BSN
+1915,NL,CHN,CHC,,4,156,77,73,80,,,N,N,570,5114,1246,212,66,53,393,639,166,124,,,620,483,3.1100000000,71,18,8,4197,1272,28,480,657,268,94,0.95,Chicago Cubs,West Side Park II,217058,100,101,CHC,CHN,CHN
+1915,NL,CIN,CIN,,7,160,79,71,83,,,N,N,516,5231,1323,194,84,15,360,512,156,142,,,585,452,2.8400000000,80,19,12,4296,1304,28,497,572,224,148,0.96,Cincinnati Reds,Crosley Field,218878,102,104,CIN,CIN,CIN
+1915,NL,NY1,SFG,,8,155,76,69,83,,,N,N,582,5218,1312,195,68,24,315,547,155,137,,,628,479,3.1100000000,78,15,9,4155,1350,40,325,637,256,119,0.96,New York Giants,Polo Grounds IV,391850,94,93,NYG,NY1,NY1
+1915,NL,PHI,PHI,,1,153,76,90,62,,,Y,N,589,4916,1216,202,39,58,460,600,121,113,,,463,331,2.1700000000,98,20,8,4122,1161,26,342,652,216,99,0.96,Philadelphia Phillies,Baker Bowl,449898,101,100,PHI,PHI,PHI
+1915,NL,PIT,PIT,,5,156,79,73,81,,,N,N,557,5113,1259,197,91,24,419,656,182,111,,,520,399,2.6000000000,91,18,11,4140,1229,21,384,544,214,100,0.96,Pittsburgh Pirates,Forbes Field,225743,99,99,PIT,PIT,PIT
+1915,NL,SLN,STL,,6,157,81,72,81,,,N,N,590,5106,1297,159,92,20,457,658,162,144,,,601,450,2.8900000000,79,13,9,4200,1320,30,402,538,235,109,0.96,St. Louis Cardinals,Robison Field,252666,100,101,STL,SLN,SLN
+1916,AL,BOS,BOS,,1,156,78,91,63,,,Y,Y,550,5018,1246,197,56,14,464,482,129,,,,480,389,2.4800000000,76,24,16,4230,1221,10,463,584,183,108,0.97,Boston Red Sox,Fenway Park I,496397,101,98,BOS,BOS,BOS
+1916,AL,CHA,CHW,,2,155,77,89,65,,,N,N,601,5081,1277,194,100,17,447,591,197,,,,497,370,2.3600000000,73,20,15,4236,1189,14,405,644,205,134,0.96,Chicago White Sox,Comiskey Park,679923,101,98,CHW,CHA,CHA
+1916,AL,CLE,CLE,,6,157,78,77,77,,,N,N,630,5064,1264,233,66,16,522,605,160,,,,602,454,2.9000000000,65,9,16,4230,1383,16,467,537,232,130,0.96,Cleveland Indians,League Park II,492106,106,106,CLE,CLE,CLE
+1916,AL,DET,DET,,3,155,77,87,67,,,N,N,670,5193,1371,202,96,17,545,529,190,,,,595,465,2.9700000000,81,8,13,4230,1254,12,578,531,211,110,0.96,Detroit Tigers,Navin Field,616772,104,101,DET,DET,DET
+1916,AL,NYA,NYY,,4,156,79,80,74,,,N,N,577,5198,1277,194,59,35,516,632,179,,,,561,440,2.7700000000,84,12,17,4284,1249,37,476,616,219,119,0.96,New York Yankees,Polo Grounds IV,469211,102,102,NYY,NYA,NYA
+1916,AL,PHA,OAK,,8,154,76,36,117,,,N,N,447,5010,1212,169,65,19,406,631,151,,,,776,585,3.9200000000,94,11,3,4029,1311,26,715,575,312,126,0.95,Philadelphia Athletics,Shibe Park,184471,95,101,PHA,PHA,PHA
+1916,AL,SLA,BAL,,5,158,79,79,75,,,N,N,588,5159,1262,181,50,14,627,640,234,,,,545,414,2.5800000000,74,9,13,4329,1292,15,478,505,248,120,0.96,St. Louis Browns,Sportsman's Park IV,335740,95,97,SLB,SLA,SLA
+1916,AL,WS1,MIN,,7,159,81,76,77,,,N,N,536,5114,1238,170,60,12,535,597,185,,,,543,424,2.6700000000,85,11,7,4290,1271,14,490,706,232,119,0.96,Washington Senators,Griffith Stadium I,177265,99,99,WSH,WS1,WS1
+1916,NL,BRO,LAD,,1,156,78,94,60,,,Y,N,585,5234,1366,195,80,28,355,550,187,,,,471,336,2.1200000000,96,22,9,4281,1201,24,372,634,224,90,0.96,Brooklyn Robins,Ebbets Field,447747,103,102,BRO,BRO,BRO
+1916,NL,BSN,ATL,,3,158,78,89,63,,,N,N,542,5075,1181,166,73,22,437,646,141,,,,453,344,2.1900000000,97,23,11,4245,1206,24,325,644,212,124,0.96,Boston Braves,Braves Field,313495,95,94,BSN,BSN,BSN
+1916,NL,CHN,CHC,,5,156,79,67,86,,,N,N,520,5179,1237,194,56,46,399,662,133,,,,541,417,2.6500000000,72,17,13,4248,1265,32,365,616,277,104,0.95,Chicago Cubs,Wrigley Field,453685,110,111,CHC,CHN,CHN
+1916,NL,CIN,CIN,,7,155,76,60,93,,,N,N,505,5254,1336,187,88,14,362,573,157,,,,617,485,3.1000000000,86,7,6,4224,1356,35,461,569,228,126,0.96,Cincinnati Reds,Crosley Field,255846,98,99,CIN,CIN,CIN
+1916,NL,NY1,SFG,,4,155,78,86,66,,,N,N,597,5152,1305,188,74,42,356,558,206,,,,504,404,2.6000000000,88,22,12,4191,1267,41,310,638,217,108,0.96,New York Giants,Polo Grounds IV,552056,95,93,NYG,NY1,NY1
+1916,NL,PHI,PHI,,2,154,79,91,62,,,N,N,581,4985,1244,223,53,42,399,571,149,,,,489,362,2.3600000000,97,25,9,4146,1238,28,295,601,234,119,0.96,Philadelphia Phillies,Baker Bowl,515365,104,101,PHI,PHI,PHI
+1916,NL,PIT,PIT,,6,157,78,65,89,,,N,N,484,5181,1246,147,91,20,372,618,173,,,,586,435,2.7600000000,88,11,7,4257,1277,24,443,596,260,97,0.95,Pittsburgh Pirates,Forbes Field,289132,101,102,PIT,PIT,PIT
+1916,NL,SLN,STL,,7,153,76,60,93,,,N,N,476,5030,1223,155,74,25,335,651,182,,,,629,473,3.1400000000,58,13,15,4065,1331,31,445,529,273,124,0.95,St. Louis Cardinals,Robison Field,224308,99,101,STL,SLN,SLN
+1917,AL,BOS,BOS,,2,157,80,90,62,,,N,N,555,5048,1243,198,64,14,466,473,105,,,,454,347,2.2000000000,115,15,7,4263,1197,12,413,509,183,116,0.97,Boston Red Sox,Fenway Park I,387856,99,97,BOS,BOS,BOS
+1917,AL,CHA,CHW,,1,156,79,100,54,,,Y,Y,656,5057,1281,152,81,18,522,479,219,,,,464,342,2.1600000000,78,22,21,4272,1236,10,413,517,200,117,0.96,Chicago White Sox,Comiskey Park,684521,102,100,CHW,CHA,CHA
+1917,AL,CLE,CLE,,3,156,78,88,66,,,N,N,584,4994,1224,218,64,13,549,596,210,,,,543,395,2.5200000000,73,20,22,4236,1270,17,438,451,242,136,0.96,Cleveland Indians,League Park II,477298,107,106,CLE,CLE,CLE
+1917,AL,DET,DET,,4,154,76,78,75,,,N,N,639,5093,1317,204,77,25,483,476,163,,,,577,397,2.5600000000,78,20,15,4188,1209,12,504,516,234,95,0.96,Detroit Tigers,Navin Field,457289,100,99,DET,DET,DET
+1917,AL,NYA,NYY,,6,155,75,71,82,,,N,N,524,5136,1226,172,52,27,496,535,136,,,,558,417,2.6600000000,87,10,6,4233,1280,28,427,571,225,129,0.96,New York Yankees,Polo Grounds IV,330294,101,101,NYY,NYA,NYA
+1917,AL,PHA,OAK,,8,154,76,55,98,,,N,N,529,5109,1296,177,62,17,435,519,112,,,,691,496,3.2700000000,80,8,8,4095,1310,23,562,516,251,106,0.96,Philadelphia Athletics,Shibe Park,221432,98,103,PHA,PHA,PHA
+1917,AL,SLA,BAL,,7,155,78,57,97,,,N,N,510,5091,1250,183,63,15,405,540,157,,,,687,492,3.2000000000,66,12,12,4155,1320,19,537,429,281,139,0.95,St. Louis Browns,Sportsman's Park IV,210486,96,98,SLB,SLA,SLA
+1917,AL,WS1,MIN,,5,157,80,74,79,,,N,N,543,5142,1238,173,70,4,500,574,166,,,,566,432,2.7500000000,84,21,10,4239,1217,12,537,637,251,127,0.96,Washington Senators,Griffith Stadium I,89682,99,99,WSH,WS1,WS1
+1917,NL,BRO,LAD,,7,156,78,70,81,,,N,N,511,5251,1299,159,78,25,334,527,130,,,,559,439,2.7800000000,99,8,9,4263,1288,32,405,582,245,102,0.96,Brooklyn Robins,Ebbets Field,221619,103,103,BRO,BRO,BRO
+1917,NL,BSN,ATL,,6,157,77,72,81,,,N,N,536,5201,1280,169,75,22,427,587,155,,,,552,438,2.7700000000,105,22,3,4272,1309,19,371,593,224,122,0.96,Boston Braves,Braves Field,174253,94,94,BSN,BSN,BSN
+1917,NL,CHN,CHC,,5,157,77,74,80,,,N,N,552,5135,1229,194,67,17,415,599,127,,,,567,409,2.6200000000,79,16,9,4212,1303,34,374,654,267,121,0.95,Chicago Cubs,Wrigley Field,360218,108,107,CHC,CHN,CHN
+1917,NL,CIN,CIN,,4,157,80,78,76,,,N,N,601,5251,1385,196,100,26,312,477,153,,,,611,419,2.7000000000,94,12,6,4191,1358,20,402,488,247,120,0.96,Cincinnati Reds,Crosley Field,269056,96,97,CIN,CIN,CIN
+1917,NL,NY1,SFG,,1,158,80,98,56,,,Y,N,635,5211,1360,170,71,39,373,533,162,,,,457,360,2.2700000000,92,18,14,4278,1221,29,327,551,208,122,0.96,New York Giants,Polo Grounds IV,500264,97,94,NYG,NY1,NY1
+1917,NL,PHI,PHI,,2,154,76,87,65,,,N,N,578,5084,1262,225,60,38,435,533,109,,,,500,380,2.4600000000,102,22,5,4167,1258,25,325,616,212,112,0.96,Philadelphia Phillies,Baker Bowl,354428,104,104,PHI,PHI,PHI
+1917,NL,PIT,PIT,,8,157,79,51,103,,,N,N,464,5169,1230,160,61,9,399,580,150,,,,595,474,3.0100000000,84,17,6,4251,1318,14,432,509,251,119,0.96,Pittsburgh Pirates,Forbes Field,192807,103,105,PIT,PIT,PIT
+1917,NL,SLN,STL,,3,154,78,82,70,,,N,N,531,5083,1271,159,93,26,359,652,159,,,,567,469,3.0300000000,66,16,10,4176,1257,29,421,502,221,153,0.96,St. Louis Cardinals,Robison Field,288491,97,99,STL,SLN,SLN
+1918,AL,BOS,BOS,,1,126,70,75,51,,,Y,Y,474,3982,990,159,54,15,406,324,110,,,,380,287,2.3100000000,105,26,2,3360,931,9,380,392,152,89,0.97,Boston Red Sox,Fenway Park I,249513,98,97,BOS,BOS,BOS
+1918,AL,CHA,CHW,,6,124,56,57,67,,,N,N,457,4132,1057,136,55,8,375,358,116,,,,446,342,2.7300000000,76,9,8,3378,1092,9,300,349,167,98,0.96,Chicago White Sox,Comiskey Park,195081,101,98,CHW,CHA,CHA
+1918,AL,CLE,CLE,,2,129,62,73,54,,,N,N,504,4166,1084,176,67,9,491,386,165,,,,447,341,2.6400000000,78,5,13,3483,1126,9,343,364,207,82,0.96,Cleveland Indians,League Park II,295515,109,108,CLE,CLE,CLE
+1918,AL,DET,DET,,7,128,58,55,71,,,N,N,476,4262,1063,141,56,13,452,380,123,,,,557,438,3.4000000000,74,8,7,3480,1130,10,437,374,212,77,0.96,Detroit Tigers,Navin Field,203719,96,96,DET,DET,DET
+1918,AL,NYA,NYY,,4,126,67,60,63,,,N,N,493,4224,1085,160,45,20,367,370,88,,,,475,386,3.0000000000,59,8,13,3471,1103,25,463,370,161,137,0.97,New York Yankees,Polo Grounds IV,282047,102,102,NYY,NYA,NYA
+1918,AL,PHA,OAK,,8,130,68,52,76,,,N,N,412,4278,1039,124,44,22,343,485,83,,,,538,414,3.2200000000,80,13,9,3468,1106,13,486,277,228,136,0.95,Philadelphia Athletics,Shibe Park,177926,101,105,PHA,PHA,PHA
+1918,AL,SLA,BAL,,5,123,53,58,64,,,N,N,426,4019,1040,152,40,5,397,340,138,,,,448,339,2.7500000000,67,8,8,3333,993,11,402,346,190,86,0.96,St. Louis Browns,Sportsman's Park IV,122076,97,99,SLB,SLA,SLA
+1918,AL,WS1,MIN,,3,130,74,72,56,,,N,N,461,4472,1144,156,49,4,376,361,137,,,,412,292,2.1400000000,75,19,8,3684,1021,10,395,505,226,95,0.96,Washington Senators,Griffith Stadium I,182122,99,98,WSH,WS1,WS1
+1918,NL,BRO,LAD,,5,126,54,57,69,,,N,N,360,4212,1052,121,62,10,212,326,113,,,,463,353,2.8100000000,85,17,2,3393,1024,22,320,395,193,74,0.96,Brooklyn Robins,Ebbets Field,83831,100,101,BRO,BRO,BRO
+1918,NL,BSN,ATL,,7,124,52,53,71,,,N,N,424,4162,1014,107,59,13,350,438,83,,,,469,360,2.9000000000,96,13,0,3351,1111,14,277,340,184,89,0.96,Boston Braves,Braves Field,84938,96,97,BSN,BSN,BSN
+1918,NL,CHN,CHC,,1,131,74,84,45,,,Y,N,538,4325,1147,164,53,21,358,343,159,,,,393,290,2.1800000000,92,23,8,3591,1050,13,296,472,188,91,0.96,Chicago Cubs,Wrigley Field,337256,102,101,CHC,CHN,CHN
+1918,NL,CIN,CIN,,3,129,71,68,60,,,N,N,530,4265,1185,165,84,15,304,303,128,,,,496,381,3.0000000000,84,14,6,3426,1136,19,381,321,192,127,0.96,Cincinnati Reds,Crosley Field,163009,98,97,CIN,CIN,CIN
+1918,NL,NY1,SFG,,2,124,56,71,53,,,N,N,480,4164,1081,150,53,13,271,365,130,,,,415,326,2.6400000000,74,18,11,3333,1002,20,228,330,152,78,0.97,New York Giants,Polo Grounds IV,256618,98,95,NYG,NY1,NY1
+1918,NL,PHI,PHI,,6,125,57,55,68,,,N,N,430,4192,1022,158,28,25,346,400,97,,,,507,399,3.1500000000,78,10,6,3417,1086,22,369,312,211,91,0.96,Philadelphia Phillies,Baker Bowl,122266,107,108,PHI,PHI,PHI
+1918,NL,PIT,PIT,,4,126,71,65,60,,,N,N,466,4091,1016,107,72,15,371,285,200,,,,412,314,2.4800000000,85,10,7,3420,1005,13,299,367,179,108,0.96,Pittsburgh Pirates,Forbes Field,213610,103,104,PIT,PIT,PIT
+1918,NL,SLN,STL,,8,131,73,51,78,,,N,N,454,4369,1066,147,64,27,329,461,119,,,,527,392,2.9600000000,72,3,5,3579,1148,16,352,361,220,116,0.96,St. Louis Cardinals,Robison Field,110599,97,98,STL,SLN,SLN
+1919,AL,BOS,BOS,,6,138,66,66,71,,,N,N,564,4548,1188,181,49,33,471,411,108,,,,552,450,3.3100000000,89,15,8,3672,1251,16,421,381,143,118,0.97,Boston Red Sox,Fenway Park I,417291,94,94,BOS,BOS,BOS
+1919,AL,CHA,CHW,,1,140,70,88,52,,,Y,N,667,4675,1343,218,70,25,427,358,150,,,,534,427,3.0400000000,88,14,3,3795,1245,24,342,468,173,116,0.96,Chicago White Sox,Comiskey Park,627186,100,99,CHW,CHA,CHA
+1919,AL,CLE,CLE,,2,139,69,84,55,,,N,N,636,4565,1268,254,72,24,498,367,113,,,,537,407,2.9400000000,80,10,10,3735,1242,19,362,432,201,102,0.96,Cleveland Indians,League Park II,538135,106,104,CLE,CLE,CLE
+1919,AL,DET,DET,,4,140,70,80,60,,,N,N,618,4665,1319,222,84,23,429,427,121,,,,578,461,3.3000000000,85,10,4,3768,1254,35,436,428,205,81,0.96,Detroit Tigers,Navin Field,643805,98,100,DET,DET,DET
+1919,AL,NYA,NYY,,3,141,73,80,59,,,N,N,578,4775,1275,193,49,45,386,479,101,,,,506,403,2.8200000000,85,14,7,3861,1143,47,433,500,193,108,0.96,New York Yankees,Polo Grounds IV,619164,101,99,NYY,NYA,NYA
+1919,AL,PHA,OAK,,8,140,70,36,104,,,N,N,457,4730,1156,175,71,35,349,565,103,,,,742,586,4.2600000000,72,1,3,3717,1371,44,503,417,257,96,0.95,Philadelphia Athletics,Shibe Park,225209,101,106,PHA,PHA,PHA
+1919,AL,SLA,BAL,,5,140,70,67,72,,,N,N,533,4672,1234,187,73,31,391,443,74,,,,567,437,3.1300000000,78,14,4,3768,1255,35,421,415,214,98,0.96,St. Louis Browns,Sportsman's Park IV,349350,102,103,SLB,SLA,SLA
+1919,AL,WS1,MIN,,7,142,72,56,84,,,N,N,533,4757,1238,177,63,24,416,511,142,,,,570,426,3.0100000000,68,13,10,3822,1237,20,451,536,227,86,0.96,Washington Senators,Griffith Stadium I,234096,99,99,WSH,WS1,WS1
+1919,NL,BRO,LAD,,5,141,70,69,71,,,N,N,525,4844,1272,167,66,25,258,405,112,,,,513,389,2.7300000000,98,12,1,3843,1256,21,292,476,218,84,0.96,Brooklyn Robins,Ebbets Field,360721,103,103,BRO,BRO,BRO
+1919,NL,BSN,ATL,,6,140,68,57,82,,,N,N,465,4746,1201,142,62,24,355,481,145,,,,563,447,3.1700000000,79,5,9,3810,1313,29,337,374,204,111,0.96,Boston Braves,Braves Field,167401,95,98,BSN,BSN,BSN
+1919,NL,CHN,CHC,,3,140,71,75,65,,,N,N,454,4581,1174,166,58,21,298,359,150,,,,407,311,2.2100000000,80,21,5,3795,1127,14,294,495,186,87,0.96,Chicago Cubs,Wrigley Field,424430,100,99,CHC,CHN,CHN
+1919,NL,CIN,CIN,,1,140,70,96,44,,,Y,Y,577,4577,1204,135,83,20,405,368,143,,,,401,316,2.2300000000,89,23,9,3822,1104,21,298,407,152,98,0.97,Cincinnati Reds,Crosley Field,532501,97,95,CIN,CIN,CIN
+1919,NL,NY1,SFG,,2,140,69,87,53,,,N,N,605,4664,1254,204,64,40,328,407,157,,,,470,377,2.7000000000,72,11,13,3768,1153,34,305,340,215,96,0.96,New York Giants,Polo Grounds IV,708857,100,97,NYG,NY1,NY1
+1919,NL,PHI,PHI,,8,138,71,47,90,,,N,N,510,4746,1191,208,50,42,323,469,114,,,,699,576,4.1400000000,93,6,2,3756,1391,40,408,397,219,112,0.96,Philadelphia Phillies,Baker Bowl,240424,107,111,PHI,PHI,PHI
+1919,NL,PIT,PIT,,4,139,70,71,68,,,N,N,472,4538,1132,130,82,17,344,381,196,,,,466,400,2.8800000000,91,17,4,3747,1113,23,263,391,160,89,0.96,Pittsburgh Pirates,Forbes Field,276810,104,103,PIT,PIT,PIT
+1919,NL,SLN,STL,,7,138,69,54,83,,,N,N,463,4588,1175,163,52,18,304,418,148,,,,552,437,3.2300000000,55,6,8,3651,1146,25,415,414,217,112,0.96,St. Louis Cardinals,Robison Field,167059,94,96,STL,SLN,SLN
+1920,AL,BOS,BOS,,5,154,76,72,81,,,N,N,650,5199,1397,216,71,22,533,429,98,111,,,698,592,3.8200000000,92,11,6,4185,1481,39,461,481,183,131,0.97,Boston Red Sox,Fenway Park I,402445,96,96,BOS,BOS,BOS
+1920,AL,CHA,CHW,,2,154,77,96,58,,,N,N,794,5328,1574,263,98,37,471,353,112,96,,,665,553,3.5900000000,109,9,10,4158,1467,45,405,438,194,142,0.96,Chicago White Sox,Comiskey Park,833492,99,99,CHW,CHA,CHA
+1920,AL,CLE,CLE,,1,154,78,98,56,,,Y,Y,857,5203,1574,300,95,35,574,379,73,92,,,642,522,3.4100000000,94,11,7,4131,1448,31,401,466,185,124,0.97,Cleveland Indians,League Park II,912832,104,101,CLE,CLE,CLE
+1920,AL,DET,DET,,7,155,78,61,93,,,N,N,652,5215,1408,228,72,30,479,391,76,66,,,833,622,4.0400000000,74,9,7,4155,1487,46,561,483,229,95,0.96,Detroit Tigers,Navin Field,579650,97,98,DET,DET,DET
+1920,AL,NYA,NYY,,3,154,77,95,59,,,N,N,838,5176,1448,268,71,115,539,626,64,82,,,629,505,3.3200000000,88,15,11,4104,1414,48,420,480,193,129,0.97,New York Yankees,Polo Grounds IV,1289422,104,101,NYY,NYA,NYA
+1920,AL,PHA,OAK,,8,156,77,48,106,,,N,N,558,5256,1324,220,49,44,353,593,50,67,,,834,603,3.9300000000,79,6,2,4140,1612,56,461,423,267,126,0.95,Philadelphia Athletics,Shibe Park,287888,101,106,PHA,PHA,PHA
+1920,AL,SLA,BAL,,4,154,78,76,77,,,N,N,797,5358,1651,279,83,50,427,339,118,79,,,766,617,4.0300000000,84,9,14,4134,1481,53,578,444,231,119,0.96,St. Louis Browns,Sportsman's Park IV,419311,103,103,SLB,SLA,SLA
+1920,AL,WS1,MIN,,6,153,76,68,84,,,N,N,723,5251,1526,233,81,36,433,543,161,114,,,802,633,4.1700000000,81,10,10,4101,1521,51,520,418,232,95,0.96,Washington Senators,Griffith Stadium I,359260,97,98,WSH,WS1,WS1
+1920,NL,BRO,LAD,,1,155,78,93,61,,,Y,N,660,5399,1493,205,99,28,359,391,70,80,,,528,415,2.6200000000,89,17,10,4281,1381,25,327,553,226,118,0.96,Brooklyn Robins,Ebbets Field,808722,104,103,BRO,BRO,BRO
+1920,NL,BSN,ATL,,7,153,74,62,90,,,N,N,523,5218,1358,168,86,23,385,488,88,98,,,670,545,3.5400000000,93,14,6,4158,1464,39,415,368,239,125,0.96,Boston Braves,Braves Field,162483,95,97,BSN,BSN,BSN
+1920,NL,CHN,CHC,,5,154,77,75,79,,,N,N,619,5117,1350,223,67,34,428,421,115,129,,,635,504,3.2700000000,95,13,9,4164,1459,37,382,508,225,112,0.96,Chicago Cubs,Wrigley Field,480783,101,102,CHC,CHN,CHN
+1920,NL,CIN,CIN,,3,154,77,82,71,,,N,N,639,5176,1432,169,76,18,382,367,158,128,,,569,448,2.9000000000,90,12,9,4173,1327,26,393,435,200,125,0.96,Cincinnati Reds,Crosley Field,568107,98,97,CIN,CIN,CIN
+1920,NL,NY1,SFG,,2,155,80,86,68,,,N,N,682,5309,1427,210,76,46,432,545,131,113,,,543,438,2.8000000000,86,18,9,4224,1379,44,297,380,209,137,0.96,New York Giants,Polo Grounds IV,929609,100,97,NYG,NY1,NY1
+1920,NL,PHI,PHI,,8,153,77,62,91,,,N,N,565,5264,1385,229,54,64,283,531,100,83,,,714,557,3.6300000000,77,8,11,4140,1480,35,444,419,232,135,0.96,Philadelphia Phillies,Baker Bowl,330998,104,109,PHI,PHI,PHI
+1920,NL,PIT,PIT,,4,155,78,79,75,,,N,N,530,5219,1342,162,90,16,374,405,181,117,,,552,454,2.8900000000,92,17,10,4245,1389,25,280,444,186,119,0.97,Pittsburgh Pirates,Forbes Field,429037,103,103,PIT,PIT,PIT
+1920,NL,SLN,STL,,5,155,76,75,79,,,N,N,675,5495,1589,238,96,32,373,484,126,114,,,682,543,3.4300000000,72,9,12,4278,1488,30,479,529,256,136,0.96,St. Louis Cardinals,Robison Field/Sportsman's Park IV,326836,98,98,STL,SLN,SLN
+1921,AL,BOS,BOS,,5,154,77,75,79,,,N,N,668,5206,1440,248,69,17,428,344,83,65,,,696,603,3.9800000000,88,9,5,4092,1521,53,452,446,157,151,0.97,Boston Red Sox,Fenway Park I,279273,97,99,BOS,BOS,BOS
+1921,AL,CHA,CHW,,7,154,77,62,92,,,N,N,683,5329,1509,242,82,35,445,474,97,93,,,858,749,4.9400000000,84,7,9,4095,1603,52,549,392,199,155,0.96,Chicago White Sox,Comiskey Park,543650,98,98,CHW,CHA,CHA
+1921,AL,CLE,CLE,,2,154,77,94,60,,,N,N,925,5383,1656,355,90,42,623,376,50,42,,,712,597,3.9000000000,81,11,14,4131,1534,43,431,475,204,124,0.96,Cleveland Indians,League Park II,748705,102,100,CLE,CLE,CLE
+1921,AL,DET,DET,,6,154,77,71,82,,,N,N,883,5461,1724,268,100,58,582,376,95,89,,,852,678,4.4000000000,73,4,16,4158,1634,71,495,452,231,107,0.96,Detroit Tigers,Navin Field,661527,99,100,DET,DET,DET
+1921,AL,NYA,NYY,,1,153,78,98,55,,,Y,N,948,5249,1576,285,87,134,588,569,89,64,,,708,579,3.8200000000,92,8,15,4092,1461,51,470,481,220,138,0.96,New York Yankees,Polo Grounds IV,1230696,102,98,NYY,NYA,NYA
+1921,AL,PHA,OAK,,8,155,77,53,100,,,N,N,657,5465,1497,256,64,82,424,565,68,55,,,894,717,4.6100000000,75,2,7,4200,1645,85,548,431,277,144,0.95,Philadelphia Athletics,Shibe Park,344430,100,104,PHA,PHA,PHA
+1921,AL,SLA,BAL,,3,154,77,81,73,,,N,N,835,5442,1655,246,106,67,413,407,92,71,,,845,706,4.6100000000,77,9,9,4137,1541,71,556,477,224,127,0.96,St. Louis Browns,Sportsman's Park IV,355978,106,105,SLB,SLA,SLA
+1921,AL,WS1,MIN,,4,154,76,80,73,,,N,N,704,5294,1468,240,96,42,462,472,111,66,,,738,610,3.9700000000,80,10,10,4149,1568,51,442,452,234,153,0.96,Washington Senators,Griffith Stadium I,456069,95,96,WSH,WS1,WS1
+1921,NL,BRO,LAD,,5,152,78,77,75,,,N,N,667,5263,1476,209,85,59,325,400,91,73,,,681,560,3.7000000000,82,8,12,4089,1556,46,361,471,232,142,0.96,Brooklyn Robins,Ebbets Field,613245,105,104,BRO,BRO,BRO
+1921,NL,BSN,ATL,,4,153,74,79,74,,,N,N,721,5385,1561,209,100,61,377,470,94,100,,,697,600,3.9000000000,74,11,12,4155,1488,54,420,382,199,122,0.96,Boston Braves,Braves Field,318627,94,96,BSN,BSN,BSN
+1921,NL,CHN,CHC,,7,153,76,64,89,,,N,N,668,5321,1553,234,56,37,343,374,70,97,,,773,665,4.3900000000,73,7,7,4089,1605,67,409,441,166,129,0.97,Chicago Cubs,Wrigley Field,410107,100,101,CHC,CHN,CHN
+1921,NL,CIN,CIN,,6,153,76,70,83,,,N,N,618,5112,1421,221,94,20,375,308,117,120,,,649,524,3.4600000000,83,7,9,4089,1500,37,305,408,193,139,0.96,Cincinnati Reds,Crosley Field,311227,95,94,CIN,CIN,CIN
+1921,NL,NY1,SFG,,1,153,79,94,59,,,Y,Y,840,5278,1575,237,93,75,469,390,137,114,,,637,541,3.5500000000,71,9,18,4116,1497,79,295,357,187,155,0.97,New York Giants,Polo Grounds IV,973477,102,98,NYG,NY1,NY1
+1921,NL,PHI,PHI,,8,154,76,51,103,,,N,N,617,5329,1512,238,50,88,294,615,66,80,,,919,671,4.4800000000,82,5,8,4044,1665,79,371,333,294,127,0.95,Philadelphia Phillies,Baker Bowl,273961,107,111,PHI,PHI,PHI
+1921,NL,PIT,PIT,,2,154,76,90,63,,,N,N,692,5379,1533,231,104,37,341,371,134,93,,,595,498,3.1700000000,88,10,10,4245,1448,37,322,500,171,129,0.97,Pittsburgh Pirates,Forbes Field,701567,102,101,PIT,PIT,PIT
+1921,NL,SLN,STL,,3,154,78,87,66,,,N,N,809,5309,1635,260,88,83,382,452,94,94,,,681,551,3.6200000000,70,10,16,4113,1486,61,399,464,219,130,0.96,St. Louis Cardinals,Sportsman's Park IV,384773,97,96,STL,SLN,SLN
+1922,AL,BOS,BOS,,8,154,73,61,93,,,N,N,598,5288,1392,250,55,45,366,455,60,63,,,769,656,4.3000000000,71,10,6,4119,1508,48,503,359,221,139,0.96,Boston Red Sox,Fenway Park I,259184,99,101,BOS,BOS,BOS
+1922,AL,CHA,CHW,,5,155,77,77,77,,,N,N,691,5267,1463,243,62,45,482,463,106,84,,,691,614,3.9400000000,86,13,8,4209,1472,57,529,484,153,132,0.97,Chicago White Sox,Comiskey Park,602860,99,100,CHW,CHA,CHA
+1922,AL,CLE,CLE,,4,155,80,78,76,,,N,N,768,5293,1544,320,73,32,554,331,89,58,,,817,705,4.5900000000,76,14,7,4149,1605,58,464,489,201,140,0.96,Cleveland Indians,League Park II,528145,102,100,CLE,CLE,CLE
+1922,AL,DET,DET,,3,155,77,79,75,,,N,N,828,5360,1641,250,87,54,530,378,78,61,,,791,660,4.2700000000,67,7,15,4173,1554,62,473,461,192,135,0.97,Detroit Tigers,Navin Field,861206,97,96,DET,DET,DET
+1922,AL,NYA,NYY,,1,154,77,94,60,,,Y,N,758,5245,1504,220,75,95,497,532,62,59,,,618,525,3.3900000000,100,7,14,4179,1402,73,423,458,155,122,0.97,New York Yankees,Polo Grounds IV,1026134,102,98,NYY,NYA,NYA
+1922,AL,PHA,OAK,,7,155,78,65,89,,,N,N,705,5211,1409,229,63,111,437,591,60,63,,,830,695,4.5900000000,73,4,6,4086,1573,107,469,373,218,119,0.96,Philadelphia Athletics,Shibe Park,425356,102,105,PHA,PHA,PHA
+1922,AL,SLA,BAL,,2,154,77,93,61,,,N,N,867,5416,1693,291,94,98,473,381,132,73,,,643,523,3.3800000000,79,8,22,4176,1412,71,419,534,196,158,0.96,St. Louis Browns,Sportsman's Park IV,712918,104,103,SLB,SLA,SLA
+1922,AL,WS1,MIN,,6,154,79,69,85,,,N,N,650,5201,1395,229,76,45,458,442,94,54,,,706,577,3.8100000000,84,13,10,4086,1485,49,500,422,201,161,0.96,Washington Senators,Griffith Stadium I,458552,95,96,WSH,WS1,WS1
+1922,NL,BRO,LAD,,6,155,78,76,78,,,N,N,743,5413,1569,235,76,56,339,318,79,60,,,754,623,4.0500000000,82,12,8,4155,1574,74,490,499,208,139,0.96,Brooklyn Robins,Ebbets Field,498865,100,100,BRO,BRO,BRO
+1922,NL,BSN,ATL,,8,154,76,53,100,,,N,N,596,5161,1355,162,73,32,387,451,67,65,,,822,655,4.3700000000,63,7,6,4044,1565,57,489,360,215,121,0.96,Boston Braves,Braves Field,167965,95,97,BSN,BSN,BSN
+1922,NL,CHN,CHC,,5,156,76,80,74,,,N,N,771,5335,1564,248,71,42,525,447,97,108,,,808,674,4.3400000000,74,8,12,4191,1579,77,475,402,202,154,0.96,Chicago Cubs,Wrigley Field,542283,102,102,CHC,CHN,CHN
+1922,NL,CIN,CIN,,2,156,79,86,68,,,N,N,766,5282,1561,226,99,45,436,381,130,136,,,677,543,3.5300000000,88,8,3,4155,1481,49,326,357,205,147,0.96,Cincinnati Reds,Crosley Field,493754,98,97,CIN,CIN,CIN
+1922,NL,NY1,SFG,,1,156,79,93,61,,,Y,Y,852,5454,1661,253,90,80,448,421,116,83,,,658,535,3.4500000000,76,7,15,4188,1454,71,393,388,194,145,0.97,New York Giants,Polo Grounds IV,945809,102,98,NYG,NY1,NY1
+1922,NL,PHI,PHI,,7,154,77,57,96,,,N,N,738,5459,1537,268,55,116,450,611,48,60,,,920,707,4.6400000000,73,6,5,4116,1692,89,460,394,222,152,0.96,Philadelphia Phillies,Baker Bowl,232471,108,113,PHI,PHI,PHI
+1922,NL,PIT,PIT,,3,155,78,85,69,,,N,N,865,5521,1698,239,110,52,423,326,145,59,,,736,613,3.9800000000,88,15,7,4161,1613,52,358,490,187,126,0.97,Pittsburgh Pirates,Forbes Field,523675,102,100,PIT,PIT,PIT
+1922,NL,SLN,STL,,3,154,77,85,69,,,N,N,863,5425,1634,280,88,107,447,425,73,63,,,819,672,4.4400000000,60,8,12,4086,1609,61,447,465,239,122,0.96,St. Louis Cardinals,Sportsman's Park IV,536998,95,94,STL,SLN,SLN
+1923,AL,BOS,BOS,,8,154,78,61,91,,,N,N,584,5181,1354,253,54,34,391,480,77,91,,,809,640,4.2000000000,77,3,11,4116,1534,48,520,412,232,126,0.96,Boston Red Sox,Fenway Park I,229688,100,103,BOS,BOS,BOS
+1923,AL,CHA,CHW,,7,156,75,69,85,,,N,N,692,5246,1463,254,57,42,532,458,191,119,,,741,629,4.0500000000,74,5,11,4191,1512,49,534,467,181,138,0.97,Chicago White Sox,Comiskey Park,573778,99,99,CHW,CHA,CHA
+1923,AL,CLE,CLE,,3,153,78,82,71,,,N,N,888,5290,1594,301,75,59,633,384,79,77,,,746,598,3.9100000000,77,10,11,4128,1517,36,465,407,227,143,0.96,Cleveland Indians,League Park II,558856,100,100,CLE,CLE,CLE
+1923,AL,DET,DET,,2,155,77,83,71,,,N,N,831,5266,1579,270,69,41,596,385,87,62,,,741,624,4.0900000000,61,9,12,4119,1502,58,449,447,200,103,0.96,Detroit Tigers,Navin Field,911377,98,97,DET,DET,DET
+1923,AL,NYA,NYY,,1,152,76,98,54,,,Y,Y,823,5347,1554,231,79,105,521,516,69,74,,,622,555,3.6200000000,101,9,10,4140,1365,68,491,506,144,131,0.97,New York Yankees,Yankee Stadium I,1007066,103,100,NYY,NYA,NYA
+1923,AL,PHA,OAK,,6,153,75,69,83,,,N,N,661,5196,1407,229,64,53,445,517,72,62,,,761,618,4.0800000000,65,7,12,4092,1465,68,550,400,225,127,0.96,Philadelphia Athletics,Shibe Park,534122,101,103,PHA,PHA,PHA
+1923,AL,SLA,BAL,,5,154,78,74,78,,,N,N,688,5298,1489,248,62,82,442,423,64,54,,,720,600,3.9300000000,83,10,10,4119,1430,59,528,488,176,145,0.97,St. Louis Browns,Sportsman's Park IV,430296,106,105,SLB,SLA,SLA
+1923,AL,WS1,MIN,,4,155,79,75,78,,,N,N,720,5244,1436,224,93,26,532,448,102,67,,,747,608,3.9800000000,71,8,16,4122,1527,56,563,474,213,182,0.96,Washington Senators,Griffith Stadium I,357406,95,95,WSH,WS1,WS1
+1923,NL,BRO,LAD,,6,155,78,76,78,,,N,N,753,5476,1559,214,81,62,425,382,71,50,,,741,580,3.7400000000,94,8,5,4188,1503,55,476,548,291,137,0.95,Brooklyn Robins,Ebbets Field,564666,98,97,BRO,BRO,BRO
+1923,NL,BSN,ATL,,7,155,77,54,100,,,N,N,636,5329,1455,213,58,32,429,404,57,80,,,798,651,4.2100000000,54,13,7,4176,1662,64,394,351,230,157,0.96,Boston Braves,Braves Field,227802,95,99,BSN,BSN,BSN
+1923,NL,CHN,CHC,,4,154,77,83,71,,,N,N,756,5259,1516,243,52,90,455,485,181,143,,,704,580,3.8200000000,80,8,11,4098,1419,86,435,408,208,144,0.96,Chicago Cubs,Wrigley Field,703705,100,100,CHC,CHN,CHN
+1923,NL,CIN,CIN,,2,154,78,91,63,,,N,N,708,5278,1506,237,95,45,439,367,96,105,,,629,496,3.2100000000,88,11,9,4173,1465,28,359,450,202,144,0.96,Cincinnati Reds,Crosley Field,575063,98,97,CIN,CIN,CIN
+1923,NL,NY1,SFG,,1,153,77,95,58,,,Y,N,854,5452,1610,248,76,85,487,406,106,70,,,679,597,3.9000000000,62,10,18,4134,1440,82,424,453,176,141,0.97,New York Giants,Polo Grounds IV,820780,100,96,NYG,NY1,NY1
+1923,NL,PHI,PHI,,8,155,75,50,104,,,N,N,748,5491,1528,259,39,112,414,556,70,73,,,1008,816,5.3400000000,68,3,8,4128,1801,100,549,384,213,172,0.96,Philadelphia Phillies,Baker Bowl,228168,111,115,PHI,PHI,PHI
+1923,NL,PIT,PIT,,3,154,77,87,67,,,N,N,786,5405,1592,224,111,49,407,362,154,75,,,696,592,3.8700000000,92,5,9,4128,1513,53,402,414,179,157,0.97,Pittsburgh Pirates,Forbes Field,611082,102,100,PIT,PIT,PIT
+1923,NL,SLN,STL,,5,154,78,79,74,,,N,N,746,5526,1582,274,76,63,438,446,89,61,,,732,601,3.8700000000,77,9,7,4194,1539,70,456,398,230,141,0.96,St. Louis Cardinals,Sportsman's Park IV,338551,97,97,STL,SLN,SLN
+1924,AL,BOS,BOS,,7,157,77,67,87,,,N,N,737,5340,1481,302,63,30,603,417,79,61,,,806,672,4.3500000000,73,8,16,4173,1563,43,523,414,207,124,0.96,Boston Red Sox,Fenway Park I,448556,99,103,BOS,BOS,BOS
+1924,AL,CHA,CHW,,8,154,77,66,87,,,N,N,793,5255,1512,254,58,41,604,418,138,86,,,858,722,4.7400000000,76,1,11,4110,1635,52,512,360,230,136,0.96,Chicago White Sox,Comiskey Park,606658,97,97,CHW,CHA,CHA
+1924,AL,CLE,CLE,,6,153,75,67,86,,,N,N,755,5332,1580,306,59,41,492,371,84,56,,,814,660,4.4000000000,87,7,7,4047,1603,43,503,315,201,130,0.96,Cleveland Indians,League Park II,481905,102,101,CLE,CLE,CLE
+1924,AL,DET,DET,,3,156,78,86,68,,,N,N,849,5389,1604,315,76,35,607,400,100,76,,,796,649,4.1900000000,60,5,20,4182,1586,55,467,441,186,142,0.97,Detroit Tigers,Navin Field,1015136,98,97,DET,DET,DET
+1924,AL,NYA,NYY,,2,153,78,89,63,,,N,N,798,5240,1516,248,86,98,478,420,69,64,,,667,583,3.8600000000,76,13,13,4077,1483,59,522,487,154,131,0.97,New York Yankees,Yankee Stadium I,1053533,100,99,NYY,NYA,NYA
+1924,AL,PHA,OAK,,5,152,75,71,81,,,N,N,685,5184,1459,251,59,63,374,482,79,66,,,778,656,4.3900000000,68,8,10,4035,1527,43,597,371,181,157,0.97,Philadelphia Athletics,Shibe Park,531992,101,101,PHA,PHA,PHA
+1924,AL,SLA,BAL,,4,153,78,74,78,,,N,N,769,5236,1543,266,62,67,465,349,85,85,,,809,687,4.5700000000,65,11,7,4059,1511,68,517,386,176,141,0.97,St. Louis Browns,Sportsman's Park IV,533349,106,107,SLB,SLA,SLA
+1924,AL,WS1,MIN,,1,156,79,92,62,,,Y,Y,755,5304,1558,255,88,22,513,392,115,87,,,613,513,3.3400000000,74,13,25,4149,1329,34,505,469,171,149,0.97,Washington Senators,Griffith Stadium I,584310,98,96,WSH,WS1,WS1
+1924,NL,BRO,LAD,,2,154,77,92,62,,,N,N,717,5339,1534,227,54,72,447,357,34,46,,,675,557,3.6400000000,97,10,5,4128,1432,58,403,638,196,121,0.96,Brooklyn Robins,Ebbets Field,818883,97,97,BRO,BRO,BRO
+1924,NL,BSN,ATL,,8,154,76,53,100,,,N,N,520,5283,1355,194,52,25,354,451,74,68,,,800,683,4.4600000000,66,10,4,4137,1607,49,402,364,168,154,0.97,Boston Braves,Braves Field,177478,95,98,BSN,BSN,BSN
+1924,NL,CHN,CHC,,5,154,78,81,72,,,N,N,698,5134,1419,207,59,66,469,521,137,149,,,699,587,3.8300000000,85,4,6,4140,1459,89,438,416,218,153,0.96,Chicago Cubs,Wrigley Field,716922,101,101,CHC,CHN,CHN
+1924,NL,CIN,CIN,,4,153,76,83,70,,,N,N,649,5301,1539,236,111,36,349,334,103,98,,,579,478,3.1200000000,77,14,9,4134,1408,30,293,451,217,142,0.96,Cincinnati Reds,Crosley Field,473707,99,97,CIN,CIN,CIN
+1924,NL,NY1,SFG,,1,154,77,93,60,,,Y,N,857,5445,1634,269,81,95,467,479,82,53,,,641,554,3.6200000000,71,4,21,4134,1464,77,392,406,186,160,0.97,New York Giants,Polo Grounds IV,844068,98,95,NYG,NY1,NY1
+1924,NL,PHI,PHI,,7,152,76,55,96,,,N,N,676,5306,1459,256,56,94,382,452,57,67,,,849,733,4.8700000000,59,7,10,4062,1689,84,469,349,175,168,0.97,Philadelphia Phillies,Baker Bowl,299818,112,115,PHI,PHI,PHI
+1924,NL,PIT,PIT,,3,153,77,90,63,,,N,N,724,5288,1517,222,122,44,366,396,181,92,,,588,502,3.2700000000,85,15,5,4146,1387,42,323,364,183,161,0.97,Pittsburgh Pirates,Forbes Field,736883,102,99,PIT,PIT,PIT
+1924,NL,SLN,STL,,6,154,77,65,89,,,N,N,740,5349,1552,270,87,67,382,418,86,86,,,750,629,4.1500000000,79,7,6,4092,1528,70,486,393,191,162,0.96,St. Louis Cardinals,Sportsman's Park IV,272885,98,98,STL,SLN,SLN
+1925,AL,BOS,BOS,,8,152,75,47,105,,,N,N,639,5166,1375,257,64,41,513,422,42,56,,,922,732,4.9700000000,68,6,6,3978,1615,67,510,310,265,150,0.95,Boston Red Sox,Fenway Park I,267782,99,103,BOS,BOS,BOS
+1925,AL,CHA,CHW,,5,154,77,79,75,,,N,N,811,5224,1482,299,59,38,662,405,129,88,,,770,660,4.2900000000,71,12,13,4155,1579,69,489,374,198,162,0.96,Chicago White Sox,Comiskey Park,832231,95,95,CHW,CHA,CHA
+1925,AL,CLE,CLE,,6,155,77,70,84,,,N,N,782,5436,1613,285,58,52,520,379,90,77,,,817,684,4.4900000000,93,6,9,4116,1604,41,493,345,212,146,0.96,Cleveland Indians,League Park II,419005,101,101,CLE,CLE,CLE
+1925,AL,DET,DET,,4,156,77,81,73,,,N,N,903,5371,1621,277,84,50,640,386,97,63,,,829,708,4.6100000000,66,2,18,4149,1582,70,556,419,171,143,0.97,Detroit Tigers,Navin Field,820766,98,98,DET,DET,DET
+1925,AL,NYA,NYY,,7,156,79,69,85,,,N,N,706,5353,1471,247,74,110,470,482,67,73,,,774,667,4.3300000000,80,8,13,4161,1560,78,505,492,162,150,0.97,New York Yankees,Yankee Stadium I,697267,98,97,NYY,NYA,NYA
+1925,AL,PHA,OAK,,2,153,77,88,64,,,N,N,831,5399,1659,298,79,76,453,432,67,59,,,713,594,3.8700000000,61,8,18,4143,1468,60,544,495,214,148,0.96,Philadelphia Athletics,Shibe Park,869703,107,106,PHA,PHA,PHA
+1925,AL,SLA,BAL,,3,154,78,82,71,,,N,N,900,5440,1620,304,68,110,498,375,85,78,,,906,754,4.9200000000,67,7,10,4137,1588,99,675,419,219,164,0.96,St. Louis Browns,Sportsman's Park IV,462898,105,106,SLB,SLA,SLA
+1925,AL,WS1,MIN,,1,152,76,96,55,,,Y,N,829,5206,1577,251,71,56,533,427,134,88,,,670,558,3.7000000000,69,10,21,4074,1434,49,543,463,172,166,0.97,Washington Senators,Griffith Stadium I,817199,99,97,WSH,WS1,WS1
+1925,NL,BRO,LAD,,6,153,77,68,85,,,N,N,786,5468,1617,250,80,64,437,383,37,30,,,866,715,4.7700000000,82,4,4,4050,1608,75,477,518,209,130,0.96,Brooklyn Robins,Ebbets Field,659435,97,97,BRO,BRO,BRO
+1925,NL,BSN,ATL,,5,153,76,70,83,,,N,N,708,5365,1567,260,70,41,405,380,77,72,,,802,666,4.3900000000,77,5,4,4098,1567,67,458,351,221,145,0.96,Boston Braves,Braves Field,313528,91,94,BSN,BSN,BSN
+1925,NL,CHN,CHC,,8,154,77,68,86,,,N,N,723,5353,1473,254,70,86,397,470,94,70,,,773,671,4.4100000000,75,5,10,4110,1575,102,485,435,198,161,0.96,Chicago Cubs,Wrigley Field,622610,102,102,CHC,CHN,CHN
+1925,NL,CIN,CIN,,3,153,76,80,73,,,N,N,690,5233,1490,221,90,44,409,327,108,107,,,643,516,3.3800000000,92,11,12,4125,1447,35,324,437,203,161,0.96,Cincinnati Reds,Crosley Field,464920,98,96,CIN,CIN,CIN
+1925,NL,NY1,SFG,,2,152,76,86,66,,,N,N,736,5327,1507,239,61,114,411,494,79,65,,,702,593,3.9400000000,80,6,8,4062,1532,73,408,446,198,129,0.96,New York Giants,Polo Grounds IV,778993,96,95,NYG,NY1,NY1
+1925,NL,PHI,PHI,,6,153,77,68,85,,,N,N,812,5412,1598,288,58,100,456,542,48,59,,,930,753,5.0200000000,69,8,9,4050,1753,117,444,371,211,147,0.96,Philadelphia Phillies,Baker Bowl,304905,108,112,PHI,PHI,PHI
+1925,NL,PIT,PIT,,1,153,77,95,58,,,Y,Y,912,5372,1651,316,105,78,499,363,159,63,,,715,582,3.8700000000,77,2,13,4062,1526,81,387,386,224,171,0.96,Pittsburgh Pirates,Forbes Field,804354,106,104,PIT,PIT,PIT
+1925,NL,SLN,STL,,4,153,76,77,76,,,N,N,828,5329,1592,292,80,109,446,414,70,51,,,764,647,4.3600000000,82,8,7,4005,1480,86,470,428,204,156,0.96,St. Louis Cardinals,Sportsman's Park IV,404959,103,102,STL,SLN,SLN
+1926,AL,BOS,BOS,,8,154,77,46,107,,,N,N,562,5185,1325,249,54,32,465,450,48,51,,,835,714,4.7200000000,53,6,5,4086,1520,45,546,336,182,143,0.97,Boston Red Sox,Fenway Park I,285155,96,101,BOS,BOS,BOS
+1926,AL,CHA,CHW,,5,155,79,81,72,,,N,N,730,5220,1508,314,60,32,556,381,121,77,,,665,573,3.7400000000,85,11,12,4140,1426,47,506,458,161,122,0.97,Chicago White Sox,Comiskey Park,710339,97,97,CHW,CHA,CHA
+1926,AL,CLE,CLE,,2,154,80,88,66,,,N,N,738,5293,1529,333,49,27,455,332,88,43,,,612,519,3.4000000000,96,11,4,4122,1412,49,450,381,172,153,0.97,Cleveland Indians,League Park II,627426,101,101,CLE,CLE,CLE
+1926,AL,DET,DET,,6,157,81,79,75,,,N,N,793,5315,1547,281,90,36,599,423,88,72,,,830,683,4.4100000000,57,10,18,4182,1570,58,555,469,197,151,0.96,Detroit Tigers,Navin Field,711914,101,100,DET,DET,DET
+1926,AL,NYA,NYY,,1,155,75,91,63,,,Y,N,847,5221,1508,262,75,121,642,580,79,60,,,713,588,3.8600000000,63,4,20,4116,1442,56,478,486,209,117,0.96,New York Yankees,Yankee Stadium I,1027675,99,96,NYY,NYA,NYA
+1926,AL,PHA,OAK,,3,150,71,83,67,,,N,N,677,5046,1359,259,65,61,523,452,56,46,,,570,449,3.0000000000,62,10,16,4038,1362,38,451,571,173,131,0.97,Philadelphia Athletics,Shibe Park,714508,106,104,PHA,PHA,PHA
+1926,AL,SLA,BAL,,7,155,79,62,92,,,N,N,682,5259,1449,253,78,72,437,465,62,71,,,845,708,4.6600000000,64,5,9,4104,1549,86,654,337,228,167,0.96,St. Louis Browns,Sportsman's Park IV,283986,105,107,SLB,SLA,SLA
+1926,AL,WS1,MIN,,4,152,74,81,69,,,N,N,802,5223,1525,244,97,43,555,369,122,89,,,761,650,4.3400000000,65,5,26,4044,1489,45,566,418,184,129,0.96,Washington Senators,Griffith Stadium I,551580,98,96,WSH,WS1,WS1
+1926,NL,BRO,LAD,,6,155,76,71,82,,,N,N,623,5130,1348,246,62,40,475,464,76,,,,705,578,3.8200000000,83,5,9,4083,1440,50,472,517,228,95,0.96,Brooklyn Robins,Ebbets Field,650819,98,100,BRO,BRO,BRO
+1926,NL,BSN,ATL,,7,153,77,66,86,,,N,N,624,5216,1444,209,62,16,426,348,81,,,,719,608,4.0100000000,60,9,9,4095,1536,46,455,408,208,150,0.96,Boston Braves,Braves Field,303598,91,93,BSN,BSN,BSN
+1926,NL,CHN,CHC,,4,155,78,82,72,,,N,N,682,5229,1453,291,49,66,445,447,85,,,,602,499,3.2600000000,77,13,14,4134,1407,39,486,508,162,174,0.97,Chicago Cubs,Wrigley Field,885063,102,101,CHC,CHN,CHN
+1926,NL,CIN,CIN,,2,157,77,87,67,,,N,N,747,5320,1541,242,120,35,454,333,51,,,,651,535,3.4200000000,88,14,8,4224,1449,40,324,424,183,160,0.97,Cincinnati Reds,Crosley Field,672987,98,97,CIN,CIN,CIN
+1926,NL,NY1,SFG,,5,151,76,74,77,,,N,N,663,5167,1435,214,58,73,339,420,94,,,,668,562,3.7700000000,61,4,15,4023,1370,70,427,419,186,150,0.97,New York Giants,Polo Grounds IV,700362,99,98,NYG,NY1,NY1
+1926,NL,PHI,PHI,,8,152,76,58,93,,,N,N,687,5254,1479,244,50,75,422,479,47,,,,900,746,5.0300000000,68,5,5,4002,1699,68,454,331,223,153,0.96,Philadelphia Phillies,Baker Bowl,240600,108,112,PHI,PHI,PHI
+1926,NL,PIT,PIT,,3,157,79,84,69,,,N,N,769,5312,1514,243,106,44,434,350,91,,,,689,562,3.6700000000,83,12,18,4137,1422,50,455,387,220,161,0.96,Pittsburgh Pirates,Forbes Field,798542,105,102,PIT,PIT,PIT
+1926,NL,SLN,STL,,1,156,79,89,65,,,Y,Y,817,5381,1541,259,82,90,478,518,83,,,,678,570,3.6700000000,90,10,6,4194,1423,76,397,365,198,141,0.96,St. Louis Cardinals,Sportsman's Park IV,668428,104,103,STL,SLN,SLN
+1927,AL,BOS,BOS,,8,154,78,51,103,,,N,N,597,5207,1348,271,78,28,430,456,82,46,,,856,716,4.7200000000,63,6,7,4098,1603,56,558,381,222,162,0.96,Boston Red Sox,Fenway Park I,305275,98,102,BOS,BOS,BOS
+1927,AL,CHA,CHW,,5,153,75,70,83,,,N,N,662,5157,1433,285,61,36,493,389,90,75,,,708,594,3.9100000000,85,10,8,4101,1467,55,440,365,180,131,0.97,Chicago White Sox,Comiskey Park,614423,98,98,CHW,CHA,CHA
+1927,AL,CLE,CLE,,6,153,77,66,87,,,N,N,668,5202,1471,321,52,26,381,366,63,72,,,766,642,4.2700000000,72,5,8,4059,1542,37,508,366,202,146,0.96,Cleveland Indians,League Park II,373138,101,102,CLE,CLE,CLE
+1927,AL,DET,DET,,4,156,78,82,71,,,N,N,845,5299,1533,282,100,51,587,420,141,73,,,805,638,4.1400000000,75,5,17,4161,1542,52,577,421,209,173,0.96,Detroit Tigers,Navin Field,773716,101,102,DET,DET,DET
+1927,AL,NYA,NYY,,1,155,77,110,44,,,Y,Y,975,5347,1644,291,103,158,635,605,90,64,,,599,494,3.2000000000,82,11,20,4167,1403,42,409,431,196,123,0.96,New York Yankees,Yankee Stadium I,1164015,98,94,NYY,NYA,NYA
+1927,AL,PHA,OAK,,2,155,77,91,63,,,N,N,841,5296,1606,281,70,56,551,326,98,63,,,726,610,3.9700000000,66,8,25,4152,1467,65,442,553,194,124,0.96,Philadelphia Athletics,Shibe Park,605529,105,102,PHA,PHA,PHA
+1927,AL,SLA,BAL,,7,155,78,59,94,,,N,N,724,5220,1440,262,59,55,443,420,91,66,,,904,744,4.9500000000,80,4,8,4059,1592,79,604,385,248,166,0.96,St. Louis Browns,Sportsman's Park IV,247879,103,105,SLB,SLA,SLA
+1927,AL,WS1,MIN,,3,157,79,85,69,,,N,N,782,5389,1549,268,87,29,498,359,133,52,,,730,618,3.9700000000,62,10,23,4206,1434,53,491,497,194,125,0.96,Washington Senators,Griffith Stadium I,528976,99,98,WSH,WS1,WS1
+1927,NL,BRO,LAD,,6,154,74,65,88,,,N,N,541,5193,1314,195,74,39,368,494,106,,,,619,513,3.3600000000,74,7,10,4125,1382,63,418,574,226,117,0.96,Brooklyn Robins,Ebbets Field,637230,100,100,BRO,BRO,BRO
+1927,NL,BSN,ATL,,7,155,74,60,94,,,N,N,651,5370,1498,216,61,37,346,363,100,,,,771,652,4.2200000000,52,3,11,4170,1602,43,468,402,231,130,0.96,Boston Braves,Braves Field,288685,92,94,BSN,BSN,BSN
+1927,NL,CHN,CHC,,4,153,78,85,68,,,N,N,750,5303,1505,266,63,74,481,492,65,,,,661,562,3.6500000000,75,11,5,4155,1439,50,514,465,181,152,0.97,Chicago Cubs,Wrigley Field,1159168,101,99,CHC,CHN,CHN
+1927,NL,CIN,CIN,,5,153,80,75,78,,,N,N,643,5185,1439,222,77,29,402,332,62,,,,653,538,3.5400000000,87,12,12,4104,1472,36,316,407,165,160,0.97,Cincinnati Reds,Crosley Field,442164,97,97,CIN,CIN,CIN
+1927,NL,NY1,SFG,,3,155,74,92,62,,,N,N,817,5372,1594,251,62,109,461,462,73,,,,720,609,3.9700000000,65,7,16,4143,1520,77,453,442,195,160,0.96,New York Giants,Polo Grounds IV,858190,99,98,NYG,NY1,NY1
+1927,NL,PHI,PHI,,8,155,78,51,103,,,N,N,678,5317,1487,216,46,57,434,482,68,,,,903,807,5.3600000000,81,5,6,4065,1710,84,462,377,168,152,0.97,Philadelphia Phillies,Baker Bowl,305420,95,99,PHI,PHI,PHI
+1927,NL,PIT,PIT,,1,156,79,94,60,,,Y,N,817,5397,1648,258,78,54,437,355,65,,,,659,563,3.6600000000,90,10,10,4155,1400,58,418,435,187,130,0.96,Pittsburgh Pirates,Forbes Field,869720,107,105,PIT,PIT,PIT
+1927,NL,SLN,STL,,2,153,80,92,61,,,N,N,754,5207,1450,264,79,84,484,511,110,,,,665,542,3.5700000000,89,14,11,4101,1416,72,363,394,213,170,0.96,St. Louis Cardinals,Sportsman's Park IV,749340,105,102,STL,SLN,SLN
+1928,AL,BOS,BOS,,8,154,74,57,96,,,N,N,589,5132,1356,260,62,38,389,512,99,64,,,770,659,4.3900000000,70,5,9,4056,1492,49,452,407,172,139,0.97,Boston Red Sox,Fenway Park I,396920,96,100,BOS,BOS,BOS
+1928,AL,CHA,CHW,,5,155,78,72,82,,,N,N,656,5207,1405,231,77,24,469,488,139,82,,,725,609,3.9800000000,88,6,11,4134,1518,66,501,418,184,149,0.97,Chicago White Sox,Comiskey Park,494152,98,100,CHW,CHA,CHA
+1928,AL,CLE,CLE,,7,155,77,62,92,,,N,N,674,5386,1535,299,61,34,377,426,50,52,,,830,684,4.4700000000,71,4,15,4134,1615,52,511,416,221,187,0.96,Cleveland Indians,League Park II,375907,101,102,CLE,CLE,CLE
+1928,AL,DET,DET,,6,154,77,68,86,,,N,N,744,5292,1476,265,97,62,469,438,113,77,,,804,659,4.3200000000,65,5,16,4116,1481,58,567,451,212,140,0.96,Detroit Tigers,Navin Field,474323,102,102,DET,DET,DET
+1928,AL,NYA,NYY,,1,154,77,101,53,,,Y,Y,894,5337,1578,269,79,133,562,544,51,51,,,685,571,3.7400000000,82,13,21,4125,1466,59,452,487,199,136,0.96,New York Yankees,Yankee Stadium I,1072132,98,94,NYY,NYA,NYA
+1928,AL,PHA,OAK,,2,153,77,98,55,,,N,N,829,5226,1540,323,75,89,533,442,59,48,,,615,510,3.3600000000,81,15,16,4101,1349,66,424,607,183,124,0.97,Philadelphia Athletics,Shibe Park,689756,103,99,PHA,PHA,PHA
+1928,AL,SLA,BAL,,3,154,77,82,72,,,N,N,772,5217,1431,276,76,63,548,479,76,43,,,742,637,4.1700000000,80,6,15,4122,1487,93,454,456,184,146,0.97,St. Louis Browns,Sportsman's Park IV,339497,103,104,SLB,SLA,SLA
+1928,AL,WS1,MIN,,4,155,80,75,79,,,N,N,718,5320,1510,277,93,40,481,390,110,59,,,705,597,3.8800000000,77,15,10,4152,1420,40,466,462,180,146,0.97,Washington Senators,Griffith Stadium I,378501,99,99,WSH,WS1,WS1
+1928,NL,BRO,LAD,,6,155,77,77,76,,,N,N,665,5243,1393,229,70,66,557,510,81,,,,640,504,3.2500000000,75,16,15,4188,1378,59,468,551,217,113,0.96,Brooklyn Robins,Ebbets Field,664863,99,100,BRO,BRO,BRO
+1928,NL,BSN,ATL,,7,153,76,50,103,,,N,N,631,5228,1439,241,41,52,447,377,60,,,,878,730,4.8300000000,54,1,6,4080,1596,100,524,343,193,141,0.96,Boston Braves,Braves Field,227001,94,97,BSN,BSN,BSN
+1928,NL,CHN,CHC,,3,154,77,91,63,,,N,N,714,5260,1460,251,64,92,508,517,83,,,,615,521,3.4000000000,75,12,14,4140,1383,56,508,531,156,176,0.97,Chicago Cubs,Wrigley Field,1143740,99,97,CHC,CHN,CHN
+1928,NL,CIN,CIN,,5,153,78,78,74,,,N,N,648,5184,1449,229,67,32,386,330,83,,,,686,600,3.9400000000,68,11,11,4113,1516,58,410,355,162,194,0.97,Cincinnati Reds,Crosley Field,490490,98,99,CIN,CIN,CIN
+1928,NL,NY1,SFG,,2,155,77,93,61,,,N,N,807,5459,1600,276,59,118,444,376,62,,,,653,568,3.6700000000,79,7,16,4182,1454,77,405,399,178,175,0.97,New York Giants,Polo Grounds IV,916191,100,98,NYG,NY1,NY1
+1928,NL,PHI,PHI,,8,152,75,43,109,,,N,N,660,5234,1396,257,47,85,503,510,53,,,,957,835,5.5600000000,42,4,11,4056,1660,108,675,404,179,171,0.97,Philadelphia Phillies,Baker Bowl,182168,106,110,PHI,PHI,PHI
+1928,NL,PIT,PIT,,4,152,77,85,67,,,N,N,837,5371,1659,246,100,52,435,352,64,,,,704,594,3.9500000000,82,8,11,4062,1422,66,446,385,201,123,0.96,Pittsburgh Pirates,Forbes Field,495070,104,102,PIT,PIT,PIT
+1928,NL,SLN,STL,,1,154,77,95,59,,,Y,N,807,5357,1505,292,70,113,568,438,82,,,,636,531,3.3800000000,83,4,21,4245,1470,86,399,422,152,134,0.97,St. Louis Cardinals,Sportsman's Park IV,761574,103,102,STL,SLN,SLN
+1929,AL,BOS,BOS,,8,155,78,58,96,,,N,N,605,5160,1377,285,69,28,413,494,85,80,,,803,672,4.4300000000,84,9,5,4098,1537,78,496,416,218,159,0.96,Boston Red Sox,Fenway Park I,394620,97,100,BOS,BOS,BOS
+1929,AL,CHA,CHW,,7,152,76,59,93,,,N,N,627,5248,1406,240,74,37,425,436,109,65,,,792,665,4.4100000000,78,5,7,4071,1481,84,505,328,190,153,0.96,Chicago White Sox,Comiskey Park,426795,98,100,CHW,CHA,CHA
+1929,AL,CLE,CLE,,3,152,76,81,71,,,N,N,717,5187,1525,294,79,62,453,363,75,85,,,736,608,4.0500000000,80,8,10,4056,1570,56,488,389,198,162,0.96,Cleveland Indians,League Park II,536210,103,105,CLE,CLE,CLE
+1929,AL,DET,DET,,6,155,77,70,84,,,N,N,926,5592,1671,339,97,110,521,496,95,72,,,928,766,4.9600000000,82,5,9,4170,1641,73,646,467,242,149,0.96,Detroit Tigers,Navin Field,869318,101,101,DET,DET,DET
+1929,AL,NYA,NYY,,2,154,77,88,66,,,N,N,899,5379,1587,262,74,142,554,518,51,44,,,775,636,4.1900000000,64,12,18,4098,1475,83,485,484,179,152,0.97,New York Yankees,Yankee Stadium I,960148,94,92,NYY,NYA,NYA
+1929,AL,PHA,OAK,,1,151,74,104,46,,,Y,Y,901,5204,1539,288,76,122,543,440,61,38,,,615,519,3.4400000000,70,9,24,4071,1371,73,487,573,148,117,0.97,Philadelphia Athletics,Shibe Park,839176,104,100,PHA,PHA,PHA
+1929,AL,SLA,BAL,,4,154,77,79,73,,,N,N,733,5174,1426,277,64,46,589,431,72,46,,,713,622,4.0800000000,83,15,10,4113,1469,100,462,415,156,148,0.97,St. Louis Browns,Sportsman's Park IV,280697,104,104,SLB,SLA,SLA
+1929,AL,WS1,MIN,,5,153,78,71,81,,,N,N,730,5237,1445,244,66,48,556,400,86,61,,,776,653,4.3400000000,62,3,17,4062,1429,48,496,494,191,156,0.96,Washington Senators,Griffith Stadium I,355506,101,100,WSH,WS1,WS1
+1929,NL,BRO,LAD,,6,153,77,70,83,,,N,N,755,5273,1535,282,69,99,504,454,80,,,,888,742,4.9200000000,59,8,16,4074,1553,92,549,549,192,113,0.96,Brooklyn Robins,Ebbets Field,731886,98,98,BRO,BRO,BRO
+1929,NL,BSN,ATL,,8,154,77,56,98,,,N,N,657,5291,1481,252,77,33,408,432,65,,,,876,769,5.1200000000,78,4,12,4056,1604,103,530,366,204,146,0.96,Boston Braves,Braves Field,372351,95,98,BSN,BSN,BSN
+1929,NL,CHN,CHC,,1,156,78,98,54,,,Y,N,982,5471,1655,310,46,139,589,567,103,,,,758,646,4.1600000000,79,14,21,4194,1542,77,537,548,154,169,0.97,Chicago Cubs,Wrigley Field,1485166,100,97,CHC,CHN,CHN
+1929,NL,CIN,CIN,,7,155,78,66,88,,,N,N,686,5269,1478,258,79,34,412,347,134,,,,760,671,4.4100000000,75,5,8,4107,1558,61,413,347,162,148,0.97,Cincinnati Reds,Crosley Field,295040,95,97,CIN,CIN,CIN
+1929,NL,NY1,SFG,,3,152,77,84,67,,,N,N,897,5388,1594,251,47,136,482,405,85,,,,709,605,3.9700000000,68,9,13,4116,1536,102,387,431,158,163,0.97,New York Giants,Polo Grounds IV,868806,100,97,NYG,NY1,NY1
+1929,NL,PHI,PHI,,5,154,76,71,82,,,N,N,897,5484,1693,305,51,153,573,470,59,,,,1032,918,6.1300000000,45,5,24,4044,1743,122,616,369,189,153,0.96,Philadelphia Phillies,Baker Bowl,281200,106,110,PHI,PHI,PHI
+1929,NL,PIT,PIT,,2,154,76,88,65,,,N,N,904,5490,1663,285,116,60,503,335,94,,,,780,668,4.3600000000,79,5,13,4137,1530,96,439,409,181,136,0.97,Pittsburgh Pirates,Forbes Field,491377,103,102,PIT,PIT,PIT
+1929,NL,SLN,STL,,4,154,77,78,74,,,N,N,831,5364,1569,310,84,100,490,455,72,,,,806,704,4.6600000000,83,6,8,4077,1604,101,474,453,174,149,0.97,St. Louis Cardinals,Sportsman's Park IV,399887,103,101,STL,SLN,SLN
+1930,AL,BOS,BOS,,8,154,76,52,102,,,N,N,612,5286,1393,257,68,47,358,552,42,35,,,814,707,4.6800000000,78,4,5,4080,1515,75,488,356,194,161,0.96,Boston Red Sox,Fenway Park I,444045,96,99,BOS,BOS,BOS
+1930,AL,CHA,CHW,,7,154,78,62,92,,,N,N,729,5419,1496,256,90,63,389,479,74,40,,,884,712,4.7100000000,63,2,10,4083,1629,74,407,471,233,136,0.96,Chicago White Sox,Comiskey Park,406123,96,99,CHW,CHA,CHA
+1930,AL,CLE,CLE,,4,154,77,81,73,,,N,N,890,5439,1654,358,59,72,490,461,51,47,,,915,737,4.8800000000,68,5,14,4080,1663,85,528,441,235,156,0.96,Cleveland Indians,League Park II,528657,103,103,CLE,CLE,CLE
+1930,AL,DET,DET,,5,154,78,75,79,,,N,N,783,5297,1504,298,90,82,461,508,98,70,,,833,706,4.7000000000,68,4,17,4053,1507,86,570,574,188,156,0.96,Detroit Tigers,Navin Field,649450,102,104,DET,DET,DET
+1930,AL,NYA,NYY,,3,154,76,86,68,,,N,N,1062,5448,1683,298,110,152,644,569,91,60,,,898,741,4.8800000000,65,7,15,4101,1566,93,524,572,208,132,0.96,New York Yankees,Yankee Stadium I,1169230,96,93,NYY,NYA,NYA
+1930,AL,PHA,OAK,,1,154,76,102,52,,,Y,Y,951,5345,1573,319,74,125,599,531,48,33,,,751,652,4.2800000000,72,8,21,4113,1457,84,488,672,145,121,0.97,Philadelphia Athletics,Shibe Park,721663,105,101,PHA,PHA,PHA
+1930,AL,SLA,BAL,,6,154,78,64,90,,,N,N,751,5278,1415,289,67,75,497,550,93,71,,,886,772,5.0700000000,68,5,10,4113,1639,124,449,470,189,152,0.96,St. Louis Browns,Sportsman's Park IV,152088,103,104,SLB,SLA,SLA
+1930,AL,WS1,MIN,,2,154,77,94,60,,,N,N,892,5370,1620,300,98,57,537,438,101,67,,,689,602,3.9600000000,78,6,14,4107,1367,52,504,524,155,150,0.97,Washington Senators,Griffith Stadium I,614474,101,99,WSH,WS1,WS1
+1930,NL,BRO,LAD,,4,154,77,86,68,,,N,N,871,5433,1654,303,73,122,481,541,53,,,,738,614,4.0300000000,74,13,15,4116,1480,115,394,526,169,167,0.97,Brooklyn Robins,Ebbets Field,1097329,99,99,BRO,BRO,BRO
+1930,NL,BSN,ATL,,6,154,77,70,84,,,N,N,693,5356,1503,246,78,66,332,397,69,,,,835,743,4.9100000000,71,6,11,4083,1624,117,475,424,178,167,0.97,Boston Braves,Braves Field,464835,97,99,BSN,BSN,BSN
+1930,NL,CHN,CHC,,2,156,79,90,64,,,N,N,998,5581,1722,305,72,171,588,635,70,,,,870,748,4.8000000000,67,6,12,4209,1642,111,528,601,170,167,0.97,Chicago Cubs,Wrigley Field,1463624,101,98,CHC,CHN,CHN
+1930,NL,CIN,CIN,,7,154,77,59,95,,,N,N,665,5245,1475,265,67,74,445,489,48,,,,857,754,5.0800000000,61,6,11,4005,1650,75,394,361,161,164,0.97,Cincinnati Reds,Crosley Field,386727,94,97,CIN,CIN,CIN
+1930,NL,NY1,SFG,,3,154,77,87,67,,,N,N,959,5553,1769,264,83,143,422,382,59,,,,814,698,4.6100000000,64,6,19,4089,1546,117,439,522,164,164,0.97,New York Giants,Polo Grounds IV,868714,98,95,NYG,NY1,NY1
+1930,NL,PHI,PHI,,8,156,77,52,102,,,N,N,944,5667,1783,345,44,126,450,459,34,,,,1199,1023,6.7100000000,54,3,7,4116,1993,142,543,384,239,169,0.96,Philadelphia Phillies,Baker Bowl,299007,107,110,PHI,PHI,PHI
+1930,NL,PIT,PIT,,5,154,77,80,74,,,N,N,891,5346,1622,285,119,86,494,449,76,,,,928,792,5.2400000000,80,7,13,4083,1730,128,438,393,216,164,0.96,Pittsburgh Pirates,Forbes Field,357795,100,100,PIT,PIT,PIT
+1930,NL,SLN,STL,,1,154,77,92,62,,,Y,N,1004,5512,1732,373,89,104,479,496,72,,,,784,673,4.3900000000,63,5,21,4140,1596,87,476,639,183,176,0.97,St. Louis Cardinals,Sportsman's Park IV,508501,104,102,STL,SLN,SLN
+1931,AL,BOS,BOS,,6,153,80,62,90,,,N,N,625,5379,1409,289,34,37,405,565,42,43,,,800,698,4.6000000000,61,5,10,4098,1559,54,473,365,187,127,0.97,Boston Red Sox,Fenway Park I,350975,94,98,BOS,BOS,BOS
+1931,AL,CHA,CHW,,8,156,77,56,97,,,N,N,704,5481,1423,238,69,27,483,445,94,39,,,939,778,5.0400000000,54,6,10,4170,1613,82,588,421,246,131,0.96,Chicago White Sox,Comiskey Park,403550,94,97,CHW,CHA,CHA
+1931,AL,CLE,CLE,,4,155,76,78,76,,,N,N,885,5445,1612,321,69,71,555,433,63,60,,,833,697,4.6300000000,76,6,9,4062,1577,64,561,470,231,143,0.96,Cleveland Indians,League Park II,483027,105,105,CLE,CLE,CLE
+1931,AL,DET,DET,,7,154,77,61,93,,,N,N,651,5430,1456,292,69,43,480,468,117,75,,,836,706,4.5900000000,86,5,6,4152,1549,79,597,511,221,139,0.96,Detroit Tigers,Navin Field,434056,103,104,DET,DET,DET
+1931,AL,NYA,NYY,,2,155,77,94,59,,,N,N,1067,5608,1667,277,78,155,748,554,138,68,,,760,658,4.2000000000,78,4,17,4230,1461,67,543,686,167,131,0.97,New York Yankees,Yankee Stadium I,912437,95,91,NYY,NYA,NYA
+1931,AL,PHA,OAK,,1,153,75,107,45,,,Y,N,858,5377,1544,311,64,118,528,543,25,23,,,626,526,3.4700000000,97,12,16,4095,1342,73,457,574,140,151,0.97,Philadelphia Athletics,Shibe Park,627464,106,103,PHA,PHA,PHA
+1931,AL,SLA,BAL,,5,154,77,63,91,,,N,N,722,5374,1455,287,62,76,488,580,73,80,,,870,720,4.7600000000,65,4,10,4086,1623,84,444,436,231,160,0.96,St. Louis Browns,Sportsman's Park IV,179126,103,105,SLB,SLA,SLA
+1931,AL,WS1,MIN,,3,156,79,92,62,,,N,N,843,5576,1588,308,93,49,481,459,72,64,,,691,582,3.7600000000,60,7,24,4182,1434,73,498,582,142,148,0.97,Washington Senators,Griffith Stadium I,492657,101,98,WSH,WS1,WS1
+1931,NL,BRO,LAD,,4,153,76,79,73,,,N,N,681,5309,1464,240,77,71,409,512,45,,,,673,579,3.8400000000,64,9,18,4068,1520,56,351,546,187,154,0.96,Brooklyn Robins,Ebbets Field,753133,100,99,BRO,BRO,BRO
+1931,NL,BSN,ATL,,7,156,78,64,90,,,N,N,533,5296,1367,221,59,34,368,430,46,,,,680,598,3.9000000000,78,12,9,4140,1465,66,406,419,167,141,0.97,Boston Braves,Braves Field,515005,97,99,BSN,BSN,BSN
+1931,NL,CHN,CHC,,3,156,77,84,70,,,N,N,828,5451,1578,340,66,84,577,641,49,,,,710,611,3.9700000000,80,8,8,4155,1448,54,524,541,169,141,0.97,Chicago Cubs,Wrigley Field,1086422,102,100,CHC,CHN,CHN
+1931,NL,CIN,CIN,,8,154,77,58,96,,,N,N,592,5343,1439,241,70,21,403,463,24,,,,742,631,4.2200000000,70,7,6,4035,1545,51,399,317,165,194,0.97,Cincinnati Reds,Crosley Field,263316,93,96,CIN,CIN,CIN
+1931,NL,NY1,SFG,,2,153,78,87,65,,,N,N,768,5372,1554,251,64,101,383,395,83,,,,599,499,3.3000000000,90,17,12,4080,1341,71,422,570,159,126,0.97,New York Giants,Polo Grounds IV,812163,97,95,NYG,NY1,NY1
+1931,NL,PHI,PHI,,6,155,76,66,88,,,N,N,684,5375,1502,299,52,81,437,492,42,,,,828,692,4.5800000000,60,6,16,4080,1603,75,511,499,204,149,0.96,Philadelphia Phillies,Baker Bowl,284849,108,110,PHI,PHI,PHI
+1931,NL,PIT,PIT,,5,155,78,75,79,,,N,N,636,5360,1425,243,70,41,493,454,59,,,,691,565,3.6600000000,89,9,5,4170,1489,55,442,345,193,167,0.96,Pittsburgh Pirates,Forbes Field,260392,98,99,PIT,PIT,PIT
+1931,NL,SLN,STL,,1,154,78,101,53,,,Y,Y,815,5435,1554,353,74,60,432,475,114,,,,614,531,3.4500000000,80,17,20,4152,1470,65,449,626,160,169,0.97,St. Louis Cardinals,Sportsman's Park IV,608535,105,103,STL,SLN,SLN
+1932,AL,BOS,BOS,,8,154,77,43,111,,,N,N,566,5295,1331,253,57,53,469,539,46,46,,,915,760,5.0200000000,42,3,7,4086,1574,79,612,365,231,165,0.96,Boston Red Sox,Fenway Park I,182150,95,99,BOS,BOS,BOS
+1932,AL,CHA,CHW,,7,152,77,49,102,,,N,N,667,5336,1426,274,56,36,459,386,89,58,,,897,722,4.8200000000,50,2,12,4044,1551,88,580,379,267,170,0.95,Chicago White Sox,Comiskey Park,233198,93,96,CHW,CHA,CHA
+1932,AL,CLE,CLE,,4,153,77,87,65,,,N,N,845,5412,1544,310,74,78,566,454,52,54,,,747,630,4.1200000000,94,6,8,4131,1506,70,446,439,189,129,0.96,Cleveland Indians,League Park II/Cleveland Stadium,468953,109,107,CLE,CLE,CLE
+1932,AL,DET,DET,,5,153,78,76,75,,,N,N,799,5409,1479,291,80,80,486,523,103,49,,,787,651,4.3000000000,67,9,17,4086,1421,89,592,521,186,154,0.96,Detroit Tigers,Navin Field,397157,104,105,DET,DET,DET
+1932,AL,NYA,NYY,,1,156,77,107,47,,,Y,Y,1002,5477,1564,279,82,160,766,527,77,66,,,724,623,3.9800000000,96,11,15,4224,1425,93,561,780,190,124,0.96,New York Yankees,Yankee Stadium I,962320,96,92,NYY,NYA,NYA
+1932,AL,PHA,OAK,,2,154,77,94,60,,,N,N,981,5537,1606,303,52,172,647,630,38,23,,,752,685,4.4500000000,95,10,10,4158,1477,112,511,595,123,142,0.98,Philadelphia Athletics,Shibe Park,405500,104,101,PHA,PHA,PHA
+1932,AL,SLA,BAL,,6,154,75,63,91,,,N,N,736,5449,1502,274,69,67,507,528,69,62,,,898,766,5.0100000000,63,7,11,4128,1592,103,574,496,187,156,0.96,St. Louis Browns,Sportsman's Park IV,112558,105,108,SLB,SLA,SLA
+1932,AL,WS1,MIN,,3,154,77,93,61,,,N,N,840,5515,1565,303,100,61,505,442,70,47,,,716,639,4.1600000000,66,11,22,4149,1463,73,526,437,125,157,0.97,Washington Senators,Griffith Stadium I,371396,99,96,WSH,WS1,WS1
+1932,NL,BRO,LAD,,3,154,78,81,73,,,N,N,752,5433,1538,296,59,110,388,574,61,,,,747,654,4.2700000000,61,7,16,4137,1538,72,403,497,182,169,0.97,Brooklyn Dodgers,Ebbets Field,681827,98,98,BRO,BRO,BRO
+1932,NL,BSN,ATL,,5,155,77,77,77,,,N,N,649,5506,1460,262,53,63,347,496,36,,,,655,555,3.5300000000,72,8,8,4242,1483,61,420,440,152,145,0.97,Boston Braves,Braves Field,507606,96,97,BSN,BSN,BSN
+1932,NL,CHN,CHC,,1,154,77,90,64,,,Y,N,720,5462,1519,296,60,69,398,514,48,,,,633,535,3.4400000000,79,9,7,4203,1444,68,409,527,173,146,0.97,Chicago Cubs,Wrigley Field,974688,100,98,CHC,CHN,CHN
+1932,NL,CIN,CIN,,8,155,77,60,94,,,N,N,575,5443,1429,265,68,47,436,436,35,,,,715,587,3.7900000000,83,6,6,4182,1505,69,276,359,178,129,0.97,Cincinnati Reds,Crosley Field,356950,96,99,CIN,CIN,CIN
+1932,NL,NY1,SFG,,6,154,77,72,82,,,N,N,755,5530,1527,263,54,116,348,391,31,,,,706,585,3.8300000000,57,3,16,4125,1533,112,387,506,191,143,0.96,New York Giants,Polo Grounds IV,484868,98,96,NYG,NY1,NY1
+1932,NL,PHI,PHI,,4,154,77,78,76,,,N,N,844,5510,1608,330,67,122,446,547,71,,,,796,687,4.4700000000,59,4,17,4152,1589,107,450,459,194,133,0.96,Philadelphia Phillies,Baker Bowl,268914,112,114,PHI,PHI,PHI
+1932,NL,PIT,PIT,,2,154,76,86,68,,,N,N,701,5421,1543,274,90,48,358,385,71,,,,711,574,3.7500000000,71,12,12,4131,1472,86,338,377,185,124,0.96,Pittsburgh Pirates,Forbes Field,287262,97,97,PIT,PIT,PIT
+1932,NL,SLN,STL,,6,156,79,72,82,,,N,N,684,5458,1467,307,51,76,420,514,92,,,,717,616,3.9700000000,70,13,9,4188,1533,76,455,681,168,155,0.97,St. Louis Cardinals,Sportsman's Park IV,279219,104,102,STL,SLN,SLN
+1933,AL,BOS,BOS,,7,149,72,63,86,,,N,N,700,5201,1407,294,56,50,525,464,58,37,,,758,641,4.3500000000,60,4,14,3981,1396,75,591,467,206,133,0.96,Boston Red Sox,Fenway Park I,268715,103,103,BOS,BOS,BOS
+1933,AL,CHA,CHW,,6,151,77,67,83,,,N,N,683,5318,1448,231,53,43,538,416,43,46,,,814,678,4.4500000000,53,8,13,4113,1505,85,519,423,186,143,0.97,Chicago White Sox,Comiskey Park,397789,95,98,CHW,CHA,CHA
+1933,AL,CLE,CLE,,4,151,77,75,76,,,N,N,654,5240,1366,218,77,50,448,426,36,40,,,669,556,3.7100000000,74,12,7,4050,1382,60,465,437,157,127,0.97,Cleveland Indians,League Park II/Cleveland Stadium,387936,106,106,CLE,CLE,CLE
+1933,AL,DET,DET,,5,155,78,75,79,,,N,N,722,5502,1479,283,78,57,475,523,68,50,,,733,614,3.9500000000,69,6,17,4194,1415,84,561,575,178,167,0.97,Detroit Tigers,Navin Field,320972,102,101,DET,DET,DET
+1933,AL,NYA,NYY,,2,152,75,91,59,,,N,N,927,5274,1495,241,75,144,700,506,76,59,,,768,656,4.3600000000,70,8,22,4062,1426,66,612,711,164,122,0.97,New York Yankees,Yankee Stadium I,728014,95,91,NYY,NYA,NYA
+1933,AL,PHA,OAK,,3,152,76,79,72,,,N,N,875,5330,1519,298,56,139,625,618,34,34,,,853,718,4.8100000000,69,6,14,4029,1523,77,644,423,203,121,0.96,Philadelphia Athletics,Shibe Park,297138,101,100,PHA,PHA,PHA
+1933,AL,SLA,BAL,,8,153,77,55,96,,,N,N,669,5285,1337,244,64,64,520,556,72,60,,,820,728,4.8200000000,55,7,10,4080,1574,96,531,426,150,162,0.97,St. Louis Browns,Sportsman's Park IV,88113,106,108,SLB,SLA,SLA
+1933,AL,WS1,MIN,,1,153,76,99,53,,,Y,N,850,5524,1586,281,86,60,539,395,65,50,,,665,590,3.8200000000,68,5,26,4167,1415,64,452,447,133,149,0.97,Washington Senators,Griffith Stadium I,437533,99,98,WSH,WS1,WS1
+1933,NL,BRO,LAD,,6,157,80,65,88,,,N,N,617,5367,1413,224,51,62,397,453,82,,,,695,574,3.7300000000,71,9,10,4158,1502,51,374,415,177,120,0.97,Brooklyn Dodgers,Ebbets Field,526815,96,96,BRO,BRO,BRO
+1933,NL,BSN,ATL,,4,156,77,83,71,,,N,N,552,5243,1320,217,56,54,326,428,25,,,,531,461,2.9600000000,85,15,16,4209,1391,54,355,383,130,148,0.97,Boston Braves,Braves Field,517803,92,92,BSN,BSN,BSN
+1933,NL,CHN,CHC,,3,154,79,86,68,,,N,N,646,5255,1422,256,51,72,392,475,52,,,,536,443,2.9300000000,95,16,9,4086,1316,51,413,488,168,163,0.97,Chicago Cubs,Wrigley Field,594112,100,99,CHC,CHN,CHN
+1933,NL,CIN,CIN,,8,153,79,58,94,,,N,N,496,5156,1267,208,37,34,349,354,30,,,,643,514,3.4200000000,74,13,8,4056,1470,47,257,310,177,139,0.97,Cincinnati Reds,Crosley Field,218281,97,101,CIN,CIN,CIN
+1933,NL,NY1,SFG,,1,156,77,91,61,,,Y,Y,636,5461,1437,204,41,82,377,477,31,,,,515,424,2.7100000000,75,23,15,4224,1280,61,400,555,178,156,0.97,New York Giants,Polo Grounds IV,604471,99,97,NYG,NY1,NY1
+1933,NL,PHI,PHI,,7,152,72,60,92,,,N,N,607,5261,1439,240,41,60,381,479,55,,,,760,644,4.3400000000,52,10,13,4008,1563,87,410,341,183,156,0.97,Philadelphia Phillies,Baker Bowl,156421,112,114,PHI,PHI,PHI
+1933,NL,PIT,PIT,,2,154,77,87,67,,,N,N,667,5429,1548,249,84,39,366,334,34,,,,619,499,3.2700000000,70,16,12,4119,1417,54,313,401,166,133,0.97,Pittsburgh Pirates,Forbes Field,288747,100,99,PIT,PIT,PIT
+1933,NL,SLN,STL,,5,154,77,82,71,,,N,N,687,5387,1486,256,61,57,391,528,99,,,,609,517,3.3700000000,73,11,16,4146,1391,55,452,635,160,119,0.97,St. Louis Cardinals,Sportsman's Park IV,256171,106,105,STL,SLN,SLN
+1934,AL,BOS,BOS,,4,153,77,76,76,,,N,N,820,5339,1465,287,70,51,610,535,116,47,,,775,653,4.3200000000,68,9,9,4083,1527,70,543,538,189,141,0.96,Boston Red Sox,Fenway Park II,610640,105,105,BOS,BOS,BOS
+1934,AL,CHA,CHW,,8,153,75,53,99,,,N,N,704,5301,1395,237,40,71,565,524,36,27,,,946,815,5.4100000000,72,5,8,4065,1599,139,628,506,207,126,0.96,Chicago White Sox,Comiskey Park,236559,103,105,CHW,CHA,CHA
+1934,AL,CLE,CLE,,3,154,78,85,69,,,N,N,814,5396,1550,340,46,100,526,433,52,32,,,763,650,4.2800000000,72,8,19,4101,1476,70,582,554,170,164,0.97,Cleveland Indians,League Park II/Cleveland Stadium,391338,101,100,CLE,CLE,CLE
+1934,AL,DET,DET,,1,154,80,101,53,,,Y,N,958,5475,1644,349,53,74,639,528,125,55,,,708,618,4.0600000000,74,13,14,4110,1467,86,488,640,156,150,0.97,Detroit Tigers,Navin Field,919161,100,98,DET,DET,DET
+1934,AL,NYA,NYY,,2,154,77,94,60,,,N,N,842,5368,1494,226,61,135,700,597,71,46,,,669,577,3.7600000000,83,13,10,4146,1349,71,542,656,160,151,0.97,New York Yankees,Yankee Stadium I,854682,94,91,NYY,NYA,NYA
+1934,AL,PHA,OAK,,5,153,76,68,82,,,N,N,764,5317,1491,236,50,144,491,584,57,35,,,838,744,5.0100000000,68,8,8,4011,1429,84,693,480,196,166,0.96,Philadelphia Athletics,Shibe Park,305847,96,98,PHA,PHA,PHA
+1934,AL,SLA,BAL,,6,154,76,67,85,,,N,N,674,5288,1417,252,59,62,514,631,43,31,,,800,674,4.4900000000,50,6,20,4050,1499,94,632,499,187,160,0.96,St. Louis Browns,Sportsman's Park IV,115305,107,110,SLB,SLA,SLA
+1934,AL,WS1,MIN,,7,155,76,66,86,,,N,N,729,5448,1512,278,70,51,570,447,47,42,,,806,718,4.6800000000,61,4,12,4143,1622,74,503,412,161,167,0.97,Washington Senators,Griffith Stadium I,330074,96,96,WSH,WS1,WS1
+1934,NL,BRO,LAD,,6,153,77,71,81,,,N,N,748,5427,1526,284,52,79,548,555,55,,,,795,674,4.4800000000,66,6,12,4062,1540,81,475,520,180,141,0.97,Brooklyn Dodgers,Ebbets Field,434188,95,96,BRO,BRO,BRO
+1934,NL,BSN,ATL,,4,152,75,78,73,,,N,N,683,5370,1460,233,44,83,375,440,30,,,,714,621,4.1100000000,62,12,20,4077,1512,78,405,462,169,120,0.97,Boston Braves,Braves Field,303205,92,94,BSN,BSN,BSN
+1934,NL,CHN,CHC,,3,152,77,86,65,,,N,N,705,5347,1494,263,44,101,375,630,59,,,,639,569,3.7600000000,73,11,9,4083,1432,80,417,633,137,135,0.97,Chicago Cubs,Wrigley Field,707525,99,96,CHC,CHN,CHN
+1934,NL,CIN,CIN,,8,152,78,52,99,,,N,N,590,5361,1428,227,65,55,313,532,34,,,,801,654,4.3700000000,51,3,19,4041,1645,61,389,438,181,136,0.97,Cincinnati Reds,Crosley Field,206773,96,100,CIN,CIN,CIN
+1934,NL,NY1,SFG,,2,153,75,93,60,,,N,N,760,5396,1485,240,41,126,406,526,19,,,,583,486,3.1900000000,68,13,30,4110,1384,75,351,499,179,141,0.97,New York Giants,Polo Grounds IV,730851,98,96,NYG,NY1,NY1
+1934,NL,PHI,PHI,,7,149,71,56,93,,,N,N,675,5218,1480,286,35,56,398,534,52,,,,794,686,4.7600000000,52,8,15,3891,1501,126,437,416,197,140,0.96,Philadelphia Phillies,Baker Bowl,169885,113,116,PHI,PHI,PHI
+1934,NL,PIT,PIT,,5,151,78,74,76,,,N,N,735,5361,1541,281,77,52,440,398,44,,,,713,620,4.2000000000,63,8,8,3987,1523,78,354,487,145,118,0.97,Pittsburgh Pirates,Forbes Field,322622,103,102,PIT,PIT,PIT
+1934,NL,SLN,STL,,1,154,77,95,58,,,Y,Y,799,5502,1582,294,75,104,392,535,69,,,,656,568,3.6900000000,78,15,16,4158,1463,77,411,689,166,141,0.97,St. Louis Cardinals,Sportsman's Park IV,325056,107,104,STL,SLN,SLN
+1935,AL,BOS,BOS,,4,154,79,78,75,,,N,N,718,5288,1458,281,63,69,609,470,91,59,,,732,619,4.0500000000,82,6,11,4128,1520,67,520,470,190,136,0.96,Boston Red Sox,Fenway Park II,558568,107,106,BOS,BOS,BOS
+1935,AL,CHA,CHW,,5,153,77,74,78,,,N,N,738,5314,1460,262,42,74,580,405,46,28,,,750,662,4.3800000000,80,8,8,4080,1443,105,574,436,145,133,0.97,Chicago White Sox,Comiskey Park,470281,102,103,CHW,CHA,CHA
+1935,AL,CLE,CLE,,3,156,77,82,71,,,N,N,776,5534,1573,324,77,93,460,567,63,54,,,739,644,4.1500000000,67,12,21,4188,1527,68,457,498,174,147,0.97,Cleveland Indians,League Park II/Cleveland Stadium,397615,102,102,CLE,CLE,CLE
+1935,AL,DET,DET,,1,152,79,93,58,,,Y,Y,919,5423,1573,301,83,106,627,456,70,45,,,665,579,3.8200000000,87,16,11,4092,1440,78,522,584,126,154,0.97,Detroit Tigers,Navin Field,1034929,96,93,DET,DET,DET
+1935,AL,NYA,NYY,,2,149,74,89,60,,,N,N,818,5214,1462,255,70,104,604,469,68,46,,,632,532,3.6000000000,76,12,13,3993,1276,91,516,594,151,114,0.97,New York Yankees,Yankee Stadium I,657508,95,91,NYY,NYA,NYA
+1935,AL,PHA,OAK,,8,149,72,58,91,,,N,N,710,5269,1470,243,44,112,475,602,43,35,,,869,754,5.1200000000,58,7,10,3978,1486,73,704,469,189,150,0.96,Philadelphia Athletics,Shibe Park,233173,99,102,PHA,PHA,PHA
+1935,AL,SLA,BAL,,7,155,76,65,87,,,N,N,718,5365,1446,291,51,73,593,561,45,25,,,930,807,5.2600000000,42,4,15,4140,1667,92,641,435,186,138,0.97,St. Louis Browns,Sportsman's Park IV,80922,104,107,SLB,SLA,SLA
+1935,AL,WS1,MIN,,6,154,77,67,86,,,N,N,823,5592,1591,255,95,32,596,406,54,37,,,903,804,5.2500000000,67,5,12,4134,1672,89,613,456,171,186,0.97,Washington Senators,Griffith Stadium I,255011,97,98,WSH,WS1,WS1
+1935,NL,BRO,LAD,,5,154,77,70,83,,,N,N,711,5410,1496,235,62,59,430,520,60,,,,767,637,4.2200000000,62,11,20,4074,1519,88,436,480,188,146,0.96,Brooklyn Dodgers,Ebbets Field,470517,98,99,BRO,BRO,BRO
+1935,NL,BSN,ATL,,8,153,75,38,115,,,N,N,575,5309,1396,233,33,75,353,436,20,,,,852,729,4.9300000000,54,6,5,3990,1645,81,404,355,197,101,0.96,Boston Braves,Braves Field,232754,92,94,BSN,BSN,BSN
+1935,NL,CHN,CHC,,1,154,77,100,54,,,Y,N,847,5486,1581,303,62,88,464,471,66,,,,597,505,3.2600000000,81,12,14,4182,1417,85,400,589,186,163,0.97,Chicago Cubs,Wrigley Field,692604,101,98,CHC,CHN,CHN
+1935,NL,CIN,CIN,,6,154,76,68,85,,,N,N,646,5296,1403,244,68,73,392,547,72,,,,772,648,4.3000000000,59,9,13,4068,1490,65,438,500,204,139,0.96,Cincinnati Reds,Crosley Field,448247,96,98,CIN,CIN,CIN
+1935,NL,NY1,SFG,,3,156,79,91,62,,,N,N,770,5623,1608,248,56,123,392,479,32,,,,675,589,3.7800000000,76,10,11,4209,1433,106,411,524,174,129,0.97,New York Giants,Polo Grounds IV,748748,99,96,NYG,NY1,NY1
+1935,NL,PHI,PHI,,7,156,79,64,89,,,N,N,685,5442,1466,249,32,92,392,661,52,,,,871,727,4.7600000000,53,8,15,4122,1652,106,505,475,228,145,0.96,Philadelphia Phillies,Baker Bowl,205470,110,113,PHI,PHI,PHI
+1935,NL,PIT,PIT,,4,153,77,86,67,,,N,N,743,5415,1543,255,90,66,457,437,30,,,,647,519,3.4200000000,76,15,11,4095,1428,63,312,549,190,94,0.96,Pittsburgh Pirates,Forbes Field,352885,103,102,PIT,PIT,PIT
+1935,NL,SLN,STL,,2,154,77,96,58,,,N,N,829,5457,1548,286,59,86,404,521,71,,,,625,541,3.5200000000,73,10,18,4152,1445,68,377,602,163,133,0.97,St. Louis Cardinals,Sportsman's Park IV,506084,104,102,STL,SLN,SLN
+1936,AL,BOS,BOS,,6,155,77,74,80,,,N,N,775,5383,1485,288,62,86,584,465,55,44,,,764,669,4.3900000000,78,11,9,4116,1501,78,552,584,162,139,0.97,Boston Red Sox,Fenway Park II,626895,106,106,BOS,BOS,BOS
+1936,AL,CHA,CHW,,4,153,75,81,70,,,N,N,920,5466,1597,282,56,60,684,417,66,29,,,873,767,5.0600000000,80,5,8,4095,1603,104,578,414,168,174,0.97,Chicago White Sox,Comiskey Park,440810,104,103,CHW,CHA,CHA
+1936,AL,CLE,CLE,,5,157,81,80,74,,,N,N,921,5646,1715,357,82,123,514,470,66,53,,,862,745,4.8300000000,74,6,12,4167,1604,73,607,619,182,154,0.97,Cleveland Indians,League Park II/Cleveland Stadium,500391,103,102,CLE,CLE,CLE
+1936,AL,DET,DET,,2,154,77,83,71,,,N,N,921,5464,1638,326,55,94,640,462,73,49,,,871,756,5.0000000000,76,13,13,4080,1568,100,562,526,154,159,0.97,Detroit Tigers,Navin Field,875948,100,98,DET,DET,DET
+1936,AL,NYA,NYY,,1,155,77,102,51,,,Y,Y,1065,5591,1676,315,83,182,700,594,77,40,,,731,649,4.1700000000,77,6,21,4200,1474,84,663,624,163,148,0.97,New York Yankees,Yankee Stadium I,976913,97,93,NYY,NYA,NYA
+1936,AL,PHA,OAK,,8,154,77,53,100,,,N,N,714,5373,1443,240,60,72,524,590,59,43,,,1045,913,6.0800000000,68,3,12,4056,1645,131,696,405,208,152,0.96,Philadelphia Athletics,Shibe Park,285173,97,101,PHA,PHA,PHA
+1936,AL,SLA,BAL,,7,155,77,57,95,,,N,N,804,5391,1502,299,66,79,625,627,62,20,,,1064,935,6.2400000000,54,3,13,4044,1776,115,609,399,188,143,0.96,St. Louis Browns,Sportsman's Park IV,93267,102,106,SLB,SLA,SLA
+1936,AL,WS1,MIN,,3,153,77,82,71,,,N,N,889,5433,1601,293,84,62,576,398,104,42,,,799,684,4.5800000000,78,8,14,4035,1484,73,588,462,182,163,0.97,Washington Senators,Griffith Stadium I,379525,94,95,WSH,WS1,WS1
+1936,NL,BRO,LAD,,7,156,79,67,87,,,N,N,662,5574,1518,263,43,33,390,458,55,,,,752,620,3.9800000000,59,7,18,4209,1466,84,528,651,202,107,0.96,Brooklyn Dodgers,Ebbets Field,489618,101,103,BRO,BRO,BRO
+1936,NL,BSN,ATL,,6,157,79,71,83,,,N,N,631,5478,1450,207,45,67,433,582,23,,,,715,619,3.9400000000,61,7,13,4239,1566,69,451,421,189,175,0.97,Boston Bees,Braves Field,340585,93,95,BSN,BSN,BSN
+1936,NL,CHN,CHC,,2,154,77,87,67,,,N,N,755,5409,1545,275,36,76,491,462,68,,,,603,544,3.5400000000,77,18,10,4146,1413,77,434,597,146,156,0.97,Chicago Cubs,Wrigley Field,699370,103,99,CHC,CHN,CHN
+1936,NL,CIN,CIN,,5,154,76,74,80,,,N,N,722,5393,1476,224,73,82,410,584,68,,,,760,641,4.2200000000,50,6,23,4101,1576,51,418,459,191,150,0.96,Cincinnati Reds,Crosley Field,466345,93,95,CIN,CIN,CIN
+1936,NL,NY1,SFG,,1,154,78,92,62,,,Y,N,742,5449,1529,237,48,97,431,452,31,,,,621,532,3.4600000000,60,12,22,4155,1458,75,401,500,168,164,0.97,New York Giants,Polo Grounds IV,837952,100,97,NYG,NY1,NY1
+1936,NL,PHI,PHI,,8,154,78,54,100,,,N,N,726,5465,1538,250,46,103,451,586,50,,,,874,704,4.6400000000,51,7,14,4095,1630,87,515,454,237,144,0.95,Philadelphia Phillies,Baker Bowl,249219,111,114,PHI,PHI,PHI
+1936,NL,PIT,PIT,,4,156,76,84,70,,,N,N,804,5586,1596,283,80,60,517,502,37,,,,718,603,3.8900000000,67,5,12,4185,1475,74,379,559,199,113,0.96,Pittsburgh Pirates,Forbes Field,372524,102,101,PIT,PIT,PIT
+1936,NL,SLN,STL,,2,155,77,87,67,,,N,N,795,5537,1554,332,60,88,442,577,69,,,,794,694,4.4700000000,65,5,24,4194,1610,89,434,559,154,134,0.97,St. Louis Cardinals,Sportsman's Park IV,448078,99,98,STL,SLN,SLN
+1937,AL,BOS,BOS,,5,154,74,80,72,,,N,N,821,5354,1506,269,64,100,601,557,79,61,,,775,680,4.4800000000,74,6,14,4098,1518,92,597,682,175,139,0.97,Boston Red Sox,Fenway Park II,559659,104,103,BOS,BOS,BOS
+1937,AL,CHA,CHW,,3,154,77,86,68,,,N,N,780,5277,1478,280,76,67,549,447,70,34,,,730,626,4.1700000000,70,15,21,4053,1435,115,532,533,174,173,0.97,Chicago White Sox,Comiskey Park,589245,100,100,CHW,CHA,CHA
+1937,AL,CLE,CLE,,4,156,78,83,71,,,N,N,817,5353,1499,304,76,103,570,551,78,51,,,768,665,4.3900000000,64,4,15,4092,1529,61,566,630,157,153,0.97,Cleveland Indians,League Park II/Cleveland Stadium,564849,98,97,CLE,CLE,CLE
+1937,AL,DET,DET,,2,155,77,89,65,,,N,N,935,5516,1611,309,62,150,656,711,89,45,,,841,746,4.8700000000,70,6,11,4134,1521,102,635,485,147,149,0.97,Detroit Tigers,Navin Field,1072276,102,101,DET,DET,DET
+1937,AL,NYA,NYY,,1,157,79,102,52,,,Y,Y,979,5487,1554,282,73,174,709,607,60,36,,,671,566,3.6500000000,82,15,21,4188,1417,92,506,652,169,134,0.97,New York Yankees,Yankee Stadium I,998148,102,97,NYY,NYA,NYA
+1937,AL,PHA,OAK,,7,154,79,54,97,,,N,N,699,5228,1398,278,60,94,583,557,95,48,,,854,719,4.8500000000,65,6,9,4005,1490,105,613,469,198,150,0.96,Philadelphia Athletics,Shibe Park,430738,98,101,PHA,PHA,PHA
+1937,AL,SLA,BAL,,8,156,78,46,108,,,N,N,715,5510,1573,327,44,71,514,510,30,27,,,1023,909,6.0000000000,55,2,8,4089,1768,143,653,468,174,166,0.97,St. Louis Browns,Sportsman's Park IV,123121,100,104,SLB,SLA,SLA
+1937,AL,WS1,MIN,,6,158,80,73,80,,,N,N,757,5578,1559,245,84,47,591,503,61,35,,,841,711,4.5800000000,75,5,14,4194,1498,96,671,524,170,181,0.97,Washington Senators,Griffith Stadium I,397799,95,96,WSH,WS1,WS1
+1937,NL,BRO,LAD,,6,155,76,62,91,,,N,N,616,5295,1401,258,53,37,469,583,69,,,,772,625,4.1300000000,63,5,8,4086,1470,68,476,592,216,127,0.96,Brooklyn Dodgers,Ebbets Field,482481,102,104,BRO,BRO,BRO
+1937,NL,BSN,ATL,,5,152,76,79,73,,,N,N,579,5124,1265,200,41,63,485,707,45,,,,556,486,3.2200000000,85,16,10,4077,1344,60,372,387,157,128,0.97,Boston Bees,Braves Field,385339,91,91,BSN,BSN,BSN
+1937,NL,CHN,CHC,,2,154,78,93,61,,,N,N,811,5349,1537,253,74,96,538,496,71,,,,682,609,3.9700000000,73,11,13,4143,1434,91,502,596,151,141,0.97,Chicago Cubs,Wrigley Field,895020,104,102,CHC,CHN,CHN
+1937,NL,CIN,CIN,,8,155,80,56,98,,,N,N,612,5230,1329,215,59,73,437,586,53,,,,707,595,3.9400000000,64,10,18,4074,1428,38,533,581,208,139,0.96,Cincinnati Reds,Crosley Field,411221,95,95,CIN,CIN,CIN
+1937,NL,NY1,SFG,,1,152,75,95,57,,,Y,N,732,5329,1484,251,41,111,412,492,45,,,,602,519,3.4300000000,67,11,17,4083,1341,85,404,653,159,143,0.97,New York Giants,Polo Grounds IV,926887,102,100,NYG,NY1,NY1
+1937,NL,PHI,PHI,,7,155,74,61,92,,,N,N,724,5424,1482,258,37,103,478,640,66,,,,869,770,5.0500000000,59,6,15,4119,1629,116,501,529,184,157,0.97,Philadelphia Phillies,Baker Bowl,212790,109,112,PHI,PHI,PHI
+1937,NL,PIT,PIT,,3,154,78,86,68,,,N,N,704,5433,1550,223,86,47,463,480,32,,,,646,540,3.5600000000,67,12,17,4098,1398,71,428,643,181,135,0.97,Pittsburgh Pirates,Forbes Field,459679,100,98,PIT,PIT,PIT
+1937,NL,SLN,STL,,4,157,80,81,73,,,N,N,789,5476,1543,264,67,94,385,569,78,,,,733,616,3.9800000000,81,10,4,4176,1546,95,448,571,164,127,0.97,St. Louis Cardinals,Sportsman's Park IV,430811,102,101,STL,SLN,SLN
+1938,AL,BOS,BOS,,2,150,75,88,61,,,N,N,902,5229,1566,298,56,98,650,463,55,51,,,751,652,4.4600000000,67,10,15,3948,1472,102,528,484,187,172,0.96,Boston Red Sox,Fenway Park II,646459,105,103,BOS,BOS,BOS
+1938,AL,CHA,CHW,,6,149,73,65,83,,,N,N,709,5199,1439,239,55,67,514,489,56,39,,,752,638,4.3600000000,83,5,9,3948,1449,101,550,432,195,155,0.96,Chicago White Sox,Comiskey Park,338278,103,103,CHW,CHA,CHA
+1938,AL,CLE,CLE,,3,153,76,86,66,,,N,N,847,5356,1506,300,89,113,550,605,83,36,,,782,692,4.6000000000,68,5,17,4059,1416,100,681,717,152,145,0.97,Cleveland Indians,League Park II/Cleveland Stadium,652006,98,97,CLE,CLE,CLE
+1938,AL,DET,DET,,4,155,79,84,70,,,N,N,862,5270,1434,219,52,137,693,581,76,41,,,795,717,4.7900000000,75,3,11,4044,1532,110,608,435,147,172,0.97,Detroit Tigers,Briggs Stadium,799557,107,106,DET,DET,DET
+1938,AL,NYA,NYY,,1,157,79,99,53,,,Y,Y,966,5410,1480,283,63,174,749,616,91,28,,,710,600,3.9100000000,91,11,13,4146,1436,85,566,567,169,169,0.97,New York Yankees,Yankee Stadium I,970916,100,95,NYY,NYA,NYA
+1938,AL,PHA,OAK,,8,154,76,53,99,,,N,N,726,5229,1410,243,62,98,605,590,65,53,,,956,806,5.4800000000,56,4,12,3972,1573,142,599,473,204,119,0.96,Philadelphia Athletics,Shibe Park,385357,96,100,PHA,PHA,PHA
+1938,AL,SLA,BAL,,7,156,77,55,97,,,N,N,755,5333,1498,273,36,92,590,528,51,40,,,962,866,5.8000000000,71,3,7,4032,1584,132,737,632,145,163,0.97,St. Louis Browns,Sportsman's Park IV,130417,99,104,SLB,SLA,SLA
+1938,AL,WS1,MIN,,5,152,78,75,76,,,N,N,814,5474,1602,278,72,85,573,379,65,37,,,873,746,4.9400000000,59,6,11,4080,1472,92,655,515,179,179,0.97,Washington Senators,Griffith Stadium I,522694,93,94,WSH,WS1,WS1
+1938,NL,BRO,LAD,,7,151,74,69,80,,,N,N,704,5142,1322,225,79,61,611,615,66,,,,710,602,4.0700000000,56,12,14,3996,1464,88,446,469,157,148,0.97,Brooklyn Dodgers,Ebbets Field,663087,103,104,BRO,BRO,BRO
+1938,NL,BSN,ATL,,5,153,75,77,75,,,N,N,561,5250,1311,199,39,54,424,548,49,,,,618,521,3.4000000000,83,15,12,4140,1375,66,465,413,173,136,0.97,Boston Bees,Braves Field,341149,89,90,BSN,BSN,BSN
+1938,NL,CHN,CHC,,1,154,77,89,63,,,Y,N,713,5333,1435,242,70,65,522,476,49,,,,598,523,3.3700000000,67,16,18,4188,1414,71,454,583,135,151,0.97,Chicago Cubs,Wrigley Field,951640,103,101,CHC,CHN,CHN
+1938,NL,CIN,CIN,,4,151,77,82,68,,,N,N,723,5391,1495,251,57,110,366,518,19,,,,634,548,3.6200000000,72,11,16,4086,1329,75,463,542,169,133,0.97,Cincinnati Reds,Crosley Field,706756,98,97,CIN,CIN,CIN
+1938,NL,NY1,SFG,,3,152,73,83,67,,,N,N,705,5255,1424,210,36,125,465,528,31,,,,637,543,3.6200000000,59,8,18,4047,1370,87,389,497,168,147,0.97,New York Giants,Polo Grounds IV,799633,101,100,NYG,NY1,NY1
+1938,NL,PHI,PHI,,8,151,75,45,105,,,N,N,550,5192,1318,233,29,40,423,507,38,,,,840,728,4.9300000000,68,3,6,3987,1516,76,582,492,201,135,0.96,Philadelphia Phillies,Baker Bowl/Shibe Park,166111,99,105,PHI,PHI,PHI
+1938,NL,PIT,PIT,,2,152,78,86,64,,,N,N,707,5422,1511,265,66,65,485,409,47,,,,630,530,3.4600000000,57,8,15,4137,1406,71,432,557,163,168,0.97,Pittsburgh Pirates,Forbes Field,641033,100,100,PIT,PIT,PIT
+1938,NL,SLN,STL,,6,156,81,71,80,,,N,N,725,5528,1542,288,74,91,412,492,55,,,,721,591,3.8400000000,58,10,16,4152,1482,77,474,534,199,145,0.96,St. Louis Cardinals,Sportsman's Park IV,291418,105,104,STL,SLN,SLN
+1939,AL,BOS,BOS,,2,152,75,89,62,,,N,N,890,5308,1543,287,57,124,591,505,42,44,,,795,684,4.5600000000,52,4,20,4050,1533,77,543,539,179,147,0.97,Boston Red Sox,Fenway Park II,573070,104,102,BOS,BOS,BOS
+1939,AL,CHA,CHW,,4,155,77,85,69,,,N,N,755,5279,1451,220,56,64,579,502,113,61,,,737,659,4.3100000000,62,5,21,4131,1470,99,454,535,167,140,0.97,Chicago White Sox,Comiskey Park,594104,103,103,CHW,CHA,CHA
+1939,AL,CLE,CLE,,3,154,77,87,67,,,N,N,797,5316,1490,291,79,85,557,574,72,46,,,700,618,4.0800000000,69,10,13,4092,1394,75,602,614,180,148,0.97,Cleveland Indians,League Park II/Cleveland Stadium,563926,97,96,CLE,CLE,CLE
+1939,AL,DET,DET,,5,155,78,81,73,,,N,N,849,5326,1487,277,67,124,620,592,88,38,,,762,652,4.2900000000,64,8,16,4101,1430,104,574,633,198,147,0.96,Detroit Tigers,Briggs Stadium,836279,107,106,DET,DET,DET
+1939,AL,NYA,NYY,,1,152,77,106,45,,,Y,Y,967,5300,1521,259,55,166,701,543,72,37,,,556,496,3.3100000000,87,15,26,4044,1208,85,567,565,126,159,0.97,New York Yankees,Yankee Stadium I,859785,99,95,NYY,NYA,NYA
+1939,AL,PHA,OAK,,7,153,76,55,97,,,N,N,711,5309,1438,282,55,98,503,532,60,34,,,1022,863,5.7900000000,50,6,12,4026,1687,148,579,397,210,131,0.96,Philadelphia Athletics,Shibe Park,395022,97,101,PHA,PHA,PHA
+1939,AL,SLA,BAL,,8,156,78,43,111,,,N,N,733,5422,1453,242,50,91,559,606,48,38,,,1035,916,6.0100000000,56,3,3,4113,1724,133,739,516,199,144,0.96,St. Louis Browns,Sportsman's Park IV,109159,102,105,SLB,SLA,SLA
+1939,AL,WS1,MIN,,6,153,77,65,87,,,N,N,702,5334,1483,249,79,44,547,460,94,47,,,797,692,4.6000000000,72,4,10,4062,1420,75,602,521,205,167,0.96,Washington Senators,Griffith Stadium I,339257,92,94,WSH,WS1,WS1
+1939,NL,BRO,LAD,,3,157,78,84,69,,,N,N,708,5350,1420,265,57,78,564,639,59,,,,645,570,3.6400000000,69,9,13,4230,1431,93,399,528,176,157,0.97,Brooklyn Dodgers,Ebbets Field,955668,105,104,BRO,BRO,BRO
+1939,NL,BSN,ATL,,7,152,73,63,88,,,N,N,572,5286,1395,199,39,56,366,494,41,,,,659,560,3.7100000000,68,11,15,4074,1400,63,513,430,181,178,0.97,Boston Bees,Braves Field,285994,92,94,BSN,BSN,BSN
+1939,NL,CHN,CHC,,4,156,80,84,70,,,N,N,724,5293,1407,263,62,91,523,553,61,,,,678,588,3.8000000000,72,8,13,4176,1504,74,430,584,186,126,0.97,Chicago Cubs,Wrigley Field,726663,102,100,CHC,CHN,CHN
+1939,NL,CIN,CIN,,1,156,81,97,57,,,Y,N,767,5378,1493,269,60,98,500,538,46,,,,595,510,3.2700000000,86,13,9,4209,1340,81,499,637,159,170,0.97,Cincinnati Reds,Crosley Field,981443,102,99,CIN,CIN,CIN
+1939,NL,NY1,SFG,,5,151,74,77,74,,,N,N,703,5129,1395,211,38,116,498,499,26,,,,685,596,4.0700000000,55,6,20,3957,1412,86,477,505,153,152,0.97,New York Giants,Polo Grounds IV,702457,101,101,NYG,NY1,NY1
+1939,NL,PHI,PHI,,8,152,74,45,106,,,N,N,553,5133,1341,232,40,49,421,486,47,,,,856,762,5.1700000000,67,3,12,3978,1502,106,579,447,171,133,0.97,Philadelphia Phillies,Shibe Park,277973,94,100,PHI,PHI,PHI
+1939,NL,PIT,PIT,,6,153,77,68,85,,,N,N,666,5269,1453,261,60,63,477,420,44,,,,721,624,4.1500000000,53,10,15,4062,1537,70,423,464,168,153,0.97,Pittsburgh Pirates,Forbes Field,376734,98,98,PIT,PIT,PIT
+1939,NL,SLN,STL,,2,155,79,92,61,,,N,N,779,5447,1601,332,62,98,475,566,44,,,,633,552,3.5900000000,45,18,32,4152,1377,76,498,603,177,140,0.97,St. Louis Cardinals,Sportsman's Park IV,400245,106,105,STL,SLN,SLN
+1940,AL,BOS,BOS,,4,154,79,82,72,,,N,N,872,5481,1566,301,80,145,590,597,55,49,,,825,749,4.8900000000,51,4,16,4137,1568,124,625,613,173,156,0.97,Boston Red Sox,Fenway Park II,716234,104,102,BOS,BOS,BOS
+1940,AL,CHA,CHW,,4,155,78,82,72,,,N,N,735,5386,1499,238,63,73,496,569,52,60,,,672,576,3.7400000000,83,10,18,4158,1335,111,480,574,185,125,0.96,Chicago White Sox,Comiskey Park,660336,102,101,CHW,CHA,CHA
+1940,AL,CLE,CLE,,2,155,82,89,65,,,N,N,710,5361,1422,287,61,101,519,597,53,36,,,637,555,3.6300000000,72,13,22,4125,1328,86,512,686,148,164,0.97,Cleveland Indians,League Park II/Cleveland Stadium,902576,98,97,CLE,CLE,CLE
+1940,AL,DET,DET,,1,155,79,90,64,,,Y,N,888,5418,1549,312,65,134,664,556,66,39,,,717,613,4.0100000000,59,10,23,4125,1425,102,570,752,194,116,0.96,Detroit Tigers,Briggs Stadium,1112693,109,108,DET,DET,DET
+1940,AL,NYA,NYY,,3,155,76,88,66,,,N,N,817,5286,1371,243,66,155,648,606,59,36,,,671,593,3.8900000000,76,10,14,4119,1389,119,511,559,152,158,0.97,New York Yankees,Yankee Stadium I,988975,96,92,NYY,NYA,NYA
+1940,AL,PHA,OAK,,8,154,71,54,100,,,N,N,703,5304,1391,242,53,105,556,656,48,33,,,932,780,5.2200000000,72,4,12,4035,1543,135,534,488,238,131,0.96,Philadelphia Athletics,Shibe Park,432145,97,101,PHA,PHA,PHA
+1940,AL,SLA,BAL,,6,156,77,67,87,,,N,N,757,5416,1423,278,58,118,556,642,51,40,,,882,781,5.1200000000,64,4,9,4119,1592,113,646,439,158,179,0.97,St. Louis Browns,Sportsman's Park IV,239591,102,105,SLB,SLA,SLA
+1940,AL,WS1,MIN,,7,154,77,64,90,,,N,N,665,5365,1453,266,67,52,468,504,94,40,,,811,688,4.5900000000,74,6,7,4050,1494,93,618,618,192,166,0.96,Washington Senators,Griffith Stadium I,381241,93,95,WSH,WS1,WS1
+1940,NL,BRO,LAD,,2,156,81,88,65,,,N,N,697,5470,1421,256,70,93,522,570,56,,,,621,557,3.5000000000,65,17,14,4299,1366,101,393,639,183,110,0.97,Brooklyn Dodgers,Ebbets Field,975978,108,105,BRO,BRO,BRO
+1940,NL,BSN,ATL,,7,152,75,65,87,,,N,N,623,5329,1366,219,50,59,402,581,48,,,,745,658,4.3600000000,76,9,12,4077,1444,83,573,435,183,169,0.97,Boston Bees,Braves Field,241616,94,96,BSN,BSN,BSN
+1940,NL,CHN,CHC,,5,154,77,75,79,,,N,N,681,5389,1441,272,48,86,482,566,63,,,,636,548,3.5400000000,69,12,14,4176,1418,74,430,564,199,143,0.96,Chicago Cubs,Wrigley Field,534878,98,97,CHC,CHN,CHN
+1940,NL,CIN,CIN,,1,155,77,100,53,,,Y,Y,707,5372,1427,264,38,89,453,503,72,,,,528,477,3.0500000000,91,10,11,4221,1263,73,445,557,117,158,0.98,Cincinnati Reds,Crosley Field,850180,102,99,CIN,CIN,CIN
+1940,NL,NY1,SFG,,6,152,76,72,80,,,N,N,663,5324,1423,201,46,91,453,478,45,,,,659,573,3.7900000000,57,11,18,4080,1383,110,473,606,139,132,0.97,New York Giants,Polo Grounds IV,747852,101,101,NYG,NY1,NY1
+1940,NL,PHI,PHI,,8,153,79,50,103,,,N,N,494,5137,1225,180,35,75,435,527,25,,,,750,663,4.4000000000,66,5,8,4071,1429,92,475,485,181,136,0.97,Philadelphia Phillies,Shibe Park,207177,95,101,PHI,PHI,PHI
+1940,NL,PIT,PIT,,4,156,75,78,76,,,N,N,809,5466,1511,276,68,76,553,494,69,,,,783,672,4.3600000000,49,8,24,4164,1569,72,492,491,217,160,0.96,Pittsburgh Pirates,Forbes Field,507934,99,99,PIT,PIT,PIT
+1940,NL,SLN,STL,,3,156,77,84,69,,,N,N,747,5499,1514,266,61,119,479,610,97,,,,699,594,3.8300000000,71,10,14,4188,1457,83,488,550,174,134,0.97,St. Louis Cardinals,Sportsman's Park IV,324078,106,103,STL,SLN,SLN
+1941,AL,BOS,BOS,,2,155,77,84,70,,,N,N,865,5359,1517,304,55,124,683,567,67,51,,,750,639,4.1900000000,70,8,11,4116,1453,88,611,574,169,139,0.97,Boston Red Sox,Fenway Park II,718497,103,101,BOS,BOS,BOS
+1941,AL,CHA,CHW,,3,156,79,77,77,,,N,N,638,5404,1376,245,47,47,510,476,91,53,,,649,554,3.5200000000,106,14,4,4248,1362,89,521,564,180,145,0.97,Chicago White Sox,Comiskey Park,677077,99,99,CHW,CHA,CHA
+1941,AL,CLE,CLE,,4,155,77,75,79,,,N,N,677,5283,1350,249,84,103,512,605,63,47,,,668,597,3.9000000000,68,10,19,4131,1366,71,660,617,142,158,0.97,Cleveland Indians,League Park II/Cleveland Stadium,745948,95,95,CLE,CLE,CLE
+1941,AL,DET,DET,,4,155,77,75,79,,,N,N,686,5370,1412,247,55,81,602,584,43,28,,,743,641,4.1800000000,52,8,16,4143,1399,80,645,697,186,129,0.96,Detroit Tigers,Briggs Stadium,684915,110,110,DET,DET,DET
+1941,AL,NYA,NYY,,1,156,78,101,53,,,Y,Y,830,5444,1464,243,60,151,616,565,51,33,,,631,548,3.5300000000,75,13,26,4188,1309,81,598,589,165,196,0.97,New York Yankees,Yankee Stadium I,964722,99,95,NYY,NYA,NYA
+1941,AL,PHA,OAK,,8,154,77,64,90,,,N,N,713,5336,1431,240,69,85,574,588,27,36,,,840,733,4.8300000000,64,3,18,4095,1516,136,557,386,200,150,0.96,Philadelphia Athletics,Shibe Park,528894,98,101,PHA,PHA,PHA
+1941,AL,SLA,BAL,,6,157,79,70,84,,,N,N,765,5408,1440,281,58,91,775,552,50,39,,,823,728,4.7200000000,65,7,10,4167,1563,120,549,454,151,156,0.97,St. Louis Browns,Sportsman's Park IV,176240,104,104,SLB,SLA,SLA
+1941,AL,WS1,MIN,,6,156,78,70,84,,,N,N,728,5521,1502,257,80,52,470,488,79,36,,,798,671,4.3500000000,69,8,7,4167,1524,69,603,544,188,169,0.96,Washington Senators,Griffith Stadium I,415663,95,97,WSH,WS1,WS1
+1941,NL,BRO,LAD,,1,157,79,100,54,,,Y,N,800,5485,1494,286,69,101,600,535,36,,,,581,496,3.1400000000,66,17,22,4263,1236,81,495,603,162,125,0.97,Brooklyn Dodgers,Ebbets Field,1214910,106,102,BRO,BRO,BRO
+1941,NL,BSN,ATL,,7,156,76,62,92,,,N,N,592,5414,1357,231,38,48,471,608,61,,,,720,608,3.9500000000,62,10,9,4155,1440,75,554,446,190,174,0.97,Boston Braves,Braves Field,263680,94,97,BSN,BSN,BSN
+1941,NL,CHN,CHC,,6,155,77,70,84,,,N,N,666,5230,1323,239,25,99,559,670,39,,,,670,564,3.7200000000,74,8,9,4092,1431,60,449,548,180,139,0.97,Chicago Cubs,Wrigley Field,545159,96,96,CHC,CHN,CHN
+1941,NL,CIN,CIN,,3,154,79,88,66,,,N,N,616,5218,1288,213,33,64,477,428,68,,,,564,488,3.1700000000,89,19,10,4158,1300,61,510,627,150,147,0.97,Cincinnati Reds,Crosley Field,643513,101,99,CIN,CIN,CIN
+1941,NL,NY1,SFG,,5,156,78,74,79,,,N,N,667,5395,1401,248,35,95,504,518,36,,,,706,609,3.9400000000,55,12,18,4173,1455,90,539,566,160,144,0.97,New York Giants,Polo Grounds IV,763098,103,102,NYG,NY1,NY1
+1941,NL,PHI,PHI,,8,155,76,43,111,,,N,N,501,5233,1277,188,38,64,451,596,65,,,,793,686,4.5000000000,35,4,9,4116,1499,79,606,552,186,147,0.96,Philadelphia Phillies,Shibe Park,231401,95,101,PHI,PHI,PHI
+1941,NL,PIT,PIT,,4,156,78,81,73,,,N,N,690,5297,1417,233,65,56,547,516,59,,,,643,531,3.4800000000,71,8,12,4122,1392,66,492,410,194,130,0.96,Pittsburgh Pirates,Forbes Field,482241,100,100,PIT,PIT,PIT
+1941,NL,SLN,STL,,2,155,79,97,56,,,N,N,734,5457,1482,254,56,70,540,543,47,,,,589,502,3.1900000000,64,15,20,4248,1289,85,502,659,171,146,0.97,St. Louis Cardinals,Sportsman's Park IV,633645,107,104,STL,SLN,SLN
+1942,AL,BOS,BOS,,2,152,77,93,59,,,N,N,761,5248,1451,244,55,103,591,508,68,61,,,594,519,3.4400000000,84,11,17,4074,1260,65,553,500,157,156,0.97,Boston Red Sox,Fenway Park II,730340,104,102,BOS,BOS,BOS
+1942,AL,CHA,CHW,,6,148,70,66,82,,,N,N,538,4949,1215,214,36,25,497,427,114,70,,,609,523,3.5800000000,86,8,8,3942,1304,74,473,432,173,144,0.97,Chicago White Sox,Comiskey Park,425734,97,98,CHW,CHA,CHA
+1942,AL,CLE,CLE,,4,156,80,75,79,,,N,N,590,5317,1344,223,58,50,500,544,69,74,,,659,559,3.5900000000,61,12,11,4206,1353,61,560,448,163,175,0.97,Cleveland Indians,League Park II/Cleveland Stadium,459447,94,94,CLE,CLE,CLE
+1942,AL,DET,DET,,5,156,77,73,81,,,N,N,589,5327,1313,217,37,76,509,476,39,40,,,587,487,3.1300000000,65,12,14,4197,1321,60,598,671,193,142,0.96,Detroit Tigers,Briggs Stadium,580087,108,108,DET,DET,DET
+1942,AL,NYA,NYY,,1,154,77,103,51,,,Y,N,801,5305,1429,223,57,108,591,556,69,33,,,507,445,2.9100000000,88,18,17,4125,1259,71,431,558,142,190,0.97,New York Yankees,Yankee Stadium I,922011,98,94,NYY,NYA,NYA
+1942,AL,PHA,OAK,,8,154,76,55,99,,,N,N,549,5285,1315,213,46,33,440,490,44,45,,,801,679,4.4500000000,67,5,9,4122,1404,89,639,546,188,124,0.96,Philadelphia Athletics,Shibe Park,423487,100,104,PHA,PHA,PHA
+1942,AL,SLA,BAL,,3,151,77,82,69,,,N,N,730,5229,1354,239,62,98,609,607,37,38,,,637,544,3.5900000000,68,12,13,4089,1387,63,505,488,167,143,0.97,St. Louis Browns,Sportsman's Park IV,255617,102,102,SLB,SLA,SLA
+1942,AL,WS1,MIN,,7,151,77,62,89,,,N,N,653,5295,1364,224,49,40,581,536,98,29,,,817,685,4.5800000000,68,12,11,4038,1496,50,558,496,222,133,0.96,Washington Senators,Griffith Stadium I,403493,99,100,WSH,WS1,WS1
+1942,NL,BRO,LAD,,2,155,79,104,50,,,N,N,742,5285,1398,263,34,62,572,484,81,,,,510,441,2.8400000000,67,16,24,4194,1205,73,493,612,138,150,0.97,Brooklyn Dodgers,Ebbets Field,1037765,103,99,BRO,BRO,BRO
+1942,NL,BSN,ATL,,7,150,71,59,89,,,N,N,515,5077,1216,210,19,68,474,507,49,,,,645,557,3.7600000000,68,9,8,4002,1326,82,518,414,139,138,0.97,Boston Braves,Braves Field,285332,97,100,BSN,BSN,BSN
+1942,NL,CHN,CHC,,6,155,78,68,86,,,N,N,591,5352,1360,224,41,75,509,607,63,,,,665,560,3.6000000000,71,10,14,4200,1447,70,525,507,169,169,0.97,Chicago Cubs,Wrigley Field,590972,96,96,CHC,CHN,CHN
+1942,NL,CIN,CIN,,4,154,77,76,76,,,N,N,527,5260,1216,198,39,66,483,549,42,,,,545,442,2.8200000000,80,12,8,4233,1213,47,526,616,175,158,0.97,Cincinnati Reds,Crosley Field,427031,100,99,CIN,CIN,CIN
+1942,NL,NY1,SFG,,3,154,79,85,67,,,N,N,675,5210,1323,162,35,109,558,511,39,,,,600,504,3.3100000000,70,12,13,4110,1299,94,493,497,137,128,0.97,New York Giants,Polo Grounds IV,779621,101,102,NYG,NY1,NY1
+1942,NL,PHI,PHI,,8,151,74,42,109,,,N,N,394,5060,1174,168,37,44,392,488,37,,,,706,614,4.1200000000,51,2,6,4023,1328,61,605,472,193,147,0.96,Philadelphia Phillies,Shibe Park,230183,94,99,PHI,PHI,PHI
+1942,NL,PIT,PIT,,5,151,77,66,81,,,N,N,585,5104,1250,173,49,54,537,536,41,,,,631,537,3.5800000000,64,13,11,4053,1376,62,435,426,182,129,0.96,Pittsburgh Pirates,Forbes Field,448897,103,102,PIT,PIT,PIT
+1942,NL,SLN,STL,,1,156,78,106,48,,,Y,Y,755,5421,1454,282,69,60,551,507,71,,,,482,399,2.5500000000,70,18,15,4230,1192,49,473,651,169,137,0.97,St. Louis Cardinals,Sportsman's Park IV,553552,108,104,STL,SLN,SLN
+1943,AL,BOS,BOS,,7,155,77,68,84,,,N,N,563,5392,1314,223,42,57,486,591,86,61,,,607,547,3.4500000000,62,13,16,4278,1369,61,615,513,153,179,0.97,Boston Red Sox,Fenway Park II,358275,102,101,BOS,BOS,BOS
+1943,AL,CHA,CHW,,4,155,76,82,72,,,N,N,573,5254,1297,193,46,33,561,581,173,87,,,594,498,3.2000000000,70,12,19,4200,1352,54,501,476,166,167,0.97,Chicago White Sox,Comiskey Park,508962,99,101,CHW,CHA,CHA
+1943,AL,CLE,CLE,,3,153,77,82,71,,,N,N,600,5269,1344,246,45,55,567,521,47,58,,,577,492,3.1500000000,64,14,20,4218,1234,52,606,585,157,183,0.97,Cleveland Indians,League Park II/Cleveland Stadium,438894,93,94,CLE,CLE,CLE
+1943,AL,DET,DET,,5,155,78,78,76,,,N,N,632,5364,1401,200,47,77,483,553,40,43,,,560,470,3.0000000000,67,18,20,4233,1226,51,549,706,177,130,0.97,Detroit Tigers,Briggs Stadium,606287,107,106,DET,DET,DET
+1943,AL,NYA,NYY,,1,155,77,98,56,,,Y,Y,669,5282,1350,218,59,100,624,562,46,60,,,542,461,2.9300000000,83,14,13,4245,1229,60,489,653,160,166,0.97,New York Yankees,Yankee Stadium I,618330,101,98,NYY,NYA,NYA
+1943,AL,PHA,OAK,,8,155,79,49,105,,,N,N,497,5244,1219,174,44,26,430,465,55,42,,,717,627,4.0500000000,73,5,13,4182,1421,73,536,503,162,148,0.97,Philadelphia Athletics,Shibe Park,376735,99,103,PHA,PHA,PHA
+1943,AL,SLA,BAL,,6,153,77,72,80,,,N,N,596,5175,1269,229,36,78,569,646,37,43,,,604,525,3.4100000000,64,10,14,4155,1397,74,488,572,152,127,0.97,St. Louis Browns,Sportsman's Park IV,214392,104,102,SLB,SLA,SLA
+1943,AL,WS1,MIN,,2,153,76,84,69,,,N,N,666,5233,1328,245,50,47,605,579,142,55,,,595,490,3.1800000000,61,16,21,4164,1293,48,540,495,179,145,0.97,Washington Senators,Griffith Stadium I,574694,96,97,WSH,WS1,WS1
+1943,NL,BRO,LAD,,3,153,77,81,72,,,N,N,716,5309,1444,263,35,39,580,422,58,,,,674,590,3.8800000000,50,13,22,4107,1326,59,637,588,167,137,0.97,Brooklyn Dodgers,Ebbets Field,661739,101,100,BRO,BRO,BRO
+1943,NL,BSN,ATL,,6,153,77,68,85,,,N,N,465,5196,1213,202,36,39,469,609,56,,,,612,504,3.2500000000,87,13,4,4191,1361,66,441,409,178,139,0.97,Boston Braves,Braves Field,271289,98,100,BSN,BSN,BSN
+1943,NL,CHN,CHC,,5,154,75,74,79,,,N,N,632,5279,1380,207,56,52,574,522,53,,,,600,510,3.3100000000,67,13,14,4158,1379,53,394,513,167,138,0.97,Chicago Cubs,Wrigley Field,508247,98,98,CHC,CHN,CHN
+1943,NL,CIN,CIN,,2,155,78,87,67,,,N,N,608,5329,1362,229,47,43,445,476,49,,,,543,488,3.1300000000,78,18,17,4212,1299,38,579,498,121,193,0.98,Cincinnati Reds,Crosley Field,379122,99,99,CIN,CIN,CIN
+1943,NL,NY1,SFG,,8,156,77,55,98,,,N,N,558,5290,1309,153,33,81,480,470,35,,,,713,632,4.0800000000,35,6,19,4182,1474,80,626,588,167,140,0.97,New York Giants,Polo Grounds IV,466095,100,101,NYG,NY1,NY1
+1943,NL,PHI,PHI,,7,157,78,64,90,,,N,N,571,5297,1321,186,36,66,499,556,29,,,,676,586,3.7900000000,66,10,14,4176,1436,59,451,431,187,143,0.97,Philadelphia Blue Jays,Shibe Park,466975,95,99,PHI,PHI,PHI
+1943,NL,PIT,PIT,,4,157,78,80,74,,,N,N,669,5353,1401,240,73,42,573,566,64,,,,605,480,3.0800000000,74,11,12,4212,1424,44,422,396,170,159,0.97,Pittsburgh Pirates,Forbes Field,498740,104,103,PIT,PIT,PIT
+1943,NL,SLN,STL,,1,157,81,105,49,,,Y,N,679,5438,1515,259,72,70,428,438,40,,,,475,407,2.5700000000,94,21,15,4281,1246,33,477,639,151,183,0.97,St. Louis Cardinals,Sportsman's Park IV,517135,106,101,STL,SLN,SLN
+1944,AL,BOS,BOS,,4,156,78,77,77,,,N,N,739,5400,1456,277,56,69,522,505,60,40,,,676,592,3.8200000000,58,7,17,4182,1404,66,592,524,172,154,0.97,Boston Red Sox,Fenway Park II,506975,99,100,BOS,BOS,BOS
+1944,AL,CHA,CHW,,7,154,77,71,83,,,N,N,543,5292,1307,210,55,23,439,448,66,47,,,662,553,3.5800000000,64,5,17,4170,1411,68,420,481,183,154,0.97,Chicago White Sox,Comiskey Park,563539,98,99,CHW,CHA,CHA
+1944,AL,CLE,CLE,,5,155,78,72,82,,,N,N,643,5481,1458,270,50,70,512,593,48,42,,,677,575,3.6500000000,48,7,18,4257,1428,40,621,524,164,192,0.97,Cleveland Indians,League Park II/Cleveland Stadium,475272,96,96,CLE,CLE,CLE
+1944,AL,DET,DET,,2,156,78,88,66,,,N,N,658,5344,1405,220,44,60,532,500,61,55,,,581,481,3.0900000000,87,20,8,4200,1373,39,452,568,190,184,0.97,Detroit Tigers,Briggs Stadium,923176,105,103,DET,DET,DET
+1944,AL,NYA,NYY,,3,154,78,83,71,,,N,N,674,5331,1410,216,74,96,523,627,91,31,,,617,524,3.3900000000,78,9,13,4170,1351,82,532,529,156,170,0.97,New York Yankees,Yankee Stadium I,789995,104,102,NYY,NYA,NYA
+1944,AL,PHA,OAK,,5,155,76,72,82,,,N,N,525,5312,1364,169,47,36,422,490,42,32,,,594,506,3.2600000000,72,10,14,4191,1345,58,390,534,174,127,0.97,Philadelphia Athletics,Shibe Park,505322,97,101,PHA,PHA,PHA
+1944,AL,SLA,BAL,,1,154,77,89,65,,,Y,N,684,5269,1328,223,45,72,531,604,44,33,,,587,492,3.1700000000,71,16,17,4191,1392,58,469,581,171,142,0.97,St. Louis Browns,Sportsman's Park IV,508644,107,107,SLB,SLA,SLA
+1944,AL,WS1,MIN,,8,154,77,64,90,,,N,N,592,5319,1386,186,42,33,470,477,127,59,,,664,536,3.4900000000,83,13,11,4143,1410,48,475,503,218,156,0.96,Washington Senators,Griffith Stadium I,525235,95,95,WSH,WS1,WS1
+1944,NL,BRO,LAD,,7,155,77,63,91,,,N,N,690,5393,1450,255,51,56,486,451,45,,,,832,711,4.6800000000,50,4,13,4101,1471,75,660,487,197,112,0.96,Brooklyn Dodgers,Ebbets Field,605905,98,98,BRO,BRO,BRO
+1944,NL,BSN,ATL,,6,155,78,65,89,,,N,N,593,5282,1299,250,39,79,456,509,37,,,,674,566,3.6700000000,70,13,12,4164,1430,80,527,454,182,160,0.97,Boston Braves,Braves Field,208691,104,106,BSN,BSN,BSN
+1944,NL,CHN,CHC,,4,157,78,75,79,,,N,N,702,5462,1425,236,46,71,520,521,53,,,,669,558,3.5900000000,70,11,13,4200,1484,75,458,545,185,151,0.97,Chicago Cubs,Wrigley Field,640110,99,97,CHC,CHN,CHN
+1944,NL,CIN,CIN,,3,155,78,89,65,,,N,N,573,5271,1340,229,31,51,423,391,51,,,,537,461,2.9700000000,93,17,12,4194,1292,60,390,369,138,153,0.97,Cincinnati Reds,Crosley Field,409567,96,97,CIN,CIN,CIN
+1944,NL,NY1,SFG,,5,155,75,67,87,,,N,N,682,5306,1398,191,47,93,512,480,39,,,,773,650,4.2900000000,47,4,21,4089,1413,116,587,499,179,128,0.97,New York Giants,Polo Grounds IV,674483,99,101,NYG,NY1,NY1
+1944,NL,PHI,PHI,,8,154,79,61,92,,,N,N,539,5301,1331,199,42,55,470,500,32,,,,658,564,3.6400000000,66,11,6,4185,1407,49,459,496,177,138,0.97,Philadelphia Blue Jays,Shibe Park,369586,96,99,PHI,PHI,PHI
+1944,NL,PIT,PIT,,2,158,81,90,63,,,N,N,744,5428,1441,248,80,70,573,616,87,,,,662,540,3.4400000000,77,10,19,4242,1466,65,435,452,191,122,0.97,Pittsburgh Pirates,Forbes Field,604278,105,103,PIT,PIT,PIT
+1944,NL,SLN,STL,,1,157,77,105,49,,,Y,Y,772,5475,1507,274,59,100,544,473,37,,,,490,423,2.6700000000,89,26,12,4281,1228,55,468,637,112,162,0.98,St. Louis Cardinals,Sportsman's Park IV,461968,103,99,STL,SLN,SLN
+1945,AL,BOS,BOS,,7,157,78,71,83,,,N,N,599,5367,1393,225,44,50,541,534,72,50,,,674,587,3.8000000000,71,15,13,4170,1389,58,656,490,168,198,0.97,Boston Red Sox,Fenway Park II,603794,103,101,BOS,BOS,BOS
+1945,AL,CHA,CHW,,6,150,74,71,78,,,N,N,596,5077,1330,204,55,22,470,467,78,54,,,633,545,3.6900000000,84,13,13,3990,1400,63,448,486,180,139,0.97,Chicago White Sox,Comiskey Park,657981,97,98,CHW,CHA,CHA
+1945,AL,CLE,CLE,,5,147,77,73,72,,,N,N,557,4898,1249,216,48,65,505,578,19,31,,,548,479,3.3100000000,76,14,12,3906,1269,39,501,497,126,149,0.97,Cleveland Indians,League Park II/Cleveland Stadium,558182,95,96,CLE,CLE,CLE
+1945,AL,DET,DET,,1,155,76,88,65,,,Y,Y,633,5257,1345,227,47,77,517,533,60,54,,,565,463,2.9900000000,78,19,16,4179,1305,48,538,588,158,173,0.97,Detroit Tigers,Briggs Stadium,1280341,107,105,DET,DET,DET
+1945,AL,NYA,NYY,,4,152,76,81,71,,,N,N,676,5176,1343,189,61,93,618,567,64,43,,,606,519,3.4500000000,78,9,14,4065,1277,66,485,474,175,170,0.97,New York Yankees,Yankee Stadium I,881845,105,103,NYY,NYA,NYA
+1945,AL,PHA,OAK,,8,153,77,52,98,,,N,N,494,5296,1297,201,37,33,449,463,25,45,,,638,555,3.6200000000,65,11,8,4143,1380,55,571,531,152,160,0.97,Philadelphia Athletics,Shibe Park,462631,98,101,PHA,PHA,PHA
+1945,AL,SLA,BAL,,3,154,76,81,70,,,N,N,597,5227,1302,215,37,63,500,555,25,31,,,548,482,3.1400000000,91,10,8,4146,1307,59,506,570,143,123,0.97,St. Louis Browns,Sportsman's Park IV,482986,106,106,SLB,SLA,SLA
+1945,AL,WS1,MIN,,2,156,78,87,67,,,N,N,622,5326,1375,197,63,27,545,489,110,65,,,562,458,2.9200000000,82,19,11,4236,1307,42,440,550,183,124,0.97,Washington Senators,Griffith Stadium I,652660,91,92,WSH,WS1,WS1
+1945,NL,BRO,LAD,,3,155,78,87,67,,,N,N,795,5418,1468,257,71,57,629,434,75,,,,724,572,3.7000000000,61,7,18,4176,1357,74,586,557,230,144,0.96,Brooklyn Dodgers,Ebbets Field,1059220,99,99,BRO,BRO,BRO
+1945,NL,BSN,ATL,,6,154,75,67,85,,,N,N,721,5441,1453,229,25,101,520,510,82,,,,728,624,4.0400000000,57,7,13,4173,1474,99,557,404,193,160,0.96,Boston Braves,Braves Field,374178,100,101,BSN,BSN,BSN
+1945,NL,CHN,CHC,,1,155,76,98,56,,,Y,N,735,5298,1465,229,52,57,554,462,69,,,,532,452,2.9800000000,86,15,14,4098,1301,57,385,541,119,124,0.98,Chicago Cubs,Wrigley Field,1036386,98,96,CHC,CHN,CHN
+1945,NL,CIN,CIN,,7,154,77,61,93,,,N,N,536,5283,1317,221,26,56,392,532,71,,,,694,607,4.0000000000,77,11,6,4095,1438,70,534,372,146,138,0.97,Cincinnati Reds,Crosley Field,290070,98,99,CIN,CIN,CIN
+1945,NL,NY1,SFG,,5,154,78,78,74,,,N,N,668,5350,1439,175,35,114,501,457,38,,,,700,620,4.0600000000,53,13,21,4122,1401,85,528,530,166,112,0.97,New York Giants,Polo Grounds IV,1016468,101,102,NYG,NY1,NY1
+1945,NL,PHI,PHI,,8,154,77,46,108,,,N,N,548,5203,1278,197,27,56,449,501,54,,,,865,697,4.6400000000,31,4,26,4056,1544,61,608,432,234,150,0.96,Philadelphia Phillies,Shibe Park,285057,96,100,PHI,PHI,PHI
+1945,NL,PIT,PIT,,4,155,79,82,72,,,N,N,753,5343,1425,259,56,72,590,480,81,,,,686,579,3.7600000000,73,8,16,4161,1477,61,455,518,178,141,0.97,Pittsburgh Pirates,Forbes Field,604694,104,104,PIT,PIT,PIT
+1945,NL,SLN,STL,,2,155,78,95,59,,,N,N,756,5487,1498,256,44,64,515,488,55,,,,583,507,3.2400000000,77,18,9,4224,1351,70,497,510,136,150,0.97,St. Louis Cardinals,Sportsman's Park IV,594630,103,99,STL,SLN,SLN
+1946,AL,BOS,BOS,,1,156,78,104,50,,,Y,N,792,5318,1441,268,50,109,687,661,45,36,,,594,524,3.3800000000,79,15,20,4188,1359,89,501,667,139,165,0.97,Boston Red Sox,Fenway Park II,1416944,106,105,BOS,BOS,BOS
+1946,AL,CHA,CHW,,5,155,79,74,80,,,N,N,562,5312,1364,206,44,37,501,600,78,64,,,595,479,3.1000000000,62,9,16,4176,1348,80,508,550,173,170,0.97,Chicago White Sox,Comiskey Park,983403,96,97,CHW,CHA,CHA
+1946,AL,CLE,CLE,,6,156,77,68,86,,,N,N,537,5242,1285,233,56,79,506,697,57,49,,,638,558,3.6200000000,63,16,13,4164,1282,84,649,789,147,147,0.97,Cleveland Indians,League Park II/Cleveland Stadium,1057289,93,94,CLE,CLE,CLE
+1946,AL,DET,DET,,2,155,79,92,62,,,N,N,704,5318,1373,212,41,108,622,616,65,41,,,567,502,3.2200000000,94,18,15,4206,1277,97,497,896,155,138,0.97,Detroit Tigers,Briggs Stadium,1722590,107,105,DET,DET,DET
+1946,AL,NYA,NYY,,3,154,77,87,67,,,N,N,684,5139,1275,208,50,136,627,706,48,35,,,547,473,3.1300000000,68,17,17,4083,1232,66,552,653,147,174,0.97,New York Yankees,Yankee Stadium I,2265512,101,98,NYY,NYA,NYA
+1946,AL,PHA,OAK,,8,155,78,49,105,,,N,N,529,5200,1317,220,51,40,482,594,39,30,,,680,582,3.9000000000,61,10,5,4026,1371,83,577,562,167,141,0.97,Philadelphia Athletics,Shibe Park,621793,98,100,PHA,PHA,PHA
+1946,AL,SLA,BAL,,7,156,77,66,88,,,N,N,621,5373,1350,220,46,84,465,713,23,35,,,710,607,3.9500000000,63,13,12,4146,1465,73,573,574,159,157,0.97,St. Louis Browns,Sportsman's Park IV,526435,106,107,SLB,SLA,SLA
+1946,AL,WS1,MIN,,4,155,76,76,78,,,N,N,608,5337,1388,260,63,60,511,641,51,50,,,706,580,3.7400000000,71,8,10,4188,1459,81,547,537,211,162,0.96,Washington Senators,Griffith Stadium I,1027216,94,95,WSH,WS1,WS1
+1946,NL,BRO,LAD,,2,157,79,96,60,,,N,N,701,5285,1376,233,66,55,691,575,100,,,,570,481,3.0500000000,52,14,28,4254,1280,58,671,647,174,154,0.97,Brooklyn Dodgers,Ebbets Field,1796824,101,99,BRO,BRO,BRO
+1946,NL,BSN,ATL,,4,154,77,81,72,,,N,N,630,5225,1377,238,48,44,558,468,60,,,,592,510,3.3500000000,73,10,12,4113,1291,76,478,566,169,129,0.97,Boston Braves,Braves Field,969673,101,101,BSN,BSN,BSN
+1946,NL,CHN,CHC,,3,155,77,82,71,,,N,N,626,5298,1344,223,50,56,586,599,43,,,,581,501,3.2400000000,59,15,11,4179,1370,58,527,619,146,119,0.97,Chicago Cubs,Wrigley Field,1342970,98,97,CHC,CHN,CHN
+1946,NL,CIN,CIN,,6,156,77,67,87,,,N,N,523,5291,1262,206,33,65,493,604,82,,,,570,484,3.0800000000,69,17,11,4239,1334,70,467,506,152,192,0.97,Cincinnati Reds,Crosley Field,715751,97,99,CIN,CIN,CIN
+1946,NL,NY1,SFG,,8,154,77,61,93,,,N,N,612,5191,1326,176,37,121,532,546,46,,,,685,589,3.9200000000,47,8,13,4059,1313,114,660,581,159,121,0.97,New York Giants,Polo Grounds IV,1219873,100,101,NYG,NY1,NY1
+1946,NL,PHI,PHI,,5,155,78,69,85,,,N,N,560,5233,1351,209,40,80,417,590,41,,,,705,607,3.9900000000,55,11,23,4107,1442,73,542,490,147,144,0.97,Philadelphia Phillies,Shibe Park,1045247,97,100,PHI,PHI,PHI
+1946,NL,PIT,PIT,,7,155,78,63,91,,,N,N,552,5199,1300,202,52,60,592,555,48,,,,668,566,3.7200000000,61,10,6,4110,1406,50,561,458,184,127,0.97,Pittsburgh Pirates,Forbes Field,749962,103,104,PIT,PIT,PIT
+1946,NL,SLN,STL,,1,156,78,98,58,,,Y,Y,712,5372,1426,265,56,81,530,537,58,,,,545,467,3.0100000000,75,18,15,4191,1326,63,493,607,123,167,0.98,St. Louis Cardinals,Sportsman's Park IV,1061807,104,101,STL,SLN,SLN
+1947,AL,BOS,BOS,,3,157,81,83,71,,,N,N,720,5322,1412,206,54,103,666,590,41,35,,,669,589,3.8100000000,64,13,19,4173,1383,84,575,586,137,172,0.97,Boston Red Sox,Fenway Park II,1427315,107,105,BOS,BOS,BOS
+1947,AL,CHA,CHW,,6,155,75,70,84,,,N,N,553,5274,1350,211,41,53,492,527,91,57,,,661,563,3.6400000000,47,11,27,4173,1384,76,603,522,155,180,0.97,Chicago White Sox,Comiskey Park,876948,96,98,CHW,CHA,CHA
+1947,AL,CLE,CLE,,4,157,78,80,74,,,N,N,687,5367,1392,234,51,112,502,609,29,25,,,588,536,3.4400000000,55,13,29,4206,1244,94,628,590,104,178,0.98,Cleveland Indians,Cleveland Stadium,1521978,98,94,CLE,CLE,CLE
+1947,AL,DET,DET,,2,158,80,85,69,,,N,N,714,5276,1363,234,42,103,762,565,52,60,,,642,555,3.5700000000,77,15,18,4194,1382,79,531,648,155,142,0.97,Detroit Tigers,Briggs Stadium,1398093,104,103,DET,DET,DET
+1947,AL,NYA,NYY,,1,155,77,97,57,,,Y,Y,794,5308,1439,230,72,115,610,581,27,23,,,568,518,3.3900000000,73,14,21,4122,1221,95,628,691,109,151,0.98,New York Yankees,Yankee Stadium I,2178937,99,95,NYY,NYA,NYA
+1947,AL,PHA,OAK,,5,156,78,78,76,,,N,N,633,5198,1311,218,52,61,605,563,37,33,,,614,542,3.5100000000,70,12,15,4173,1291,85,597,493,143,161,0.97,Philadelphia Athletics,Shibe Park,911566,102,103,PHA,PHA,PHA
+1947,AL,SLA,BAL,,8,154,77,59,95,,,N,N,564,5145,1238,189,52,90,583,664,69,49,,,744,657,4.3300000000,50,7,13,4095,1426,103,604,552,134,169,0.97,St. Louis Browns,Sportsman's Park IV,320474,102,105,SLB,SLA,SLA
+1947,AL,WS1,MIN,,7,154,77,64,90,,,N,N,496,5112,1234,186,48,42,525,534,53,51,,,675,601,3.9700000000,67,15,12,4086,1408,63,579,551,142,151,0.97,Washington Senators,Griffith Stadium I,850758,97,100,WSH,WS1,WS1
+1947,NL,BRO,LAD,,1,155,78,94,60,,,Y,N,774,5249,1428,241,50,83,732,561,88,,,,668,584,3.8200000000,47,14,34,4125,1299,104,626,592,129,164,0.97,Brooklyn Dodgers,Ebbets Field,1807526,104,101,BRO,BRO,BRO
+1947,NL,BSN,ATL,,3,154,77,86,68,,,N,N,701,5253,1444,265,42,85,558,500,58,,,,622,548,3.6200000000,74,14,13,4086,1342,93,453,494,153,124,0.97,Boston Braves,Braves Field,1277361,98,97,BSN,BSN,BSN
+1947,NL,CHN,CHC,,6,155,79,69,85,,,N,N,567,5305,1373,231,48,71,471,578,22,,,,722,614,4.0400000000,46,8,15,4101,1449,106,618,571,150,159,0.97,Chicago Cubs,Wrigley Field,1364039,96,97,CHC,CHN,CHN
+1947,NL,CIN,CIN,,5,154,77,73,81,,,N,N,681,5299,1372,242,43,95,539,530,46,,,,755,669,4.4100000000,54,13,13,4095,1442,102,589,633,136,134,0.97,Cincinnati Reds,Crosley Field,899975,100,102,CIN,CIN,CIN
+1947,NL,NY1,SFG,,4,155,76,81,73,,,N,N,830,5343,1446,220,48,221,494,568,29,,,,761,672,4.4400000000,58,6,14,4089,1428,122,590,553,155,136,0.97,New York Giants,Polo Grounds IV,1600793,101,100,NYG,NY1,NY1
+1947,NL,PHI,PHI,,7,155,77,62,92,,,N,N,589,5256,1354,210,52,60,464,594,60,,,,687,599,3.9600000000,70,8,14,4086,1399,98,513,514,152,140,0.97,Philadelphia Phillies,Shibe Park,907332,96,98,PHI,PHI,PHI
+1947,NL,PIT,PIT,,7,156,79,62,92,,,N,N,744,5307,1385,216,44,156,607,687,30,,,,817,714,4.6800000000,44,9,13,4122,1488,155,592,530,149,131,0.97,Pittsburgh Pirates,Forbes Field,1283531,103,104,PIT,PIT,PIT
+1947,NL,SLN,STL,,2,156,77,89,65,,,N,N,780,5422,1462,235,65,115,612,511,28,,,,634,548,3.5300000000,65,12,20,4191,1417,106,495,642,127,169,0.97,St. Louis Cardinals,Sportsman's Park IV,1247913,104,101,STL,SLN,SLN
+1948,AL,BOS,BOS,,2,155,78,96,59,,,N,N,907,5363,1471,277,40,121,823,552,38,17,,,720,653,4.2600000000,70,11,13,4137,1445,83,592,513,116,174,0.98,Boston Red Sox,Fenway Park II,1558798,105,102,BOS,BOS,BOS
+1948,AL,CHA,CHW,,8,154,76,51,101,,,N,N,559,5192,1303,172,39,55,595,528,46,47,,,814,731,4.8900000000,35,2,23,4035,1454,89,673,403,154,176,0.97,Chicago White Sox,Comiskey Park,777844,96,99,CHW,CHA,CHA
+1948,AL,CLE,CLE,,1,156,79,97,58,,,Y,Y,840,5446,1534,242,54,155,646,575,54,44,,,568,504,3.2200000000,66,26,30,4227,1246,82,628,595,114,183,0.98,Cleveland Indians,Cleveland Stadium,2620627,97,95,CLE,CLE,CLE
+1948,AL,DET,DET,,5,154,77,78,76,,,N,N,700,5235,1396,219,58,78,671,504,22,32,,,726,635,4.1500000000,60,5,22,4131,1367,92,589,678,155,143,0.97,Detroit Tigers,Briggs Stadium,1743035,103,102,DET,DET,DET
+1948,AL,NYA,NYY,,3,154,77,94,60,,,N,N,857,5324,1480,251,75,139,623,478,24,24,,,633,569,3.7500000000,62,16,24,4095,1289,94,641,654,120,161,0.97,New York Yankees,Yankee Stadium I,2373901,99,95,NYY,NYA,NYA
+1948,AL,PHA,OAK,,4,154,77,84,70,,,N,N,729,5181,1345,231,47,68,726,523,40,32,,,735,673,4.4300000000,74,7,18,4104,1456,86,638,486,113,180,0.98,Philadelphia Athletics,Shibe Park,945076,101,101,PHA,PHA,PHA
+1948,AL,SLA,BAL,,6,155,76,59,94,,,N,N,671,5303,1438,251,62,63,578,572,63,44,,,849,764,5.0100000000,35,4,20,4119,1513,103,737,531,168,190,0.97,St. Louis Browns,Sportsman's Park IV,335564,103,106,SLB,SLA,SLA
+1948,AL,WS1,MIN,,7,154,78,56,97,,,N,N,578,5111,1245,203,75,31,568,572,76,48,,,796,701,4.6500000000,42,4,22,4071,1439,81,734,446,154,144,0.97,Washington Senators,Griffith Stadium I,795254,97,101,WSH,WS1,WS1
+1948,NL,BRO,LAD,,3,155,78,84,70,,,N,N,744,5328,1393,256,54,91,601,684,114,,,,667,580,3.7500000000,52,9,22,4176,1328,119,633,670,160,151,0.97,Brooklyn Dodgers,Ebbets Field,1398967,104,101,BRO,BRO,BRO
+1948,NL,BSN,ATL,,1,154,76,91,62,,,Y,N,739,5297,1458,272,49,95,671,536,43,,,,584,520,3.3700000000,70,10,17,4167,1354,93,430,579,143,132,0.97,Boston Braves,Braves Field,1455439,99,98,BSN,BSN,BSN
+1948,NL,CHN,CHC,,8,155,78,64,90,,,N,N,597,5352,1402,225,44,87,443,578,39,,,,706,602,4.0000000000,51,7,10,4065,1355,89,619,636,172,152,0.97,Chicago Cubs,Wrigley Field,1237792,95,98,CHC,CHN,CHN
+1948,NL,CIN,CIN,,7,153,77,64,89,,,N,N,588,5127,1266,221,37,104,478,586,42,,,,752,667,4.4700000000,40,8,20,4029,1410,104,572,599,153,135,0.97,Cincinnati Reds,Crosley Field,823386,97,99,CIN,CIN,CIN
+1948,NL,NY1,SFG,,5,155,77,78,76,,,N,N,780,5277,1352,210,49,164,599,648,51,,,,704,600,3.9300000000,54,15,21,4119,1425,122,556,527,156,134,0.97,New York Giants,Polo Grounds IV,1459269,101,100,NYG,NY1,NY1
+1948,NL,PHI,PHI,,6,155,76,66,88,,,N,N,591,5287,1367,227,39,91,440,598,68,,,,729,617,4.0800000000,61,6,15,4086,1385,95,556,550,210,126,0.96,Philadelphia Phillies,Shibe Park,767429,98,99,PHI,PHI,PHI
+1948,NL,PIT,PIT,,4,156,80,83,71,,,N,N,706,5286,1388,191,54,108,580,578,68,,,,699,632,4.1500000000,65,5,19,4113,1373,120,564,543,135,150,0.97,Pittsburgh Pirates,Forbes Field,1517021,102,103,PIT,PIT,PIT
+1948,NL,SLN,STL,,2,155,77,85,69,,,N,N,742,5302,1396,238,58,105,594,521,24,,,,646,594,3.9100000000,60,13,18,4104,1392,103,476,625,118,138,0.98,St. Louis Cardinals,Sportsman's Park IV,1111440,106,103,STL,SLN,SLN
+1949,AL,BOS,BOS,,2,155,77,96,58,,,N,N,896,5320,1500,272,36,131,835,510,43,25,,,667,607,3.9700000000,84,16,16,4131,1375,82,661,598,120,207,0.98,Boston Red Sox,Fenway Park II,1596650,108,104,BOS,BOS,BOS
+1949,AL,CHA,CHW,,6,154,77,63,91,,,N,N,648,5204,1340,207,66,43,702,596,62,55,,,737,651,4.3000000000,57,10,17,4089,1362,108,693,502,135,180,0.97,Chicago White Sox,Comiskey Park,937151,96,99,CHW,CHA,CHA
+1949,AL,CLE,CLE,,3,154,77,89,65,,,N,N,675,5221,1358,194,58,112,601,534,44,40,,,574,516,3.3600000000,65,10,19,4149,1275,82,611,594,103,192,0.98,Cleveland Indians,Cleveland Stadium,2233771,98,95,CLE,CLE,CLE
+1949,AL,DET,DET,,4,155,78,87,67,,,N,N,751,5259,1405,215,51,88,751,502,39,52,,,655,584,3.7700000000,70,19,12,4179,1338,102,628,631,132,174,0.97,Detroit Tigers,Briggs Stadium,1821204,101,99,DET,DET,DET
+1949,AL,NYA,NYY,,1,155,78,97,57,,,Y,Y,829,5196,1396,215,60,115,731,539,58,30,,,637,562,3.6900000000,59,12,36,4113,1231,98,812,671,137,195,0.97,New York Yankees,Yankee Stadium I,2283676,100,96,NYY,NYA,NYA
+1949,AL,PHA,OAK,,5,154,77,81,73,,,N,N,726,5123,1331,214,49,82,783,493,36,25,,,725,642,4.2300000000,85,9,11,4095,1359,105,758,490,140,217,0.97,Philadelphia Athletics,Shibe Park,816514,97,98,PHA,PHA,PHA
+1949,AL,SLA,BAL,,7,155,77,53,101,,,N,N,667,5112,1301,213,30,117,631,700,38,39,,,913,776,5.2100000000,43,3,16,4023,1583,113,685,432,165,154,0.97,St. Louis Browns,Sportsman's Park IV,270936,105,109,SLB,SLA,SLA
+1949,AL,WS1,MIN,,8,154,77,50,104,,,N,N,584,5234,1330,207,41,81,593,495,46,33,,,868,762,5.1000000000,44,9,9,4035,1438,79,779,451,161,168,0.97,Washington Senators,Griffith Stadium I,770745,98,101,WSH,WS1,WS1
+1949,NL,BRO,LAD,,1,156,78,97,57,,,Y,N,879,5400,1477,236,47,152,638,570,117,,,,651,594,3.8000000000,62,15,17,4224,1306,132,582,743,124,162,0.97,Brooklyn Dodgers,Ebbets Field,1633747,105,102,BRO,BRO,BRO
+1949,NL,BSN,ATL,,4,157,77,75,79,,,N,N,706,5336,1376,246,33,103,684,656,28,,,,719,621,3.9900000000,68,12,11,4200,1466,110,520,589,149,144,0.97,Boston Braves,Braves Field,1081795,95,94,BSN,BSN,BSN
+1949,NL,CHN,CHC,,8,154,77,61,93,,,N,N,593,5214,1336,212,53,97,396,573,53,,,,773,678,4.5000000000,44,8,17,4071,1487,104,575,544,187,160,0.97,Chicago Cubs,Wrigley Field,1143139,97,99,CHC,CHN,CHN
+1949,NL,CIN,CIN,,7,156,78,62,92,,,N,N,627,5469,1423,264,35,86,429,559,31,,,,770,676,4.3400000000,55,10,6,4203,1423,124,640,538,136,150,0.97,Cincinnati Reds,Crosley Field,707782,101,104,CIN,CIN,CIN
+1949,NL,NY1,SFG,,5,156,79,73,81,,,N,N,736,5308,1383,203,52,147,613,523,43,,,,693,583,3.8200000000,68,10,9,4122,1328,132,544,516,163,134,0.97,New York Giants,Polo Grounds IV,1218446,101,99,NYG,NY1,NY1
+1949,NL,PHI,PHI,,3,154,77,81,73,,,N,N,662,5307,1349,232,55,122,528,670,27,,,,668,601,3.8900000000,58,12,15,4173,1389,104,502,495,158,141,0.97,Philadelphia Phillies,Shibe Park,819698,97,97,PHI,PHI,PHI
+1949,NL,PIT,PIT,,6,154,77,71,83,,,N,N,681,5214,1350,191,41,126,548,554,48,,,,760,689,4.5700000000,53,9,15,4068,1452,142,535,556,132,173,0.97,Pittsburgh Pirates,Forbes Field,1449435,102,104,PIT,PIT,PIT
+1949,NL,SLN,STL,,2,157,79,96,58,,,N,N,766,5463,1513,281,54,102,569,482,17,,,,616,538,3.4400000000,64,13,19,4221,1356,87,507,606,142,149,0.97,St. Louis Cardinals,Sportsman's Park IV,1430676,104,103,STL,SLN,SLN
+1950,AL,BOS,BOS,,3,154,77,94,60,,,N,N,1027,5516,1665,287,61,161,719,582,32,17,,,804,739,4.8800000000,66,6,28,4086,1413,121,748,630,111,181,0.98,Boston Red Sox,Fenway Park II,1344080,111,108,BOS,BOS,BOS
+1950,AL,CHA,CHW,,6,156,79,60,94,,,N,N,625,5260,1368,172,47,93,551,566,19,22,,,749,669,4.4100000000,62,7,9,4095,1370,107,734,566,135,181,0.97,Chicago White Sox,Comiskey Park,781330,97,98,CHW,CHA,CHA
+1950,AL,CLE,CLE,,4,155,77,92,62,,,N,N,806,5263,1417,222,46,164,693,624,40,34,,,654,574,3.7500000000,69,11,16,4134,1289,120,647,674,129,150,0.97,Cleveland Indians,Cleveland Stadium,1727464,97,94,CLE,CLE,CLE
+1950,AL,DET,DET,,2,157,81,95,59,,,N,N,837,5381,1518,285,50,114,722,480,23,40,,,713,644,4.1200000000,72,9,20,4221,1444,141,553,576,120,194,0.98,Detroit Tigers,Briggs Stadium,1951474,103,102,DET,DET,DET
+1950,AL,NYA,NYY,,1,155,77,98,56,,,Y,Y,914,5361,1511,234,70,159,687,463,41,28,,,691,633,4.1500000000,66,12,31,4116,1322,118,708,712,119,188,0.97,New York Yankees,Yankee Stadium I,2081380,97,94,NYY,NYA,NYA
+1950,AL,PHA,OAK,,8,154,77,52,102,,,N,N,670,5212,1361,204,53,100,685,493,42,25,,,913,821,5.4900000000,50,3,18,4038,1528,138,729,466,155,208,0.97,Philadelphia Athletics,Shibe Park,309805,98,99,PHA,PHA,PHA
+1950,AL,SLA,BAL,,7,154,74,58,96,,,N,N,684,5163,1269,235,43,106,690,744,39,40,,,916,789,5.2000000000,56,7,14,4095,1629,129,651,448,196,155,0.96,St. Louis Browns,Sportsman's Park IV,247131,104,108,SLB,SLA,SLA
+1950,AL,WS1,MIN,,5,155,78,67,87,,,N,N,690,5251,1365,190,53,76,671,606,42,25,,,813,706,4.6600000000,59,7,18,4092,1479,99,648,486,167,181,0.97,Washington Senators,Griffith Stadium I,699697,95,98,WSH,WS1,WS1
+1950,NL,BRO,LAD,,2,155,78,89,65,,,N,N,847,5364,1461,247,46,194,607,632,77,,,,724,661,4.2800000000,62,10,21,4167,1397,163,591,772,127,183,0.97,Brooklyn Dodgers,Ebbets Field,1185896,103,99,BRO,BRO,BRO
+1950,NL,BSN,ATL,,4,156,79,83,71,,,N,N,785,5363,1411,246,36,148,615,616,71,,,,736,637,4.1400000000,88,7,10,4155,1411,129,554,615,182,146,0.97,Boston Braves,Braves Field,944391,94,93,BSN,BSN,BSN
+1950,NL,CHN,CHC,,7,154,78,64,89,,,N,N,643,5230,1298,224,47,161,479,767,46,,,,772,652,4.2800000000,55,9,19,4113,1452,130,593,559,198,169,0.96,Chicago Cubs,Wrigley Field,1165944,99,102,CHC,CHN,CHN
+1950,NL,CIN,CIN,,6,153,76,66,87,,,N,N,654,5253,1366,257,27,99,504,497,37,,,,734,651,4.3200000000,67,7,13,4071,1363,145,582,686,140,132,0.97,Cincinnati Reds,Crosley Field,538794,100,102,CIN,CIN,CIN
+1950,NL,NY1,SFG,,3,154,76,86,68,,,N,N,735,5238,1352,204,50,133,627,629,42,,,,643,567,3.7100000000,70,19,15,4125,1268,140,536,596,137,181,0.97,New York Giants,Polo Grounds IV,1008878,101,99,NYG,NY1,NY1
+1950,NL,PHI,PHI,,1,157,78,91,63,,,Y,N,722,5426,1440,225,55,125,535,569,33,,,,624,547,3.5000000000,57,13,27,4218,1324,122,530,620,151,155,0.97,Philadelphia Phillies,Shibe Park,1217035,98,97,PHI,PHI,PHI
+1950,NL,PIT,PIT,,8,154,77,57,96,,,N,N,681,5327,1404,227,59,138,564,693,43,,,,857,754,4.9600000000,42,6,16,4104,1472,152,616,556,136,165,0.97,Pittsburgh Pirates,Forbes Field,1166267,103,106,PIT,PIT,PIT
+1950,NL,SLN,STL,,5,153,76,78,75,,,N,N,693,5215,1353,255,50,102,606,604,23,,,,670,598,3.9700000000,57,10,14,4068,1398,119,535,603,130,172,0.97,St. Louis Cardinals,Sportsman's Park IV,1093411,104,103,STL,SLN,SLN
+1951,AL,BOS,BOS,,3,154,75,87,67,,,N,N,804,5378,1428,233,32,127,756,594,20,21,,,725,644,4.1400000000,46,7,24,4197,1413,100,599,658,138,184,0.97,Boston Red Sox,Fenway Park II,1312282,110,109,BOS,BOS,BOS
+1951,AL,CHA,CHW,,4,155,78,81,73,,,N,N,714,5378,1453,229,64,86,596,524,99,70,,,644,551,3.5000000000,74,11,14,4254,1353,109,549,572,151,176,0.97,Chicago White Sox,Comiskey Park,1328234,98,98,CHW,CHA,CHA
+1951,AL,CLE,CLE,,2,155,77,93,61,,,N,N,696,5250,1346,208,35,140,606,632,52,35,,,594,522,3.3800000000,76,10,19,4173,1287,86,577,642,134,151,0.97,Cleveland Indians,Cleveland Stadium,1704984,95,92,CLE,CLE,CLE
+1951,AL,DET,DET,,5,154,77,73,81,,,N,N,685,5336,1413,231,35,104,568,525,37,34,,,741,660,4.2900000000,51,8,17,4152,1385,102,602,597,163,166,0.97,Detroit Tigers,Briggs Stadium,1132641,100,101,DET,DET,DET
+1951,AL,NYA,NYY,,1,154,78,98,56,,,Y,Y,798,5194,1395,208,48,140,605,547,78,39,,,621,541,3.5600000000,66,24,22,4101,1290,92,562,664,144,190,0.97,New York Yankees,Yankee Stadium I,1950107,97,93,NYY,NYA,NYA
+1951,AL,PHA,OAK,,6,154,79,70,84,,,N,N,736,5277,1381,262,43,102,677,565,47,36,,,745,674,4.4700000000,52,7,22,4074,1421,109,569,437,135,204,0.97,Philadelphia Athletics,Shibe Park,465469,101,103,PHA,PHA,PHA
+1951,AL,SLA,BAL,,8,154,77,52,102,,,N,N,611,5219,1288,223,47,86,521,693,35,38,,,882,789,5.1800000000,56,5,9,4110,1525,131,801,550,171,179,0.97,St. Louis Browns,Sportsman's Park IV,293790,103,107,SLB,SLA,SLA
+1951,AL,WS1,MIN,,7,154,76,62,92,,,N,N,672,5329,1399,242,45,54,560,515,45,38,,,764,681,4.4900000000,58,6,13,4098,1429,110,630,475,160,148,0.97,Washington Senators,Griffith Stadium I,695167,98,100,WSH,WS1,WS1
+1951,NL,BRO,LAD,,2,158,78,97,60,,,N,N,855,5492,1511,249,37,184,603,649,89,70,,,672,613,3.8800000000,64,10,13,4269,1360,150,549,693,128,192,0.97,Brooklyn Dodgers,Ebbets Field,1282628,102,99,BRO,BRO,BRO
+1951,NL,BSN,ATL,,4,155,78,76,78,,,N,N,723,5293,1385,234,37,130,565,617,80,34,,,662,579,3.7500000000,73,16,12,4167,1378,96,595,604,145,157,0.97,Boston Braves,Braves Field,487475,93,93,BSN,BSN,BSN
+1951,NL,CHN,CHC,,8,155,77,62,92,,,N,N,614,5307,1327,200,47,103,477,647,63,30,,,750,668,4.3400000000,48,10,10,4155,1416,125,572,544,181,161,0.97,Chicago Cubs,Wrigley Field,894415,102,104,CHC,CHN,CHN
+1951,NL,CIN,CIN,,6,155,77,68,86,,,N,N,559,5285,1309,215,33,88,415,577,44,40,,,667,571,3.7000000000,55,14,23,4170,1357,119,490,584,140,141,0.97,Cincinnati Reds,Crosley Field,588268,101,103,CIN,CIN,CIN
+1951,NL,NY1,SFG,,1,157,78,98,59,,,Y,N,781,5360,1396,201,53,179,671,624,55,34,,,641,546,3.4800000000,64,9,18,4236,1334,148,482,625,170,175,0.97,New York Giants,Polo Grounds IV,1059539,101,99,NYG,NY1,NY1
+1951,NL,PHI,PHI,,5,154,77,73,81,,,N,N,648,5332,1384,199,47,108,505,525,63,28,,,644,586,3.8100000000,57,19,15,4152,1373,110,497,570,138,146,0.97,Philadelphia Phillies,Shibe Park,937658,99,97,PHI,PHI,PHI
+1951,NL,PIT,PIT,,7,155,78,64,90,,,N,N,689,5318,1372,218,56,137,557,615,29,27,,,845,734,4.7900000000,40,9,22,4140,1479,157,609,580,170,178,0.97,Pittsburgh Pirates,Forbes Field,980590,102,106,PIT,PIT,PIT
+1951,NL,SLN,STL,,3,155,79,81,73,,,N,N,683,5317,1404,230,57,95,569,492,30,30,,,671,609,3.9500000000,58,9,23,4161,1391,119,568,546,125,187,0.98,St. Louis Cardinals,Sportsman's Park IV,1013429,100,100,STL,SLN,SLN
+1952,AL,BOS,BOS,,6,154,77,76,78,,,N,N,668,5246,1338,233,34,113,542,739,59,47,,,658,579,3.8000000000,53,7,24,4116,1332,107,623,624,143,181,0.97,Boston Red Sox,Fenway Park II,1115750,108,107,BOS,BOS,BOS
+1952,AL,CHA,CHW,,3,156,79,81,73,,,N,N,610,5316,1337,199,38,80,541,521,61,38,,,568,511,3.2500000000,53,15,28,4248,1251,86,578,774,123,158,0.98,Chicago White Sox,Comiskey Park,1231675,101,99,CHW,CHA,CHA
+1952,AL,CLE,CLE,,2,155,77,93,61,,,N,N,763,5330,1399,211,49,148,626,749,46,39,,,606,519,3.3200000000,80,19,18,4221,1278,94,556,671,155,141,0.97,Cleveland Indians,Cleveland Stadium,1444607,94,91,CLE,CLE,CLE
+1952,AL,DET,DET,,8,156,77,50,104,,,N,N,557,5258,1278,190,37,103,553,605,27,38,,,738,655,4.2500000000,51,10,14,4164,1394,111,591,702,149,145,0.97,Detroit Tigers,Briggs Stadium,1026846,100,103,DET,DET,DET
+1952,AL,NYA,NYY,,1,154,77,95,59,,,Y,Y,727,5294,1411,221,56,129,566,652,52,42,,,557,482,3.1400000000,72,21,27,4143,1240,94,581,666,127,199,0.97,New York Yankees,Yankee Stadium I,1629665,95,91,NYY,NYA,NYA
+1952,AL,PHA,OAK,,4,155,78,79,75,,,N,N,664,5163,1305,212,35,89,683,561,52,43,,,723,638,4.1500000000,73,11,16,4152,1402,113,526,562,140,148,0.97,Philadelphia Athletics,Shibe Park,627100,106,108,PHA,PHA,PHA
+1952,AL,SLA,BAL,,7,155,78,64,90,,,N,N,604,5353,1340,225,46,82,540,720,30,34,,,733,640,4.1200000000,48,6,18,4197,1388,111,598,581,155,176,0.97,St. Louis Browns,Sportsman's Park IV,518796,103,106,SLB,SLA,SLA
+1952,AL,WS1,MIN,,5,157,78,78,76,,,N,N,598,5357,1282,225,44,50,580,607,48,37,,,608,535,3.3700000000,75,10,15,4287,1405,78,577,574,130,152,0.97,Washington Senators,Griffith Stadium I,699457,97,97,WSH,WS1,WS1
+1952,NL,BRO,LAD,,1,155,80,96,57,,,Y,N,775,5266,1380,199,32,153,663,699,90,49,,,603,549,3.5300000000,45,11,24,4197,1295,121,544,773,105,169,0.98,Brooklyn Dodgers,Ebbets Field,1088704,102,98,BRO,BRO,BRO
+1952,NL,BSN,ATL,,7,155,77,64,89,,,N,N,569,5221,1214,187,31,110,483,711,58,34,,,651,586,3.7800000000,63,11,13,4188,1388,106,525,687,153,143,0.97,Boston Braves,Braves Field,281278,97,98,BSN,BSN,BSN
+1952,NL,CHN,CHC,,5,155,77,77,77,,,N,N,628,5330,1408,223,45,107,422,712,50,40,,,631,551,3.5800000000,59,15,15,4158,1265,101,534,661,146,123,0.97,Chicago Cubs,Wrigley Field,1024826,101,103,CHC,CHN,CHN
+1952,NL,CIN,CIN,,6,154,77,69,85,,,N,N,615,5234,1303,212,45,104,480,709,32,42,,,659,607,4.0100000000,56,11,12,4089,1377,111,517,579,107,145,0.98,Cincinnati Reds,Crosley Field,604197,99,100,CIN,CIN,CIN
+1952,NL,NY1,SFG,,2,154,77,92,62,,,N,N,722,5229,1337,186,56,151,536,672,30,31,,,639,547,3.5900000000,49,12,31,4113,1282,121,538,655,153,175,0.97,New York Giants,Polo Grounds IV,984940,101,99,NYG,NY1,NY1
+1952,NL,PHI,PHI,,4,154,76,87,67,,,N,N,657,5205,1353,237,45,93,540,534,60,41,,,552,473,3.0700000000,80,17,16,4158,1306,95,373,609,150,145,0.97,Philadelphia Phillies,Shibe Park,755417,99,98,PHI,PHI,PHI
+1952,NL,PIT,PIT,,8,155,77,42,112,,,N,N,515,5193,1201,181,30,92,486,724,43,41,,,793,704,4.6500000000,43,5,8,4089,1395,133,615,564,181,167,0.97,Pittsburgh Pirates,Forbes Field,686673,102,107,PIT,PIT,PIT
+1952,NL,SLN,STL,,3,154,77,88,66,,,N,N,677,5200,1386,247,54,97,537,479,33,32,,,630,553,3.6600000000,49,12,27,4083,1274,119,501,712,141,159,0.97,St. Louis Cardinals,Sportsman's Park IV,913113,100,99,STL,SLN,SLN
+1953,AL,BOS,BOS,,4,153,76,84,69,,,N,N,656,5246,1385,255,37,101,496,601,33,45,,,632,546,3.5800000000,41,15,37,4119,1333,92,584,642,147,173,0.97,Boston Red Sox,Fenway Park II,1026133,105,105,BOS,BOS,BOS
+1953,AL,CHA,CHW,,3,156,78,89,65,,,N,N,716,5212,1345,226,53,74,601,530,73,55,,,592,532,3.4100000000,57,17,33,4209,1299,113,583,714,125,144,0.98,Chicago White Sox,Comiskey Park,1191353,103,101,CHW,CHA,CHA
+1953,AL,CLE,CLE,,2,155,78,92,62,,,N,N,770,5285,1426,201,29,160,609,683,33,29,,,627,555,3.6400000000,81,11,15,4119,1311,92,519,586,126,197,0.97,Cleveland Indians,Cleveland Stadium,1069176,98,94,CLE,CLE,CLE
+1953,AL,DET,DET,,6,158,79,60,94,,,N,N,695,5553,1479,259,44,108,506,603,30,35,,,923,825,5.2500000000,50,2,16,4245,1633,154,585,645,131,149,0.97,Detroit Tigers,Briggs Stadium,884658,98,102,DET,DET,DET
+1953,AL,NYA,NYY,,1,151,77,99,52,,,Y,Y,801,5194,1420,226,52,139,656,644,34,44,,,547,483,3.2000000000,50,18,39,4074,1286,94,500,604,126,182,0.97,New York Yankees,Yankee Stadium I,1537811,97,93,NYY,NYA,NYA
+1953,AL,PHA,OAK,,7,157,78,59,95,,,N,N,632,5455,1398,205,38,116,498,602,41,24,,,799,731,4.6700000000,51,7,11,4227,1475,121,594,566,136,161,0.97,Philadelphia Athletics,Connie Mack Stadium,362113,104,107,PHA,PHA,PHA
+1953,AL,SLA,BAL,,8,154,77,54,100,,,N,N,555,5264,1310,214,25,112,507,644,17,34,,,778,688,4.4800000000,28,10,24,4149,1467,101,626,639,152,165,0.97,St. Louis Browns,Sportsman's Park IV,297238,102,106,SLB,SLA,SLA
+1953,AL,WS1,MIN,,5,152,75,76,76,,,N,N,687,5149,1354,230,53,69,596,604,65,36,,,614,547,3.6600000000,76,16,10,4032,1313,112,478,515,120,173,0.97,Washington Senators,Griffith Stadium I,595594,98,98,WSH,WS1,WS1
+1953,NL,BRO,LAD,,1,155,78,105,49,,,Y,N,955,5373,1529,274,59,208,655,686,90,47,,,689,629,4.1000000000,51,11,29,4140,1337,169,509,817,118,161,0.98,Brooklyn Dodgers,Ebbets Field,1163419,103,100,BRO,BRO,BRO
+1953,NL,CHN,CHC,,7,155,77,65,89,,,N,N,633,5272,1372,204,57,137,514,746,49,21,,,835,723,4.7900000000,38,3,22,4077,1491,151,554,623,193,141,0.96,Chicago Cubs,Wrigley Field,763658,102,103,CHC,CHN,CHN
+1953,NL,CIN,CIN,,6,155,78,68,86,,,N,N,714,5343,1396,190,34,166,485,701,25,20,,,788,704,4.6400000000,47,7,15,4095,1484,179,488,506,129,176,0.97,Cincinnati Reds,Crosley Field,548086,100,101,CIN,CIN,CIN
+1953,NL,ML1,ATL,,2,157,79,92,62,,,N,N,738,5349,1422,227,52,156,439,637,46,27,,,589,509,3.3000000000,72,14,15,4161,1282,107,539,738,143,169,0.97,Milwaukee Braves,County Stadium,1826397,94,92,MLN,MLN,MLN
+1953,NL,NY1,SFG,,5,155,77,70,84,,,N,N,768,5362,1452,195,45,176,499,608,31,21,,,747,645,4.2500000000,46,10,20,4095,1403,146,610,647,150,151,0.97,New York Giants,Polo Grounds IV,811518,103,101,NYG,NY1,NY1
+1953,NL,PHI,PHI,,3,156,78,83,71,,,N,N,716,5290,1400,228,62,115,530,597,42,21,,,666,578,3.8000000000,76,13,15,4107,1410,138,410,637,147,161,0.97,Philadelphia Phillies,Connie Mack Stadium,853644,99,98,PHI,PHI,PHI
+1953,NL,PIT,PIT,,8,154,77,50,104,,,N,N,622,5253,1297,178,49,99,524,715,41,39,,,887,788,5.2200000000,49,4,10,4074,1529,168,577,607,163,139,0.97,Pittsburgh Pirates,Forbes Field,572757,99,104,PIT,PIT,PIT
+1953,NL,SLN,STL,,3,157,78,83,71,,,N,N,768,5397,1474,281,56,140,574,617,18,22,,,713,651,4.2300000000,51,11,36,4158,1406,139,533,732,138,161,0.97,St. Louis Cardinals,Sportsman's Park IV,880242,100,99,STL,SLN,SLN
+1954,AL,BAL,BAL,,7,154,77,54,100,,,N,N,483,5206,1309,195,49,52,468,634,30,31,,,668,592,3.8800000000,58,6,8,4119,1279,78,688,668,147,152,0.97,Baltimore Orioles,Memorial Stadium,1060910,92,96,BAL,BAL,BAL
+1954,AL,BOS,BOS,,4,156,79,69,85,,,N,N,700,5399,1436,244,41,123,654,660,51,30,,,728,629,4.0100000000,41,10,22,4236,1434,118,612,707,176,163,0.97,Boston Red Sox,Fenway Park II,931127,111,110,BOS,BOS,BOS
+1954,AL,CHA,CHW,,3,155,78,94,60,,,N,N,711,5168,1382,203,47,94,604,536,98,58,,,521,469,3.0500000000,60,23,33,4149,1255,94,517,701,108,149,0.98,Chicago White Sox,Comiskey Park,1231629,103,100,CHW,CHA,CHA
+1954,AL,CLE,CLE,,1,156,77,111,43,,,Y,N,746,5222,1368,188,39,156,637,668,30,33,,,504,438,2.7800000000,77,12,36,4257,1220,89,486,678,128,148,0.97,Cleveland Indians,Cleveland Stadium,1335472,102,98,CLE,CLE,CLE
+1954,AL,DET,DET,,5,155,77,68,86,,,N,N,584,5233,1351,215,41,90,492,603,48,44,,,664,585,3.8100000000,58,13,13,4149,1375,138,506,603,127,131,0.97,Detroit Tigers,Briggs Stadium,1079847,99,100,DET,DET,DET
+1954,AL,NYA,NYY,,2,155,78,103,51,,,N,N,805,5226,1400,215,59,133,650,632,34,41,,,563,500,3.2600000000,51,16,37,4137,1284,86,552,655,127,198,0.97,New York Yankees,Yankee Stadium I,1475171,97,93,NYY,NYA,NYA
+1954,AL,PHA,OAK,,8,156,77,51,103,,,N,N,542,5206,1228,191,41,94,504,677,30,29,,,875,789,5.1800000000,49,3,13,4113,1523,141,685,555,166,163,0.97,Philadelphia Athletics,Connie Mack Stadium,304666,100,105,PHA,PHA,PHA
+1954,AL,WS1,MIN,,6,155,78,66,88,,,N,N,632,5249,1292,188,69,81,610,719,37,21,,,680,590,3.8400000000,69,10,7,4149,1396,79,573,562,137,172,0.97,Washington Senators,Griffith Stadium I,503542,94,96,WSH,WS1,WS1
+1954,NL,BRO,LAD,,2,154,77,92,62,,,N,N,778,5251,1418,246,56,186,634,625,46,39,,,740,667,4.3100000000,39,8,36,4179,1399,164,533,762,129,138,0.97,Brooklyn Dodgers,Ebbets Field,1020531,104,101,BRO,BRO,BRO
+1954,NL,CHN,CHC,,7,154,77,64,90,,,N,N,700,5359,1412,229,45,159,478,693,46,31,,,766,689,4.5100000000,41,6,19,4122,1375,131,619,622,154,164,0.97,Chicago Cubs,Wrigley Field,748183,101,103,CHC,CHN,CHN
+1954,NL,CIN,CIN,,5,154,77,74,80,,,N,N,729,5234,1369,221,46,147,557,645,47,30,,,763,684,4.5000000000,34,8,27,4101,1491,169,547,537,137,194,0.97,Cincinnati Redlegs,Crosley Field,704167,102,103,CIN,CIN,CIN
+1954,NL,ML1,ATL,,3,154,77,89,65,,,N,N,670,5261,1395,217,41,139,471,619,54,31,,,556,494,3.1900000000,63,13,21,4182,1296,106,553,698,116,171,0.98,Milwaukee Braves,County Stadium,2131388,94,92,MLN,MLN,MLN
+1954,NL,NY1,SFG,,1,154,76,97,57,,,Y,Y,732,5245,1386,194,42,186,522,561,30,23,,,550,477,3.0900000000,45,19,33,4170,1258,113,613,692,154,172,0.97,New York Giants,Polo Grounds IV,1155067,101,100,NYG,NY1,NY1
+1954,NL,PHI,PHI,,4,154,78,75,79,,,N,N,659,5184,1384,243,58,102,604,620,30,27,,,614,544,3.5900000000,78,14,12,4095,1329,133,450,570,145,133,0.97,Philadelphia Phillies,Connie Mack Stadium,738991,100,99,PHI,PHI,PHI
+1954,NL,PIT,PIT,,8,154,77,53,101,,,N,N,557,5088,1260,181,57,76,566,737,21,13,,,845,736,4.9200000000,37,4,15,4038,1510,128,564,525,173,136,0.97,Pittsburgh Pirates,Forbes Field,475494,98,102,PIT,PIT,PIT
+1954,NL,SLN,STL,,6,154,77,72,82,,,N,N,799,5405,1518,285,58,119,582,586,63,46,,,790,695,4.5000000000,40,11,18,4170,1484,170,535,680,146,178,0.97,St. Louis Cardinals,Sportsman's Park IV,1039698,100,101,STL,SLN,SLN
+1955,AL,BAL,BAL,,7,156,79,57,97,,,N,N,540,5257,1263,177,39,54,560,742,34,46,,,754,649,4.2100000000,35,10,20,4164,1403,103,625,595,162,159,0.97,Baltimore Orioles,Memorial Stadium,852039,92,96,BAL,BAL,BAL
+1955,AL,BOS,BOS,,4,154,78,84,70,,,N,N,755,5273,1392,241,39,137,707,733,43,17,,,652,572,3.7200000000,44,9,34,4152,1333,128,582,674,136,140,0.97,Boston Red Sox,Fenway Park II,1203200,110,109,BOS,BOS,BOS
+1955,AL,CHA,CHW,,3,155,77,91,63,,,N,N,725,5220,1401,204,36,116,567,595,69,45,,,557,516,3.3700000000,55,20,23,4134,1301,111,497,720,111,147,0.98,Chicago White Sox,Comiskey Park,1175684,103,99,CHW,CHA,CHA
+1955,AL,CLE,CLE,,2,154,77,93,61,,,N,N,698,5146,1325,195,31,148,723,715,28,24,,,601,522,3.3900000000,45,15,36,4158,1285,111,558,877,108,152,0.98,Cleveland Indians,Cleveland Stadium,1221780,104,101,CLE,CLE,CLE
+1955,AL,DET,DET,,5,154,77,79,75,,,N,N,775,5283,1407,211,38,130,641,583,41,22,,,658,581,3.7900000000,66,16,12,4140,1381,126,517,629,139,159,0.97,Detroit Tigers,Briggs Stadium,1181838,98,98,DET,DET,DET
+1955,AL,KC1,OAK,,6,155,76,63,91,,,N,N,638,5335,1395,189,46,121,463,725,22,36,,,911,822,5.3500000000,29,9,22,4146,1486,175,707,572,146,174,0.97,Kansas City Athletics,Municipal Stadium I,1393054,100,105,KCA,KC1,KC1
+1955,AL,NYA,NYY,,1,154,77,96,58,,,Y,N,762,5161,1342,179,55,175,609,658,55,25,,,569,492,3.2300000000,52,19,33,4116,1163,108,688,731,128,180,0.97,New York Yankees,Yankee Stadium I,1490138,99,95,NYY,NYA,NYA
+1955,AL,WS1,MIN,,8,154,77,53,101,,,N,N,598,5142,1277,178,54,80,538,654,25,32,,,789,695,4.6200000000,37,10,16,4062,1450,99,634,607,154,170,0.97,Washington Senators,Griffith Stadium I,425238,97,100,WSH,WS1,WS1
+1955,NL,BRO,LAD,,1,154,77,98,55,,,Y,Y,857,5193,1406,230,44,201,674,718,79,56,,,650,563,3.6800000000,46,11,37,4134,1296,168,483,773,133,156,0.97,Brooklyn Dodgers,Ebbets Field,1033589,104,101,BRO,BRO,BRO
+1955,NL,CHN,CHC,,6,154,77,72,81,,,N,N,626,5214,1287,187,55,164,428,806,37,35,,,713,638,4.1700000000,47,10,23,4134,1306,153,601,686,147,147,0.97,Chicago Cubs,Wrigley Field,875800,100,102,CHC,CHN,CHN
+1955,NL,CIN,CIN,,5,154,77,75,79,,,N,N,761,5270,1424,216,28,181,556,657,51,36,,,684,598,3.9500000000,38,12,22,4089,1373,161,443,576,139,169,0.97,Cincinnati Redlegs,Crosley Field,693662,105,104,CIN,CIN,CIN
+1955,NL,ML1,ATL,,2,154,77,85,69,,,N,N,743,5277,1377,219,55,182,504,735,42,27,,,668,592,3.8500000000,61,5,12,4149,1339,138,591,654,152,155,0.97,Milwaukee Braves,County Stadium,2005836,96,93,MLN,MLN,MLN
+1955,NL,NY1,SFG,,3,154,79,80,74,,,N,N,702,5288,1377,173,34,169,497,581,38,22,,,673,581,3.7700000000,52,6,14,4158,1347,155,560,721,141,165,0.97,New York Giants,Polo Grounds IV,824112,101,101,NYG,NY1,NY1
+1955,NL,PHI,PHI,,4,154,77,77,77,,,N,N,675,5092,1300,214,50,132,652,673,44,32,,,666,592,3.9300000000,58,11,21,4068,1291,161,477,657,110,117,0.98,Philadelphia Phillies,Connie Mack Stadium,922886,98,98,PHI,PHI,PHI
+1955,NL,PIT,PIT,,8,154,75,60,94,,,N,N,560,5173,1262,210,60,91,471,652,22,22,,,767,664,4.3900000000,41,5,16,4086,1480,142,536,622,166,175,0.97,Pittsburgh Pirates,Forbes Field,469397,98,101,PIT,PIT,PIT
+1955,NL,SLN,STL,,7,154,77,68,86,,,N,N,654,5266,1375,228,36,143,458,597,64,59,,,757,697,4.5600000000,42,10,15,4128,1376,185,549,730,146,152,0.97,St. Louis Cardinals,Sportsman's Park IV,849130,99,100,STL,SLN,SLN
+1956,AL,BAL,BAL,,6,154,77,69,85,,,N,N,571,5090,1242,198,34,91,563,725,39,42,,,705,635,4.2000000000,38,10,24,4080,1362,99,547,715,133,142,0.97,Baltimore Orioles,Memorial Stadium,901201,92,94,BAL,BAL,BAL
+1956,AL,BOS,BOS,,4,155,78,84,70,,,N,N,780,5349,1473,261,45,139,727,687,28,19,,,751,648,4.1700000000,50,8,20,4194,1354,130,668,712,169,168,0.97,Boston Red Sox,Fenway Park II,1137158,113,111,BOS,BOS,BOS
+1956,AL,CHA,CHW,,3,154,77,85,69,,,N,N,776,5286,1412,218,43,128,619,660,70,33,,,634,576,3.7300000000,65,11,13,4167,1351,118,524,722,122,160,0.97,Chicago White Sox,Comiskey Park,1000090,101,99,CHW,CHA,CHA
+1956,AL,CLE,CLE,,2,155,77,88,66,,,N,N,712,5148,1256,199,23,153,681,764,40,32,,,581,511,3.3200000000,67,17,24,4152,1233,116,564,845,129,130,0.97,Cleveland Indians,Cleveland Stadium,865467,103,101,CLE,CLE,CLE
+1956,AL,DET,DET,,5,155,78,82,72,,,N,N,789,5364,1494,209,50,150,644,618,43,26,,,699,622,4.0600000000,62,10,15,4137,1389,140,655,788,140,151,0.97,Detroit Tigers,Briggs Stadium,1051182,101,100,DET,DET,DET
+1956,AL,KC1,OAK,,8,154,77,52,102,,,N,N,619,5256,1325,204,41,112,480,727,40,30,,,831,740,4.8600000000,30,3,18,4110,1424,187,679,636,166,187,0.97,Kansas City Athletics,Municipal Stadium I,1015154,100,104,KCA,KC1,KC1
+1956,AL,NYA,NYY,,1,154,77,97,57,,,Y,Y,857,5312,1433,193,55,190,615,755,51,37,,,631,557,3.6300000000,50,10,35,4146,1285,114,652,732,135,214,0.97,New York Yankees,Yankee Stadium I,1491784,97,93,NYY,NYA,NYA
+1956,AL,WS1,MIN,,7,155,77,59,95,,,N,N,652,5202,1302,198,62,112,690,877,37,34,,,924,810,5.3300000000,36,1,18,4104,1539,171,730,663,168,173,0.97,Washington Senators,Griffith Stadium II,431647,96,100,WSH,WS1,WS1
+1956,NL,BRO,LAD,,1,154,77,93,61,,,Y,N,720,5098,1315,212,36,179,649,738,65,37,,,601,543,3.5700000000,46,12,30,4104,1251,171,441,772,111,149,0.98,Brooklyn Dodgers,Ebbets Field,1213562,109,107,BRO,BRO,BRO
+1956,NL,CHN,CHC,,8,157,80,60,94,,,N,N,597,5260,1281,202,50,142,446,776,55,38,,,708,612,3.9600000000,37,6,17,4176,1325,161,613,744,143,141,0.97,Chicago Cubs,Wrigley Field,720118,99,101,CHC,CHN,CHN
+1956,NL,CIN,CIN,,3,155,77,91,63,,,N,N,775,5291,1406,201,32,221,528,760,45,22,,,658,594,3.8500000000,47,4,29,4167,1406,141,458,653,113,147,0.98,Cincinnati Redlegs,Crosley Field,1125928,106,105,CIN,CIN,CIN
+1956,NL,ML1,ATL,,2,155,77,92,62,,,N,N,709,5207,1350,212,54,177,486,714,29,20,,,569,481,3.1100000000,64,12,27,4179,1295,133,467,639,130,159,0.97,Milwaukee Braves,County Stadium,2046331,94,92,MLN,MLN,MLN
+1956,NL,NY1,SFG,,6,154,77,67,87,,,N,N,540,5190,1268,192,45,145,402,659,67,34,,,650,579,3.7800000000,31,9,28,4134,1287,144,551,765,144,143,0.97,New York Giants,Polo Grounds IV,629179,99,100,NYG,NY1,NY1
+1956,NL,PHI,PHI,,5,154,77,71,83,,,N,N,668,5204,1313,207,49,121,585,673,45,23,,,738,643,4.2000000000,57,4,15,4131,1407,172,437,750,144,140,0.97,Philadelphia Phillies,Connie Mack Stadium,934798,98,99,PHI,PHI,PHI
+1956,NL,PIT,PIT,,7,157,78,66,88,,,N,N,588,5221,1340,199,57,110,383,752,24,33,,,653,572,3.7400000000,37,8,24,4128,1406,142,469,662,162,140,0.97,Pittsburgh Pirates,Forbes Field,949878,97,100,PIT,PIT,PIT
+1956,NL,SLN,STL,,4,156,78,76,78,,,N,N,678,5378,1443,234,49,124,503,622,41,35,,,698,612,3.9700000000,41,12,30,4164,1339,155,546,709,134,172,0.97,St. Louis Cardinals,Sportsman's Park IV,1029773,100,100,STL,SLN,SLN
+1957,AL,BAL,BAL,,5,154,77,76,76,,,N,N,597,5264,1326,191,39,87,504,699,57,35,,,588,541,3.4600000000,44,13,25,4224,1272,95,493,767,109,159,0.98,Baltimore Orioles,Memorial Stadium,1029581,93,94,BAL,BAL,BAL
+1957,AL,BOS,BOS,,3,154,77,82,72,,,N,N,721,5267,1380,231,32,153,624,739,29,21,,,668,593,3.8800000000,55,9,23,4128,1391,116,498,692,149,179,0.97,Boston Red Sox,Fenway Park II,1181087,106,105,BOS,BOS,BOS
+1957,AL,CHA,CHW,,2,155,77,90,64,,,N,N,707,5265,1369,208,41,106,633,745,109,51,,,566,521,3.3500000000,59,16,27,4203,1305,124,470,665,107,169,0.98,Chicago White Sox,Comiskey Park,1135668,101,99,CHW,CHA,CHA
+1957,AL,CLE,CLE,,6,153,77,76,77,,,N,N,682,5171,1304,199,26,140,591,786,40,47,,,722,623,4.0600000000,46,7,23,4140,1381,130,618,807,147,154,0.97,Cleveland Indians,Cleveland Stadium,722256,100,99,CLE,CLE,CLE
+1957,AL,DET,DET,,4,154,77,78,76,,,N,N,614,5348,1376,224,37,116,504,643,36,47,,,614,561,3.5600000000,52,9,21,4251,1330,147,505,756,121,151,0.98,Detroit Tigers,Briggs Stadium,1272346,103,102,DET,DET,DET
+1957,AL,KC1,OAK,,7,154,77,59,94,,,N,N,563,5170,1262,195,40,166,364,760,35,27,,,710,637,4.1900000000,26,6,19,4107,1344,153,565,626,125,162,0.97,Kansas City Athletics,Municipal Stadium I,901067,101,104,KCA,KC1,KC1
+1957,AL,NYA,NYY,,1,154,77,98,56,,,Y,N,723,5271,1412,200,54,145,562,709,49,38,,,534,465,3.0000000000,41,13,42,4185,1198,110,580,810,123,183,0.98,New York Yankees,Yankee Stadium I,1497134,99,95,NYY,NYA,NYA
+1957,AL,WS1,MIN,,8,154,77,55,99,,,N,N,603,5231,1274,215,38,111,527,733,13,38,,,808,742,4.8500000000,31,5,16,4131,1482,149,580,691,128,159,0.97,Washington Senators,Griffith Stadium II,457079,98,102,WSH,WS1,WS1
+1957,NL,BRO,LAD,,3,154,77,84,70,,,N,N,690,5242,1325,188,38,147,550,848,60,34,,,591,521,3.3500000000,44,18,29,4197,1285,144,456,891,127,136,0.97,Brooklyn Dodgers,Ebbets Field,1028258,109,107,BRO,BRO,BRO
+1957,NL,CHN,CHC,,7,156,78,62,92,,,N,N,628,5369,1312,223,31,147,461,989,28,25,,,722,644,4.1300000000,30,5,26,4209,1397,144,601,859,137,140,0.97,Chicago Cubs,Wrigley Field,670629,99,100,CHC,CHN,CHN
+1957,NL,CIN,CIN,,4,154,77,80,74,,,N,N,747,5389,1452,251,33,187,546,752,51,36,,,781,716,4.6200000000,40,5,29,4185,1486,179,429,707,107,139,0.98,Cincinnati Redlegs,Crosley Field,1070850,106,105,CIN,CIN,CIN
+1957,NL,ML1,ATL,,1,155,78,95,59,,,Y,Y,772,5458,1469,221,62,199,461,729,35,16,,,613,544,3.4700000000,60,9,24,4233,1347,124,570,693,120,173,0.98,Milwaukee Braves,County Stadium,2215404,93,90,MLN,MLN,MLN
+1957,NL,NY1,SFG,,6,154,77,69,85,,,N,N,643,5346,1349,171,54,157,447,669,64,38,,,701,623,4.0100000000,35,9,20,4194,1436,150,471,701,161,180,0.97,New York Giants,Polo Grounds IV,653923,100,102,NYG,NY1,NY1
+1957,NL,PHI,PHI,,5,156,78,77,77,,,N,N,623,5241,1311,213,44,117,534,758,57,26,,,656,590,3.7900000000,54,9,23,4203,1363,139,412,858,136,117,0.97,Philadelphia Phillies,Connie Mack Stadium,1146230,97,98,PHI,PHI,PHI
+1957,NL,PIT,PIT,,7,155,77,62,92,,,N,N,586,5402,1447,231,60,92,374,733,46,35,,,696,601,3.8800000000,47,9,15,4185,1463,158,421,663,170,143,0.97,Pittsburgh Pirates,Forbes Field,850732,97,98,PIT,PIT,PIT
+1957,NL,SLN,STL,,2,154,77,87,67,,,N,N,737,5472,1497,235,43,132,493,672,58,44,,,666,593,3.7800000000,46,11,29,4239,1385,140,506,778,131,168,0.97,St. Louis Cardinals,Sportsman's Park IV,1183575,102,102,STL,SLN,SLN
+1958,AL,BAL,BAL,,6,154,78,74,79,,,N,N,521,5111,1233,195,19,108,483,731,33,35,,,575,517,3.4000000000,55,15,28,4107,1277,106,403,749,114,159,0.98,Baltimore Orioles,Memorial Stadium,829991,94,95,BAL,BAL,BAL
+1958,AL,BOS,BOS,,3,155,77,79,75,,,N,N,697,5218,1335,229,30,155,638,820,29,22,,,691,601,3.9200000000,44,5,28,4140,1396,121,521,695,145,172,0.97,Boston Red Sox,Fenway Park II,1077047,106,106,BOS,BOS,BOS
+1958,AL,CHA,CHW,,2,155,77,82,72,,,N,N,634,5249,1348,191,42,101,518,669,101,33,,,615,557,3.6100000000,55,15,25,4167,1296,152,515,751,113,160,0.98,Chicago White Sox,Comiskey Park,797451,99,97,CHW,CHA,CHA
+1958,AL,CLE,CLE,,4,153,76,77,76,,,N,N,694,5201,1340,210,31,161,494,819,50,49,,,635,569,3.7300000000,51,2,20,4119,1283,123,604,766,152,171,0.97,Cleveland Indians,Cleveland Stadium,663805,99,98,CLE,CLE,CLE
+1958,AL,DET,DET,,5,154,77,77,77,,,N,N,659,5194,1384,229,41,109,463,678,48,32,,,606,541,3.5900000000,59,8,19,4071,1294,133,437,797,106,140,0.98,Detroit Tigers,Briggs Stadium,1098924,107,107,DET,DET,DET
+1958,AL,KC1,OAK,,7,156,78,73,81,,,N,N,642,5261,1297,196,50,138,452,747,22,36,,,713,645,4.1500000000,42,9,25,4194,1405,150,467,721,125,166,0.97,Kansas City Athletics,Municipal Stadium I,925090,102,104,KCA,KC1,KC1
+1958,AL,NYA,NYY,,1,155,78,92,62,,,Y,Y,759,5294,1418,212,39,164,537,822,48,32,,,577,493,3.2200000000,53,21,33,4137,1201,116,557,796,128,182,0.97,New York Yankees,Yankee Stadium I,1428438,96,94,NYY,NYA,NYA
+1958,AL,WS1,MIN,,8,156,78,61,93,,,N,N,553,5156,1240,161,38,121,477,751,22,41,,,747,693,4.5300000000,28,6,28,4128,1443,156,558,762,118,163,0.98,Washington Senators,Griffith Stadium II,475288,98,101,WSH,WS1,WS1
+1958,NL,CHN,CHC,,5,154,77,72,82,,,N,N,709,5289,1402,207,49,182,487,853,39,23,,,725,638,4.2200000000,27,5,24,4083,1322,142,619,805,150,161,0.97,Chicago Cubs,Wrigley Field,979904,98,99,CHC,CHN,CHN
+1958,NL,CIN,CIN,,4,154,77,76,78,,,N,N,695,5273,1359,242,40,123,572,765,61,38,,,621,574,3.7300000000,50,7,20,4155,1422,148,419,705,99,148,0.98,Cincinnati Redlegs,Crosley Field,788582,106,105,CIN,CIN,CIN
+1958,NL,LAN,LAD,,7,154,77,71,83,,,N,N,668,5173,1297,166,50,172,495,850,73,47,,,761,679,4.4700000000,30,7,31,4104,1399,173,606,855,145,198,0.97,Los Angeles Dodgers,Los Angeles Memorial Coliseum,1845556,104,104,LAD,LAN,LAN
+1958,NL,ML1,ATL,,1,154,77,92,62,,,Y,N,675,5225,1388,221,21,167,478,646,26,8,,,541,491,3.2100000000,72,16,17,4128,1261,125,426,773,119,152,0.98,Milwaukee Braves,County Stadium,1971101,92,89,MLN,MLN,MLN
+1958,NL,PHI,PHI,,8,154,77,69,85,,,N,N,664,5363,1424,238,56,124,573,871,51,33,,,762,671,4.3200000000,51,6,15,4191,1480,148,446,778,129,136,0.97,Philadelphia Phillies,Connie Mack Stadium,931110,99,100,PHI,PHI,PHI
+1958,NL,PIT,PIT,,2,154,77,84,70,,,N,N,662,5247,1386,229,68,134,396,753,30,15,,,607,541,3.5600000000,43,10,41,4101,1344,123,470,679,133,173,0.97,Pittsburgh Pirates,Forbes Field,1311988,97,98,PIT,PIT,PIT
+1958,NL,SFN,SFG,,3,154,77,80,74,,,N,N,727,5318,1399,250,42,170,531,817,64,29,,,698,614,3.9800000000,38,7,25,4167,1400,166,512,775,152,156,0.97,San Francisco Giants,Seals Stadium,1272625,98,96,SFG,SFN,SFN
+1958,NL,SLN,STL,,5,154,77,72,82,,,N,N,619,5255,1371,216,39,111,533,637,44,43,,,704,632,4.1200000000,45,6,25,4143,1398,158,567,822,152,163,0.97,St. Louis Cardinals,Sportsman's Park IV,1063730,104,105,STL,SLN,SLN
+1959,AL,BAL,BAL,,6,155,78,74,80,,,N,N,551,5208,1240,182,23,109,536,690,36,24,,,621,554,3.5600000000,45,15,30,4200,1290,111,476,735,147,163,0.97,Baltimore Orioles,Memorial Stadium,891926,97,98,BAL,BAL,BAL
+1959,AL,BOS,BOS,,5,154,77,75,79,,,N,N,726,5225,1335,248,28,125,626,810,68,25,,,696,632,4.1700000000,38,9,25,4092,1386,135,589,724,130,167,0.97,Boston Red Sox,Fenway Park II,984102,104,104,BOS,BOS,BOS
+1959,AL,CHA,CHW,,1,156,78,94,60,,,Y,N,669,5297,1325,220,46,97,580,634,113,53,,,588,521,3.2900000000,44,13,36,4275,1297,129,525,761,130,141,0.97,Chicago White Sox,Comiskey Park,1423144,99,98,CHW,CHA,CHA
+1959,AL,CLE,CLE,,2,154,77,89,65,,,N,N,745,5288,1390,216,25,167,433,721,33,36,,,646,576,3.7500000000,58,7,23,4149,1230,148,635,799,127,138,0.97,Cleveland Indians,Cleveland Stadium,1497976,97,96,CLE,CLE,CLE
+1959,AL,DET,DET,,4,154,77,76,78,,,N,N,713,5211,1346,196,30,160,580,737,34,17,,,732,635,4.2000000000,53,9,24,4080,1327,177,432,829,124,131,0.97,Detroit Tigers,Briggs Stadium,1221221,106,105,DET,DET,DET
+1959,AL,KC1,OAK,,7,154,77,66,88,,,N,N,681,5264,1383,231,43,117,481,780,34,24,,,760,657,4.3500000000,44,8,21,4080,1452,148,492,703,159,156,0.97,Kansas City Athletics,Municipal Stadium I,963683,102,104,KCA,KC1,KC1
+1959,AL,NYA,NYY,,3,155,77,79,75,,,N,N,687,5379,1397,224,40,153,457,828,45,22,,,647,560,3.6000000000,38,15,28,4197,1281,120,594,836,131,160,0.97,New York Yankees,Yankee Stadium I,1552030,96,94,NYY,NYA,NYA
+1959,AL,WS1,MIN,,8,154,77,63,91,,,N,N,619,5092,1205,173,32,163,517,881,51,34,,,701,606,4.0100000000,46,10,21,4080,1358,123,467,694,162,140,0.97,Washington Senators,Griffith Stadium II,615372,100,102,WSH,WS1,WS1
+1959,NL,CHN,CHC,,5,155,77,74,80,,,N,N,673,5296,1321,209,44,163,498,911,32,19,,,688,620,4.0100000000,30,11,25,4173,1337,152,519,765,140,142,0.97,Chicago Cubs,Wrigley Field,858255,99,100,CHC,CHN,CHN
+1959,NL,CIN,CIN,,5,154,77,74,80,,,N,N,764,5288,1448,258,34,161,499,763,65,28,,,738,650,4.3100000000,44,7,26,4071,1460,162,456,690,126,157,0.97,Cincinnati Redlegs,Crosley Field,801298,104,103,CIN,CIN,CIN
+1959,NL,LAN,LAD,,1,156,78,88,68,,,Y,Y,705,5282,1360,196,46,148,591,891,84,51,,,670,594,3.7900000000,43,14,26,4233,1317,157,614,1077,114,154,0.98,Los Angeles Dodgers,Los Angeles Memorial Coliseum,2071045,107,107,LAD,LAN,LAN
+1959,NL,ML1,ATL,,2,157,79,86,70,,,N,N,724,5388,1426,216,36,177,488,765,41,14,,,623,546,3.5100000000,69,18,18,4200,1406,128,429,775,123,138,0.97,Milwaukee Braves,County Stadium,1749112,92,90,MLN,MLN,MLN
+1959,NL,PHI,PHI,,8,155,78,64,90,,,N,N,599,5109,1237,196,38,113,498,858,39,46,,,725,642,4.2700000000,54,8,15,4062,1357,150,474,769,154,132,0.97,Philadelphia Phillies,Connie Mack Stadium,802815,101,104,PHI,PHI,PHI
+1959,NL,PIT,PIT,,4,155,77,78,76,,,N,N,651,5369,1414,230,42,112,442,715,32,26,,,680,604,3.9000000000,48,7,17,4179,1432,134,418,730,154,165,0.97,Pittsburgh Pirates,Forbes Field,1359917,99,98,PIT,PIT,PIT
+1959,NL,SFN,SFG,,3,154,77,83,71,,,N,N,705,5281,1377,239,35,167,473,875,81,34,,,613,531,3.4700000000,52,12,23,4128,1279,139,500,873,152,118,0.97,San Francisco Giants,Seals Stadium,1422130,98,96,SFG,SFN,SFN
+1959,NL,SLN,STL,,7,154,77,71,83,,,N,N,641,5317,1432,244,49,118,485,747,65,53,,,725,657,4.3400000000,36,8,21,4089,1427,137,564,846,146,158,0.97,St. Louis Cardinals,Sportsman's Park IV,929953,106,107,STL,SLN,SLN
+1960,AL,BAL,BAL,,2,154,77,89,65,,,N,N,682,5170,1307,206,33,123,596,801,37,24,,,606,538,3.5200000000,48,11,22,4125,1222,117,552,785,107,172,0.98,Baltimore Orioles,Memorial Stadium,1187849,99,98,BAL,BAL,BAL
+1960,AL,BOS,BOS,,7,154,77,65,89,,,N,N,658,5215,1359,234,32,124,570,798,34,28,,,775,699,4.6200000000,34,6,23,4083,1440,127,580,767,140,156,0.97,Boston Red Sox,Fenway Park II,1129866,103,103,BOS,BOS,BOS
+1960,AL,CHA,CHW,,3,154,77,87,67,,,N,N,741,5191,1402,242,38,112,567,648,122,48,,,617,552,3.6000000000,42,11,26,4143,1338,127,533,695,109,175,0.98,Chicago White Sox,Comiskey Park,1644460,100,98,CHW,CHA,CHA
+1960,AL,CLE,CLE,,4,154,77,76,78,,,N,N,667,5296,1415,218,20,127,444,573,58,25,,,693,607,3.9500000000,32,10,30,4146,1308,161,636,771,126,165,0.97,Cleveland Indians,Cleveland Stadium,950985,97,97,CLE,CLE,CLE
+1960,AL,DET,DET,,6,154,77,71,83,,,N,N,633,5202,1243,188,34,150,636,728,66,32,,,644,568,3.6400000000,40,7,25,4215,1336,141,474,824,137,138,0.97,Detroit Tigers,Briggs Stadium,1167669,103,103,DET,DET,DET
+1960,AL,KC1,OAK,,8,155,78,58,96,,,N,N,615,5226,1303,212,34,110,513,744,16,11,,,756,669,4.3800000000,44,4,14,4122,1428,160,525,664,127,149,0.97,Kansas City Athletics,Municipal Stadium I,774944,100,103,KCA,KC1,KC1
+1960,AL,NYA,NYY,,1,155,77,97,57,,,Y,N,746,5290,1377,215,40,193,537,818,37,23,,,627,547,3.5200000000,38,16,42,4194,1225,123,609,712,129,162,0.97,New York Yankees,Yankee Stadium I,1627349,94,92,NYY,NYA,NYA
+1960,AL,WS1,MIN,,5,154,77,73,81,,,N,N,672,5248,1283,205,43,147,584,883,52,43,,,696,589,3.7700000000,34,10,35,4215,1392,130,538,775,165,159,0.97,Washington Senators,Griffith Stadium II,743404,101,102,WSH,WS1,WS1
+1960,NL,CHN,CHC,,7,156,79,60,94,,,N,N,634,5311,1293,213,48,119,531,897,51,34,,,776,678,4.3500000000,36,6,25,4206,1393,152,565,805,143,133,0.97,Chicago Cubs,Wrigley Field,809770,99,100,CHC,CHN,CHN
+1960,NL,CIN,CIN,,6,154,77,67,87,,,N,N,640,5289,1324,230,40,140,512,858,73,37,,,692,618,4.0000000000,33,8,35,4170,1417,134,442,740,125,155,0.97,Cincinnati Reds,Crosley Field,663486,102,102,CIN,CIN,CIN
+1960,NL,LAN,LAD,,4,154,77,82,72,,,N,N,662,5227,1333,216,38,126,529,837,95,53,,,593,528,3.4000000000,46,13,20,4194,1218,154,564,1122,124,142,0.97,Los Angeles Dodgers,Los Angeles Memorial Coliseum,2253887,106,105,LAD,LAN,LAN
+1960,NL,ML1,ATL,,2,154,77,88,66,,,N,N,724,5263,1393,198,48,170,463,793,69,37,,,658,579,3.7600000000,55,13,28,4161,1327,130,518,807,139,137,0.97,Milwaukee Braves,County Stadium,1497799,93,91,MLN,MLN,MLN
+1960,NL,PHI,PHI,,8,154,77,59,95,,,N,N,546,5169,1235,196,44,99,448,1054,45,48,,,691,613,4.0100000000,45,6,16,4125,1423,133,439,736,155,129,0.97,Philadelphia Phillies,Connie Mack Stadium,862205,100,103,PHI,PHI,PHI
+1960,NL,PIT,PIT,,1,155,78,95,59,,,Y,Y,734,5406,1493,236,56,120,486,747,34,24,,,593,543,3.4900000000,47,11,33,4197,1363,105,386,811,128,163,0.97,Pittsburgh Pirates,Forbes Field,1705828,101,100,PIT,PIT,PIT
+1960,NL,SFN,SFG,,5,156,77,79,75,,,N,N,671,5324,1357,220,62,130,467,846,86,45,,,631,534,3.4400000000,55,16,26,4188,1288,107,512,897,165,117,0.97,San Francisco Giants,Candlestick Park,1795356,95,93,SFG,SFN,SFN
+1960,NL,SLN,STL,,3,155,77,86,68,,,N,N,639,5187,1317,213,48,138,501,792,48,35,,,616,554,3.6400000000,37,11,30,4113,1316,127,511,906,141,152,0.97,St. Louis Cardinals,Sportsman's Park IV,1096632,108,109,STL,SLN,SLN
+1961,AL,BAL,BAL,,3,163,82,95,67,,,N,N,691,5481,1393,227,36,149,581,902,39,30,,,588,526,3.2200000000,54,21,33,4413,1226,109,617,926,126,173,0.98,Baltimore Orioles,Memorial Stadium,951089,96,96,BAL,BAL,BAL
+1961,AL,BOS,BOS,,6,163,82,76,86,,,N,N,729,5508,1401,251,37,112,647,847,56,36,,,792,687,4.2900000000,35,6,30,4326,1472,167,679,831,143,140,0.97,Boston Red Sox,Fenway Park II,850589,102,103,BOS,BOS,BOS
+1961,AL,CHA,CHW,,4,163,81,86,76,,,N,N,765,5556,1475,216,46,138,550,612,100,40,,,726,653,4.0600000000,39,3,33,4344,1491,158,498,814,128,138,0.98,Chicago White Sox,Comiskey Park,1146019,99,97,CHW,CHA,CHA
+1961,AL,CLE,CLE,,5,161,81,78,83,,,N,N,737,5609,1493,257,39,150,492,720,34,11,,,752,665,4.1500000000,35,12,23,4329,1426,178,599,801,139,142,0.97,Cleveland Indians,Cleveland Stadium,725547,97,98,CLE,CLE,CLE
+1961,AL,DET,DET,,2,163,82,101,61,,,N,N,841,5561,1481,215,53,180,673,867,98,36,,,671,575,3.5500000000,62,12,30,4377,1404,170,469,836,146,147,0.97,Detroit Tigers,Tiger Stadium,1600710,103,102,DET,DET,DET
+1961,AL,KC1,OAK,,9,162,80,61,100,,,N,N,683,5423,1342,216,47,90,580,772,58,22,,,863,745,4.7400000000,32,5,23,4245,1519,141,629,703,174,160,0.97,Kansas City Athletics,Municipal Stadium I,683817,101,103,KCA,KC1,KC1
+1961,AL,LAA,ANA,,8,162,82,70,91,,,N,N,744,5424,1331,218,22,189,681,1068,37,28,,,784,689,4.3100000000,25,5,34,4314,1391,180,713,973,192,154,0.96,Los Angeles Angels,Wrigley Field (LA),603510,111,112,LAA,LAA,LAA
+1961,AL,MIN,MIN,,7,161,81,70,90,,,N,N,707,5417,1353,215,40,167,597,840,47,43,,,778,681,4.2800000000,49,14,23,4296,1415,163,570,914,174,150,0.97,Minnesota Twins,Metropolitan Stadium,1256723,106,106,MIN,MIN,MIN
+1961,AL,NYA,NYY,,1,163,81,109,53,,,Y,Y,827,5559,1461,194,40,240,543,785,28,18,,,612,558,3.4600000000,47,14,39,4353,1288,137,542,866,124,180,0.98,New York Yankees,Yankee Stadium I,1747725,95,93,NYY,NYA,NYA
+1961,AL,WS2,TEX,,9,161,79,61,100,,,N,N,618,5366,1307,217,44,119,558,917,81,47,,,776,670,4.2300000000,39,8,21,4275,1405,131,586,666,156,171,0.97,Washington Senators,Griffith Stadium II,597287,95,97,WSA,WS2,WS2
+1961,NL,CHN,CHC,,7,156,78,64,90,,,N,N,689,5344,1364,238,51,176,539,1027,35,25,,,800,689,4.4800000000,34,6,25,4155,1492,165,465,755,183,175,0.97,Chicago Cubs,Wrigley Field,673057,101,104,CHC,CHN,CHN
+1961,NL,CIN,CIN,,1,154,77,93,61,,,Y,N,710,5243,1414,247,35,158,423,761,70,33,,,653,575,3.7800000000,46,12,40,4110,1300,147,500,829,134,124,0.97,Cincinnati Reds,Crosley Field,1117603,102,101,CIN,CIN,CIN
+1961,NL,LAN,LAD,,2,154,77,89,65,,,N,N,735,5189,1358,193,40,157,596,796,86,45,,,697,619,4.0400000000,40,10,35,4134,1346,167,544,1105,136,162,0.97,Los Angeles Dodgers,Los Angeles Memorial Coliseum,1804250,108,107,LAD,LAN,LAN
+1961,NL,ML1,ATL,,4,155,77,83,71,,,N,N,712,5288,1365,199,34,188,534,880,70,43,,,656,601,3.8900000000,57,8,16,4173,1357,153,493,652,111,152,0.98,Milwaukee Braves,County Stadium,1101441,94,92,MLN,MLN,MLN
+1961,NL,PHI,PHI,,8,155,78,47,107,,,N,N,584,5213,1265,185,50,103,475,928,56,30,,,796,708,4.6100000000,29,9,13,4149,1452,155,521,775,144,179,0.97,Philadelphia Phillies,Connie Mack Stadium,590039,98,101,PHI,PHI,PHI
+1961,NL,PIT,PIT,,6,154,77,75,79,,,N,N,694,5311,1448,232,57,128,428,721,26,30,,,675,593,3.9200000000,34,9,29,4086,1442,121,400,759,150,189,0.97,Pittsburgh Pirates,Forbes Field,1199128,101,99,PIT,PIT,PIT
+1961,NL,SFN,SFG,,3,155,77,85,69,,,N,N,773,5233,1379,219,32,183,506,764,79,54,,,655,581,3.7700000000,39,9,30,4164,1306,152,502,924,133,126,0.97,San Francisco Giants,Candlestick Park,1390679,97,95,SFG,SFN,SFN
+1961,NL,SLN,STL,,5,155,78,80,74,,,N,N,703,5307,1436,236,51,103,494,745,46,28,,,668,568,3.7400000000,49,10,24,4104,1334,136,570,823,166,165,0.97,St. Louis Cardinals,Sportsman's Park IV,855305,110,110,STL,SLN,SLN
+1962,AL,BAL,BAL,,7,162,82,77,85,,,N,N,652,5491,1363,225,34,156,516,931,45,32,,,680,599,3.6900000000,32,8,33,4386,1373,147,549,898,122,152,0.98,Baltimore Orioles,Memorial Stadium,790254,94,93,BAL,BAL,BAL
+1962,AL,BOS,BOS,,8,160,79,76,84,,,N,N,707,5530,1429,257,53,146,525,923,39,33,,,756,674,4.2200000000,34,12,40,4311,1416,159,632,923,128,152,0.97,Boston Red Sox,Fenway Park II,733080,103,104,BOS,BOS,BOS
+1962,AL,CHA,CHW,,5,162,81,85,77,,,N,N,707,5514,1415,250,56,92,620,674,76,40,,,658,601,3.7300000000,50,13,28,4353,1380,123,537,821,110,153,0.98,Chicago White Sox,Comiskey Park,1131562,100,99,CHW,CHA,CHA
+1962,AL,CLE,CLE,,6,162,81,80,82,,,N,N,682,5484,1341,202,22,180,502,939,35,16,,,745,663,4.1400000000,45,12,31,4323,1410,174,594,780,139,168,0.97,Cleveland Indians,Cleveland Stadium,716076,97,97,CLE,CLE,CLE
+1962,AL,DET,DET,,4,161,82,85,76,,,N,N,758,5456,1352,191,36,209,651,894,69,21,,,692,611,3.8100000000,46,8,35,4329,1452,169,503,873,156,114,0.97,Detroit Tigers,Tiger Stadium,1207881,103,102,DET,DET,DET
+1962,AL,KC1,OAK,,9,162,81,72,90,,,N,N,745,5576,1467,220,58,116,556,803,76,21,,,837,763,4.7900000000,32,4,33,4302,1450,199,655,825,132,131,0.97,Kansas City Athletics,Municipal Stadium I,635675,104,106,KCA,KC1,KC1
+1962,AL,LAA,ANA,,3,162,81,86,76,,,N,N,718,5499,1377,232,35,137,602,917,46,27,,,706,603,3.7000000000,23,15,47,4398,1412,118,616,858,175,153,0.97,Los Angeles Angels,Dodger Stadium,1144063,97,97,LAA,LAA,LAA
+1962,AL,MIN,MIN,,2,163,82,91,71,,,N,N,798,5561,1445,215,39,185,649,823,33,20,,,713,632,3.8900000000,53,11,27,4389,1400,166,493,948,129,173,0.97,Minnesota Twins,Metropolitan Stadium,1433116,104,103,MIN,MIN,MIN
+1962,AL,NYA,NYY,,1,162,80,96,66,,,Y,Y,817,5644,1509,240,29,199,584,842,42,29,,,680,604,3.7000000000,33,10,42,4410,1375,146,499,838,131,151,0.97,New York Yankees,Yankee Stadium I,1493574,97,95,NYY,NYA,NYA
+1962,AL,WS2,TEX,,10,162,80,60,101,,,N,N,599,5484,1370,206,38,132,466,789,99,53,,,716,649,4.0400000000,38,11,13,4335,1400,151,593,771,139,160,0.97,Washington Senators,R.F.K. Stadium,729775,100,102,WSA,WS2,WS2
+1962,NL,CHN,CHC,,9,162,81,59,103,,,N,N,632,5534,1398,196,56,126,504,1044,78,50,,,827,725,4.5400000000,29,4,26,4314,1509,159,601,783,146,171,0.97,Chicago Cubs,Wrigley Field,609802,104,105,CHC,CHN,CHN
+1962,NL,CIN,CIN,,3,162,81,98,64,,,N,N,802,5645,1523,252,40,167,498,903,66,39,,,685,608,3.7500000000,51,13,35,4380,1397,149,567,964,143,144,0.97,Cincinnati Reds,Crosley Field,982095,104,102,CIN,CIN,CIN
+1962,NL,HOU,HOU,,8,162,82,64,96,,,N,N,592,5558,1370,170,47,105,493,806,42,30,,,717,618,3.8300000000,34,9,19,4359,1446,113,471,1047,173,149,0.97,Houston Colt .45's,Colt Stadium,924456,93,95,HOU,HOU,HOU
+1962,NL,LAN,LAD,,2,165,83,102,63,,,N,N,842,5628,1510,192,65,140,572,886,198,43,,,697,599,3.6200000000,44,8,46,4464,1386,115,588,1104,191,144,0.97,Los Angeles Dodgers,Dodger Stadium,2755184,93,91,LAD,LAN,LAN
+1962,NL,ML1,ATL,,5,162,81,86,76,,,N,N,730,5458,1376,204,38,181,581,975,57,27,,,665,586,3.6800000000,59,10,24,4302,1443,151,407,802,123,154,0.98,Milwaukee Braves,County Stadium,766921,97,96,MLN,MLN,MLN
+1962,NL,NYN,NYM,,10,161,80,40,120,,,N,N,617,5492,1318,166,40,139,616,991,59,48,,,948,801,5.0400000000,43,4,10,4290,1577,192,571,772,210,167,0.96,New York Mets,Polo Grounds IV,922530,100,105,NYM,NYN,NYN
+1962,NL,PHI,PHI,,7,161,80,81,80,,,N,N,705,5420,1410,199,39,142,531,923,79,42,,,759,678,4.2800000000,43,7,24,4278,1469,155,574,863,138,167,0.97,Philadelphia Phillies,Connie Mack Stadium,762034,97,98,PHI,PHI,PHI
+1962,NL,PIT,PIT,,4,161,81,93,68,,,N,N,706,5483,1468,240,65,108,432,836,50,39,,,626,536,3.3700000000,40,13,41,4296,1433,118,466,897,152,177,0.97,Pittsburgh Pirates,Forbes Field,1090648,101,100,PIT,PIT,PIT
+1962,NL,SFN,SFG,,1,165,82,103,62,,,Y,N,878,5588,1552,235,32,204,523,822,73,50,,,690,615,3.7900000000,62,10,39,4383,1399,148,503,886,142,153,0.97,San Francisco Giants,Candlestick Park,1592594,99,96,SFG,SFN,SFN
+1962,NL,SLN,STL,,6,163,81,84,78,,,N,N,774,5643,1528,221,31,137,515,846,86,41,,,664,577,3.5500000000,53,17,25,4389,1394,149,517,914,132,170,0.97,St. Louis Cardinals,Sportsman's Park IV,953895,111,109,STL,SLN,SLN
+1963,AL,BAL,BAL,,4,162,81,86,76,,,N,N,644,5448,1359,207,32,146,469,940,97,34,,,621,557,3.4500000000,35,8,43,4356,1353,137,507,913,99,157,0.98,Baltimore Orioles,Memorial Stadium,774343,96,95,BAL,BAL,BAL
+1963,AL,BOS,BOS,,7,161,80,76,85,,,N,N,666,5575,1403,247,34,171,475,954,27,16,,,704,639,3.9700000000,29,7,32,4347,1367,152,539,1009,132,119,0.97,Boston Red Sox,Fenway Park II,942642,103,104,BOS,BOS,BOS
+1963,AL,CHA,CHW,,2,162,82,94,68,,,N,N,683,5508,1379,208,40,114,571,896,64,28,,,544,485,2.9700000000,49,21,39,4407,1311,100,440,932,130,163,0.97,Chicago White Sox,Comiskey Park,1158848,98,96,CHW,CHA,CHA
+1963,AL,CLE,CLE,,5,162,81,79,83,,,N,N,635,5496,1314,214,29,169,469,1102,59,36,,,702,619,3.7900000000,40,14,25,4407,1390,176,478,1018,143,129,0.97,Cleveland Indians,Cleveland Stadium,562507,100,100,CLE,CLE,CLE
+1963,AL,DET,DET,,5,162,81,79,83,,,N,N,700,5500,1388,195,36,148,592,908,73,32,,,703,631,3.9000000000,42,7,28,4368,1407,195,477,930,113,124,0.98,Detroit Tigers,Tiger Stadium,821952,103,103,DET,DET,DET
+1963,AL,KC1,OAK,,8,162,81,73,89,,,N,N,615,5495,1356,225,38,95,529,829,47,26,,,704,635,3.9200000000,35,11,29,4374,1417,156,540,887,124,131,0.98,Kansas City Athletics,Municipal Stadium I,762364,106,108,KCA,KC1,KC1
+1963,AL,LAA,ANA,,9,161,81,70,91,,,N,N,597,5506,1378,208,38,95,448,916,43,30,,,660,569,3.5200000000,30,13,31,4365,1317,120,578,889,163,155,0.97,Los Angeles Angels,Dodger Stadium,821015,94,94,LAA,LAA,LAA
+1963,AL,MIN,MIN,,3,161,81,91,70,,,N,N,767,5531,1408,223,35,225,547,912,32,14,,,602,527,3.2800000000,58,13,30,4338,1322,162,459,941,144,140,0.97,Minnesota Twins,Metropolitan Stadium,1406652,102,101,MIN,MIN,MIN
+1963,AL,NYA,NYY,,1,161,80,104,57,,,Y,N,714,5506,1387,197,35,188,434,808,42,26,,,547,494,3.0700000000,59,19,31,4347,1239,115,476,965,108,162,0.98,New York Yankees,Yankee Stadium I,1308920,100,97,NYY,NYA,NYA
+1963,AL,WS2,TEX,,10,162,80,56,106,,,N,N,578,5446,1237,190,35,138,497,963,68,28,,,812,711,4.4200000000,29,8,25,4341,1486,176,537,744,182,165,0.97,Washington Senators,R.F.K. Stadium,535604,100,103,WSA,WS2,WS2
+1963,NL,CHN,CHC,,7,162,81,82,80,,,N,N,570,5404,1286,205,44,127,439,1049,68,60,,,578,499,3.0800000000,45,15,28,4371,1357,119,400,851,155,172,0.97,Chicago Cubs,Wrigley Field,979551,106,107,CHC,CHN,CHN
+1963,NL,CIN,CIN,,5,162,81,86,76,,,N,N,648,5416,1333,225,44,122,474,960,92,58,,,594,526,3.2900000000,55,22,36,4317,1307,117,425,1048,135,127,0.97,Cincinnati Reds,Crosley Field,858805,103,102,CIN,CIN,CIN
+1963,NL,HOU,HOU,,9,162,81,66,96,,,N,N,464,5384,1184,170,39,62,456,938,39,30,,,640,554,3.4400000000,36,16,20,4350,1341,95,378,937,162,100,0.97,Houston Colt .45's,Colt Stadium,719502,94,96,HOU,HOU,HOU
+1963,NL,LAN,LAD,,1,163,81,99,63,,,Y,Y,640,5428,1361,178,34,110,453,867,124,70,,,550,465,2.8500000000,51,24,29,4407,1329,111,402,1095,158,129,0.97,Los Angeles Dodgers,Dodger Stadium,2538602,93,91,LAD,LAN,LAN
+1963,NL,ML1,ATL,,6,163,82,84,78,,,N,N,677,5518,1345,204,39,139,525,954,75,52,,,603,534,3.2700000000,56,18,25,4413,1327,149,489,924,129,161,0.98,Milwaukee Braves,County Stadium,773018,99,98,MLN,MLN,MLN
+1963,NL,NYN,NYM,,10,162,81,51,111,,,N,N,501,5336,1168,156,35,96,457,1078,41,52,,,774,653,4.1200000000,42,5,12,4281,1452,162,529,806,208,151,0.96,New York Mets,Polo Grounds IV,1080108,100,105,NYM,NYN,NYN
+1963,NL,PHI,PHI,,4,162,81,87,75,,,N,N,642,5524,1390,228,54,126,403,955,56,39,,,578,500,3.0900000000,45,12,31,4371,1262,113,553,1052,142,147,0.97,Philadelphia Phillies,Connie Mack Stadium,907141,99,99,PHI,PHI,PHI
+1963,NL,PIT,PIT,,8,162,81,74,88,,,N,N,567,5536,1385,181,49,108,454,940,57,41,,,595,499,3.1000000000,34,16,33,4344,1350,99,457,900,182,195,0.97,Pittsburgh Pirates,Forbes Field,783648,101,100,PIT,PIT,PIT
+1963,NL,SFN,SFG,,3,162,81,88,74,,,N,N,725,5579,1442,206,35,197,441,889,55,49,,,641,547,3.3500000000,46,9,30,4407,1380,126,464,954,156,113,0.97,San Francisco Giants,Candlestick Park,1571306,99,97,SFG,SFN,SFN
+1963,NL,SLN,STL,,2,162,81,93,69,,,N,N,747,5678,1540,231,66,128,458,915,77,42,,,628,540,3.3200000000,49,17,32,4389,1329,124,463,978,147,136,0.97,St. Louis Cardinals,Sportsman's Park IV,1170546,110,109,STL,SLN,SLN
+1964,AL,BAL,BAL,,3,163,82,97,65,,,N,N,679,5463,1357,229,20,162,537,1019,78,38,,,567,512,3.1600000000,44,17,41,4374,1292,129,456,939,95,159,0.98,Baltimore Orioles,Memorial Stadium,1116215,100,99,BAL,BAL,BAL
+1964,AL,BOS,BOS,,8,162,81,72,90,,,N,N,688,5513,1425,253,29,186,504,917,18,16,,,793,711,4.5000000000,21,9,38,4266,1464,178,571,1094,136,123,0.97,Boston Red Sox,Fenway Park II,883276,105,106,BOS,BOS,BOS
+1964,AL,CHA,CHW,,2,162,81,98,64,,,N,N,642,5491,1356,184,40,106,562,902,75,39,,,501,443,2.7200000000,44,20,45,4401,1216,124,401,955,122,164,0.98,Chicago White Sox,Comiskey Park,1250053,97,95,CHW,CHA,CHA
+1964,AL,CLE,CLE,,6,164,82,79,83,,,N,N,689,5603,1386,208,22,164,500,1063,79,51,,,693,620,3.7500000000,37,16,37,4461,1443,154,565,1162,118,149,0.98,Cleveland Indians,Cleveland Stadium,653293,99,99,CLE,CLE,CLE
+1964,AL,DET,DET,,4,163,82,85,77,,,N,N,699,5513,1394,199,57,157,517,912,60,27,,,678,620,3.8400000000,35,11,35,4359,1343,164,536,993,109,137,0.98,Detroit Tigers,Tiger Stadium,816139,102,101,DET,DET,DET
+1964,AL,KC1,OAK,,10,163,81,57,105,,,N,N,621,5524,1321,216,29,166,548,1104,34,20,,,836,761,4.7100000000,18,6,27,4365,1516,220,614,966,154,152,0.97,Kansas City Athletics,Municipal Stadium I,642478,104,106,KCA,KC1,KC1
+1964,AL,LAA,ANA,,5,162,81,82,80,,,N,N,544,5362,1297,186,27,102,472,920,49,39,,,551,469,2.9100000000,30,28,41,4350,1273,100,530,965,138,168,0.97,Los Angeles Angels,Dodger Stadium,760439,90,90,LAA,LAA,LAA
+1964,AL,MIN,MIN,,6,163,82,79,83,,,N,N,737,5610,1413,227,46,221,553,1019,46,22,,,678,588,3.5800000000,47,4,29,4431,1361,181,545,1099,145,131,0.97,Minnesota Twins,Metropolitan Stadium,1207514,101,99,MIN,MIN,MIN
+1964,AL,NYA,NYY,,1,164,81,99,63,,,Y,N,730,5705,1442,208,35,162,520,976,54,18,,,577,527,3.1500000000,46,18,45,4518,1312,129,504,989,107,158,0.98,New York Yankees,Yankee Stadium I,1305638,101,100,NYY,NYA,NYA
+1964,AL,WS2,TEX,,9,162,81,62,100,,,N,N,578,5396,1246,199,28,125,514,1124,47,30,,,733,635,3.9800000000,27,5,26,4305,1417,172,505,794,127,145,0.97,Washington Senators,R.F.K. Stadium,600106,100,102,WSA,WS2,WS2
+1964,NL,CHN,CHC,,8,162,81,76,86,,,N,N,649,5545,1391,239,50,145,499,1041,70,49,,,724,655,4.0800000000,58,11,19,4335,1510,144,423,737,162,147,0.97,Chicago Cubs,Wrigley Field,751647,104,105,CHC,CHN,CHN
+1964,NL,CIN,CIN,,2,163,82,92,70,,,N,N,660,5561,1383,220,38,130,457,974,90,36,,,566,500,3.0700000000,54,14,35,4401,1306,112,436,1122,130,137,0.97,Cincinnati Reds,Crosley Field,862466,103,102,CIN,CIN,CIN
+1964,NL,HOU,HOU,,9,162,81,66,96,,,N,N,495,5303,1214,162,41,70,381,872,40,48,,,628,541,3.4100000000,30,9,31,4284,1421,105,353,852,149,124,0.97,Houston Colt .45's,Colt Stadium,725773,95,97,HOU,HOU,HOU
+1964,NL,LAN,LAD,,6,164,81,80,82,,,N,N,614,5499,1375,180,39,79,438,893,141,60,,,572,486,2.9500000000,47,19,27,4449,1289,88,458,1062,170,126,0.97,Los Angeles Dodgers,Dodger Stadium,2228751,93,92,LAD,LAN,LAN
+1964,NL,ML1,ATL,,5,162,81,88,74,,,N,N,803,5591,1522,274,32,159,486,825,53,41,,,744,656,4.1200000000,45,14,39,4302,1411,160,452,906,143,139,0.97,Milwaukee Braves,County Stadium,910911,101,100,MLN,MLN,MLN
+1964,NL,NYN,NYM,,10,163,82,53,109,,,N,N,569,5566,1372,195,31,103,353,932,36,31,,,776,679,4.2500000000,40,10,15,4314,1511,130,466,717,166,154,0.97,New York Mets,Shea Stadium,1732597,97,100,NYM,NYN,NYN
+1964,NL,PHI,PHI,,2,162,81,92,70,,,N,N,693,5493,1415,241,51,130,440,924,30,35,,,632,545,3.3600000000,37,17,41,4383,1402,129,440,1009,156,150,0.97,Philadelphia Phillies,Connie Mack Stadium,1425891,99,98,PHI,PHI,PHI
+1964,NL,PIT,PIT,,6,162,81,80,82,,,N,N,663,5566,1469,225,54,121,408,970,39,33,,,636,564,3.5200000000,42,14,29,4329,1429,92,476,951,177,179,0.97,Pittsburgh Pirates,Forbes Field,759496,100,99,PIT,PIT,PIT
+1964,NL,SFN,SFG,,4,162,81,90,72,,,N,N,656,5535,1360,185,38,165,505,900,64,35,,,587,523,3.1900000000,48,17,30,4428,1348,118,480,1023,159,136,0.97,San Francisco Giants,Candlestick Park,1504364,102,101,SFG,SFN,SFN
+1964,NL,SLN,STL,,1,162,81,93,69,,,Y,Y,715,5625,1531,240,53,109,427,925,73,51,,,652,551,3.4300000000,47,10,38,4335,1405,133,410,877,172,147,0.97,St. Louis Cardinals,Sportsman's Park IV,1143294,109,108,STL,SLN,SLN
+1965,AL,BAL,BAL,,3,162,79,94,68,,,N,N,641,5450,1299,227,38,125,529,907,67,31,,,578,489,2.9800000000,32,15,41,4431,1268,120,510,939,126,152,0.98,Baltimore Orioles,Memorial Stadium,781649,102,101,BAL,BAL,BAL
+1965,AL,BOS,BOS,,9,162,81,62,100,,,N,N,669,5487,1378,244,40,165,607,964,47,24,,,791,678,4.2400000000,33,9,25,4317,1443,158,543,993,159,129,0.97,Boston Red Sox,Fenway Park II,652201,106,108,BOS,BOS,BOS
+1965,AL,CAL,ANA,,7,162,80,75,87,,,N,N,527,5354,1279,200,36,92,443,973,107,59,,,569,508,3.1700000000,39,14,33,4323,1259,91,563,847,123,149,0.98,California Angels,Dodger Stadium,566727,97,98,CAL,CAL,CAL
+1965,AL,CHA,CHW,,2,162,81,95,67,,,N,N,647,5509,1354,200,38,125,533,916,50,33,,,555,492,2.9900000000,21,14,53,4443,1261,122,460,946,126,156,0.98,Chicago White Sox,Comiskey Park,1130519,93,92,CHW,CHA,CHA
+1965,AL,CLE,CLE,,5,162,82,87,75,,,N,N,663,5469,1367,198,21,156,506,857,109,46,,,613,535,3.3000000000,41,13,41,4374,1254,129,500,1156,114,127,0.98,Cleveland Indians,Cleveland Stadium,934786,101,101,CLE,CLE,CLE
+1965,AL,DET,DET,,4,162,81,89,73,,,N,N,680,5368,1278,190,27,162,554,952,57,41,,,602,542,3.3500000000,45,14,31,4365,1283,137,509,1069,114,126,0.98,Detroit Tigers,Tiger Stadium,1029645,102,101,DET,DET,DET
+1965,AL,KC1,OAK,,10,162,81,59,103,,,N,N,585,5393,1294,186,59,110,521,1020,110,51,,,755,675,4.2400000000,18,7,32,4299,1399,161,574,882,139,142,0.97,Kansas City Athletics,Municipal Stadium I,528344,99,101,KCA,KC1,KC1
+1965,AL,MIN,MIN,,1,162,81,102,60,,,Y,N,774,5488,1396,257,42,150,554,969,92,33,,,600,508,3.1400000000,32,12,45,4371,1278,166,503,934,172,158,0.97,Minnesota Twins,Metropolitan Stadium,1463258,105,103,MIN,MIN,MIN
+1965,AL,NYA,NYY,,6,162,83,77,85,,,N,N,611,5470,1286,196,31,149,489,951,35,20,,,604,532,3.2800000000,41,11,31,4377,1337,126,511,1001,137,166,0.97,New York Yankees,Yankee Stadium I,1213552,99,98,NYY,NYA,NYA
+1965,AL,WS2,TEX,,8,162,81,70,92,,,N,N,591,5374,1227,179,33,136,570,1125,30,19,,,721,627,3.9300000000,21,8,40,4305,1376,160,633,867,143,148,0.97,Washington Senators,R.F.K. Stadium,560083,98,100,WSA,WS2,WS2
+1965,NL,CHN,CHC,,8,164,83,72,90,,,N,N,635,5540,1316,202,33,134,532,948,65,47,,,723,618,3.7800000000,33,9,35,4416,1470,154,481,855,171,166,0.97,Chicago Cubs,Wrigley Field,641361,102,104,CHC,CHN,CHN
+1965,NL,CIN,CIN,,4,162,81,89,73,,,N,N,825,5658,1544,268,61,183,538,1003,82,40,,,704,628,3.8800000000,43,9,34,4371,1355,136,587,1113,117,142,0.98,Cincinnati Reds,Crosley Field,1047824,107,106,CIN,CIN,CIN
+1965,NL,HOU,HOU,,9,162,81,65,97,,,N,N,569,5483,1299,188,42,97,502,877,90,37,,,711,623,3.8400000000,29,7,26,4383,1459,123,388,931,166,130,0.97,Houston Astros,Astrodome,2151470,92,94,HOU,HOU,HOU
+1965,NL,LAN,LAD,,1,162,81,97,65,,,Y,Y,608,5425,1329,193,32,78,492,891,172,77,,,521,461,2.8100000000,58,23,34,4428,1223,127,425,1079,134,135,0.97,Los Angeles Dodgers,Dodger Stadium,2553577,93,92,LAD,LAN,LAN
+1965,NL,ML1,ATL,,5,162,81,86,76,,,N,N,708,5542,1419,243,28,196,408,976,64,37,,,633,566,3.5200000000,43,4,38,4341,1336,123,541,966,140,145,0.97,Milwaukee Braves,County Stadium,555584,101,99,MLN,MLN,MLN
+1965,NL,NYN,NYM,,10,164,82,50,112,,,N,N,495,5441,1202,203,27,107,392,1129,28,42,,,752,656,4.0600000000,29,11,14,4362,1462,147,498,776,169,153,0.97,New York Mets,Shea Stadium,1768389,96,99,NYM,NYN,NYN
+1965,NL,PHI,PHI,,6,162,80,85,76,,,N,N,654,5528,1380,205,53,144,494,1091,46,32,,,667,576,3.5300000000,50,18,21,4404,1426,116,466,1071,157,153,0.97,Philadelphia Phillies,Connie Mack Stadium,1166376,98,98,PHI,PHI,PHI
+1965,NL,PIT,PIT,,3,163,82,90,72,,,N,N,675,5686,1506,217,57,111,419,1008,51,38,,,580,495,3.0100000000,49,17,27,4437,1324,89,469,882,152,189,0.97,Pittsburgh Pirates,Forbes Field,909279,101,99,PIT,PIT,PIT
+1965,NL,SFN,SFG,,2,163,81,95,67,,,N,N,682,5495,1384,169,43,159,476,844,47,27,,,593,521,3.2000000000,42,17,42,4395,1325,137,408,1060,148,124,0.97,San Francisco Giants,Candlestick Park,1546075,104,102,SFG,SFN,SFN
+1965,NL,SLN,STL,,7,162,81,80,81,,,N,N,707,5579,1415,234,46,109,477,882,100,52,,,674,612,3.7700000000,40,11,35,4383,1414,166,467,916,130,152,0.97,St. Louis Cardinals,Sportsman's Park IV,1241201,110,109,STL,SLN,SLN
+1966,AL,BAL,BAL,,1,160,79,97,63,,,Y,Y,755,5529,1426,243,35,175,514,926,55,43,,,601,541,3.3200000000,23,13,51,4398,1267,127,514,1070,115,142,0.98,Baltimore Orioles,Memorial Stadium,1203366,99,98,BAL,BAL,BAL
+1966,AL,BOS,BOS,,9,162,81,72,90,,,N,N,655,5498,1318,228,44,145,542,1020,35,24,,,731,637,3.9200000000,32,10,31,4389,1402,164,577,977,153,153,0.97,Boston Red Sox,Fenway Park II,811172,111,112,BOS,BOS,BOS
+1966,AL,CAL,ANA,,6,162,81,80,82,,,N,N,604,5360,1244,179,54,122,525,1062,80,54,,,643,576,3.5600000000,31,12,40,4371,1364,136,511,836,136,186,0.97,California Angels,Anaheim Stadium,1400321,97,97,CAL,CAL,CAL
+1966,AL,CHA,CHW,,4,163,81,83,79,,,N,N,574,5348,1235,193,40,87,476,872,153,78,,,517,439,2.6800000000,38,22,34,4425,1229,101,403,896,160,149,0.97,Chicago White Sox,Comiskey Park,990016,93,92,CHW,CHA,CHA
+1966,AL,CLE,CLE,,5,162,81,81,81,,,N,N,574,5474,1300,156,25,155,450,914,53,41,,,586,526,3.2300000000,49,15,28,4401,1260,129,489,1111,138,132,0.97,Cleveland Indians,Cleveland Stadium,903359,100,100,CLE,CLE,CLE
+1966,AL,DET,DET,,3,162,81,88,74,,,N,N,719,5507,1383,224,45,179,551,987,41,34,,,698,622,3.8500000000,36,11,38,4362,1356,185,520,1026,117,142,0.98,Detroit Tigers,Tiger Stadium,1124293,103,102,DET,DET,DET
+1966,AL,KC1,OAK,,7,160,81,74,86,,,N,N,564,5328,1259,212,56,70,421,982,132,50,,,648,568,3.5600000000,19,11,47,4305,1281,106,630,854,139,154,0.97,Kansas City Athletics,Municipal Stadium I,773929,97,99,KCA,KC1,KC1
+1966,AL,MIN,MIN,,2,162,81,89,73,,,N,N,663,5390,1341,219,33,144,513,844,67,42,,,581,500,3.1300000000,52,11,28,4314,1246,139,392,1015,139,118,0.97,Minnesota Twins,Metropolitan Stadium,1259374,107,105,MIN,MIN,MIN
+1966,AL,NYA,NYY,,10,160,82,70,89,,,N,N,611,5330,1254,182,36,162,485,817,49,29,,,612,536,3.4100000000,29,7,32,4245,1318,124,443,842,142,142,0.97,New York Yankees,Yankee Stadium I,1124648,95,96,NYY,NYA,NYA
+1966,AL,WS2,TEX,,8,159,78,71,88,,,N,N,557,5318,1245,185,40,126,450,1069,53,37,,,659,583,3.7000000000,25,6,35,4257,1282,154,448,866,142,139,0.97,Washington Senators,R.F.K. Stadium,576260,99,101,WSA,WS2,WS2
+1966,NL,ATL,ATL,,5,163,82,85,77,,,N,N,782,5617,1476,220,32,207,512,913,59,47,,,683,601,3.6800000000,37,10,36,4407,1430,129,485,884,154,139,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1539801,103,102,ATL,ATL,ATL
+1966,NL,CHN,CHC,,10,162,81,59,103,,,N,N,644,5592,1418,203,43,140,457,998,76,47,,,809,701,4.3300000000,28,6,24,4374,1513,184,479,908,166,132,0.97,Chicago Cubs,Wrigley Field,635891,101,102,CHC,CHN,CHN
+1966,NL,CIN,CIN,,7,160,79,76,84,,,N,N,692,5521,1434,232,33,149,394,877,70,50,,,702,651,4.0800000000,28,10,35,4308,1408,153,490,1043,122,133,0.98,Cincinnati Reds,Crosley Field,742958,110,109,CIN,CIN,CIN
+1966,NL,HOU,HOU,,8,163,81,72,90,,,N,N,612,5511,1405,203,35,112,491,885,90,47,,,695,603,3.7600000000,34,13,26,4329,1468,130,391,929,174,126,0.97,Houston Astros,Astrodome,1872108,93,94,HOU,HOU,HOU
+1966,NL,LAN,LAD,,1,162,81,95,67,,,Y,N,606,5471,1399,201,27,108,430,830,94,64,,,490,424,2.6200000000,52,20,35,4374,1287,84,356,1084,133,128,0.97,Los Angeles Dodgers,Dodger Stadium,2617029,92,91,LAD,LAN,LAN
+1966,NL,NYN,NYM,,9,161,81,66,95,,,N,N,587,5371,1286,187,35,98,446,992,55,46,,,761,661,4.1700000000,37,9,22,4281,1497,166,521,773,159,171,0.97,New York Mets,Shea Stadium,1932693,97,100,NYM,NYN,NYN
+1966,NL,PHI,PHI,,4,162,81,87,75,,,N,N,696,5607,1448,224,49,117,510,969,56,42,,,640,579,3.5700000000,52,15,23,4377,1439,137,412,928,113,147,0.98,Philadelphia Phillies,Connie Mack Stadium,1108201,100,99,PHI,PHI,PHI
+1966,NL,PIT,PIT,,3,162,81,92,70,,,N,N,759,5676,1586,238,66,158,405,1011,64,60,,,641,572,3.5200000000,35,12,43,4389,1445,125,463,898,141,215,0.97,Pittsburgh Pirates,Forbes Field,1196618,100,99,PIT,PIT,PIT
+1966,NL,SFN,SFG,,2,161,81,93,68,,,N,N,675,5539,1373,195,31,181,414,860,29,30,,,626,531,3.2400000000,52,14,27,4428,1370,140,359,973,168,131,0.97,San Francisco Giants,Candlestick Park,1657192,104,103,SFG,SFN,SFN
+1966,NL,SLN,STL,,6,162,81,83,79,,,N,N,571,5480,1377,196,61,108,345,977,144,61,,,577,504,3.1100000000,47,19,32,4377,1345,130,448,892,145,166,0.97,St. Louis Cardinals,Sportsman's Park IV/Busch Stadium II,1712980,100,100,STL,SLN,SLN
+1967,AL,BAL,BAL,,6,161,77,76,85,,,N,N,654,5456,1312,215,44,138,531,1002,54,37,,,592,537,3.3200000000,29,17,36,4371,1218,116,566,1034,124,144,0.98,Baltimore Orioles,Memorial Stadium,955053,100,98,BAL,BAL,BAL
+1967,AL,BOS,BOS,,1,162,81,92,70,,,Y,N,722,5471,1394,216,39,158,522,1020,68,59,,,614,545,3.3600000000,41,9,44,4377,1307,142,477,1010,142,142,0.97,Boston Red Sox,Fenway Park II,1727832,109,109,BOS,BOS,BOS
+1967,AL,CAL,ANA,,5,161,83,84,77,,,N,N,567,5307,1265,170,37,114,453,1021,40,36,,,587,507,3.1900000000,19,14,46,4290,1246,118,525,892,111,135,0.98,California Angels,Anaheim Stadium,1317713,95,96,CAL,CAL,CAL
+1967,AL,CHA,CHW,,4,162,82,89,73,,,N,N,531,5383,1209,181,34,89,480,849,124,82,,,491,406,2.4500000000,36,24,39,4470,1197,87,465,927,137,149,0.97,Chicago White Sox,Comiskey Park,985634,93,93,CHW,CHA,CHA
+1967,AL,CLE,CLE,,8,162,81,75,87,,,N,N,559,5461,1282,213,35,131,413,984,53,65,,,613,533,3.2500000000,49,14,27,4431,1258,120,559,1189,115,138,0.98,Cleveland Indians,Cleveland Stadium,662980,102,102,CLE,CLE,CLE
+1967,AL,DET,DET,,2,163,82,91,71,,,N,N,683,5410,1315,192,36,152,626,994,37,21,,,587,532,3.3200000000,46,17,40,4329,1230,151,472,1038,130,126,0.97,Detroit Tigers,Tiger Stadium,1447143,103,101,DET,DET,DET
+1967,AL,KC1,OAK,,10,161,81,62,99,,,N,N,533,5349,1244,212,50,69,452,1019,132,59,,,660,584,3.6800000000,26,10,34,4284,1265,125,558,990,132,120,0.97,Kansas City Athletics,Municipal Stadium I,726639,97,99,KCA,KC1,KC1
+1967,AL,MIN,MIN,,2,164,81,91,71,,,N,N,671,5458,1309,216,48,131,512,976,55,37,,,590,510,3.1400000000,58,18,24,4383,1336,115,396,1089,132,123,0.97,Minnesota Twins,Metropolitan Stadium,1483547,108,107,MIN,MIN,MIN
+1967,AL,NYA,NYY,,9,163,82,72,90,,,N,N,522,5443,1225,166,17,100,532,1043,63,37,,,621,533,3.2400000000,37,16,27,4440,1375,110,480,898,154,144,0.97,New York Yankees,Yankee Stadium I,1259514,95,96,NYY,NYA,NYA
+1967,AL,WS2,TEX,,6,161,80,76,85,,,N,N,550,5441,1211,168,25,115,472,1037,53,37,,,637,553,3.3800000000,24,14,39,4419,1334,113,495,878,144,167,0.97,Washington Senators,R.F.K. Stadium,770868,96,97,WSA,WS2,WS2
+1967,NL,ATL,ATL,,7,162,81,77,85,,,N,N,631,5450,1307,191,29,158,512,947,55,45,,,640,561,3.4700000000,35,5,32,4362,1377,118,449,862,138,148,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1389222,99,99,ATL,ATL,ATL
+1967,NL,CHN,CHC,,3,162,84,87,74,,,N,N,702,5463,1373,211,49,128,509,912,63,50,,,624,563,3.4800000000,47,7,28,4371,1352,142,463,888,121,143,0.98,Chicago Cubs,Wrigley Field,977226,105,105,CHC,CHN,CHN
+1967,NL,CIN,CIN,,4,162,81,87,75,,,N,N,604,5519,1366,251,54,109,372,969,92,63,,,563,497,3.0500000000,34,18,39,4404,1328,101,498,1065,121,124,0.98,Cincinnati Reds,Crosley Field,958300,112,112,CIN,CIN,CIN
+1967,NL,HOU,HOU,,9,162,81,69,93,,,N,N,626,5506,1372,259,46,93,537,934,88,38,,,742,647,4.0300000000,35,8,21,4335,1444,120,485,1060,157,120,0.97,Houston Astros,Astrodome,1348303,96,97,HOU,HOU,HOU
+1967,NL,LAN,LAD,,8,162,81,73,89,,,N,N,519,5456,1285,203,38,82,485,881,56,47,,,595,525,3.2100000000,41,17,24,4419,1421,93,393,967,160,144,0.97,Los Angeles Dodgers,Dodger Stadium,1664362,91,91,LAD,LAN,LAN
+1967,NL,NYN,NYM,,10,162,78,61,101,,,N,N,498,5417,1288,178,23,83,362,981,58,44,,,672,594,3.7300000000,36,10,19,4299,1369,124,536,893,157,147,0.97,New York Mets,Shea Stadium,1565492,98,100,NYM,NYN,NYN
+1967,NL,PHI,PHI,,5,162,80,82,80,,,N,N,612,5401,1306,221,47,103,545,1033,79,62,,,581,500,3.1000000000,46,17,23,4359,1372,86,403,967,137,174,0.97,Philadelphia Phillies,Connie Mack Stadium,828888,101,101,PHI,PHI,PHI
+1967,NL,PIT,PIT,,6,163,81,81,81,,,N,N,679,5724,1585,193,62,91,387,914,79,37,,,693,606,3.7400000000,35,5,35,4374,1439,108,561,820,141,186,0.97,Pittsburgh Pirates,Forbes Field,907012,100,99,PIT,PIT,PIT
+1967,NL,SFN,SFG,,2,162,82,91,71,,,N,N,652,5524,1354,201,39,140,520,978,22,30,,,551,478,2.9200000000,64,17,25,4422,1283,113,453,990,134,149,0.97,San Francisco Giants,Candlestick Park,1242480,100,99,SFG,SFN,SFN
+1967,NL,SLN,STL,,1,161,81,101,60,,,Y,Y,695,5566,1462,225,40,115,443,919,102,54,,,557,496,3.0500000000,44,17,45,4395,1313,97,431,956,140,127,0.97,St. Louis Cardinals,Busch Stadium II,2090145,99,97,STL,SLN,SLN
+1968,AL,BAL,BAL,,2,162,80,91,71,,,N,N,579,5275,1187,215,28,133,570,1019,78,32,,,497,429,2.6600000000,53,16,31,4353,1111,101,502,1044,120,131,0.98,Baltimore Orioles,Memorial Stadium,943977,101,99,BAL,BAL,BAL
+1968,AL,BOS,BOS,,4,162,81,86,76,,,N,N,614,5303,1253,207,17,125,582,974,76,62,,,611,535,3.3300000000,55,17,31,4341,1303,115,523,972,128,147,0.97,Boston Red Sox,Fenway Park II,1940788,108,107,BOS,BOS,BOS
+1968,AL,CAL,ANA,,8,162,81,67,95,,,N,N,498,5331,1209,170,33,83,447,1080,62,50,,,615,548,3.4300000000,29,11,31,4311,1234,131,519,869,140,156,0.97,California Angels,Anaheim Stadium,1025956,95,97,CAL,CAL,CAL
+1968,AL,CHA,CHW,,8,162,81,67,95,,,N,N,463,5405,1233,169,33,71,397,840,90,50,,,527,449,2.7500000000,20,11,40,4404,1290,97,451,834,151,152,0.97,Chicago White Sox,Comiskey Park,803775,106,107,CHW,CHA,CHA
+1968,AL,CLE,CLE,,3,162,81,86,75,,,N,N,516,5416,1266,210,36,75,427,858,115,61,,,504,433,2.6600000000,48,23,32,4392,1087,98,540,1157,126,130,0.97,Cleveland Indians,Cleveland Stadium,857994,99,100,CLE,CLE,CLE
+1968,AL,DET,DET,,1,164,81,103,59,,,Y,Y,671,5490,1292,190,39,185,521,964,26,32,,,492,448,2.7100000000,59,19,29,4467,1180,129,486,1115,101,133,0.98,Detroit Tigers,Tiger Stadium,2031847,103,101,DET,DET,DET
+1968,AL,MIN,MIN,,7,162,81,79,83,,,N,N,562,5373,1274,207,41,105,445,966,98,54,,,546,460,2.8900000000,46,14,29,4299,1224,92,414,996,170,117,0.97,Minnesota Twins,Metropolitan Stadium,1143257,107,105,MIN,MIN,MIN
+1968,AL,NYA,NYY,,5,164,82,83,79,,,N,N,536,5310,1137,154,34,109,566,958,90,50,,,531,455,2.7900000000,45,14,27,4401,1308,99,424,831,139,142,0.97,New York Yankees,Yankee Stadium I,1185666,96,96,NYY,NYA,NYA
+1968,AL,OAK,OAK,,6,163,83,82,80,,,N,N,569,5406,1300,192,40,94,472,1022,147,61,,,544,475,2.9400000000,45,18,29,4365,1220,124,505,997,145,136,0.97,Oakland Athletics,Oakland Coliseum,837466,94,94,OAK,OAK,OAK
+1968,AL,WS2,TEX,,10,161,81,65,96,,,N,N,524,5400,1208,160,37,124,454,960,29,19,,,665,582,3.6400000000,26,11,28,4317,1402,118,517,826,148,144,0.97,Washington Senators,R.F.K. Stadium,546661,97,98,WSA,WS2,WS2
+1968,NL,ATL,ATL,,5,163,81,81,81,,,N,N,514,5552,1399,179,31,80,414,782,83,44,,,549,478,2.9200000000,44,16,29,4422,1326,87,362,871,125,139,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,1126540,101,101,ATL,ATL,ATL
+1968,NL,CHN,CHC,,3,163,82,84,78,,,N,N,612,5458,1319,203,43,130,415,854,41,30,,,611,551,3.4100000000,46,12,32,4359,1399,138,392,894,119,149,0.98,Chicago Cubs,Wrigley Field,1043409,107,106,CHC,CHN,CHN
+1968,NL,CIN,CIN,,4,163,82,83,79,,,N,N,690,5767,1573,281,36,106,379,938,59,55,,,673,589,3.5600000000,24,16,38,4470,1399,114,573,963,144,144,0.97,Cincinnati Reds,Crosley Field,733354,106,106,CIN,CIN,CIN
+1968,NL,HOU,HOU,,10,162,81,72,90,,,N,N,510,5336,1233,205,28,66,479,988,44,51,,,588,524,3.2600000000,50,12,23,4338,1362,68,479,1021,152,129,0.97,Houston Astros,Astrodome,1312887,97,99,HOU,HOU,HOU
+1968,NL,LAN,LAD,,7,162,81,76,86,,,N,N,470,5354,1234,202,36,67,439,980,57,43,,,509,433,2.6900000000,38,23,31,4344,1293,65,414,994,144,144,0.97,Los Angeles Dodgers,Dodger Stadium,1581093,92,92,LAD,LAN,LAN
+1968,NL,NYN,NYM,,9,163,82,73,89,,,N,N,473,5503,1252,178,30,81,379,1203,72,45,,,499,448,2.7200000000,45,25,32,4449,1250,87,430,1014,133,142,0.97,New York Mets,Shea Stadium,1781657,100,101,NYM,NYN,NYN
+1968,NL,PHI,PHI,,7,162,81,76,86,,,N,N,543,5372,1253,178,30,100,462,1003,58,51,,,615,541,3.3600000000,42,12,27,4344,1416,91,421,935,127,163,0.98,Philadelphia Phillies,Connie Mack Stadium,664546,100,101,PHI,PHI,PHI
+1968,NL,PIT,PIT,,6,163,81,80,82,,,N,N,583,5569,1404,180,44,80,422,953,130,59,,,532,453,2.7400000000,42,19,30,4461,1322,73,485,897,139,162,0.97,Pittsburgh Pirates,Forbes Field,693485,98,97,PIT,PIT,PIT
+1968,NL,SFN,SFG,,2,163,81,88,74,,,N,N,599,5441,1301,162,33,108,508,904,50,37,,,529,442,2.7100000000,77,20,16,4407,1302,86,344,942,162,125,0.97,San Francisco Giants,Candlestick Park,837220,101,100,SFG,SFN,SFN
+1968,NL,SLN,STL,,1,162,81,97,65,,,Y,N,583,5561,1383,227,48,73,378,897,110,45,,,472,409,2.4900000000,63,30,32,4437,1282,82,375,971,140,135,0.97,St. Louis Cardinals,Busch Stadium II,2011167,99,97,STL,SLN,SLN
+1969,AL,BAL,BAL,E,1,162,81,109,53,Y,,Y,N,779,5518,1465,234,29,175,634,806,82,45,,,517,463,2.8300000000,50,20,36,4419,1194,117,498,897,101,145,0.98,Baltimore Orioles,Memorial Stadium,1062069,101,99,BAL,BAL,BAL
+1969,AL,BOS,BOS,E,3,162,81,87,75,N,,N,N,743,5494,1381,234,37,197,658,923,41,47,,,736,639,3.9200000000,30,7,41,4398,1423,155,685,935,157,178,0.97,Boston Red Sox,Fenway Park II,1833246,107,106,BOS,BOS,BOS
+1969,AL,CAL,ANA,W,3,163,81,71,91,N,,N,N,528,5316,1221,151,29,88,516,929,54,39,,,652,566,3.5400000000,25,9,39,4314,1294,126,517,885,135,164,0.97,California Angels,Anaheim Stadium,758388,94,95,CAL,CAL,CAL
+1969,AL,CHA,CHW,W,5,162,81,68,94,N,,N,N,625,5450,1346,210,27,112,552,844,54,22,,,723,672,4.2100000000,29,10,25,4311,1470,146,564,810,122,163,0.98,Chicago White Sox,Comiskey Park,589546,106,107,CHW,CHA,CHA
+1969,AL,CLE,CLE,E,6,161,81,62,99,N,,N,N,573,5365,1272,173,24,119,535,906,85,37,,,717,629,3.9400000000,35,7,22,4311,1330,134,681,1000,142,153,0.97,Cleveland Indians,Cleveland Stadium,619970,103,103,CLE,CLE,CLE
+1969,AL,DET,DET,E,2,162,81,90,72,N,,N,N,701,5441,1316,188,29,182,578,922,35,28,,,601,535,3.3100000000,55,20,28,4365,1250,128,586,1032,126,130,0.97,Detroit Tigers,Tiger Stadium,1577481,105,104,DET,DET,DET
+1969,AL,KCA,KCR,W,4,163,82,69,93,N,,N,N,586,5462,1311,179,32,98,522,901,129,70,,,688,605,3.7200000000,42,10,25,4392,1357,136,560,894,156,114,0.97,Kansas City Royals,Municipal Stadium II,902414,100,101,KCR,KCA,KCA
+1969,AL,MIN,MIN,W,1,162,81,97,65,Y,,N,N,790,5677,1520,246,32,163,599,906,115,70,,,618,539,3.2400000000,41,8,43,4491,1388,119,524,906,150,177,0.97,Minnesota Twins,Metropolitan Stadium,1349328,104,102,MIN,MIN,MIN
+1969,AL,NYA,NYY,E,5,162,80,80,81,N,,N,N,562,5308,1247,210,44,94,565,840,119,74,,,587,517,3.2300000000,53,13,20,4320,1258,118,522,801,131,158,0.97,New York Yankees,Yankee Stadium I,1067996,96,96,NYY,NYA,NYA
+1969,AL,OAK,OAK,W,2,162,81,88,74,N,,N,N,740,5614,1400,210,28,148,617,953,100,39,,,678,610,3.7100000000,42,14,36,4440,1356,163,586,887,137,162,0.97,Oakland Athletics,Oakland Coliseum,778232,95,95,OAK,OAK,OAK
+1969,AL,SE1,MIL,W,6,163,82,64,98,N,,N,N,639,5444,1276,179,27,125,626,1015,167,59,,,799,707,4.3500000000,21,6,33,4389,1490,172,653,963,167,149,0.97,Seattle Pilots,Sicks Stadium,677944,97,100,SEP,SE1,SE1
+1969,AL,WS2,TEX,E,4,162,81,86,76,N,,N,N,694,5447,1365,171,40,148,630,900,52,40,,,644,561,3.4900000000,28,10,41,4341,1310,135,656,835,140,159,0.97,Washington Senators,R.F.K. Stadium,918106,94,95,WSA,WS2,WS2
+1969,NL,ATL,ATL,W,1,162,81,93,69,Y,,N,N,691,5460,1411,195,22,141,485,665,59,48,,,631,567,3.5300000000,38,7,42,4335,1334,144,438,893,115,114,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,1458320,101,101,ATL,ATL,ATL
+1969,NL,CHN,CHC,E,2,163,82,92,70,N,,N,N,720,5530,1400,215,40,142,559,928,30,32,,,611,540,3.3400000000,58,22,27,4362,1366,118,475,1017,136,149,0.97,Chicago Cubs,Wrigley Field,1674993,113,112,CHC,CHN,CHN
+1969,NL,CIN,CIN,W,3,163,81,89,73,N,,N,N,798,5634,1558,224,42,171,474,1042,79,56,,,768,669,4.1100000000,23,11,44,4395,1478,149,611,818,168,158,0.97,Cincinnati Reds,Crosley Field,987991,105,105,CIN,CIN,CIN
+1969,NL,HOU,HOU,W,5,162,81,81,81,N,,N,N,676,5348,1284,208,40,104,699,972,101,58,,,668,574,3.6000000000,52,11,34,4305,1347,111,547,1221,150,136,0.97,Houston Astros,Astrodome,1442995,98,98,HOU,HOU,HOU
+1969,NL,LAN,LAD,W,4,162,81,85,77,N,,N,N,645,5532,1405,185,52,97,484,823,80,51,,,561,499,3.0800000000,47,20,31,4371,1324,122,420,975,109,130,0.98,Los Angeles Dodgers,Dodger Stadium,1784527,93,92,LAD,LAN,LAN
+1969,NL,MON,WSN,E,6,162,81,52,110,N,,N,N,582,5419,1300,202,33,125,529,962,52,52,,,791,686,4.3300000000,26,8,21,4278,1429,145,702,973,184,179,0.97,Montreal Expos,Jarry Park,1212608,100,102,MON,MON,MON
+1969,NL,NYN,NYM,E,1,162,82,100,62,Y,,Y,Y,632,5427,1311,184,41,109,527,1089,66,43,,,541,488,2.9900000000,51,28,35,4404,1217,119,517,1012,122,146,0.98,New York Mets,Shea Stadium,2175373,102,101,NYM,NYN,NYN
+1969,NL,PHI,PHI,E,5,162,81,63,99,N,,N,N,645,5408,1304,227,35,137,549,1130,73,49,,,745,660,4.1400000000,47,14,21,4302,1494,134,570,921,136,157,0.97,Philadelphia Phillies,Connie Mack Stadium,519414,98,99,PHI,PHI,PHI
+1969,NL,PIT,PIT,E,3,162,81,88,74,N,,N,N,725,5626,1557,220,52,119,454,944,74,34,,,652,580,3.6100000000,39,9,33,4335,1348,96,553,1124,155,169,0.97,Pittsburgh Pirates,Forbes Field,769369,98,97,PIT,PIT,PIT
+1969,NL,SDN,SDP,W,6,162,81,52,110,N,,N,N,468,5357,1203,180,42,99,423,1143,45,44,,,746,670,4.2400000000,16,9,25,4266,1454,113,592,764,155,140,0.97,San Diego Padres,Jack Murphy Stadium,512970,96,98,SDP,SDN,SDN
+1969,NL,SFN,SFG,W,2,162,81,90,72,N,,N,N,713,5474,1325,187,28,136,711,1054,71,32,,,636,534,3.2600000000,71,15,17,4419,1381,120,461,906,169,155,0.97,San Francisco Giants,Candlestick Park,873603,99,98,SFG,SFN,SFN
+1969,NL,SLN,STL,E,4,162,80,87,75,N,,N,N,595,5536,1403,228,44,90,503,876,87,49,,,540,477,2.9400000000,63,12,26,4380,1289,99,511,1004,138,144,0.97,St. Louis Cardinals,Busch Stadium II,1682783,100,99,STL,SLN,SLN
+1970,AL,BAL,BAL,E,1,162,81,108,54,Y,,Y,Y,792,5545,1424,213,25,179,717,952,84,39,,,574,517,3.1500000000,60,12,31,4434,1317,139,469,941,117,148,0.98,Baltimore Orioles,Memorial Stadium,1057069,101,98,BAL,BAL,BAL
+1970,AL,BOS,BOS,E,3,162,81,87,75,N,,N,N,786,5535,1450,252,28,203,594,855,50,48,,,722,622,3.8700000000,38,8,44,4338,1391,156,594,1003,156,131,0.97,Boston Red Sox,Fenway Park II,1595278,108,107,BOS,BOS,BOS
+1970,AL,CAL,ANA,W,3,162,81,86,76,N,,N,N,631,5532,1391,197,40,114,447,922,69,27,,,630,565,3.4800000000,21,10,49,4386,1280,154,559,922,127,169,0.98,California Angels,Anaheim Stadium,1077741,96,97,CAL,CAL,CAL
+1970,AL,CHA,CHW,W,6,162,84,56,106,N,,N,N,633,5514,1394,192,20,123,477,872,53,33,,,822,721,4.5400000000,20,6,30,4290,1554,164,556,762,165,187,0.97,Chicago White Sox,Comiskey Park,495355,101,102,CHW,CHA,CHA
+1970,AL,CLE,CLE,E,5,162,81,76,86,N,,N,N,649,5463,1358,197,23,183,503,909,25,36,,,675,630,3.9100000000,34,8,35,4353,1333,163,689,1076,133,168,0.97,Cleveland Indians,Cleveland Stadium,729752,104,105,CLE,CLE,CLE
+1970,AL,DET,DET,E,4,162,81,79,83,N,,N,N,666,5377,1282,207,38,148,656,825,29,30,,,731,658,4.0900000000,33,9,39,4341,1443,153,623,1045,132,142,0.97,Detroit Tigers,Tiger Stadium,1501293,101,101,DET,DET,DET
+1970,AL,KCA,KCR,W,4,162,79,65,97,N,,N,N,611,5503,1341,202,41,97,514,958,97,53,,,705,614,3.7800000000,30,11,25,4389,1346,138,641,915,152,162,0.97,Kansas City Royals,Municipal Stadium II,693047,99,100,KCR,KCA,KCA
+1970,AL,MIN,MIN,W,1,162,81,98,64,Y,,N,N,744,5483,1438,230,41,153,501,905,57,52,,,605,520,3.2300000000,26,12,58,4344,1329,130,486,940,123,130,0.98,Minnesota Twins,Metropolitan Stadium,1261887,103,102,MIN,MIN,MIN
+1970,AL,ML4,MIL,W,4,163,81,65,97,N,,N,N,613,5395,1305,202,24,126,592,985,91,73,,,751,676,4.2100000000,31,2,27,4338,1397,146,587,895,136,142,0.97,Milwaukee Brewers,County Stadium,933690,100,101,MIL,MIL,MIL
+1970,AL,NYA,NYY,E,2,163,81,93,69,N,,N,N,680,5492,1381,208,41,111,588,808,105,61,,,612,530,3.2400000000,36,6,49,4413,1386,130,451,777,130,146,0.98,New York Yankees,Yankee Stadium I,1136879,95,95,NYY,NYA,NYA
+1970,AL,OAK,OAK,W,2,162,81,89,73,N,,N,N,678,5376,1338,208,24,171,584,977,131,68,,,593,529,3.3000000000,33,15,40,4326,1253,134,542,858,141,152,0.97,Oakland Athletics,Oakland Coliseum,778355,97,95,OAK,OAK,OAK
+1970,AL,WS2,TEX,E,6,162,81,70,92,N,,N,N,626,5460,1302,184,28,138,635,989,72,42,,,689,615,3.8000000000,20,11,40,4371,1375,139,611,823,116,173,0.98,Washington Senators,R.F.K. Stadium,824789,95,95,WSA,WS2,WS2
+1970,NL,ATL,ATL,W,5,162,81,76,86,N,,N,N,736,5546,1495,215,24,160,522,736,58,34,,,772,688,4.3300000000,45,9,24,4290,1451,185,478,960,140,118,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1078848,106,106,ATL,ATL,ATL
+1970,NL,CHN,CHC,E,2,162,80,84,78,N,,N,N,806,5491,1424,228,44,179,607,844,39,16,,,679,600,3.7600000000,59,9,25,4305,1402,143,475,1000,137,146,0.97,Chicago Cubs,Wrigley Field,1642705,111,110,CHC,CHN,CHN
+1970,NL,CIN,CIN,W,1,162,81,102,60,Y,,Y,N,775,5540,1498,253,45,191,547,984,115,52,,,681,592,3.6900000000,32,15,60,4332,1370,118,592,843,151,173,0.97,Cincinnati Reds,Crosley Field/Riverfront Stadium,1803568,104,103,CIN,CIN,CIN
+1970,NL,HOU,HOU,W,4,162,81,79,83,N,,N,N,744,5574,1446,250,47,129,598,911,114,41,,,763,684,4.2300000000,36,6,35,4368,1491,131,577,942,138,144,0.97,Houston Astros,Astrodome,1253444,96,96,HOU,HOU,HOU
+1970,NL,LAN,LAD,W,2,161,81,87,74,N,,N,N,749,5606,1515,233,67,87,541,841,138,57,,,684,619,3.8200000000,37,17,42,4374,1394,164,496,880,133,135,0.97,Los Angeles Dodgers,Dodger Stadium,1697142,95,94,LAD,LAN,LAN
+1970,NL,MON,WSN,E,6,162,80,73,89,N,,N,N,687,5411,1284,211,35,136,659,972,65,45,,,807,719,4.5000000000,29,10,32,4314,1434,162,716,914,141,193,0.97,Montreal Expos,Jarry Park,1424683,99,101,MON,MON,MON
+1970,NL,NYN,NYM,E,3,162,82,83,79,N,,N,N,695,5443,1358,211,42,120,684,1062,118,54,,,630,559,3.4500000000,47,10,32,4377,1260,135,575,1064,124,136,0.97,New York Mets,Shea Stadium,2697479,100,99,NYM,NYN,NYN
+1970,NL,PHI,PHI,E,5,161,80,73,88,N,,N,N,594,5456,1299,224,58,101,519,1066,72,64,,,730,677,4.1700000000,24,8,36,4383,1483,132,538,1047,112,134,0.98,Philadelphia Phillies,Connie Mack Stadium,708247,98,99,PHI,PHI,PHI
+1970,NL,PIT,PIT,E,1,162,82,89,73,Y,,N,N,729,5637,1522,235,70,130,444,871,66,34,,,664,597,3.7000000000,36,13,43,4359,1386,106,625,990,137,195,0.97,Pittsburgh Pirates,Forbes Field/Three Rivers Stadium,1341947,97,96,PIT,PIT,PIT
+1970,NL,SDN,SDP,W,6,162,81,63,99,N,,N,N,681,5494,1353,208,36,172,500,1164,60,45,,,788,698,4.3600000000,24,9,32,4320,1483,149,611,886,157,159,0.97,San Diego Padres,Jack Murphy Stadium,643679,96,98,SDP,SDN,SDN
+1970,NL,SFN,SFG,W,3,162,81,86,76,N,,N,N,831,5578,1460,257,35,165,729,1005,83,27,,,826,728,4.5000000000,50,7,30,4371,1514,156,604,931,170,153,0.97,San Francisco Giants,Candlestick Park,740720,100,99,SFG,SFN,SFN
+1970,NL,SLN,STL,E,4,162,81,76,86,N,,N,N,744,5689,1497,218,51,113,569,961,117,47,,,747,665,4.0600000000,51,11,20,4425,1483,102,632,960,150,159,0.97,St. Louis Cardinals,Busch Stadium II,1629736,103,102,STL,SLN,SLN
+1971,AL,BAL,BAL,E,1,158,77,101,57,Y,,Y,N,742,5303,1382,207,25,158,672,844,66,38,,,530,470,2.9900000000,71,15,22,4245,1257,125,416,793,112,148,0.98,Baltimore Orioles,Memorial Stadium,1023037,99,97,BAL,BAL,BAL
+1971,AL,BOS,BOS,E,3,162,80,85,77,N,,N,N,691,5401,1360,246,28,161,552,871,51,34,,,667,609,3.8000000000,44,11,35,4329,1424,136,535,871,116,149,0.98,Boston Red Sox,Fenway Park II,1678732,108,108,BOS,BOS,BOS
+1971,AL,CAL,ANA,W,4,162,81,76,86,N,,N,N,511,5495,1271,213,18,96,441,827,72,34,,,576,510,3.1000000000,39,11,32,4443,1246,101,607,904,131,159,0.98,California Angels,Anaheim Stadium,926373,93,93,CAL,CAL,CAL
+1971,AL,CHA,CHW,W,3,162,81,79,83,N,,N,N,617,5382,1346,185,30,138,562,870,83,65,,,597,503,3.1200000000,46,19,32,4350,1348,100,468,976,160,128,0.97,Chicago White Sox,Comiskey Park,833891,104,104,CHW,CHA,CHA
+1971,AL,CLE,CLE,E,6,162,81,60,102,N,,N,N,543,5467,1303,200,20,109,467,868,57,37,,,747,685,4.2800000000,21,7,32,4320,1352,154,770,937,116,159,0.98,Cleveland Indians,Cleveland Stadium,591361,109,110,CLE,CLE,CLE
+1971,AL,DET,DET,E,2,162,81,91,71,N,,N,N,701,5502,1399,214,38,179,540,854,35,43,,,645,592,3.6300000000,53,11,32,4404,1355,126,609,1000,106,156,0.98,Detroit Tigers,Tiger Stadium,1591073,105,105,DET,DET,DET
+1971,AL,KCA,KCR,W,2,161,81,85,76,N,,N,N,603,5295,1323,225,40,80,490,819,130,46,,,566,513,3.2500000000,34,15,44,4260,1301,84,496,775,132,178,0.97,Kansas City Royals,Municipal Stadium II,910784,99,99,KCR,KCA,KCA
+1971,AL,MIN,MIN,W,5,160,79,74,86,N,,N,N,654,5414,1406,197,31,116,512,846,66,44,,,670,599,3.8100000000,43,9,25,4248,1384,139,529,895,117,134,0.98,Minnesota Twins,Metropolitan Stadium,940858,103,102,MIN,MIN,MIN
+1971,AL,ML4,MIL,W,6,161,82,69,92,N,,N,N,534,5185,1188,160,23,104,543,924,82,53,,,609,532,3.3800000000,32,23,32,4248,1303,130,569,795,138,152,0.97,Milwaukee Brewers,County Stadium,731531,98,100,MIL,MIL,MIL
+1971,AL,NYA,NYY,E,4,162,81,82,80,N,,N,N,648,5413,1377,195,43,97,581,717,75,55,,,641,553,3.4300000000,67,15,12,4356,1382,126,423,707,125,159,0.98,New York Yankees,Yankee Stadium I,1070771,94,94,NYY,NYA,NYA
+1971,AL,OAK,OAK,W,1,161,81,101,60,Y,,N,N,691,5494,1383,195,25,160,542,1018,80,53,,,564,498,3.0500000000,57,18,36,4407,1229,131,501,999,117,157,0.98,Oakland Athletics,Oakland Coliseum,914993,98,97,OAK,OAK,OAK
+1971,AL,WS2,TEX,E,5,159,81,63,96,N,,N,N,537,5290,1219,189,30,86,575,956,68,45,,,660,583,3.7000000000,30,10,26,4254,1376,132,554,762,141,170,0.97,Washington Senators,R.F.K. Stadium,655156,94,95,WSA,WS2,WS2
+1971,NL,ATL,ATL,W,3,162,82,82,80,N,,N,N,643,5575,1434,192,30,153,434,747,57,46,,,699,614,3.7500000000,40,11,31,4422,1529,152,485,823,146,180,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1006320,106,107,ATL,ATL,ATL
+1971,NL,CHN,CHC,E,3,162,81,83,79,N,,N,N,637,5438,1401,202,34,128,527,772,44,32,,,648,579,3.6100000000,75,17,13,4332,1458,132,411,900,126,150,0.98,Chicago Cubs,Wrigley Field,1653007,113,113,CHC,CHN,CHN
+1971,NL,CIN,CIN,W,4,162,81,79,83,N,,N,N,586,5414,1306,203,28,138,438,907,59,33,,,581,537,3.3500000000,27,11,38,4332,1298,112,501,750,103,174,0.98,Cincinnati Reds,Riverfront Stadium,1501122,95,94,CIN,CIN,CIN
+1971,NL,HOU,HOU,W,4,162,81,79,83,N,,N,N,585,5492,1319,230,52,71,478,888,101,51,,,567,512,3.1300000000,43,10,25,4413,1318,75,475,914,104,152,0.98,Houston Astros,Astrodome,1261589,98,97,HOU,HOU,HOU
+1971,NL,LAN,LAD,W,2,162,81,89,73,N,,N,N,663,5523,1469,213,38,95,489,755,76,40,,,587,520,3.2300000000,48,18,33,4347,1363,110,399,853,131,159,0.97,Los Angeles Dodgers,Dodger Stadium,2064594,94,93,LAD,LAN,LAN
+1971,NL,MON,WSN,E,5,162,80,71,90,N,,N,N,622,5335,1312,197,29,88,543,800,51,43,,,729,656,4.1200000000,49,8,25,4302,1418,133,658,829,150,164,0.97,Montreal Expos,Jarry Park,1290963,100,101,MON,MON,MON
+1971,NL,NYN,NYM,E,3,162,81,83,79,N,,N,N,588,5477,1365,203,29,98,547,958,89,43,,,550,487,2.9900000000,42,13,22,4398,1227,100,529,1157,112,135,0.98,New York Mets,Shea Stadium,2266680,98,98,NYM,NYN,NYN
+1971,NL,PHI,PHI,E,6,162,81,67,95,N,,N,N,558,5538,1289,209,35,123,499,1031,63,39,,,688,606,3.7100000000,31,10,25,4410,1396,132,525,838,121,158,0.98,Philadelphia Phillies,Veterans Stadium,1511223,100,102,PHI,PHI,PHI
+1971,NL,PIT,PIT,E,1,162,80,97,65,Y,,Y,Y,788,5674,1555,223,61,154,469,919,65,31,,,599,537,3.3100000000,43,15,48,4383,1426,108,470,813,133,164,0.97,Pittsburgh Pirates,Three Rivers Stadium,1501132,102,100,PIT,PIT,PIT
+1971,NL,SDN,SDP,W,6,161,81,61,100,N,,N,N,486,5366,1250,184,31,96,438,966,70,45,,,610,514,3.2200000000,47,10,17,4314,1351,93,559,923,161,144,0.97,San Diego Padres,Jack Murphy Stadium,557513,93,95,SDP,SDN,SDN
+1971,NL,SFN,SFG,W,1,162,81,90,72,Y,,N,N,706,5461,1348,224,36,140,654,1042,101,36,,,644,536,3.3200000000,45,14,30,4362,1324,128,471,831,177,153,0.97,San Francisco Giants,Candlestick Park,1106043,99,99,SFG,SFN,SFN
+1971,NL,SLN,STL,E,2,163,82,90,72,N,,N,N,739,5610,1542,225,54,95,543,757,124,53,,,699,628,3.8500000000,56,14,22,4401,1482,104,576,911,142,155,0.97,St. Louis Cardinals,Busch Stadium II,1604671,104,104,STL,SLN,SLN
+1972,AL,BAL,BAL,E,3,154,77,80,74,N,,N,N,519,5028,1153,193,29,100,507,935,78,41,,,430,385,2.5300000000,62,20,21,4113,1116,85,395,788,100,150,0.98,Baltimore Orioles,Memorial Stadium,899950,103,101,BAL,BAL,BAL
+1972,AL,BOS,BOS,E,2,155,78,85,70,N,,N,N,640,5208,1289,229,34,124,522,858,66,30,,,620,533,3.4700000000,48,20,25,4146,1309,101,512,918,130,141,0.97,Boston Red Sox,Fenway Park II,1441718,106,106,BOS,BOS,BOS
+1972,AL,CAL,ANA,W,5,155,80,75,80,N,,N,N,454,5165,1249,171,26,78,358,850,57,37,,,533,468,3.0600000000,57,18,16,4131,1109,90,620,1000,114,135,0.98,California Angels,Anaheim Stadium,744190,94,95,CAL,CAL,CAL
+1972,AL,CHA,CHW,W,2,154,78,87,67,N,,N,N,566,5083,1208,170,28,108,511,991,100,52,,,538,480,3.1200000000,36,14,42,4155,1269,94,431,936,135,136,0.97,Chicago White Sox,Comiskey Park,1177318,103,103,CHW,CHA,CHA
+1972,AL,CLE,CLE,E,5,156,77,72,84,N,,N,N,472,5207,1220,187,18,91,420,762,49,53,,,519,457,2.9200000000,47,13,24,4230,1232,123,534,846,111,157,0.98,Cleveland Indians,Cleveland Stadium,626354,104,106,CLE,CLE,CLE
+1972,AL,DET,DET,E,1,156,78,86,70,Y,,N,N,558,5099,1206,179,32,122,483,793,17,21,,,514,456,2.9600000000,46,11,33,4164,1212,101,465,952,96,137,0.98,Detroit Tigers,Tiger Stadium,1892386,103,103,DET,DET,DET
+1972,AL,KCA,KCR,W,4,154,77,76,78,N,,N,N,580,5167,1317,220,26,78,534,711,85,44,,,545,497,3.2400000000,44,16,29,4143,1293,85,405,801,116,164,0.98,Kansas City Royals,Municipal Stadium II,707656,99,98,KCR,KCA,KCA
+1972,AL,MIN,MIN,W,3,154,74,77,77,N,,N,N,537,5234,1277,182,31,93,478,905,53,41,,,535,441,2.8400000000,37,17,34,4197,1188,105,444,838,159,133,0.97,Minnesota Twins,Metropolitan Stadium,797901,105,105,MIN,MIN,MIN
+1972,AL,ML4,MIL,E,6,156,79,65,91,N,,N,N,493,5124,1204,167,22,88,472,868,64,57,,,595,533,3.4500000000,37,14,32,4173,1289,116,486,740,139,145,0.97,Milwaukee Brewers,County Stadium,600440,97,98,MIL,MIL,MIL
+1972,AL,NYA,NYY,E,4,155,77,79,76,N,,N,N,557,5168,1288,201,24,103,491,689,71,42,,,527,465,3.0500000000,35,19,39,4119,1306,87,419,625,134,179,0.97,New York Yankees,Yankee Stadium I,966328,97,96,NYY,NYA,NYA
+1972,AL,OAK,OAK,W,1,155,77,93,62,Y,,Y,Y,604,5200,1248,195,29,134,463,886,87,48,,,457,406,2.5800000000,42,23,43,4251,1170,96,418,862,130,146,0.97,Oakland Athletics,Oakland Coliseum,921323,95,93,OAK,OAK,OAK
+1972,AL,TEX,TEX,W,6,154,77,54,100,N,,N,N,461,5029,1092,166,17,56,503,926,126,73,,,628,539,3.5300000000,11,8,34,4122,1258,92,613,868,166,147,0.97,Texas Rangers,Arlington Stadium,662974,96,98,TEX,TEX,TEX
+1972,NL,ATL,ATL,W,4,155,78,70,84,N,,N,N,628,5278,1363,186,17,144,532,770,47,35,,,730,653,4.2700000000,40,4,27,4131,1412,155,512,732,156,130,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,752973,109,110,ATL,ATL,ATL
+1972,NL,CHN,CHC,E,2,156,77,85,70,N,,N,N,685,5247,1346,206,40,133,565,815,69,47,,,567,500,3.2200000000,54,19,32,4194,1329,112,421,824,132,148,0.97,Chicago Cubs,Wrigley Field,1299163,110,110,CHC,CHN,CHN
+1972,NL,CIN,CIN,W,1,154,76,95,59,Y,,Y,N,707,5241,1317,214,44,124,606,914,140,63,,,557,504,3.2100000000,25,15,60,4236,1313,129,435,806,110,143,0.98,Cincinnati Reds,Riverfront Stadium,1611459,94,93,CIN,CIN,CIN
+1972,NL,HOU,HOU,W,3,153,77,84,69,N,,N,N,708,5267,1359,233,38,134,524,907,111,56,,,636,580,3.7700000000,38,14,31,4155,1340,114,498,971,114,151,0.98,Houston Astros,Astrodome,1469247,98,97,HOU,HOU,HOU
+1972,NL,LAN,LAD,W,2,155,75,85,70,N,,N,N,584,5270,1349,178,39,98,480,786,82,39,,,527,433,2.7800000000,50,23,29,4209,1196,83,429,856,162,145,0.97,Los Angeles Dodgers,Dodger Stadium,1860858,98,97,LAD,LAN,LAN
+1972,NL,MON,WSN,E,5,156,78,70,86,N,,N,N,513,5156,1205,156,22,91,474,828,68,66,,,609,559,3.5900000000,39,11,23,4203,1281,103,579,888,134,141,0.97,Montreal Expos,Jarry Park,1142145,101,102,MON,MON,MON
+1972,NL,NYN,NYM,E,3,156,78,83,73,N,,N,N,528,5135,1154,175,31,105,589,990,41,41,,,578,512,3.2600000000,32,12,41,4242,1263,118,486,1059,116,122,0.98,New York Mets,Shea Stadium,2134185,97,97,NYM,NYN,NYN
+1972,NL,PHI,PHI,E,6,156,79,59,97,N,,N,N,503,5248,1240,200,36,98,487,930,42,50,,,635,569,3.6600000000,43,13,15,4200,1318,117,536,927,116,142,0.98,Philadelphia Phillies,Veterans Stadium,1343329,102,104,PHI,PHI,PHI
+1972,NL,PIT,PIT,E,1,155,78,96,59,Y,,N,N,691,5490,1505,251,47,110,404,871,49,30,,,512,441,2.8100000000,39,15,48,4242,1282,90,433,838,136,171,0.97,Pittsburgh Pirates,Three Rivers Stadium,1427460,99,97,PIT,PIT,PIT
+1972,NL,SDN,SDP,W,6,153,80,58,95,N,,N,N,488,5213,1181,168,38,102,407,976,78,46,,,665,589,3.7800000000,39,17,19,4209,1350,121,618,960,144,146,0.97,San Diego Padres,Jack Murphy Stadium,644273,92,95,SDP,SDN,SDN
+1972,NL,SFN,SFG,W,5,155,77,69,86,N,,N,N,662,5245,1281,211,36,150,480,964,123,45,,,649,568,3.6900000000,44,8,23,4158,1309,130,507,771,154,121,0.97,San Francisco Giants,Candlestick Park,647744,102,102,SFG,SFN,SFN
+1972,NL,SLN,STL,E,4,156,77,75,81,N,,N,N,568,5326,1383,214,42,70,437,793,104,48,,,600,532,3.4200000000,64,13,13,4197,1290,87,531,912,140,146,0.97,St. Louis Cardinals,Busch Stadium II,1196894,99,99,STL,SLN,SLN
+1973,AL,BAL,BAL,E,1,162,81,97,65,Y,,N,N,754,5537,1474,229,48,119,648,752,146,64,,,561,498,3.0700000000,67,14,26,4383,1297,124,475,715,119,184,0.98,Baltimore Orioles,Memorial Stadium,958667,99,98,BAL,BAL,BAL
+1973,AL,BOS,BOS,E,2,162,81,89,73,N,,N,N,738,5513,1472,235,30,147,581,799,114,45,,,647,584,3.6500000000,67,10,33,4320,1417,158,499,808,127,162,0.97,Boston Red Sox,Fenway Park II,1481002,106,106,BOS,BOS,BOS
+1973,AL,CAL,ANA,W,4,162,81,79,83,N,,N,N,629,5505,1395,183,29,93,509,816,59,47,,,657,571,3.5300000000,72,13,19,4368,1351,104,614,1010,156,153,0.97,California Angels,Anaheim Stadium,1058206,92,92,CAL,CAL,CAL
+1973,AL,CHA,CHW,W,5,162,81,77,85,N,,N,N,652,5475,1400,228,38,111,537,952,83,73,,,705,624,3.8600000000,48,15,35,4368,1484,110,574,848,144,165,0.97,Chicago White Sox,Comiskey Park,1302527,105,105,CHW,CHA,CHA
+1973,AL,CLE,CLE,E,6,162,81,71,91,N,,N,N,680,5592,1429,205,29,158,471,793,60,68,,,826,745,4.5800000000,55,9,21,4392,1532,172,602,883,138,174,0.97,Cleveland Indians,Cleveland Stadium,615107,103,104,CLE,CLE,CLE
+1973,AL,DET,DET,E,3,162,81,85,77,N,,N,N,642,5508,1400,213,32,157,509,722,28,30,,,674,627,3.9000000000,39,11,46,4341,1468,154,493,911,112,144,0.98,Detroit Tigers,Tiger Stadium,1724146,106,107,DET,DET,DET
+1973,AL,KCA,KCR,W,2,162,81,88,74,N,,N,N,755,5508,1440,239,40,114,644,696,105,69,,,752,675,4.1900000000,40,7,41,4347,1521,114,617,790,167,192,0.97,Kansas City Royals,Royals Stadium,1345341,106,106,KCR,KCA,KCA
+1973,AL,MIN,MIN,W,3,162,81,81,81,N,,N,N,738,5625,1521,240,44,120,598,954,87,46,,,692,608,3.7700000000,48,18,34,4353,1443,115,519,879,139,147,0.97,Minnesota Twins,Metropolitan Stadium,907499,104,104,MIN,MIN,MIN
+1973,AL,ML4,MIL,E,5,162,81,74,88,N,,N,N,708,5526,1399,229,40,145,563,977,110,66,,,731,643,3.9800000000,50,11,28,4362,1476,119,623,671,145,167,0.97,Milwaukee Brewers,County Stadium,1092158,97,98,MIL,MIL,MIL
+1973,AL,NYA,NYY,E,4,162,81,80,82,N,,N,N,641,5492,1435,212,17,131,489,680,47,43,,,610,530,3.3400000000,47,16,39,4281,1379,109,457,708,156,172,0.97,New York Yankees,Yankee Stadium I,1262103,97,96,NYY,NYA,NYA
+1973,AL,OAK,OAK,W,1,162,81,94,68,Y,,Y,Y,758,5507,1431,216,28,147,595,919,128,57,,,615,533,3.2900000000,46,16,41,4371,1311,143,494,797,137,170,0.97,Oakland Athletics,Oakland Coliseum,1000763,95,93,OAK,OAK,OAK
+1973,AL,TEX,TEX,W,6,162,81,57,105,N,,N,N,619,5488,1397,195,29,110,503,791,91,53,,,844,737,4.6400000000,35,10,27,4290,1514,130,680,831,161,164,0.97,Texas Rangers,Arlington Stadium,686085,95,97,TEX,TEX,TEX
+1973,NL,ATL,ATL,W,5,162,81,76,85,N,,N,N,799,5631,1497,219,34,206,608,870,84,40,,,774,690,4.2500000000,34,9,35,4386,1467,144,575,803,166,142,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,800655,108,108,ATL,ATL,ATL
+1973,NL,CHN,CHC,E,5,161,80,77,84,N,,N,N,614,5363,1322,201,21,117,575,855,65,58,,,655,584,3.6600000000,27,13,40,4311,1471,128,438,885,157,155,0.97,Chicago Cubs,Wrigley Field,1351705,107,107,CHC,CHN,CHN
+1973,NL,CIN,CIN,W,1,162,81,99,63,Y,,N,N,741,5505,1398,232,34,137,639,947,148,55,,,621,556,3.4000000000,39,17,43,4419,1389,135,518,801,115,162,0.98,Cincinnati Reds,Riverfront Stadium,2017601,95,93,CIN,CIN,CIN
+1973,NL,HOU,HOU,W,4,162,81,82,80,N,,N,N,681,5532,1391,216,35,134,469,962,92,48,,,672,608,3.7500000000,45,14,26,4380,1389,111,575,907,112,140,0.98,Houston Astros,Astrodome,1394004,99,99,HOU,HOU,HOU
+1973,NL,LAN,LAD,W,2,162,81,95,66,N,,N,N,675,5604,1473,219,29,110,497,795,109,50,,,565,497,3.0000000000,45,15,38,4473,1270,129,461,961,125,166,0.98,Los Angeles Dodgers,Dodger Stadium,2136192,97,95,LAD,LAN,LAN
+1973,NL,MON,WSN,E,4,162,81,79,83,N,,N,N,668,5369,1345,190,23,125,695,777,77,68,,,702,598,3.7100000000,26,6,38,4353,1356,128,681,866,163,156,0.97,Montreal Expos,Jarry Park,1246863,103,104,MON,MON,MON
+1973,NL,NYN,NYM,E,1,161,81,82,79,Y,,Y,N,608,5457,1345,198,24,85,540,805,27,22,,,588,531,3.2600000000,47,15,40,4395,1345,127,490,1027,126,140,0.98,New York Mets,Shea Stadium,1912390,98,99,NYM,NYN,NYN
+1973,NL,PHI,PHI,E,6,162,81,71,91,N,,N,N,642,5546,1381,218,29,134,476,979,51,47,,,717,642,3.9900000000,49,11,22,4341,1435,131,632,919,134,179,0.97,Philadelphia Phillies,Veterans Stadium,1475934,102,103,PHI,PHI,PHI
+1973,NL,PIT,PIT,E,3,162,81,80,82,N,,N,N,704,5608,1465,257,44,154,432,842,23,30,,,693,601,3.7300000000,26,11,44,4350,1426,110,564,839,151,156,0.97,Pittsburgh Pirates,Three Rivers Stadium,1319913,98,96,PIT,PIT,PIT
+1973,NL,SDN,SDP,W,6,162,81,60,102,N,,N,N,548,5457,1330,198,26,112,401,966,88,36,,,770,661,4.1600000000,34,10,23,4290,1461,157,548,845,170,152,0.97,San Diego Padres,Jack Murphy Stadium,611826,91,94,SDP,SDN,SDN
+1973,NL,SFN,SFG,W,3,162,81,88,74,N,,N,N,739,5537,1452,212,52,161,590,913,112,52,,,702,611,3.7900000000,33,8,44,4356,1442,145,485,787,163,138,0.97,San Francisco Giants,Candlestick Park,834193,105,105,SFG,SFN,SFN
+1973,NL,SLN,STL,E,2,162,81,81,81,N,,N,N,643,5478,1418,240,35,75,531,796,100,46,,,603,527,3.2500000000,42,14,36,4380,1366,105,486,867,158,149,0.97,St. Louis Cardinals,Busch Stadium II,1574046,100,100,STL,SLN,SLN
+1974,AL,BAL,BAL,E,1,162,81,91,71,Y,,N,N,659,5535,1418,226,27,116,509,770,145,58,,,612,536,3.2700000000,57,16,25,4422,1393,101,480,701,128,174,0.98,Baltimore Orioles,Memorial Stadium,962572,97,95,BAL,BAL,BAL
+1974,AL,BOS,BOS,E,3,162,81,84,78,N,,N,N,696,5499,1449,236,31,109,569,811,104,58,,,661,601,3.7200000000,71,12,18,4365,1462,126,463,751,145,156,0.97,Boston Red Sox,Fenway Park II,1556411,108,107,BOS,BOS,BOS
+1974,AL,CAL,ANA,W,6,163,81,68,94,N,,N,N,618,5401,1372,203,31,95,509,801,119,79,,,657,563,3.5200000000,64,13,12,4317,1339,101,649,986,147,150,0.97,California Angels,Anaheim Stadium,917269,94,94,CAL,CAL,CAL
+1974,AL,CHA,CHW,W,4,163,82,80,80,N,,N,N,684,5577,1492,225,23,135,519,858,64,53,,,721,641,3.9400000000,55,11,29,4395,1470,103,548,826,147,188,0.97,Chicago White Sox,Comiskey Park,1149596,103,104,CHW,CHA,CHA
+1974,AL,CLE,CLE,E,4,162,81,77,85,N,,N,N,662,5474,1395,201,19,131,432,756,79,68,,,694,610,3.8000000000,45,9,27,4335,1419,138,479,650,143,157,0.97,Cleveland Indians,Cleveland Stadium,1114262,99,100,CLE,CLE,CLE
+1974,AL,DET,DET,E,6,162,81,72,90,N,,N,N,620,5568,1375,200,35,131,436,784,67,38,,,768,673,4.1600000000,54,7,15,4365,1443,148,621,869,158,155,0.97,Detroit Tigers,Tiger Stadium,1243080,102,104,DET,DET,DET
+1974,AL,KCA,KCR,W,5,162,81,77,85,N,,N,N,667,5582,1448,232,42,89,550,768,146,76,,,662,574,3.5100000000,54,13,17,4413,1477,91,482,731,152,166,0.97,Kansas City Royals,Royals Stadium,1173292,105,105,KCR,KCA,KCA
+1974,AL,MIN,MIN,W,3,163,82,82,80,N,,N,N,673,5632,1530,190,37,111,520,791,74,45,,,669,588,3.6400000000,43,11,29,4365,1436,115,513,934,151,164,0.97,Minnesota Twins,Metropolitan Stadium,662401,104,104,MIN,MIN,MIN
+1974,AL,ML4,MIL,E,5,162,81,76,86,N,,N,N,647,5472,1335,228,49,120,500,909,106,75,,,660,609,3.7600000000,43,11,24,4371,1476,126,493,621,127,168,0.98,Milwaukee Brewers,County Stadium,955741,99,99,MIL,MIL,MIL
+1974,AL,NYA,NYY,E,2,162,81,89,73,N,,N,N,671,5524,1451,220,30,101,515,690,53,35,,,623,535,3.3100000000,53,13,24,4365,1402,104,528,829,142,158,0.97,New York Yankees,Shea Stadium,1273075,99,98,NYY,NYA,NYA
+1974,AL,OAK,OAK,W,1,162,81,90,72,Y,,Y,Y,689,5331,1315,205,37,132,568,876,164,93,,,551,472,2.9500000000,49,12,28,4317,1322,90,430,755,141,154,0.97,Oakland Athletics,Oakland Coliseum,845693,94,92,OAK,OAK,OAK
+1974,AL,TEX,TEX,W,2,161,80,84,76,N,,N,N,690,5449,1482,198,39,99,508,710,113,80,,,698,608,3.8200000000,62,16,12,4299,1423,126,449,871,163,164,0.97,Texas Rangers,Arlington Stadium,1193902,97,98,TEX,TEX,TEX
+1974,NL,ATL,ATL,W,3,163,81,88,74,N,,N,N,661,5533,1375,202,37,120,571,772,72,44,,,563,500,3.0500000000,46,21,22,4422,1343,97,488,772,132,161,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,981085,104,104,ATL,ATL,ATL
+1974,NL,CHN,CHC,E,6,162,81,66,96,N,,N,N,669,5574,1397,221,42,110,621,857,78,73,,,826,697,4.2800000000,23,6,26,4398,1593,122,576,895,199,141,0.96,Chicago Cubs,Wrigley Field,1015378,103,105,CHC,CHN,CHN
+1974,NL,CIN,CIN,W,2,163,82,98,64,N,,N,N,776,5535,1437,271,35,135,693,940,146,49,,,631,555,3.4100000000,34,11,27,4398,1364,126,536,875,134,151,0.97,Cincinnati Reds,Riverfront Stadium,2164307,99,97,CIN,CIN,CIN
+1974,NL,HOU,HOU,W,4,162,81,81,81,N,,N,N,653,5489,1441,222,41,110,471,864,108,65,,,632,557,3.4600000000,36,18,18,4350,1396,84,601,738,108,161,0.98,Houston Astros,Astrodome,1090728,96,96,HOU,HOU,HOU
+1974,NL,LAN,LAD,W,1,162,81,102,60,Y,,Y,N,798,5557,1511,231,34,139,597,820,149,75,,,561,483,2.9700000000,33,19,23,4395,1272,112,464,943,157,122,0.97,Los Angeles Dodgers,Dodger Stadium,2632474,96,94,LAD,LAN,LAN
+1974,NL,MON,WSN,E,4,161,80,79,82,N,,N,N,662,5343,1355,201,29,86,652,812,124,49,,,657,572,3.6000000000,35,8,27,4287,1340,99,544,822,153,157,0.97,Montreal Expos,Jarry Park,1019134,105,106,MON,MON,MON
+1974,NL,NYN,NYM,E,5,162,81,71,91,N,,N,N,572,5468,1286,183,22,96,597,735,43,23,,,646,559,3.4200000000,46,15,14,4410,1433,99,504,908,158,150,0.97,New York Mets,Shea Stadium,1722209,99,99,NYM,NYN,NYN
+1974,NL,PHI,PHI,E,3,162,81,80,82,N,,N,N,676,5494,1434,233,50,95,469,822,115,58,,,701,629,3.9100000000,46,4,19,4341,1394,111,682,892,148,168,0.97,Philadelphia Phillies,Veterans Stadium,1808648,104,104,PHI,PHI,PHI
+1974,NL,PIT,PIT,E,1,162,81,88,74,Y,,N,N,751,5702,1560,238,46,114,514,828,55,31,,,657,568,3.4900000000,51,9,17,4398,1428,93,543,721,162,154,0.97,Pittsburgh Pirates,Three Rivers Stadium,1110552,97,95,PIT,PIT,PIT
+1974,NL,SDN,SDP,W,6,162,81,60,102,N,,N,N,541,5415,1239,196,27,99,564,900,85,45,,,830,735,4.5800000000,25,7,19,4335,1536,124,715,855,170,126,0.97,San Diego Padres,Jack Murphy Stadium,1075399,95,98,SDP,SDN,SDN
+1974,NL,SFN,SFG,W,5,162,81,72,90,N,,N,N,634,5482,1380,228,38,93,548,869,107,51,,,723,604,3.7800000000,27,11,25,4317,1409,116,559,756,175,153,0.97,San Francisco Giants,Candlestick Park,519987,105,105,SFG,SFN,SFN
+1974,NL,SLN,STL,E,2,161,81,86,75,N,,N,N,677,5620,1492,216,46,83,531,752,172,62,,,643,570,3.4800000000,37,13,20,4419,1399,97,616,794,147,192,0.97,St. Louis Cardinals,Busch Stadium II,1838413,100,100,STL,SLN,SLN
+1975,AL,BAL,BAL,E,2,159,77,90,69,N,,N,N,682,5474,1382,224,33,124,580,834,104,55,,,553,511,3.1700000000,70,19,21,4353,1285,110,500,717,107,175,0.98,Baltimore Orioles,Memorial Stadium,1002157,94,93,BAL,BAL,BAL
+1975,AL,BOS,BOS,E,1,160,81,95,65,Y,,Y,N,796,5448,1500,284,44,134,565,741,66,58,,,709,635,3.9800000000,62,11,31,4308,1463,145,490,720,135,142,0.97,Boston Red Sox,Fenway Park II,1748587,110,109,BOS,BOS,BOS
+1975,AL,CAL,ANA,W,6,161,81,72,89,N,,N,N,628,5377,1324,195,41,55,593,811,220,108,,,723,628,3.8900000000,59,19,16,4359,1386,123,613,975,184,164,0.97,California Angels,Anaheim Stadium,1058163,92,93,CAL,CAL,CAL
+1975,AL,CHA,CHW,W,5,161,81,75,86,N,,N,N,655,5490,1400,209,38,94,611,800,101,54,,,703,634,3.9300000000,34,7,39,4356,1489,107,655,799,140,155,0.97,Chicago White Sox,Comiskey Park,750802,102,103,CHW,CHA,CHA
+1975,AL,CLE,CLE,E,4,159,80,79,80,N,,N,N,688,5404,1409,201,25,153,525,667,106,89,,,703,612,3.8400000000,37,6,33,4305,1395,136,599,800,134,156,0.97,Cleveland Indians,Cleveland Stadium,977039,99,99,CLE,CLE,CLE
+1975,AL,DET,DET,E,6,159,80,57,102,N,,N,N,570,5366,1338,171,39,125,383,872,63,57,,,786,662,4.2700000000,52,10,17,4188,1496,137,533,787,173,141,0.97,Detroit Tigers,Tiger Stadium,1058836,104,106,DET,DET,DET
+1975,AL,KCA,KCR,W,2,162,81,91,71,N,,N,N,710,5491,1431,263,58,118,591,675,155,75,,,649,561,3.4700000000,52,11,25,4368,1422,108,498,815,155,151,0.97,Kansas City Royals,Royals Stadium,1151836,103,102,KCR,KCA,KCA
+1975,AL,MIN,MIN,W,4,159,82,76,83,N,,N,N,724,5514,1497,215,28,121,563,746,81,48,,,736,640,4.0500000000,57,7,22,4269,1381,137,617,846,169,147,0.97,Minnesota Twins,Metropolitan Stadium,737156,102,102,MIN,MIN,MIN
+1975,AL,ML4,MIL,E,5,162,81,68,94,N,,N,N,675,5378,1343,242,34,146,553,922,65,64,,,792,690,4.3400000000,36,10,34,4293,1496,133,624,643,180,162,0.97,Milwaukee Brewers,County Stadium,1213357,100,101,MIL,MIL,MIL
+1975,AL,NYA,NYY,E,3,160,78,83,77,N,,N,N,681,5415,1430,230,39,110,486,710,102,59,,,588,521,3.2900000000,70,11,20,4272,1325,104,502,809,135,148,0.97,New York Yankees,Shea Stadium,1288048,99,98,NYY,NYA,NYA
+1975,AL,OAK,OAK,W,1,162,81,98,64,Y,,N,N,758,5415,1376,220,33,151,609,846,183,82,,,606,526,3.2700000000,36,10,44,4344,1267,102,523,784,143,140,0.97,Oakland Athletics,Oakland Coliseum,1075518,98,96,OAK,OAK,OAK
+1975,AL,TEX,TEX,W,3,162,80,79,83,N,,N,N,714,5599,1431,208,17,134,613,863,102,62,,,733,628,3.8600000000,60,16,17,4395,1456,123,518,792,191,173,0.97,Texas Rangers,Arlington Stadium,1127924,99,99,TEX,TEX,TEX
+1975,NL,ATL,ATL,W,5,161,80,67,94,N,,N,N,583,5424,1323,179,28,107,543,759,55,38,,,739,621,3.9100000000,32,4,24,4290,1543,101,519,669,175,147,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,534672,103,104,ATL,ATL,ATL
+1975,NL,CHN,CHC,E,5,162,81,75,87,N,,N,N,712,5470,1419,229,41,95,650,802,67,55,,,827,720,4.4900000000,27,8,33,4332,1587,130,551,850,178,152,0.97,Chicago Cubs,Wrigley Field,1034819,104,106,CHC,CHN,CHN
+1975,NL,CIN,CIN,W,1,162,81,108,54,Y,,Y,Y,840,5581,1515,278,37,124,691,916,168,36,,,586,546,3.3700000000,22,8,50,4377,1422,112,487,663,102,173,0.98,Cincinnati Reds,Riverfront Stadium,2315603,102,99,CIN,CIN,CIN
+1975,NL,HOU,HOU,W,6,162,81,64,97,N,,N,N,664,5515,1401,218,54,84,523,762,133,62,,,711,654,4.0400000000,39,6,25,4374,1436,106,679,839,137,166,0.97,Houston Astros,Astrodome,858002,93,93,HOU,HOU,HOU
+1975,NL,LAN,LAD,W,2,162,81,88,74,N,,N,N,648,5453,1355,217,31,118,611,825,138,52,,,534,477,2.9200000000,51,18,21,4407,1215,104,448,894,127,106,0.97,Los Angeles Dodgers,Dodger Stadium,2539349,96,94,LAD,LAN,LAN
+1975,NL,MON,WSN,E,5,162,81,75,87,N,,N,N,601,5518,1346,216,31,98,579,954,108,58,,,690,612,3.7200000000,30,12,25,4440,1448,102,665,831,180,179,0.97,Montreal Expos,Jarry Park,908292,104,106,MON,MON,MON
+1975,NL,NYN,NYM,E,3,162,81,82,80,N,,N,N,646,5587,1430,217,34,101,501,805,32,26,,,625,552,3.3900000000,40,14,31,4398,1344,99,580,989,151,144,0.97,New York Mets,Shea Stadium,1730566,96,95,NYM,NYN,NYN
+1975,NL,PHI,PHI,E,2,162,81,86,76,N,,N,N,735,5592,1506,283,42,125,610,960,126,57,,,694,618,3.8200000000,33,11,30,4365,1353,111,546,897,152,156,0.97,Philadelphia Phillies,Veterans Stadium,1909233,104,103,PHI,PHI,PHI
+1975,NL,PIT,PIT,E,1,161,80,92,69,Y,,N,N,712,5489,1444,255,47,138,468,832,49,28,,,565,481,3.0100000000,43,14,31,4311,1302,79,551,768,151,147,0.97,Pittsburgh Pirates,Three Rivers Stadium,1270018,99,97,PIT,PIT,PIT
+1975,NL,SDN,SDP,W,4,162,81,71,91,N,,N,N,552,5429,1324,215,22,78,506,754,85,50,,,683,566,3.4800000000,40,12,20,4389,1494,99,521,713,188,163,0.97,San Diego Padres,Jack Murphy Stadium,1281747,94,96,SDP,SDN,SDN
+1975,NL,SFN,SFG,W,3,161,81,80,81,N,,N,N,659,5447,1412,235,45,84,604,775,99,47,,,671,595,3.7400000000,37,9,24,4296,1406,92,612,856,145,164,0.97,San Francisco Giants,Candlestick Park,522919,104,105,SFG,SFN,SFN
+1975,NL,SLN,STL,E,3,163,82,82,80,N,,N,N,662,5597,1527,239,46,81,444,649,116,49,,,689,577,3.5700000000,33,13,36,4362,1452,98,571,824,171,140,0.97,St. Louis Cardinals,Busch Stadium II,1695270,104,105,STL,SLN,SLN
+1976,AL,BAL,BAL,E,2,162,81,88,74,N,,N,N,619,5457,1326,213,28,119,519,883,150,61,,,598,542,3.3200000000,59,16,23,4404,1396,80,489,678,118,157,0.98,Baltimore Orioles,Memorial Stadium,1058609,94,93,BAL,BAL,BAL
+1976,AL,BOS,BOS,E,3,162,81,83,79,N,,N,N,716,5511,1448,257,53,134,500,832,95,70,,,660,570,3.5200000000,49,13,27,4374,1495,109,409,673,139,148,0.97,Boston Red Sox,Fenway Park II,1895846,113,112,BOS,BOS,BOS
+1976,AL,CAL,ANA,W,4,162,81,76,86,N,,N,N,550,5385,1265,210,23,63,534,812,126,80,,,631,551,3.3600000000,64,15,17,4431,1323,95,553,992,150,139,0.97,California Angels,Anaheim Stadium,1006774,93,94,CAL,CAL,CAL
+1976,AL,CHA,CHW,W,6,161,80,64,97,N,,N,N,586,5532,1410,209,46,73,471,739,120,53,,,745,684,4.2500000000,54,10,22,4344,1460,87,600,802,130,155,0.97,Chicago White Sox,Comiskey Park,914945,101,102,CHW,CHA,CHA
+1976,AL,CLE,CLE,E,4,159,79,81,78,N,,N,N,615,5412,1423,189,38,85,479,631,75,69,,,615,552,3.4700000000,30,17,46,4296,1361,80,533,928,121,159,0.98,Cleveland Indians,Cleveland Stadium,948776,98,98,CLE,CLE,CLE
+1976,AL,DET,DET,E,5,161,80,74,87,N,,N,N,609,5441,1401,207,38,101,450,730,107,59,,,709,615,3.8700000000,55,12,20,4293,1426,101,550,738,168,161,0.97,Detroit Tigers,Tiger Stadium,1467020,103,105,DET,DET,DET
+1976,AL,KCA,KCR,W,1,162,81,90,72,Y,,N,N,713,5540,1490,259,57,65,484,650,218,106,,,611,525,3.2100000000,41,12,35,4416,1356,83,493,735,139,147,0.97,Kansas City Royals,Royals Stadium,1680265,102,100,KCR,KCA,KCA
+1976,AL,MIN,MIN,W,3,162,81,85,77,N,,N,N,743,5574,1526,222,51,81,550,714,146,75,,,704,598,3.6900000000,29,11,23,4377,1421,89,610,762,172,182,0.97,Minnesota Twins,Metropolitan Stadium,715394,103,102,MIN,MIN,MIN
+1976,AL,ML4,MIL,E,6,161,81,66,95,N,,N,N,570,5396,1326,170,38,88,511,909,62,61,,,655,580,3.6400000000,45,10,27,4305,1406,99,567,677,152,160,0.97,Milwaukee Brewers,County Stadium,1012164,98,99,MIL,MIL,MIL
+1976,AL,NYA,NYY,E,1,159,80,97,62,Y,,Y,N,730,5555,1496,231,36,120,470,616,163,65,,,575,516,3.1900000000,62,15,37,4365,1300,97,448,674,126,141,0.98,New York Yankees,Yankee Stadium II,2012434,100,98,NYY,NYA,NYA
+1976,AL,OAK,OAK,W,2,161,81,87,74,N,,N,N,686,5353,1319,208,33,113,592,818,341,123,,,598,528,3.2600000000,39,15,29,4377,1412,96,415,711,144,130,0.97,Oakland Athletics,Oakland Coliseum,780593,95,95,OAK,OAK,OAK
+1976,AL,TEX,TEX,W,4,162,81,76,86,N,,N,N,616,5555,1390,213,26,80,568,809,87,45,,,652,564,3.4500000000,63,15,15,4416,1464,106,461,773,156,142,0.97,Texas Rangers,Arlington Stadium,1164982,102,102,TEX,TEX,TEX
+1976,NL,ATL,ATL,W,6,162,81,70,92,N,,N,N,620,5345,1309,170,30,82,589,811,74,61,,,700,617,3.8600000000,33,13,27,4314,1435,86,564,818,167,151,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,818179,106,108,ATL,ATL,ATL
+1976,NL,CHN,CHC,E,4,162,81,75,87,N,,N,N,611,5519,1386,216,24,105,490,834,74,74,,,728,642,3.9300000000,27,12,33,4413,1511,123,490,850,140,145,0.97,Chicago Cubs,Wrigley Field,1026217,108,109,CHC,CHN,CHN
+1976,NL,CIN,CIN,W,1,162,81,102,60,Y,,Y,Y,857,5702,1599,271,63,141,681,902,210,57,,,633,574,3.5100000000,33,12,45,4413,1436,100,491,790,102,157,0.98,Cincinnati Reds,Riverfront Stadium,2629708,102,100,CIN,CIN,CIN
+1976,NL,HOU,HOU,W,3,162,82,80,82,N,,N,N,625,5464,1401,195,50,66,530,719,150,57,,,657,571,3.5600000000,42,17,29,4332,1349,82,662,780,140,155,0.97,Houston Astros,Astrodome,886146,91,91,HOU,HOU,HOU
+1976,NL,LAN,LAD,W,2,162,81,92,70,N,,N,N,608,5472,1371,200,34,91,486,744,144,55,,,543,493,3.0200000000,47,17,28,4410,1330,97,479,747,128,154,0.98,Los Angeles Dodgers,Dodger Stadium,2386301,98,97,LAD,LAN,LAN
+1976,NL,MON,WSN,E,6,162,80,55,107,N,,N,N,531,5428,1275,224,32,94,433,841,86,44,,,734,638,3.9900000000,26,10,21,4320,1442,89,659,783,147,179,0.97,Montreal Expos,Jarry Park,646704,105,107,MON,MON,MON
+1976,NL,NYN,NYM,E,3,162,82,86,76,N,,N,N,615,5415,1334,198,34,102,561,797,66,58,,,538,473,2.9400000000,53,18,25,4347,1248,97,419,1025,131,116,0.97,New York Mets,Shea Stadium,1468754,94,94,NYM,NYN,NYN
+1976,NL,PHI,PHI,E,1,162,81,101,61,Y,,N,N,770,5528,1505,259,45,110,542,793,127,70,,,557,499,3.0800000000,34,9,44,4377,1377,98,397,918,115,148,0.98,Philadelphia Phillies,Veterans Stadium,2480150,104,102,PHI,PHI,PHI
+1976,NL,PIT,PIT,E,2,162,81,92,70,N,,N,N,708,5604,1499,249,56,110,433,807,130,45,,,630,547,3.3600000000,45,12,35,4398,1402,95,460,762,163,142,0.97,Pittsburgh Pirates,Three Rivers Stadium,1025945,100,99,PIT,PIT,PIT
+1976,NL,SDN,SDP,W,5,162,80,73,89,N,,N,N,570,5369,1327,216,37,64,488,716,92,46,,,662,581,3.6500000000,47,11,18,4296,1368,87,543,652,141,148,0.97,San Diego Padres,Jack Murphy Stadium,1458478,92,94,SDP,SDN,SDN
+1976,NL,SFN,SFG,W,4,162,81,74,88,N,,N,N,595,5452,1340,211,37,85,518,778,88,55,,,686,573,3.5300000000,27,18,31,4383,1464,68,518,746,183,153,0.97,San Francisco Giants,Candlestick Park,626868,103,103,SFG,SFN,SFN
+1976,NL,SLN,STL,E,5,162,81,72,90,N,,N,N,629,5516,1432,243,57,63,512,860,123,55,,,671,581,3.6000000000,35,15,26,4359,1416,91,581,731,174,163,0.97,St. Louis Cardinals,Busch Stadium II,1207079,101,101,STL,SLN,SLN
+1977,AL,BAL,BAL,E,2,161,81,97,64,N,,N,N,719,5494,1433,231,25,148,560,945,90,51,,,653,603,3.7400000000,65,11,23,4353,1414,124,494,737,106,189,0.98,Baltimore Orioles,Memorial Stadium,1195769,94,94,BAL,BAL,BAL
+1977,AL,BOS,BOS,E,2,161,80,97,64,N,,N,N,859,5510,1551,258,56,213,528,905,66,47,,,712,652,4.1100000000,40,13,40,4284,1555,158,378,758,132,162,0.97,Boston Red Sox,Fenway Park II,2074549,113,112,BOS,BOS,BOS
+1977,AL,CAL,ANA,W,5,162,81,74,88,N,,N,N,675,5410,1380,233,40,131,542,880,159,89,,,695,594,3.7200000000,53,13,26,4311,1383,136,572,965,147,137,0.97,California Angels,Anaheim Stadium,1432633,96,96,CAL,CAL,CAL
+1977,AL,CHA,CHW,W,3,162,81,90,72,N,,N,N,844,5633,1568,254,52,192,559,666,42,44,,,771,682,4.2500000000,34,3,40,4332,1557,136,516,842,159,125,0.97,Chicago White Sox,Comiskey Park,1657135,100,101,CHW,CHA,CHA
+1977,AL,CLE,CLE,E,5,161,81,71,90,N,,N,N,676,5491,1476,221,46,100,531,688,87,87,,,739,661,4.1000000000,45,8,30,4356,1441,136,550,876,130,145,0.97,Cleveland Indians,Cleveland Stadium,900365,96,97,CLE,CLE,CLE
+1977,AL,DET,DET,E,4,162,81,74,88,N,,N,N,714,5604,1480,228,45,166,452,764,60,46,,,751,669,4.1300000000,44,3,23,4371,1526,162,470,784,140,153,0.97,Detroit Tigers,Tiger Stadium,1359856,105,105,DET,DET,DET
+1977,AL,KCA,KCR,W,1,162,81,102,60,Y,,N,N,822,5594,1549,299,77,146,522,687,170,87,,,651,571,3.5200000000,41,15,42,4380,1377,110,499,850,137,145,0.97,Kansas City Royals,Royals Stadium,1852603,102,100,KCR,KCA,KCA
+1977,AL,MIN,MIN,W,4,161,80,84,77,N,,N,N,867,5639,1588,273,60,123,563,754,105,65,,,776,699,4.3600000000,35,4,25,4326,1546,151,507,737,144,184,0.97,Minnesota Twins,Metropolitan Stadium,1162727,99,99,MIN,MIN,MIN
+1977,AL,ML4,MIL,E,6,162,81,67,95,N,,N,N,639,5517,1425,255,46,125,443,862,85,67,,,765,687,4.3200000000,38,6,25,4293,1461,136,566,719,139,165,0.97,Milwaukee Brewers,County Stadium,1114938,100,100,MIL,MIL,MIL
+1977,AL,NYA,NYY,E,1,162,81,100,62,Y,,Y,Y,831,5605,1576,267,47,184,533,681,93,57,,,651,581,3.6100000000,52,16,34,4347,1395,139,486,758,132,151,0.97,New York Yankees,Yankee Stadium II,2103092,99,97,NYY,NYA,NYA
+1977,AL,OAK,OAK,W,7,161,81,63,98,N,,N,N,605,5358,1284,176,37,117,516,910,176,89,,,749,645,4.0400000000,32,4,26,4308,1459,145,560,788,190,136,0.97,Oakland Athletics,Oakland Coliseum,495599,97,98,OAK,OAK,OAK
+1977,AL,SEA,SEA,W,6,162,81,64,98,N,,N,N,624,5460,1398,218,33,133,426,769,110,67,,,855,769,4.8300000000,18,1,31,4299,1508,194,578,785,147,162,0.97,Seattle Mariners,Kingdome,1338511,99,101,SEA,SEA,SEA
+1977,AL,TEX,TEX,W,2,162,81,94,68,N,,N,N,767,5541,1497,265,39,135,596,904,154,85,,,657,582,3.5600000000,49,17,31,4416,1412,134,471,864,117,156,0.98,Texas Rangers,Arlington Stadium,1250722,101,101,TEX,TEX,TEX
+1977,AL,TOR,TOR,E,7,161,80,54,107,N,,N,N,605,5418,1367,230,41,100,499,819,65,55,,,822,725,4.5700000000,40,3,20,4284,1538,152,623,771,163,133,0.97,Toronto Blue Jays,Exhibition Stadium,1701052,101,103,TOR,TOR,TOR
+1977,NL,ATL,ATL,W,6,162,81,61,101,N,,N,N,678,5534,1404,218,20,139,537,876,82,53,,,895,779,4.8500000000,28,5,31,4335,1581,169,701,915,175,127,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,872464,112,114,ATL,ATL,ATL
+1977,NL,CHN,CHC,E,4,162,81,81,81,N,,N,N,692,5604,1489,271,37,111,534,796,64,45,,,739,654,4.0100000000,16,10,44,4404,1500,128,489,942,153,147,0.97,Chicago Cubs,Wrigley Field,1439834,111,112,CHC,CHN,CHN
+1977,NL,CIN,CIN,W,2,162,81,88,74,N,,N,N,802,5524,1513,269,42,181,600,911,170,64,,,725,672,4.2100000000,33,12,32,4311,1469,156,544,868,95,154,0.98,Cincinnati Reds,Riverfront Stadium,2519670,102,101,CIN,CIN,CIN
+1977,NL,HOU,HOU,W,3,162,81,81,81,N,,N,N,680,5530,1405,263,60,114,515,839,187,72,,,650,576,3.5400000000,37,11,28,4395,1384,110,545,871,142,136,0.97,Houston Astros,Astrodome,1109560,91,91,HOU,HOU,HOU
+1977,NL,LAN,LAD,W,1,162,81,98,64,Y,,Y,N,769,5589,1484,223,28,191,588,896,114,62,,,582,528,3.2200000000,34,13,39,4425,1393,119,438,930,124,160,0.98,Los Angeles Dodgers,Dodger Stadium,2955087,100,98,LAD,LAN,LAN
+1977,NL,MON,WSN,E,5,162,81,75,87,N,,N,N,665,5675,1474,294,50,138,478,877,88,50,,,736,660,4.0100000000,31,11,33,4443,1426,135,579,856,129,128,0.98,Montreal Expos,Stade Olympique,1433757,97,97,MON,MON,MON
+1977,NL,NYN,NYM,E,6,162,79,64,98,N,,N,N,587,5410,1319,227,30,88,529,887,98,81,,,663,600,3.7700000000,27,12,28,4299,1378,118,490,911,134,132,0.97,New York Mets,Shea Stadium,1066825,95,95,NYM,NYN,NYN
+1977,NL,PHI,PHI,E,1,162,81,101,61,Y,,N,N,847,5546,1548,266,56,186,573,806,135,68,,,668,600,3.7100000000,31,7,47,4365,1451,134,482,856,120,168,0.98,Philadelphia Phillies,Veterans Stadium,2700070,105,103,PHI,PHI,PHI
+1977,NL,PIT,PIT,E,2,162,81,96,66,N,,N,N,734,5662,1550,278,57,133,474,878,260,120,,,665,594,3.6100000000,25,15,39,4443,1406,149,485,890,145,137,0.97,Pittsburgh Pirates,Three Rivers Stadium,1237349,102,101,PIT,PIT,PIT
+1977,NL,SDN,SDP,W,5,162,81,69,93,N,,N,N,692,5602,1397,245,49,120,602,1057,133,57,,,834,722,4.4300000000,6,5,44,4398,1556,160,673,827,189,142,0.97,San Diego Padres,Jack Murphy Stadium,1376269,90,91,SDP,SDN,SDN
+1977,NL,SFN,SFG,W,4,162,81,75,87,N,,N,N,673,5497,1392,227,41,134,568,842,90,59,,,711,608,3.7500000000,27,10,33,4377,1501,114,529,854,178,136,0.97,San Francisco Giants,Candlestick Park,700056,99,100,SFG,SFN,SFN
+1977,NL,SLN,STL,E,3,162,83,83,79,N,,N,N,737,5527,1490,252,56,96,489,823,134,112,,,688,612,3.8100000000,26,10,31,4338,1420,139,532,768,139,174,0.97,St. Louis Cardinals,Busch Stadium II,1659287,99,99,STL,SLN,SLN
+1978,AL,BAL,BAL,E,4,161,81,90,71,N,,N,N,659,5422,1397,248,19,154,552,864,75,61,,,633,565,3.5600000000,65,16,33,4287,1340,107,509,754,110,166,0.98,Baltimore Orioles,Memorial Stadium,1051724,94,93,BAL,BAL,BAL
+1978,AL,BOS,BOS,E,2,163,82,99,64,N,,N,N,796,5587,1493,270,46,172,582,835,74,51,,,657,579,3.5400000000,57,15,26,4416,1530,137,464,706,146,171,0.97,Boston Red Sox,Fenway Park II,2320643,112,110,BOS,BOS,BOS
+1978,AL,CAL,ANA,W,2,162,81,87,75,N,,N,N,691,5472,1417,226,28,108,539,682,86,69,,,666,590,3.6500000000,44,13,33,4365,1382,125,599,892,136,136,0.97,California Angels,Anaheim Stadium,1755386,96,96,CAL,CAL,CAL
+1978,AL,CHA,CHW,W,5,161,80,71,90,N,,N,N,634,5393,1423,221,41,106,409,625,83,68,,,731,659,4.2100000000,38,9,33,4227,1380,128,586,710,138,130,0.97,Chicago White Sox,Comiskey Park,1491100,101,102,CHW,CHA,CHA
+1978,AL,CLE,CLE,E,6,159,78,69,90,N,,N,N,639,5365,1400,223,45,106,488,698,64,63,,,694,621,3.9700000000,36,6,28,4221,1397,100,568,739,121,142,0.98,Cleveland Indians,Cleveland Stadium,800584,99,100,CLE,CLE,CLE
+1978,AL,DET,DET,E,5,162,81,86,76,N,,N,N,714,5601,1520,218,34,129,563,695,90,38,,,653,588,3.6400000000,60,12,21,4365,1441,135,503,684,117,177,0.98,Detroit Tigers,Tiger Stadium,1714893,103,103,DET,DET,DET
+1978,AL,KCA,KCR,W,1,162,81,92,70,Y,,N,N,743,5474,1469,305,59,98,498,644,216,84,,,634,550,3.4400000000,53,14,33,4317,1350,108,478,657,150,153,0.97,Kansas City Royals,Royals Stadium,2255493,103,102,KCR,KCA,KCA
+1978,AL,MIN,MIN,W,4,162,81,73,89,N,,N,N,666,5522,1472,259,47,82,604,684,99,56,,,678,598,3.6900000000,48,9,26,4377,1468,102,520,703,146,171,0.97,Minnesota Twins,Metropolitan Stadium,787878,102,102,MIN,MIN,MIN
+1978,AL,ML4,MIL,E,3,162,81,93,69,N,,N,N,804,5536,1530,265,38,173,520,805,95,53,,,650,582,3.6500000000,62,19,24,4308,1442,109,398,577,150,144,0.97,Milwaukee Brewers,County Stadium,1601406,100,100,MIL,MIL,MIL
+1978,AL,NYA,NYY,E,1,163,81,100,63,Y,,Y,Y,735,5583,1489,228,38,125,505,695,98,42,,,582,516,3.1800000000,39,16,36,4380,1321,111,478,817,113,134,0.98,New York Yankees,Yankee Stadium II,2335871,97,96,NYY,NYA,NYA
+1978,AL,OAK,OAK,W,6,162,80,69,93,N,,N,N,532,5321,1304,200,31,100,433,800,144,117,,,690,576,3.6200000000,26,11,29,4299,1401,106,582,750,179,145,0.97,Oakland Athletics,Oakland Coliseum,526999,94,96,OAK,OAK,OAK
+1978,AL,SEA,SEA,W,7,160,81,56,104,N,,N,N,614,5358,1327,229,37,97,522,702,123,47,,,834,736,4.6700000000,28,4,20,4257,1540,155,567,630,141,174,0.97,Seattle Mariners,Kingdome,877440,100,101,SEA,SEA,SEA
+1978,AL,TEX,TEX,W,2,162,82,87,75,N,,N,N,692,5347,1353,216,36,132,624,779,196,91,,,632,544,3.3600000000,54,12,25,4368,1431,108,421,776,153,140,0.97,Texas Rangers,Arlington Stadium,1447963,100,100,TEX,TEX,TEX
+1978,AL,TOR,TOR,E,7,161,81,59,102,N,,N,N,590,5430,1358,217,39,98,448,645,28,52,,,775,721,4.5400000000,35,5,23,4287,1529,149,614,758,130,163,0.97,Toronto Blue Jays,Exhibition Stadium,1562585,101,104,TOR,TOR,TOR
+1978,NL,ATL,ATL,W,6,162,81,69,93,N,,N,N,600,5381,1313,191,39,123,550,874,90,65,,,750,653,4.0800000000,29,12,32,4320,1404,132,624,848,153,126,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,904494,112,114,ATL,ATL,ATL
+1978,NL,CHN,CHC,E,3,162,82,79,83,N,,N,N,664,5532,1461,224,48,72,562,746,110,58,,,724,655,4.0500000000,24,7,38,4365,1475,125,539,768,144,154,0.97,Chicago Cubs,Wrigley Field,1525311,112,112,CHC,CHN,CHN
+1978,NL,CIN,CIN,W,2,161,80,92,69,N,,N,N,710,5392,1378,270,32,136,636,899,137,58,,,688,613,3.8100000000,16,10,46,4344,1437,122,567,908,134,120,0.97,Cincinnati Reds,Riverfront Stadium,2532497,100,100,CIN,CIN,CIN
+1978,NL,HOU,HOU,W,5,162,81,74,88,N,,N,N,605,5458,1408,231,45,70,434,743,178,59,,,634,581,3.6300000000,48,17,23,4320,1328,86,578,930,132,109,0.97,Houston Astros,Astrodome,1126145,92,92,HOU,HOU,HOU
+1978,NL,LAN,LAD,W,1,162,81,95,67,Y,,Y,N,727,5437,1435,251,27,149,610,818,137,52,,,573,499,3.1200000000,46,16,38,4320,1362,107,440,800,140,138,0.97,Los Angeles Dodgers,Dodger Stadium,3347845,100,98,LAD,LAN,LAN
+1978,NL,MON,WSN,E,4,162,80,76,86,N,,N,N,633,5530,1404,269,31,121,396,881,80,42,,,611,549,3.4200000000,42,13,32,4338,1332,117,572,740,134,150,0.97,Montreal Expos,Stade Olympique,1427007,99,98,MON,MON,MON
+1978,NL,NYN,NYM,E,6,162,80,66,96,N,,N,N,607,5433,1332,227,47,86,549,829,100,77,,,690,626,3.8700000000,21,7,26,4365,1447,114,531,775,132,160,0.97,New York Mets,Shea Stadium,1007328,96,97,NYM,NYN,NYN
+1978,NL,PHI,PHI,E,1,162,82,90,72,Y,,N,N,708,5448,1404,248,32,133,552,866,152,58,,,586,531,3.3300000000,38,9,29,4308,1343,118,393,813,104,156,0.98,Philadelphia Phillies,Veterans Stadium,2583389,101,100,PHI,PHI,PHI
+1978,NL,PIT,PIT,E,2,161,81,88,73,N,,N,N,684,5406,1390,239,54,115,480,874,213,90,,,637,547,3.4100000000,30,13,44,4332,1366,103,499,880,166,133,0.97,Pittsburgh Pirates,Three Rivers Stadium,964106,105,104,PIT,PIT,PIT
+1978,NL,SDN,SDP,W,4,162,81,84,78,N,,N,N,591,5360,1349,208,42,75,536,848,152,70,,,598,522,3.2800000000,21,10,55,4299,1385,74,483,744,160,171,0.97,San Diego Padres,Jack Murphy Stadium,1670107,91,92,SDP,SDN,SDN
+1978,NL,SFN,SFG,W,3,162,81,89,73,N,,N,N,613,5364,1331,240,41,117,554,814,87,54,,,594,534,3.3000000000,42,17,29,4365,1377,84,453,840,146,118,0.97,San Francisco Giants,Candlestick Park,1740477,96,96,SFG,SFN,SFN
+1978,NL,SLN,STL,E,5,162,81,69,93,N,,N,N,600,5415,1351,263,44,79,420,713,97,42,,,657,572,3.5800000000,32,13,22,4311,1300,94,600,859,136,155,0.97,St. Louis Cardinals,Busch Stadium II,1278215,99,99,STL,SLN,SLN
+1979,AL,BAL,BAL,E,1,159,79,102,57,Y,,Y,N,757,5371,1401,258,24,181,608,847,99,49,,,582,519,3.2600000000,52,12,30,4302,1279,133,467,786,125,161,0.98,Baltimore Orioles,Memorial Stadium,1681009,97,95,BAL,BAL,BAL
+1979,AL,BOS,BOS,E,3,160,80,91,69,N,,N,N,841,5538,1567,310,34,194,512,708,60,43,,,711,641,4.0300000000,47,11,29,4293,1487,133,463,731,142,166,0.97,Boston Red Sox,Fenway Park II,2353114,106,106,BOS,BOS,BOS
+1979,AL,CAL,ANA,W,1,162,81,88,74,Y,,N,N,866,5550,1563,242,43,164,589,843,100,53,,,768,692,4.3400000000,46,9,33,4308,1463,131,573,820,135,172,0.97,California Angels,Anaheim Stadium,2523575,96,96,CAL,CAL,CAL
+1979,AL,CHA,CHW,W,5,160,79,73,87,N,,N,N,730,5463,1505,290,33,127,454,668,97,62,,,748,642,4.1000000000,28,9,37,4227,1365,114,618,675,173,142,0.97,Chicago White Sox,Comiskey Park,1280702,100,101,CHW,CHA,CHA
+1979,AL,CLE,CLE,E,6,161,81,81,80,N,,N,N,760,5376,1388,206,29,138,657,786,143,90,,,805,727,4.5700000000,28,7,32,4293,1502,138,570,781,126,149,0.97,Cleveland Indians,Cleveland Stadium,1011644,101,101,CLE,CLE,CLE
+1979,AL,DET,DET,E,5,161,80,85,76,N,,N,N,770,5375,1446,221,35,164,575,814,176,86,,,738,675,4.2700000000,25,5,37,4269,1429,167,547,802,120,184,0.98,Detroit Tigers,Tiger Stadium,1630929,103,103,DET,DET,DET
+1979,AL,KCA,KCR,W,2,162,81,85,77,N,,N,N,851,5653,1596,286,79,116,528,675,207,76,,,816,716,4.4500000000,42,7,27,4344,1477,165,536,640,146,160,0.97,Kansas City Royals,Royals Stadium,2261845,102,101,KCR,KCA,KCA
+1979,AL,MIN,MIN,W,4,162,81,82,80,N,,N,N,764,5544,1544,256,46,112,526,693,66,45,,,725,663,4.1300000000,31,6,33,4332,1590,128,452,721,134,203,0.97,Minnesota Twins,Metropolitan Stadium,1070521,104,104,MIN,MIN,MIN
+1979,AL,ML4,MIL,E,2,161,81,95,66,N,,N,N,807,5536,1552,291,41,185,549,745,100,53,,,722,644,4.0300000000,61,12,23,4317,1563,162,381,580,127,153,0.98,Milwaukee Brewers,County Stadium,1918343,100,99,MIL,MIL,MIL
+1979,AL,NYA,NYY,E,4,160,81,89,71,N,,N,N,734,5421,1443,226,40,150,509,590,65,46,,,672,609,3.8300000000,43,10,37,4296,1446,123,455,731,122,183,0.98,New York Yankees,Yankee Stadium II,2537765,98,96,NYY,NYA,NYA
+1979,AL,OAK,OAK,W,7,162,81,54,108,N,,N,N,573,5348,1276,188,32,108,482,751,104,69,,,860,754,4.7500000000,41,4,20,4287,1606,147,654,726,174,137,0.97,Oakland Athletics,Oakland Coliseum,306763,94,96,OAK,OAK,OAK
+1979,AL,SEA,SEA,W,6,162,81,67,95,N,,N,N,711,5544,1490,250,52,132,515,725,126,52,,,820,732,4.5800000000,37,7,26,4314,1567,165,571,736,141,170,0.97,Seattle Mariners,Kingdome,844447,102,104,SEA,SEA,SEA
+1979,AL,TEX,TEX,W,3,162,81,83,79,N,,N,N,750,5562,1549,252,26,140,461,607,79,51,,,698,616,3.8600000000,26,10,42,4311,1371,135,532,773,130,151,0.97,Texas Rangers,Arlington Stadium,1519671,99,98,TEX,TEX,TEX
+1979,AL,TOR,TOR,E,7,162,81,53,109,N,,N,N,613,5423,1362,253,34,95,448,663,75,56,,,862,759,4.8200000000,44,7,11,4251,1537,165,594,613,158,187,0.97,Toronto Blue Jays,Exhibition Stadium,1431651,100,102,TOR,TOR,TOR
+1979,NL,ATL,ATL,W,6,160,79,66,94,N,,N,N,669,5422,1389,220,28,126,490,818,98,50,,,763,653,4.1800000000,32,3,34,4221,1496,132,494,779,183,139,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,769465,107,109,ATL,ATL,ATL
+1979,NL,CHN,CHC,E,5,162,81,80,82,N,,N,N,706,5550,1494,250,43,135,478,762,73,52,,,707,623,3.8800000000,20,11,44,4338,1500,127,521,933,159,163,0.97,Chicago Cubs,Wrigley Field,1648587,110,111,CHC,CHN,CHN
+1979,NL,CIN,CIN,W,1,161,80,90,71,Y,,N,N,731,5477,1445,266,31,132,614,902,99,47,,,644,573,3.5800000000,27,10,40,4320,1415,103,485,773,124,152,0.98,Cincinnati Reds,Riverfront Stadium,2356933,101,101,CIN,CIN,CIN
+1979,NL,HOU,HOU,W,2,162,81,89,73,N,,N,N,583,5394,1382,224,52,49,461,745,190,95,,,582,514,3.2000000000,55,19,31,4341,1278,90,504,854,137,146,0.97,Houston Astros,Astrodome,1900312,94,94,HOU,HOU,HOU
+1979,NL,LAN,LAD,W,3,162,81,79,83,N,,N,N,739,5490,1443,220,24,183,556,834,106,46,,,717,615,3.8300000000,30,6,34,4332,1425,101,555,811,118,123,0.98,Los Angeles Dodgers,Dodger Stadium,2860954,99,98,LAD,LAN,LAN
+1979,NL,MON,WSN,E,2,160,81,95,65,N,,N,N,701,5465,1445,273,42,143,432,890,121,56,,,581,505,3.1400000000,33,18,39,4341,1379,116,450,813,131,123,0.97,Montreal Expos,Stade Olympique,2102173,99,98,MON,MON,MON
+1979,NL,NYN,NYM,E,6,163,82,63,99,N,,N,N,593,5591,1399,255,41,74,498,817,135,79,,,706,632,3.8400000000,16,10,36,4446,1486,120,607,819,140,168,0.97,New York Mets,Shea Stadium,788905,96,97,NYM,NYN,NYN
+1979,NL,PHI,PHI,E,4,163,81,84,78,N,,N,N,683,5463,1453,250,53,119,602,764,128,76,,,718,666,4.1600000000,33,14,29,4323,1455,135,477,787,106,148,0.98,Philadelphia Phillies,Veterans Stadium,2775011,103,102,PHI,PHI,PHI
+1979,NL,PIT,PIT,E,1,163,81,98,64,Y,,Y,Y,775,5661,1541,264,52,148,483,855,180,66,,,643,566,3.4100000000,24,7,52,4479,1424,125,504,904,134,163,0.97,Pittsburgh Pirates,Three Rivers Stadium,1435454,105,105,PIT,PIT,PIT
+1979,NL,SDN,SDP,W,5,161,81,68,93,N,,N,N,603,5446,1316,193,53,93,534,770,100,58,,,681,596,3.6900000000,29,7,25,4359,1438,108,513,779,140,154,0.97,San Diego Padres,Jack Murphy Stadium,1456967,93,94,SDP,SDN,SDN
+1979,NL,SFN,SFG,W,4,162,81,71,91,N,,N,N,672,5395,1328,192,36,125,580,925,140,73,,,751,664,4.1600000000,25,6,34,4308,1484,143,577,880,161,138,0.97,San Francisco Giants,Candlestick Park,1456402,93,94,SFG,SFN,SFN
+1979,NL,SLN,STL,E,3,163,82,86,76,N,,N,N,731,5734,1594,279,63,100,460,838,116,69,,,693,614,3.7200000000,38,10,25,4458,1449,127,501,788,132,166,0.98,St. Louis Cardinals,Busch Stadium II,1627256,102,102,STL,SLN,SLN
+1980,AL,BAL,BAL,E,2,162,81,100,62,N,,N,N,805,5585,1523,258,29,156,587,766,111,38,,,640,590,3.6400000000,42,10,41,4380,1438,134,507,789,95,178,0.98,Baltimore Orioles,Memorial Stadium,1797438,99,98,BAL,BAL,BAL
+1980,AL,BOS,BOS,E,5,160,81,83,77,N,,N,N,757,5603,1588,297,36,162,475,720,79,48,,,767,701,4.3800000000,30,8,43,4323,1557,129,481,696,149,206,0.97,Boston Red Sox,Fenway Park II,1956092,106,105,BOS,BOS,BOS
+1980,AL,CAL,ANA,W,6,160,81,65,95,N,,N,N,698,5443,1442,236,32,106,539,889,91,63,,,797,717,4.5200000000,22,6,30,4284,1548,141,529,725,134,144,0.97,California Angels,Anaheim Stadium,2297327,97,97,CAL,CAL,CAL
+1980,AL,CHA,CHW,W,5,162,81,70,90,N,,N,N,587,5444,1408,255,38,91,399,670,68,54,,,722,625,3.9200000000,32,12,42,4305,1434,108,563,724,171,162,0.97,Chicago White Sox,Comiskey Park,1200365,100,100,CHW,CHA,CHA
+1980,AL,CLE,CLE,E,6,160,79,79,81,N,,N,N,738,5470,1517,221,40,89,617,625,118,58,,,807,743,4.6800000000,35,8,32,4284,1519,137,552,843,105,143,0.98,Cleveland Indians,Cleveland Stadium,1033827,101,102,CLE,CLE,CLE
+1980,AL,DET,DET,E,4,163,82,84,78,N,,N,N,830,5648,1543,232,53,143,645,844,75,68,,,757,693,4.2500000000,40,9,30,4401,1505,152,558,741,129,165,0.97,Detroit Tigers,Tiger Stadium,1785293,102,102,DET,DET,DET
+1980,AL,KCA,KCR,W,1,162,81,97,65,Y,,Y,N,809,5714,1633,266,59,115,508,709,185,43,,,694,621,3.8300000000,37,10,42,4377,1496,129,465,614,141,150,0.97,Kansas City Royals,Royals Stadium,2288714,100,100,KCR,KCA,KCA
+1980,AL,MIN,MIN,W,3,161,80,77,84,N,,N,N,670,5530,1468,252,46,99,436,703,62,46,,,724,634,3.9300000000,35,9,30,4353,1502,120,468,744,146,192,0.97,Minnesota Twins,Metropolitan Stadium,769206,108,108,MIN,MIN,MIN
+1980,AL,ML4,MIL,E,3,162,82,86,76,N,,N,N,811,5653,1555,298,36,203,455,745,131,56,,,682,598,3.7100000000,48,14,30,4350,1530,137,420,575,147,189,0.97,Milwaukee Brewers,County Stadium,1857408,97,96,MIL,MIL,MIL
+1980,AL,NYA,NYY,E,1,162,81,103,59,Y,,N,N,820,5553,1484,239,34,189,643,739,86,36,,,662,582,3.5800000000,29,15,50,4392,1433,102,463,845,138,160,0.97,New York Yankees,Yankee Stadium II,2627417,98,97,NYY,NYA,NYA
+1980,AL,OAK,OAK,W,2,162,81,83,79,N,,N,N,686,5495,1424,212,35,137,506,824,175,82,,,642,566,3.4600000000,94,9,13,4413,1347,142,521,769,130,115,0.97,Oakland Athletics,Oakland Coliseum,842259,93,93,OAK,OAK,OAK
+1980,AL,SEA,SEA,W,7,163,81,59,103,N,,N,N,610,5489,1359,211,35,104,483,727,116,62,,,793,709,4.3800000000,31,7,26,4371,1565,159,540,703,149,189,0.97,Seattle Mariners,Kingdome,836204,101,103,SEA,SEA,SEA
+1980,AL,TEX,TEX,W,4,163,80,76,85,N,,N,N,756,5690,1616,263,27,124,480,589,91,49,,,752,648,4.0200000000,35,6,25,4353,1561,119,519,890,147,169,0.97,Texas Rangers,Arlington Stadium,1198175,97,96,TEX,TEX,TEX
+1980,AL,TOR,TOR,E,7,162,81,67,95,N,,N,N,624,5571,1398,249,53,126,448,813,67,72,,,762,683,4.1900000000,39,9,23,4398,1523,135,635,705,133,206,0.97,Toronto Blue Jays,Exhibition Stadium,1400327,105,107,TOR,TOR,TOR
+1980,NL,ATL,ATL,W,4,161,80,81,80,N,,N,N,630,5402,1352,226,22,144,434,899,73,52,,,660,598,3.7700000000,29,9,37,4284,1397,131,454,696,162,156,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1048411,103,103,ATL,ATL,ATL
+1980,NL,CHN,CHC,E,6,162,81,64,98,N,,N,N,614,5619,1411,251,35,107,471,912,93,64,,,728,639,3.8900000000,13,6,35,4437,1525,109,589,923,174,149,0.97,Chicago Cubs,Wrigley Field,1206776,107,109,CHC,CHN,CHN
+1980,NL,CIN,CIN,W,3,163,82,89,73,N,,N,N,707,5516,1445,256,45,113,537,852,156,43,,,670,624,3.8500000000,30,12,37,4377,1404,113,506,833,106,144,0.98,Cincinnati Reds,Riverfront Stadium,2022450,101,100,CIN,CIN,CIN
+1980,NL,HOU,HOU,W,1,163,81,93,70,Y,,N,N,637,5566,1455,231,67,75,540,755,194,74,,,589,510,3.1000000000,31,18,41,4446,1367,69,466,929,140,145,0.97,Houston Astros,Astrodome,2278217,92,91,HOU,HOU,HOU
+1980,NL,LAN,LAD,W,2,163,82,92,71,N,,N,N,663,5568,1462,209,24,148,492,846,123,72,,,591,532,3.2500000000,24,19,42,4416,1358,105,480,835,123,149,0.98,Los Angeles Dodgers,Dodger Stadium,3249287,99,98,LAD,LAN,LAN
+1980,NL,MON,WSN,E,2,162,80,90,72,N,,N,N,694,5465,1407,250,61,114,547,865,237,82,,,629,563,3.4800000000,33,15,36,4368,1447,100,460,823,144,126,0.97,Montreal Expos,Stade Olympique,2208175,100,99,MON,MON,MON
+1980,NL,NYN,NYM,E,5,162,82,67,95,N,,N,N,611,5478,1407,218,41,61,501,840,158,99,,,702,621,3.8500000000,17,9,33,4353,1473,140,510,886,154,132,0.97,New York Mets,Shea Stadium,1192073,97,98,NYM,NYN,NYN
+1980,NL,PHI,PHI,E,1,162,81,91,71,Y,,Y,Y,728,5625,1517,272,54,117,472,708,140,62,,,639,564,3.4300000000,25,8,40,4440,1419,87,530,889,136,136,0.97,Philadelphia Phillies,Veterans Stadium,2651650,105,105,PHI,PHI,PHI
+1980,NL,PIT,PIT,E,3,162,81,83,79,N,,N,N,666,5517,1469,249,38,116,452,760,209,102,,,646,580,3.5800000000,25,8,43,4374,1422,110,451,832,137,154,0.97,Pittsburgh Pirates,Three Rivers Stadium,1646757,103,102,PIT,PIT,PIT
+1980,NL,SDN,SDP,W,6,163,81,73,89,N,,N,N,591,5540,1410,195,43,67,563,791,239,73,,,654,595,3.6500000000,19,9,39,4398,1474,97,536,728,131,157,0.98,San Diego Padres,Jack Murphy Stadium,1139026,94,95,SDP,SDN,SDN
+1980,NL,SFN,SFG,W,5,161,81,75,86,N,,N,N,573,5368,1310,199,44,80,509,840,100,58,,,634,557,3.4600000000,27,10,35,4344,1446,92,492,811,156,124,0.97,San Francisco Giants,Candlestick Park,1096115,97,98,SFG,SFN,SFN
+1980,NL,SLN,STL,E,4,162,81,74,88,N,,N,N,738,5608,1541,300,49,101,451,781,117,54,,,710,632,3.9300000000,34,9,27,4341,1454,90,495,664,122,174,0.98,St. Louis Cardinals,Busch Stadium II,1385147,104,103,STL,SLN,SLN
+1981,AL,BAL,BAL,E,2,105,55,59,46,N,,N,N,429,3516,883,165,11,88,404,454,41,34,,,437,386,3.7000000000,25,10,23,2820,923,83,347,489,68,114,0.98,Baltimore Orioles,Memorial Stadium,1024247,100,99,BAL,BAL,BAL
+1981,AL,BOS,BOS,E,5,108,53,59,49,N,,N,N,519,3820,1052,168,17,90,378,520,32,31,,,481,418,3.8100000000,19,4,24,2961,983,90,354,536,91,108,0.97,Boston Red Sox,Fenway Park II,1060379,107,106,BOS,BOS,BOS
+1981,AL,CAL,ANA,W,5,110,54,51,59,N,,N,N,476,3688,944,134,16,97,393,571,44,33,,,453,399,3.7000000000,27,5,19,2914,958,81,323,426,101,120,0.97,California Angels,Anaheim Stadium,1441545,100,99,CAL,CAL,CAL
+1981,AL,CHA,CHW,W,3,106,49,54,52,N,,N,N,476,3615,982,135,27,76,322,518,86,44,,,423,363,3.4700000000,20,8,23,2822,891,73,336,529,87,113,0.97,Chicago White Sox,Comiskey Park,946651,98,98,CHW,CHA,CHA
+1981,AL,CLE,CLE,E,6,103,54,52,51,N,,N,N,431,3507,922,150,21,39,343,379,119,37,,,442,401,3.8800000000,33,10,13,2793,989,67,311,569,87,91,0.97,Cleveland Indians,Cleveland Stadium,661395,100,100,CLE,CLE,CLE
+1981,AL,DET,DET,E,3,109,55,60,49,N,,N,N,427,3600,922,148,29,65,404,500,61,37,,,404,380,3.5300000000,33,13,22,2907,840,83,373,476,65,109,0.98,Detroit Tigers,Tiger Stadium,1149144,104,103,DET,DET,DET
+1981,AL,KCA,KCR,W,4,103,47,50,53,Y,,N,N,397,3560,952,169,29,61,301,419,100,53,,,405,365,3.5600000000,24,8,24,2767,909,75,273,404,72,94,0.98,Kansas City Royals,Royals Stadium,1279403,99,98,KCR,KCA,KCA
+1981,AL,MIN,MIN,W,7,110,61,41,68,N,,N,N,378,3676,884,147,36,47,275,497,34,27,,,486,433,3.9800000000,13,6,22,2937,1021,79,376,500,93,103,0.97,Minnesota Twins,Metropolitan Stadium,469090,107,108,MIN,MIN,MIN
+1981,AL,ML4,MIL,E,1,109,49,62,47,Y,,N,N,493,3743,961,173,20,96,300,461,39,36,,,459,428,3.9100000000,11,4,35,2958,994,72,352,448,79,135,0.98,Milwaukee Brewers,County Stadium,874292,95,94,MIL,MIL,MIL
+1981,AL,NYA,NYY,E,4,107,51,59,48,Y,,Y,N,421,3529,889,148,22,100,391,434,47,30,,,343,305,2.9000000000,16,13,30,2844,827,64,287,606,72,100,0.98,New York Yankees,Yankee Stadium II,1614353,98,97,NYY,NYA,NYA
+1981,AL,OAK,OAK,W,1,109,56,64,45,Y,,N,N,458,3677,910,119,26,104,342,647,98,47,,,403,364,3.3000000000,60,13,10,2979,883,80,370,505,81,74,0.98,Oakland Athletics,Oakland Coliseum,1304052,95,95,OAK,OAK,OAK
+1981,AL,SEA,SEA,W,6,110,57,44,65,N,,N,N,426,3780,950,148,13,89,329,553,100,50,,,521,469,4.2300000000,10,6,23,2992,1039,76,360,478,91,122,0.97,Seattle Mariners,Kingdome,636276,105,106,SEA,SEA,SEA
+1981,AL,TEX,TEX,W,2,105,56,57,48,N,,N,N,452,3581,968,178,15,49,295,396,46,41,,,389,355,3.4000000000,23,8,18,2820,891,67,322,488,69,102,0.98,Texas Rangers,Arlington Stadium,850076,94,94,TEX,TEX,TEX
+1981,AL,TOR,TOR,E,7,106,53,37,69,N,,N,N,329,3521,797,137,23,61,284,556,66,57,,,466,404,3.8200000000,20,4,18,2859,908,72,377,451,105,102,0.97,Toronto Blue Jays,Exhibition Stadium,755083,106,108,TOR,TOR,TOR
+1981,NL,ATL,ATL,W,5,107,50,50,56,N,,N,N,395,3642,886,148,22,64,321,540,98,39,,,416,371,3.4500000000,11,6,24,2904,936,62,330,471,102,93,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,535418,102,103,ATL,ATL,ATL
+1981,NL,CHN,CHC,E,6,106,58,38,65,N,,N,N,370,3546,838,138,29,57,342,611,72,41,,,483,426,4.0100000000,6,2,20,2868,983,59,388,532,113,103,0.97,Chicago Cubs,Wrigley Field,565637,104,106,CHC,CHN,CHN
+1981,NL,CIN,CIN,W,1,108,54,66,42,N,,N,N,464,3637,972,190,24,64,375,553,58,37,,,440,400,3.7300000000,25,19,20,2897,863,67,393,593,80,99,0.98,Cincinnati Reds,Riverfront Stadium,1093730,102,102,CIN,CIN,CIN
+1981,NL,HOU,HOU,W,3,110,51,61,49,Y,,N,N,394,3693,948,160,35,45,340,488,81,43,,,331,293,2.6600000000,23,9,25,2970,842,40,300,610,87,81,0.98,Houston Astros,Astrodome,1321282,95,94,HOU,HOU,HOU
+1981,NL,LAN,LAD,W,2,110,56,63,47,Y,,Y,Y,450,3751,984,133,20,82,331,550,73,46,,,356,333,3.0100000000,26,19,24,2991,904,54,302,603,87,101,0.98,Los Angeles Dodgers,Dodger Stadium,2381292,97,96,LAD,LAN,LAN
+1981,NL,MON,WSN,E,2,108,56,60,48,Y,,N,N,443,3591,883,146,28,81,368,498,138,40,,,394,357,3.3000000000,20,12,23,2925,902,58,268,520,81,88,0.98,Montreal Expos,Stade Olympique,1534564,101,100,MON,MON,MON
+1981,NL,NYN,NYM,E,5,105,52,41,62,N,,N,N,348,3493,868,136,35,57,304,603,103,42,,,432,365,3.5500000000,7,3,24,2778,906,74,336,490,130,89,0.96,New York Mets,Shea Stadium,704244,98,99,NYM,NYN,NYN
+1981,NL,PHI,PHI,E,3,107,55,59,48,Y,,N,N,491,3665,1002,165,25,69,372,432,103,46,,,472,432,4.0500000000,19,5,23,2880,967,72,347,580,86,90,0.98,Philadelphia Phillies,Veterans Stadium,1638752,104,104,PHI,PHI,PHI
+1981,NL,PIT,PIT,E,4,103,51,46,56,N,,N,N,407,3576,920,176,30,55,278,494,122,52,,,425,373,3.5600000000,11,5,29,2826,953,60,346,492,86,106,0.97,Pittsburgh Pirates,Three Rivers Stadium,541789,104,104,PIT,PIT,PIT
+1981,NL,SDN,SDP,W,6,110,55,41,69,N,,N,N,382,3757,963,170,35,32,311,525,83,62,,,455,414,3.7200000000,9,6,23,3006,1013,64,414,492,102,117,0.97,San Diego Padres,Jack Murphy Stadium,519161,93,94,SDP,SDN,SDN
+1981,NL,SFN,SFG,W,4,111,53,56,55,N,,N,N,427,3766,941,161,26,63,386,543,89,50,,,414,368,3.2800000000,8,4,33,3028,970,57,393,561,99,102,0.97,San Francisco Giants,Candlestick Park,632274,98,98,SFG,SFN,SFN
+1981,NL,SLN,STL,E,1,103,53,59,43,N,,N,N,464,3537,936,158,45,50,379,495,88,45,,,417,380,3.6300000000,11,5,33,2829,902,52,290,388,82,108,0.98,St. Louis Cardinals,Busch Stadium II,1010247,103,102,STL,SLN,SLN
+1982,AL,BAL,BAL,E,2,163,82,94,68,N,,N,N,774,5557,1478,259,27,179,634,796,49,38,,,687,648,3.9900000000,38,8,34,4386,1436,147,488,719,101,140,0.98,Baltimore Orioles,Memorial Stadium,1613031,100,99,BAL,BAL,BAL
+1982,AL,BOS,BOS,E,3,162,81,89,73,N,,N,N,753,5596,1536,271,31,136,547,736,42,39,,,713,651,4.0300000000,23,11,33,4359,1557,155,478,816,121,172,0.98,Boston Red Sox,Fenway Park II,1950124,107,106,BOS,BOS,BOS
+1982,AL,CAL,ANA,W,1,162,81,93,69,Y,,N,N,814,5532,1518,268,26,186,613,760,55,53,,,670,621,3.8200000000,40,10,27,4392,1436,124,482,728,106,171,0.98,California Angels,Anaheim Stadium,2807360,100,99,CAL,CAL,CAL
+1982,AL,CHA,CHW,W,3,162,80,87,75,N,,N,N,786,5575,1523,266,52,136,533,866,136,58,,,710,619,3.8700000000,30,10,41,4317,1502,99,460,753,154,173,0.97,Chicago White Sox,Comiskey Park,1567787,100,99,CHW,CHA,CHA
+1982,AL,CLE,CLE,E,6,162,81,78,84,N,,N,N,683,5559,1458,225,32,109,651,625,151,68,,,748,670,4.1100000000,31,9,30,4404,1433,122,589,882,123,129,0.98,Cleveland Indians,Cleveland Stadium,1044021,101,101,CLE,CLE,CLE
+1982,AL,DET,DET,E,4,162,81,83,79,N,,N,N,729,5590,1489,237,40,177,470,807,93,66,,,685,613,3.8000000000,45,5,27,4353,1371,172,554,740,115,165,0.98,Detroit Tigers,Tiger Stadium,1636058,100,99,DET,DET,DET
+1982,AL,KCA,KCR,W,2,162,81,90,72,N,,N,N,784,5629,1603,295,58,132,442,758,133,48,,,717,649,4.0800000000,16,12,45,4293,1443,163,471,650,127,140,0.97,Kansas City Royals,Royals Stadium,2284464,100,100,KCR,KCA,KCA
+1982,AL,MIN,MIN,W,7,162,81,60,102,N,,N,N,657,5544,1427,234,44,148,474,887,38,33,,,819,752,4.7200000000,26,7,30,4299,1484,208,643,812,105,162,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,921186,103,104,MIN,MIN,MIN
+1982,AL,ML4,MIL,E,1,163,82,95,67,Y,,Y,N,891,5733,1599,277,41,216,484,714,84,52,,,717,649,3.9800000000,34,6,47,4401,1514,152,511,717,125,185,0.98,Milwaukee Brewers,County Stadium,1978896,94,93,MIL,MIL,MIL
+1982,AL,NYA,NYY,E,5,162,81,79,83,N,,N,N,709,5526,1417,225,37,161,590,719,69,45,,,716,647,3.9900000000,24,8,39,4377,1471,113,491,939,128,158,0.97,New York Yankees,Yankee Stadium II,2041219,98,97,NYY,NYA,NYA
+1982,AL,OAK,OAK,W,5,162,81,68,94,N,,N,N,691,5448,1286,211,27,149,582,948,232,87,,,819,734,4.5400000000,42,6,22,4368,1506,177,648,697,160,140,0.97,Oakland Athletics,Oakland Coliseum,1735489,94,95,OAK,OAK,OAK
+1982,AL,SEA,SEA,W,4,162,81,76,86,N,,N,N,651,5626,1431,259,33,130,456,806,131,82,,,712,636,3.8800000000,23,11,39,4428,1431,173,547,1002,138,158,0.97,Seattle Mariners,Kingdome,1070404,103,105,SEA,SEA,SEA
+1982,AL,TEX,TEX,W,6,162,81,64,98,N,,N,N,590,5445,1354,204,26,115,447,750,63,45,,,749,681,4.2800000000,32,5,24,4293,1554,128,483,690,121,169,0.98,Texas Rangers,Arlington Stadium,1154432,95,95,TEX,TEX,TEX
+1982,AL,TOR,TOR,E,6,162,81,78,84,N,,N,N,651,5526,1447,262,45,106,415,749,118,81,,,701,633,3.9500000000,41,13,25,4329,1428,147,493,776,136,146,0.97,Toronto Blue Jays,Exhibition Stadium,1275978,110,110,TOR,TOR,TOR
+1982,NL,ATL,ATL,W,1,162,81,89,73,Y,,N,N,739,5507,1411,215,22,146,554,869,151,77,,,702,621,3.8200000000,15,11,51,4389,1484,126,502,813,137,186,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1801985,104,104,ATL,ATL,ATL
+1982,NL,CHN,CHC,E,5,162,81,73,89,N,,N,N,676,5531,1436,239,46,102,460,869,132,70,,,709,630,3.9200000000,9,7,43,4341,1510,125,452,764,132,110,0.97,Chicago Cubs,Wrigley Field,1249278,102,103,CHC,CHN,CHN
+1982,NL,CIN,CIN,W,6,162,81,61,101,N,,N,N,545,5479,1375,228,34,82,470,817,131,69,,,661,594,3.6600000000,22,7,31,4380,1414,105,570,998,128,158,0.98,Cincinnati Reds,Riverfront Stadium,1326528,102,102,CIN,CIN,CIN
+1982,NL,HOU,HOU,W,5,162,81,77,85,N,,N,N,569,5440,1342,236,48,74,435,830,140,61,,,620,549,3.4200000000,37,16,31,4338,1338,87,479,899,136,154,0.97,Houston Astros,Astrodome,1558555,92,92,HOU,HOU,HOU
+1982,NL,LAN,LAD,W,2,162,81,88,74,N,,N,N,691,5642,1487,222,32,138,528,804,151,56,,,612,539,3.2600000000,37,16,28,4464,1356,81,468,932,139,131,0.97,Los Angeles Dodgers,Dodger Stadium,3608881,98,97,LAD,LAN,LAN
+1982,NL,MON,WSN,E,3,162,81,86,76,N,,N,N,697,5557,1454,270,38,133,503,816,156,56,,,616,537,3.3100000000,34,10,43,4380,1371,110,448,936,122,117,0.98,Montreal Expos,Stade Olympique,2318292,102,101,MON,MON,MON
+1982,NL,NYN,NYM,E,6,162,81,65,97,N,,N,N,609,5510,1361,227,26,97,456,1005,137,58,,,723,624,3.8800000000,15,5,37,4341,1508,119,582,759,175,134,0.97,New York Mets,Shea Stadium,1323036,99,101,NYM,NYN,NYN
+1982,NL,PHI,PHI,E,2,162,81,89,73,N,,N,N,664,5454,1417,245,25,112,506,831,128,76,,,654,584,3.6100000000,38,13,33,4368,1395,86,472,1002,121,138,0.98,Philadelphia Phillies,Veterans Stadium,2376394,103,102,PHI,PHI,PHI
+1982,NL,PIT,PIT,E,4,162,81,84,78,N,,N,N,724,5614,1535,272,40,134,447,862,161,75,,,696,621,3.8100000000,19,7,39,4398,1434,118,521,933,145,133,0.97,Pittsburgh Pirates,Three Rivers Stadium,1024106,104,104,PIT,PIT,PIT
+1982,NL,SDN,SDP,W,4,162,81,81,81,N,,N,N,675,5575,1435,217,52,81,429,877,165,77,,,658,577,3.5200000000,20,11,41,4428,1348,139,502,765,152,142,0.97,San Diego Padres,Jack Murphy Stadium,1607516,96,96,SDP,SDN,SDN
+1982,NL,SFN,SFG,W,3,162,81,87,75,N,,N,N,673,5499,1393,213,30,133,607,915,130,56,,,687,593,3.6400000000,18,4,45,4395,1507,109,466,810,173,125,0.97,San Francisco Giants,Candlestick Park,1200948,99,99,SFG,SFN,SFN
+1982,NL,SLN,STL,E,1,162,81,92,70,Y,,Y,Y,685,5455,1439,239,52,67,569,805,200,91,,,609,549,3.3700000000,25,10,47,4395,1420,94,502,689,124,169,0.98,St. Louis Cardinals,Busch Stadium II,2111906,101,101,STL,SLN,SLN
+1983,AL,BAL,BAL,E,1,162,81,98,64,Y,,Y,Y,799,5546,1492,283,27,168,601,800,61,33,,,652,586,3.6300000000,36,15,38,4356,1451,130,452,774,121,159,0.98,Baltimore Orioles,Memorial Stadium,2042071,98,98,BAL,BAL,BAL
+1983,AL,BOS,BOS,E,6,162,81,78,84,N,,N,N,724,5590,1512,287,32,142,536,758,30,26,,,775,697,4.3400000000,29,7,42,4338,1572,158,493,767,130,168,0.97,Boston Red Sox,Fenway Park II,1782285,107,107,BOS,BOS,BOS
+1983,AL,CAL,ANA,W,5,162,81,70,92,N,,N,N,722,5640,1467,241,22,154,509,835,41,39,,,779,706,4.3100000000,39,7,23,4422,1636,130,496,668,154,190,0.97,California Angels,Anaheim Stadium,2555016,99,99,CAL,CAL,CAL
+1983,AL,CHA,CHW,W,1,162,81,99,63,Y,,N,N,800,5484,1439,270,42,157,527,888,165,50,,,650,589,3.6700000000,35,12,48,4335,1355,128,447,877,120,158,0.98,Chicago White Sox,Comiskey Park,2132821,104,103,CHW,CHA,CHA
+1983,AL,CLE,CLE,E,7,162,81,70,92,N,,N,N,704,5476,1451,249,31,86,605,691,109,71,,,785,709,4.4300000000,34,8,25,4323,1531,120,529,794,122,174,0.98,Cleveland Indians,Cleveland Stadium,768941,104,105,CLE,CLE,CLE
+1983,AL,DET,DET,E,2,162,81,92,70,N,,N,N,789,5592,1530,283,53,156,508,831,93,53,,,679,613,3.8000000000,42,9,28,4353,1318,170,522,875,124,142,0.98,Detroit Tigers,Tiger Stadium,1829636,97,96,DET,DET,DET
+1983,AL,KCA,KCR,W,2,163,82,79,83,N,,N,N,696,5598,1515,273,54,109,397,722,182,47,,,767,679,4.2500000000,19,8,49,4311,1535,133,471,593,164,178,0.97,Kansas City Royals,Royals Stadium,1963875,100,100,KCR,KCA,KCA
+1983,AL,MIN,MIN,W,5,162,81,70,92,N,,N,N,709,5601,1463,280,41,141,467,802,44,29,,,822,744,4.6600000000,20,5,39,4311,1559,163,580,748,118,170,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,858939,104,105,MIN,MIN,MIN
+1983,AL,ML4,MIL,E,5,162,81,87,75,N,,N,N,764,5620,1556,281,57,132,475,665,101,49,,,708,649,4.0200000000,35,10,43,4362,1513,133,491,689,113,162,0.98,Milwaukee Brewers,County Stadium,2397131,93,92,MIL,MIL,MIL
+1983,AL,NYA,NYY,E,3,162,81,91,71,N,,N,N,770,5631,1535,269,40,153,533,686,84,42,,,703,624,3.8600000000,47,12,32,4368,1449,116,455,892,139,157,0.97,New York Yankees,Yankee Stadium II,2257976,96,95,NYY,NYA,NYA
+1983,AL,OAK,OAK,W,4,162,81,74,88,N,,N,N,708,5516,1447,237,28,121,524,872,235,98,,,782,701,4.3400000000,22,12,33,4362,1462,135,626,719,157,157,0.97,Oakland Athletics,Oakland Coliseum,1294941,93,94,OAK,OAK,OAK
+1983,AL,SEA,SEA,W,7,162,81,60,102,N,,N,N,558,5336,1280,247,31,111,460,840,144,80,,,740,649,4.1200000000,25,9,39,4254,1455,145,544,910,134,159,0.97,Seattle Mariners,Kingdome,813537,104,105,SEA,SEA,SEA
+1983,AL,TEX,TEX,W,3,163,81,77,85,N,,N,N,639,5610,1429,242,33,106,442,767,119,60,,,609,539,3.3100000000,43,11,32,4398,1392,97,471,826,113,151,0.98,Texas Rangers,Arlington Stadium,1363469,97,98,TEX,TEX,TEX
+1983,AL,TOR,TOR,E,4,162,81,89,73,N,,N,N,795,5581,1546,268,58,167,510,810,131,72,,,726,661,4.1200000000,43,8,32,4335,1434,145,517,835,115,148,0.98,Toronto Blue Jays,Exhibition Stadium,1930415,106,106,TOR,TOR,TOR
+1983,NL,ATL,ATL,W,2,162,80,88,74,N,,N,N,746,5472,1489,218,45,130,582,847,146,88,,,640,587,3.6700000000,18,4,48,4320,1412,132,540,895,137,176,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,2119935,108,107,ATL,ATL,ATL
+1983,NL,CHN,CHC,E,5,162,81,71,91,N,,N,N,701,5512,1436,272,42,140,470,868,84,40,,,719,647,4.0800000000,9,10,42,4284,1496,117,498,807,115,164,0.98,Chicago Cubs,Wrigley Field,1479717,104,104,CHC,CHN,CHN
+1983,NL,CIN,CIN,W,6,162,81,74,88,N,,N,N,623,5333,1274,236,35,107,588,1006,154,77,,,710,637,3.9800000000,34,5,29,4323,1365,135,627,934,114,121,0.98,Cincinnati Reds,Riverfront Stadium,1190419,103,104,CIN,CIN,CIN
+1983,NL,HOU,HOU,W,3,162,82,85,77,N,,N,N,643,5502,1412,239,60,97,517,869,164,95,,,646,562,3.4500000000,22,14,48,4398,1276,94,570,904,147,165,0.97,Houston Astros,Astrodome,1351962,93,93,HOU,HOU,HOU
+1983,NL,LAN,LAD,W,1,163,80,91,71,Y,,N,N,654,5440,1358,197,34,146,541,925,166,76,,,609,504,3.1000000000,27,12,40,4392,1336,97,495,1000,168,132,0.97,Los Angeles Dodgers,Dodger Stadium,3510313,99,99,LAD,LAN,LAN
+1983,NL,MON,WSN,E,3,163,81,82,80,N,,N,N,677,5611,1482,297,41,102,509,733,138,44,,,646,585,3.5800000000,38,15,34,4413,1406,120,479,899,116,130,0.98,Montreal Expos,Stade Olympique,2320651,99,99,MON,MON,MON
+1983,NL,NYN,NYM,E,6,162,82,68,94,N,,N,N,575,5444,1314,172,26,112,436,1031,141,64,,,680,593,3.6800000000,18,7,33,4353,1384,97,615,717,151,171,0.97,New York Mets,Shea Stadium,1112774,99,100,NYM,NYN,NYN
+1983,NL,PHI,PHI,E,1,163,82,90,72,Y,,Y,N,696,5426,1352,209,45,125,640,906,143,75,,,635,542,3.3400000000,20,10,41,4383,1429,111,464,1092,152,117,0.97,Philadelphia Phillies,Veterans Stadium,2128339,99,99,PHI,PHI,PHI
+1983,NL,PIT,PIT,E,2,162,81,84,78,N,,N,N,659,5531,1460,238,29,121,497,873,124,77,,,648,577,3.5500000000,25,14,41,4386,1378,109,563,1061,115,165,0.98,Pittsburgh Pirates,Three Rivers Stadium,1225916,103,102,PIT,PIT,PIT
+1983,NL,SDN,SDP,W,4,163,82,81,81,N,,N,N,653,5527,1384,207,34,93,482,822,179,67,,,653,590,3.6200000000,23,5,44,4401,1389,144,528,850,129,135,0.97,San Diego Padres,Jack Murphy Stadium,1539815,97,97,SDP,SDN,SDN
+1983,NL,SFN,SFG,W,5,162,81,79,83,N,,N,N,687,5369,1324,206,30,142,619,990,140,78,,,697,594,3.7000000000,20,9,47,4335,1431,127,520,881,171,109,0.97,San Francisco Giants,Candlestick Park,1251530,97,98,SFG,SFN,SFN
+1983,NL,SLN,STL,E,4,162,81,79,83,N,,N,N,679,5550,1496,262,63,83,543,879,207,89,,,710,615,3.7900000000,22,10,27,4380,1479,115,525,709,152,173,0.97,St. Louis Cardinals,Busch Stadium II,2317914,101,100,STL,SLN,SLN
+1984,AL,BAL,BAL,E,5,162,81,85,77,N,,N,N,681,5456,1374,234,23,160,620,884,51,36,,,667,593,3.7100000000,48,13,32,4317,1393,137,512,714,123,166,0.98,Baltimore Orioles,Memorial Stadium,2045784,98,97,BAL,BAL,BAL
+1984,AL,BOS,BOS,E,4,162,81,86,76,N,,N,N,810,5648,1598,259,45,181,500,842,38,25,,,764,670,4.1800000000,40,12,32,4326,1524,141,517,927,143,128,0.97,Boston Red Sox,Fenway Park II,1661618,105,105,BOS,BOS,BOS
+1984,AL,CAL,ANA,W,2,162,81,81,81,N,,N,N,696,5470,1363,211,30,150,556,928,80,51,,,697,642,3.9600000000,36,12,26,4374,1526,143,474,754,128,170,0.98,California Angels,Anaheim Stadium,2402997,100,100,CAL,CAL,CAL
+1984,AL,CHA,CHW,W,5,162,81,74,88,N,,N,N,679,5513,1360,225,38,172,523,883,109,49,,,736,667,4.1300000000,43,9,32,4362,1416,155,483,840,122,160,0.98,Chicago White Sox,Comiskey Park,2136988,105,104,CHW,CHA,CHA
+1984,AL,CLE,CLE,E,6,163,81,75,87,N,,N,N,761,5643,1498,222,39,123,600,815,126,77,,,766,694,4.2600000000,21,7,35,4401,1523,141,545,803,146,163,0.97,Cleveland Indians,Cleveland Stadium,734079,102,103,CLE,CLE,CLE
+1984,AL,DET,DET,E,1,162,82,104,58,Y,,Y,Y,829,5644,1529,254,46,187,602,941,106,68,,,643,568,3.4900000000,19,8,51,4392,1358,130,489,914,124,162,0.98,Detroit Tigers,Tiger Stadium,2704794,100,98,DET,DET,DET
+1984,AL,KCA,KCR,W,1,162,81,84,78,Y,,N,N,673,5543,1487,269,52,117,400,832,106,64,,,686,629,3.9200000000,18,9,50,4332,1426,136,433,724,129,157,0.98,Kansas City Royals,Royals Stadium,1810018,100,101,KCR,KCA,KCA
+1984,AL,MIN,MIN,W,2,162,81,81,81,N,,N,N,673,5562,1473,259,33,114,437,735,39,30,,,675,615,3.8500000000,32,9,38,4311,1429,159,463,713,120,134,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1598692,104,105,MIN,MIN,MIN
+1984,AL,ML4,MIL,E,7,161,81,67,94,N,,N,N,641,5511,1446,232,36,96,432,673,52,57,,,734,646,4.0600000000,13,7,41,4299,1532,137,480,785,136,156,0.97,Milwaukee Brewers,County Stadium,1608509,96,97,MIL,MIL,MIL
+1984,AL,NYA,NYY,E,3,162,81,87,75,N,,N,N,758,5661,1560,275,32,130,534,673,62,38,,,679,615,3.7800000000,15,12,43,4395,1485,120,518,992,142,177,0.97,New York Yankees,Yankee Stadium II,1821815,96,95,NYY,NYA,NYA
+1984,AL,OAK,OAK,W,4,162,81,77,85,N,,N,N,738,5457,1415,257,29,158,568,871,145,64,,,796,712,4.4800000000,15,6,44,4290,1554,155,592,695,146,159,0.97,Oakland Athletics,Oakland Coliseum,1353281,93,93,OAK,OAK,OAK
+1984,AL,SEA,SEA,W,5,162,81,74,88,N,,N,N,682,5546,1429,244,34,129,519,871,116,62,,,774,691,4.3100000000,26,4,35,4326,1497,138,619,972,126,143,0.97,Seattle Mariners,Kingdome,870372,98,100,SEA,SEA,SEA
+1984,AL,TEX,TEX,W,7,161,80,69,92,N,,N,N,656,5569,1452,227,29,120,420,807,81,50,,,714,625,3.9100000000,38,6,21,4314,1443,148,518,863,138,138,0.97,Texas Rangers,Arlington Stadium,1102471,103,104,TEX,TEX,TEX
+1984,AL,TOR,TOR,E,2,163,81,89,73,N,,N,N,750,5687,1555,275,68,143,460,816,193,67,,,696,628,3.8600000000,34,10,33,4392,1433,140,528,875,123,166,0.98,Toronto Blue Jays,Exhibition Stadium,2110009,104,103,TOR,TOR,TOR
+1984,NL,ATL,ATL,W,2,162,81,80,82,N,,N,N,632,5422,1338,234,27,111,555,896,140,85,,,655,574,3.5700000000,17,7,49,4341,1401,122,525,859,139,153,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1724892,107,107,ATL,ATL,ATL
+1984,NL,CHN,CHC,E,1,161,80,96,65,Y,,N,N,762,5437,1415,240,47,136,567,967,154,66,,,658,598,3.7500000000,19,8,50,4302,1458,99,442,879,121,137,0.98,Chicago Cubs,Wrigley Field,2107655,108,108,CHC,CHN,CHN
+1984,NL,CIN,CIN,W,5,162,81,70,92,N,,N,N,627,5498,1342,238,30,106,566,978,160,63,,,747,675,4.1600000000,25,6,25,4383,1445,128,578,946,139,116,0.97,Cincinnati Reds,Riverfront Stadium,1275887,104,105,CIN,CIN,CIN
+1984,NL,HOU,HOU,W,2,162,81,80,82,N,,N,N,693,5548,1465,222,67,79,494,837,105,61,,,630,535,3.3200000000,24,13,29,4347,1350,91,502,950,133,160,0.97,Houston Astros,Astrodome,1229862,92,92,HOU,HOU,HOU
+1984,NL,LAN,LAD,W,4,162,81,79,83,N,,N,N,580,5399,1316,213,23,102,488,829,109,69,,,600,514,3.1700000000,39,16,27,4380,1381,76,499,1033,163,146,0.97,Los Angeles Dodgers,Dodger Stadium,3134824,98,98,LAD,LAN,LAN
+1984,NL,MON,WSN,E,5,161,81,78,83,N,,N,N,593,5439,1367,242,36,96,470,782,131,38,,,585,526,3.3100000000,19,10,48,4293,1333,114,474,861,132,147,0.97,Montreal Expos,Stade Olympique,1606531,96,96,MON,MON,MON
+1984,NL,NYN,NYM,E,2,162,81,90,72,N,,N,N,652,5438,1400,235,25,107,500,1001,149,54,,,676,577,3.6000000000,12,15,50,4326,1371,104,573,1028,129,154,0.97,New York Mets,Shea Stadium,1842695,99,99,NYM,NYN,NYN
+1984,NL,PHI,PHI,E,4,162,81,81,81,N,,N,N,720,5614,1494,248,51,147,555,1084,186,60,,,690,586,3.6200000000,11,6,35,4374,1416,101,448,904,161,112,0.97,Philadelphia Phillies,Veterans Stadium,2062693,102,101,PHI,PHI,PHI
+1984,NL,PIT,PIT,E,6,162,81,75,87,N,,N,N,615,5537,1412,237,33,98,438,841,96,62,,,567,508,3.1100000000,27,13,34,4410,1344,102,502,995,128,142,0.98,Pittsburgh Pirates,Three Rivers Stadium,773500,101,101,PIT,PIT,PIT
+1984,NL,SDN,SDP,W,1,162,81,92,70,Y,,Y,N,686,5504,1425,207,42,109,472,810,152,68,,,634,565,3.4800000000,13,17,44,4380,1327,122,563,812,138,144,0.97,San Diego Padres,Jack Murphy Stadium,1983904,100,100,SDP,SDN,SDN
+1984,NL,SFN,SFG,W,6,162,81,66,96,N,,N,N,682,5650,1499,229,26,112,528,980,126,76,,,807,713,4.3900000000,9,7,38,4383,1589,125,549,854,169,134,0.97,San Francisco Giants,Candlestick Park,1001545,97,98,SFG,SFN,SFN
+1984,NL,SLN,STL,E,3,162,81,84,78,N,,N,N,652,5433,1369,225,44,75,516,924,220,71,,,645,576,3.5800000000,19,12,51,4347,1427,94,494,808,118,184,0.98,St. Louis Cardinals,Busch Stadium II,2037448,98,98,STL,SLN,SLN
+1985,AL,BAL,BAL,E,4,161,81,83,78,N,,N,N,818,5517,1451,234,22,214,604,908,69,43,,,764,694,4.3800000000,32,6,33,4281,1480,160,568,793,115,168,0.98,Baltimore Orioles,Memorial Stadium,2132387,97,97,BAL,BAL,BAL
+1985,AL,BOS,BOS,E,5,163,81,81,81,N,,N,N,800,5720,1615,292,31,162,562,816,66,27,,,720,659,4.0600000000,35,8,29,4383,1487,130,540,913,145,161,0.97,Boston Red Sox,Fenway Park II,1786633,104,104,BOS,BOS,BOS
+1985,AL,CAL,ANA,W,2,162,79,90,72,N,,N,N,732,5442,1364,215,31,153,648,902,106,51,,,703,633,3.9100000000,22,8,41,4371,1453,171,514,767,112,202,0.98,California Angels,Anaheim Stadium,2567427,100,100,CAL,CAL,CAL
+1985,AL,CHA,CHW,W,3,163,81,85,77,N,,N,N,736,5470,1386,247,37,146,471,843,108,56,,,720,656,4.0700000000,20,8,39,4353,1411,161,569,1023,111,152,0.98,Chicago White Sox,Comiskey Park,1669888,104,104,CHW,CHA,CHA
+1985,AL,CLE,CLE,E,7,162,81,60,102,N,,N,N,729,5527,1465,254,31,116,492,817,132,72,,,861,775,4.9100000000,24,7,28,4263,1556,170,547,702,141,161,0.97,Cleveland Indians,Cleveland Stadium,655181,99,100,CLE,CLE,CLE
+1985,AL,DET,DET,E,3,161,81,84,77,N,,N,N,729,5575,1413,254,45,202,526,926,75,41,,,688,612,3.7800000000,31,11,40,4368,1313,141,556,943,141,152,0.97,Detroit Tigers,Tiger Stadium,2286609,100,98,DET,DET,DET
+1985,AL,KCA,KCR,W,1,162,82,91,71,Y,,Y,Y,687,5500,1384,261,49,154,473,840,128,48,,,639,567,3.4900000000,27,11,41,4383,1433,103,463,846,127,160,0.98,Kansas City Royals,Royals Stadium,2162717,100,100,KCR,KCA,KCA
+1985,AL,MIN,MIN,W,4,162,84,77,85,N,,N,N,705,5509,1453,282,41,141,502,779,68,44,,,782,710,4.4800000000,41,7,34,4278,1468,164,462,767,120,139,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1651814,105,105,MIN,MIN,MIN
+1985,AL,ML4,MIL,E,6,161,80,71,90,N,,N,N,690,5568,1467,250,44,101,462,746,69,34,,,802,701,4.3900000000,34,5,37,4311,1510,175,499,777,142,153,0.97,Milwaukee Brewers,County Stadium,1360265,100,101,MIL,MIL,MIL
+1985,AL,NYA,NYY,E,2,161,80,97,64,N,,N,N,839,5458,1458,272,31,176,620,771,155,53,,,660,590,3.6900000000,25,9,49,4320,1373,157,518,907,123,172,0.97,New York Yankees,Yankee Stadium II,2214587,98,97,NYY,NYA,NYA
+1985,AL,OAK,OAK,W,4,162,79,77,85,N,,N,N,757,5581,1475,230,34,155,508,861,117,58,,,787,712,4.4100000000,10,6,41,4359,1451,172,607,785,140,137,0.97,Oakland Athletics,Oakland Coliseum,1334599,92,92,OAK,OAK,OAK
+1985,AL,SEA,SEA,W,6,162,83,74,88,N,,N,N,719,5521,1410,277,38,171,564,942,94,35,,,818,745,4.6800000000,23,8,30,4296,1456,154,637,868,122,156,0.98,Seattle Mariners,Kingdome,1128696,100,101,SEA,SEA,SEA
+1985,AL,TEX,TEX,W,7,161,80,62,99,N,,N,N,617,5361,1359,213,41,129,530,819,130,76,,,785,715,4.5600000000,18,5,33,4233,1479,173,501,863,119,145,0.98,Texas Rangers,Arlington Stadium,1112497,101,102,TEX,TEX,TEX
+1985,AL,TOR,TOR,E,1,161,80,99,62,Y,,N,N,759,5508,1482,281,53,158,503,807,144,77,,,588,533,3.3100000000,18,9,47,4344,1312,147,484,823,125,164,0.98,Toronto Blue Jays,Exhibition Stadium,2468925,104,103,TOR,TOR,TOR
+1985,NL,ATL,ATL,W,5,162,81,66,96,N,,N,N,632,5526,1359,213,28,126,553,849,72,52,,,781,678,4.1900000000,9,9,29,4371,1512,134,642,776,159,197,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1350137,105,106,ATL,ATL,ATL
+1985,NL,CHN,CHC,E,4,162,81,77,84,N,,N,N,686,5492,1397,239,28,150,562,937,182,49,,,729,667,4.1600000000,20,8,42,4326,1492,156,519,820,134,150,0.97,Chicago Cubs,Wrigley Field,2161534,110,110,CHC,CHN,CHN
+1985,NL,CIN,CIN,W,2,162,81,89,72,N,,N,N,677,5431,1385,249,34,114,576,856,159,70,,,666,598,3.7100000000,24,11,45,4353,1347,131,535,910,121,142,0.98,Cincinnati Reds,Riverfront Stadium,1834619,104,105,CIN,CIN,CIN
+1985,NL,HOU,HOU,W,3,162,81,83,79,N,,N,N,706,5582,1457,261,42,121,477,873,96,56,,,691,593,3.6600000000,17,9,42,4374,1393,119,543,909,152,159,0.97,Houston Astros,Astrodome,1184314,97,96,HOU,HOU,HOU
+1985,NL,LAN,LAD,W,1,162,81,95,67,Y,,N,N,682,5502,1434,226,28,129,539,846,136,58,,,579,482,2.9600000000,37,21,36,4395,1280,102,462,979,166,131,0.97,Los Angeles Dodgers,Dodger Stadium,3264593,97,96,LAD,LAN,LAN
+1985,NL,MON,WSN,E,3,161,81,84,77,N,,N,N,633,5429,1342,242,49,118,492,880,169,77,,,636,575,3.5500000000,13,13,53,4371,1346,99,509,870,121,152,0.98,Montreal Expos,Stade Olympique,1502494,95,95,MON,MON,MON
+1985,NL,NYN,NYM,E,2,162,81,98,64,N,,N,N,695,5549,1425,239,35,134,546,872,117,53,,,568,514,3.1100000000,32,19,37,4464,1306,111,515,1039,115,138,0.98,New York Mets,Shea Stadium,2761601,99,97,NYM,NYN,NYN
+1985,NL,PHI,PHI,E,5,162,81,75,87,N,,N,N,667,5477,1343,238,47,141,527,1095,122,51,,,673,592,3.6800000000,24,9,30,4341,1424,115,596,899,139,142,0.97,Philadelphia Phillies,Veterans Stadium,1830350,103,103,PHI,PHI,PHI
+1985,NL,PIT,PIT,E,6,161,80,57,104,N,,N,N,568,5436,1340,251,28,80,514,842,110,60,,,708,637,3.9700000000,15,6,29,4335,1406,107,584,962,133,127,0.97,Pittsburgh Pirates,Three Rivers Stadium,735900,99,100,PIT,PIT,PIT
+1985,NL,SDN,SDP,W,3,162,81,83,79,N,,N,N,650,5507,1405,241,28,109,513,809,60,39,,,622,548,3.4000000000,26,19,44,4353,1399,127,443,727,124,158,0.98,San Diego Padres,Jack Murphy Stadium,2210352,99,99,SDP,SDN,SDN
+1985,NL,SFN,SFG,W,6,162,81,62,100,N,,N,N,556,5420,1263,217,31,115,488,962,99,55,,,674,581,3.6100000000,13,5,24,4344,1348,125,572,985,144,134,0.97,San Francisco Giants,Candlestick Park,818697,95,96,SFG,SFN,SFN
+1985,NL,SLN,STL,E,1,162,81,101,61,Y,,Y,N,747,5467,1446,245,59,87,586,853,314,96,,,572,504,3.1000000000,37,20,44,4392,1343,98,453,798,108,166,0.98,St. Louis Cardinals,Busch Stadium II,2637563,100,99,STL,SLN,SLN
+1986,AL,BAL,BAL,E,7,162,79,73,89,N,,N,N,708,5524,1425,223,13,169,563,862,64,34,,,760,686,4.3000000000,17,6,39,4308,1451,177,535,954,135,163,0.97,Baltimore Orioles,Memorial Stadium,1973176,98,99,BAL,BAL,BAL
+1986,AL,BOS,BOS,E,1,161,81,95,66,Y,,Y,N,794,5498,1488,320,21,144,595,707,41,34,,,696,624,3.9300000000,36,6,41,4287,1469,167,474,1033,129,146,0.97,Boston Red Sox,Fenway Park II,2147641,101,100,BOS,BOS,BOS
+1986,AL,CAL,ANA,W,1,162,82,92,70,Y,,N,N,786,5433,1387,236,36,167,671,860,109,42,,,684,621,3.8400000000,29,12,40,4368,1356,153,478,955,107,156,0.98,California Angels,Anaheim Stadium,2655872,99,99,CAL,CAL,CAL
+1986,AL,CHA,CHW,W,5,162,81,72,90,N,,N,N,644,5406,1335,197,34,121,487,940,115,54,,,699,630,3.9300000000,18,8,38,4326,1361,143,561,895,117,142,0.98,Chicago White Sox,Comiskey Park,1424313,104,104,CHW,CHA,CHA
+1986,AL,CLE,CLE,E,5,163,81,84,78,N,,N,N,831,5702,1620,270,45,157,456,944,141,54,,,841,736,4.5800000000,31,7,34,4341,1548,167,605,744,156,148,0.97,Cleveland Indians,Cleveland Stadium,1471805,98,99,CLE,CLE,CLE
+1986,AL,DET,DET,E,3,162,81,87,75,N,,N,N,798,5512,1447,234,30,198,613,885,138,58,,,714,645,4.0200000000,33,12,38,4329,1374,183,571,880,108,163,0.98,Detroit Tigers,Tiger Stadium,1899437,100,99,DET,DET,DET
+1986,AL,KCA,KCR,W,3,162,81,76,86,N,,N,N,654,5561,1403,264,45,137,474,919,97,46,,,673,611,3.8200000000,24,13,31,4320,1413,121,479,888,123,153,0.98,Kansas City Royals,Royals Stadium,2320794,102,101,KCR,KCA,KCA
+1986,AL,MIN,MIN,W,6,162,81,71,91,N,,N,N,741,5531,1446,257,39,196,501,977,81,61,,,839,759,4.7700000000,39,6,24,4296,1579,200,503,937,118,168,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1255453,102,102,MIN,MIN,MIN
+1986,AL,ML4,MIL,E,6,161,80,77,84,N,,N,N,667,5461,1393,255,38,127,530,986,100,50,,,734,638,4.0100000000,29,12,32,4293,1478,158,494,952,146,146,0.97,Milwaukee Brewers,County Stadium,1265041,103,104,MIL,MIL,MIL
+1986,AL,NYA,NYY,E,2,162,80,90,72,N,,N,N,797,5570,1512,275,23,188,645,911,139,48,,,738,659,4.1100000000,13,8,58,4329,1461,175,492,878,127,153,0.97,New York Yankees,Yankee Stadium II,2268030,99,98,NYY,NYA,NYA
+1986,AL,OAK,OAK,W,3,162,83,76,86,N,,N,N,731,5435,1370,213,25,163,553,983,139,61,,,760,686,4.3100000000,22,8,37,4299,1334,166,667,937,135,120,0.97,Oakland Athletics,Oakland Coliseum,1314646,92,92,OAK,OAK,OAK
+1986,AL,SEA,SEA,W,7,162,82,67,95,N,,N,N,718,5498,1392,243,41,158,572,1148,93,76,,,835,743,4.6500000000,33,5,27,4317,1590,171,585,944,156,191,0.97,Seattle Mariners,Kingdome,1029045,100,101,SEA,SEA,SEA
+1986,AL,TEX,TEX,W,2,162,81,87,75,N,,N,N,771,5529,1479,248,43,184,511,1088,103,85,,,743,662,4.1100000000,15,8,41,4350,1356,145,736,1059,120,160,0.98,Texas Rangers,Arlington Stadium,1692002,102,103,TEX,TEX,TEX
+1986,AL,TOR,TOR,E,4,163,81,86,76,N,,N,N,809,5716,1540,285,35,181,496,848,110,59,,,733,669,4.0800000000,16,12,44,4428,1467,164,487,1002,100,150,0.98,Toronto Blue Jays,Exhibition Stadium,2455477,103,102,TOR,TOR,TOR
+1986,NL,ATL,ATL,W,6,161,81,72,89,N,,N,N,615,5384,1348,241,24,138,538,904,93,76,,,719,628,3.9700000000,17,5,39,4272,1443,117,576,932,141,181,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,1387181,105,106,ATL,ATL,ATL
+1986,NL,CHN,CHC,E,5,160,80,70,90,N,,N,N,680,5499,1409,258,27,155,508,966,132,62,,,781,721,4.4900000000,11,6,42,4335,1546,143,557,962,124,147,0.98,Chicago Cubs,Wrigley Field,1859102,107,108,CHC,CHN,CHN
+1986,NL,CIN,CIN,W,2,162,81,86,76,N,,N,N,732,5536,1404,237,35,144,586,920,177,53,,,717,638,3.9100000000,14,8,45,4404,1465,136,524,924,140,160,0.97,Cincinnati Reds,Riverfront Stadium,1692432,104,104,CIN,CIN,CIN
+1986,NL,HOU,HOU,W,1,162,81,96,66,Y,,N,N,654,5441,1388,244,32,125,536,916,163,75,,,569,510,3.1500000000,18,19,51,4368,1203,116,523,1160,130,108,0.97,Houston Astros,Astrodome,1734276,97,96,HOU,HOU,HOU
+1986,NL,LAN,LAD,W,5,162,81,73,89,N,,N,N,638,5471,1373,232,14,130,478,966,155,67,,,679,607,3.7600000000,35,14,25,4362,1428,115,499,1051,179,118,0.97,Los Angeles Dodgers,Dodger Stadium,3023208,93,93,LAD,LAN,LAN
+1986,NL,MON,WSN,E,4,161,80,78,83,N,,N,N,637,5508,1401,255,50,110,537,1016,193,95,,,688,616,3.7800000000,15,9,50,4398,1350,119,566,1051,133,132,0.97,Montreal Expos,Stade Olympique,1128981,100,100,MON,MON,MON
+1986,NL,NYN,NYM,E,1,162,81,108,54,Y,,Y,Y,783,5558,1462,261,31,148,631,968,118,48,,,578,513,3.1100000000,27,11,46,4452,1304,103,509,1083,138,145,0.97,New York Mets,Shea Stadium,2767601,98,96,NYM,NYN,NYN
+1986,NL,PHI,PHI,E,2,161,80,86,75,N,,N,N,739,5483,1386,266,39,154,589,1154,153,59,,,713,621,3.8500000000,22,11,39,4353,1473,130,553,874,137,157,0.97,Philadelphia Phillies,Veterans Stadium,1933335,104,104,PHI,PHI,PHI
+1986,NL,PIT,PIT,E,6,162,81,64,98,N,,N,N,663,5456,1366,273,33,111,569,929,152,84,,,700,628,3.9000000000,17,9,30,4350,1397,138,570,924,142,134,0.97,Pittsburgh Pirates,Three Rivers Stadium,1000917,102,103,PIT,PIT,PIT
+1986,NL,SDN,SDP,W,4,162,81,74,88,N,,N,N,656,5515,1442,239,25,136,484,917,96,68,,,723,640,3.9900000000,13,7,32,4329,1406,150,607,934,135,135,0.97,San Diego Padres,Jack Murphy Stadium,1805716,98,98,SDP,SDN,SDN
+1986,NL,SFN,SFG,W,3,162,81,83,79,N,,N,N,698,5501,1394,269,29,114,536,1087,148,93,,,618,540,3.3300000000,18,10,35,4380,1264,121,591,992,143,149,0.97,San Francisco Giants,Candlestick Park,1528748,95,95,SFG,SFN,SFN
+1986,NL,SLN,STL,E,3,161,81,79,82,N,,N,N,601,5378,1270,216,48,58,568,905,262,78,,,611,549,3.3700000000,17,4,46,4398,1364,135,485,761,123,178,0.98,St. Louis Cardinals,Busch Stadium II,2471974,100,99,STL,SLN,SLN
+1987,AL,BAL,BAL,E,6,162,82,67,95,N,,N,N,729,5576,1437,219,20,211,524,939,69,45,,,880,801,5.0100000000,17,6,30,4317,1555,226,547,870,109,174,0.98,Baltimore Orioles,Memorial Stadium,1835692,97,98,BAL,BAL,BAL
+1987,AL,BOS,BOS,E,5,162,80,78,84,N,,N,N,842,5586,1554,273,26,174,606,825,77,45,,,825,761,4.7700000000,47,13,16,4308,1584,190,517,1034,110,158,0.98,Boston Red Sox,Fenway Park II,2231551,103,102,BOS,BOS,BOS
+1987,AL,CAL,ANA,W,6,162,81,75,87,N,,N,N,770,5570,1406,257,26,172,590,926,125,44,,,803,709,4.3800000000,20,7,36,4371,1481,212,504,941,117,162,0.98,California Angels,Anaheim Stadium,2696299,97,97,CAL,CAL,CAL
+1987,AL,CHA,CHW,W,5,162,81,77,85,N,,N,N,748,5538,1427,283,36,173,487,971,138,52,,,746,691,4.3000000000,29,12,37,4341,1436,189,537,792,115,174,0.98,Chicago White Sox,Comiskey Park,1208060,103,103,CHW,CHA,CHA
+1987,AL,CLE,CLE,E,7,162,81,61,101,N,,N,N,742,5606,1476,267,30,187,489,977,140,54,,,957,834,5.2800000000,24,8,25,4266,1566,219,606,849,152,128,0.97,Cleveland Indians,Cleveland Stadium,1077898,100,101,CLE,CLE,CLE
+1987,AL,DET,DET,E,1,162,81,98,64,Y,,N,N,896,5649,1535,274,32,225,653,913,106,50,,,735,650,4.0200000000,33,10,31,4368,1430,180,563,976,122,147,0.98,Detroit Tigers,Tiger Stadium,2061830,96,95,DET,DET,DET
+1987,AL,KCA,KCR,W,2,162,81,83,79,N,,N,N,715,5499,1443,239,40,168,523,1034,125,43,,,691,611,3.8600000000,44,11,26,4272,1424,128,548,923,131,151,0.97,Kansas City Royals,Royals Stadium,2392471,102,102,KCR,KCA,KCA
+1987,AL,MIN,MIN,W,1,162,81,85,77,Y,,Y,Y,786,5441,1422,258,35,196,523,898,113,65,,,806,734,4.6300000000,16,4,39,4281,1465,210,564,990,98,147,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2081976,103,103,MIN,MIN,MIN
+1987,AL,ML4,MIL,E,3,162,81,91,71,N,,N,N,862,5625,1552,272,46,163,598,1040,176,74,,,817,752,4.6200000000,28,6,45,4392,1548,169,529,1039,145,155,0.97,Milwaukee Brewers,County Stadium,1909244,103,103,MIL,MIL,MIL
+1987,AL,NYA,NYY,E,4,162,81,89,73,N,,N,N,788,5511,1445,239,16,196,604,949,105,43,,,758,701,4.3600000000,19,10,47,4338,1475,179,542,900,102,155,0.98,New York Yankees,Yankee Stadium II,2427672,99,99,NYY,NYA,NYA
+1987,AL,OAK,OAK,W,3,162,81,81,81,N,,N,N,806,5511,1432,263,33,199,593,1056,140,63,,,789,694,4.3200000000,18,6,40,4335,1442,176,531,1042,142,122,0.97,Oakland Athletics,Oakland Coliseum,1678921,93,93,OAK,OAK,OAK
+1987,AL,SEA,SEA,W,4,162,81,78,84,N,,N,N,760,5508,1499,282,48,161,500,863,174,73,,,801,713,4.4900000000,39,10,33,4290,1503,199,497,919,121,150,0.98,Seattle Mariners,Kingdome,1134255,105,106,SEA,SEA,SEA
+1987,AL,TEX,TEX,W,6,162,81,75,87,N,,N,N,823,5564,1478,264,35,194,567,1081,120,71,,,849,743,4.6300000000,20,3,27,4332,1388,199,760,1103,148,148,0.97,Texas Rangers,Arlington Stadium,1763053,100,101,TEX,TEX,TEX
+1987,AL,TOR,TOR,E,2,162,81,96,66,N,,N,N,845,5635,1514,277,38,215,555,970,126,50,,,655,604,3.7400000000,18,8,43,4362,1323,158,567,1064,111,148,0.98,Toronto Blue Jays,Exhibition Stadium,2778429,102,101,TOR,TOR,TOR
+1987,NL,ATL,ATL,W,5,161,81,69,92,N,,N,N,747,5428,1401,284,24,152,641,834,135,68,,,829,734,4.6300000000,16,4,32,4281,1529,163,587,837,116,170,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,1217402,104,106,ATL,ATL,ATL
+1987,NL,CHN,CHC,E,6,161,80,76,85,N,,N,N,720,5583,1475,244,33,209,504,1064,109,48,,,801,725,4.5500000000,11,5,48,4302,1524,159,628,1024,130,154,0.97,Chicago Cubs,Wrigley Field,2035130,103,104,CHC,CHN,CHN
+1987,NL,CIN,CIN,W,2,162,81,84,78,N,,N,N,783,5560,1478,262,29,192,514,928,169,46,,,752,684,4.2400000000,7,6,44,4356,1486,170,485,919,128,137,0.97,Cincinnati Reds,Riverfront Stadium,2185205,104,103,CIN,CIN,CIN
+1987,NL,HOU,HOU,W,3,162,81,76,86,N,,N,N,648,5485,1386,238,28,122,526,936,162,46,,,678,615,3.8400000000,13,13,33,4323,1363,141,525,1137,115,113,0.98,Houston Astros,Astrodome,1909902,96,96,HOU,HOU,HOU
+1987,NL,LAN,LAD,W,4,162,81,73,89,N,,N,N,635,5517,1389,236,23,125,445,923,128,59,,,675,601,3.7200000000,29,8,32,4365,1415,130,565,1097,155,144,0.97,Los Angeles Dodgers,Dodger Stadium,2797409,98,98,LAD,LAN,LAN
+1987,NL,MON,WSN,E,3,162,81,91,71,N,,N,N,741,5527,1467,310,39,120,501,918,166,74,,,720,632,3.9200000000,16,8,50,4350,1428,145,446,1012,147,122,0.97,Montreal Expos,Stade Olympique,1850324,103,103,MON,MON,MON
+1987,NL,NYN,NYM,E,2,162,81,92,70,N,,N,N,823,5601,1499,287,34,192,592,1012,159,49,,,698,620,3.8400000000,16,7,51,4362,1407,135,510,1032,137,137,0.97,New York Mets,Shea Stadium,3034129,95,93,NYM,NYN,NYN
+1987,NL,PHI,PHI,E,4,162,81,80,82,N,,N,N,702,5475,1390,248,51,169,587,1109,111,49,,,749,673,4.1800000000,13,7,48,4344,1453,167,587,877,121,137,0.98,Philadelphia Phillies,Veterans Stadium,2100110,103,104,PHI,PHI,PHI
+1987,NL,PIT,PIT,E,4,162,81,80,82,N,,N,N,723,5536,1464,282,45,131,535,914,140,58,,,744,674,4.2000000000,25,13,39,4335,1377,164,562,914,123,147,0.98,Pittsburgh Pirates,Three Rivers Stadium,1161193,100,100,PIT,PIT,PIT
+1987,NL,SDN,SDP,W,6,162,81,65,97,N,,N,N,668,5456,1419,209,48,113,577,992,198,91,,,763,680,4.2700000000,14,10,33,4299,1402,175,602,897,146,135,0.97,San Diego Padres,Jack Murphy Stadium,1454061,96,97,SDP,SDN,SDN
+1987,NL,SFN,SFG,W,1,162,81,90,72,Y,,N,N,783,5608,1458,274,32,205,511,1094,126,97,,,669,601,3.6800000000,19,10,38,4413,1407,146,547,1038,129,183,0.98,San Francisco Giants,Candlestick Park,1917168,96,95,SFG,SFN,SFN
+1987,NL,SLN,STL,E,1,162,81,95,67,Y,,Y,N,798,5500,1449,252,49,94,644,933,248,72,,,693,637,3.9100000000,10,7,48,4398,1484,129,533,873,116,172,0.98,St. Louis Cardinals,Busch Stadium II,3072122,102,102,STL,SLN,SLN
+1988,AL,BAL,BAL,E,7,161,80,54,107,N,,N,N,550,5358,1275,199,20,137,504,869,69,44,,,789,714,4.5400000000,20,7,26,4248,1506,153,523,709,118,172,0.98,Baltimore Orioles,Memorial Stadium,1660738,97,98,BAL,BAL,BAL
+1988,AL,BOS,BOS,E,1,162,81,89,73,Y,,N,N,813,5545,1569,310,39,124,623,728,65,36,,,689,629,3.9700000000,26,14,37,4278,1415,143,493,1085,93,123,0.98,Boston Red Sox,Fenway Park II,2464851,105,104,BOS,BOS,BOS
+1988,AL,CAL,ANA,W,4,162,81,75,87,N,,N,N,714,5582,1458,258,31,124,469,819,86,52,,,771,698,4.3200000000,26,9,33,4365,1503,135,568,817,135,175,0.97,California Angels,Anaheim Stadium,2340925,97,97,CAL,CAL,CAL
+1988,AL,CHA,CHW,W,5,161,81,71,90,N,,N,N,631,5449,1327,224,35,132,446,908,98,46,,,757,659,4.1200000000,11,9,43,4317,1467,138,533,754,154,177,0.97,Chicago White Sox,Comiskey Park,1115749,100,100,CHW,CHA,CHA
+1988,AL,CLE,CLE,E,6,162,81,78,84,N,,N,N,666,5505,1435,235,28,134,416,866,97,50,,,731,663,4.1600000000,35,10,46,4302,1501,120,442,812,124,131,0.98,Cleveland Indians,Cleveland Stadium,1411610,102,103,CLE,CLE,CLE
+1988,AL,DET,DET,E,2,162,81,88,74,N,,N,N,703,5433,1358,213,28,143,588,841,87,42,,,658,596,3.7100000000,34,8,36,4335,1361,150,497,890,109,129,0.98,Detroit Tigers,Tiger Stadium,2081162,97,97,DET,DET,DET
+1988,AL,KCA,KCR,W,3,161,80,84,77,N,,N,N,704,5469,1419,275,40,121,486,944,137,54,,,648,579,3.6500000000,29,12,32,4284,1415,102,465,886,124,147,0.98,Kansas City Royals,Royals Stadium,2350181,101,101,KCR,KCA,KCA
+1988,AL,MIN,MIN,W,2,162,81,91,71,N,,N,N,759,5510,1508,294,31,151,528,832,107,63,,,672,625,3.9300000000,18,9,52,4293,1457,146,453,897,83,155,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,3030672,103,102,MIN,MIN,MIN
+1988,AL,ML4,MIL,E,3,162,81,87,75,N,,N,N,682,5488,1409,258,26,113,439,911,159,55,,,616,555,3.4500000000,30,8,51,4347,1355,125,437,832,120,146,0.98,Milwaukee Brewers,County Stadium,1923238,101,100,MIL,MIL,MIL
+1988,AL,NYA,NYY,E,5,161,80,85,76,N,,N,N,772,5592,1469,272,12,148,588,935,146,39,,,748,689,4.2600000000,16,5,43,4368,1512,157,487,861,134,161,0.97,New York Yankees,Yankee Stadium II,2633701,99,100,NYY,NYA,NYA
+1988,AL,OAK,OAK,W,1,162,81,104,58,Y,,Y,N,800,5602,1474,251,22,156,580,926,129,54,,,620,569,3.4400000000,22,9,64,4467,1376,116,553,983,105,151,0.98,Oakland Athletics,Oakland Coliseum,2287335,97,96,OAK,OAK,OAK
+1988,AL,SEA,SEA,W,7,161,81,68,93,N,,N,N,664,5436,1397,271,27,148,461,787,95,61,,,744,658,4.1500000000,28,11,28,4284,1385,144,558,981,123,168,0.98,Seattle Mariners,Kingdome,1022398,104,105,SEA,SEA,SEA
+1988,AL,TEX,TEX,W,6,161,81,70,91,N,,N,N,637,5479,1378,227,39,112,542,1022,130,57,,,735,647,4.0500000000,41,11,31,4314,1310,129,654,912,129,145,0.97,Texas Rangers,Arlington Stadium,1581901,102,103,TEX,TEX,TEX
+1988,AL,TOR,TOR,E,3,162,81,87,75,N,,N,N,763,5557,1491,271,47,158,521,935,107,36,,,680,612,3.8000000000,16,17,47,4347,1404,143,528,904,110,170,0.98,Toronto Blue Jays,Exhibition Stadium,2595175,100,99,TOR,TOR,TOR
+1988,NL,ATL,ATL,W,6,160,79,54,106,N,,N,N,555,5440,1319,228,28,96,432,848,95,69,,,741,657,4.0900000000,14,4,25,4338,1481,108,524,810,151,138,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,848089,104,106,ATL,ATL,ATL
+1988,NL,CHN,CHC,E,4,163,82,77,85,N,,N,N,660,5675,1481,262,46,113,403,910,120,46,,,694,625,3.8400000000,30,10,29,4392,1494,115,490,897,125,128,0.98,Chicago Cubs,Wrigley Field,2089034,105,105,CHC,CHN,CHN
+1988,NL,CIN,CIN,W,2,161,80,87,74,N,,N,N,641,5426,1334,246,25,122,479,922,207,56,,,596,542,3.3500000000,24,13,43,4365,1271,121,504,934,121,131,0.98,Cincinnati Reds,Riverfront Stadium,2072528,104,104,CIN,CIN,CIN
+1988,NL,HOU,HOU,W,5,162,81,82,80,N,,N,N,617,5494,1338,239,31,96,474,840,198,71,,,631,558,3.4100000000,21,15,40,4422,1339,123,478,1049,138,124,0.97,Houston Astros,Astrodome,1933505,96,96,HOU,HOU,HOU
+1988,NL,LAN,LAD,W,1,162,81,94,67,Y,,Y,Y,628,5431,1346,217,25,99,437,947,131,46,,,544,481,2.9600000000,32,24,49,4389,1291,84,473,1029,142,126,0.97,Los Angeles Dodgers,Dodger Stadium,2980262,98,97,LAD,LAN,LAN
+1988,NL,MON,WSN,E,3,163,81,81,81,N,,N,N,628,5573,1400,260,48,107,454,1053,189,89,,,592,507,3.0800000000,18,12,43,4446,1310,122,476,923,142,145,0.97,Montreal Expos,Stade Olympique,1478659,104,104,MON,MON,MON
+1988,NL,NYN,NYM,E,1,160,80,100,60,Y,,N,N,703,5408,1387,251,24,152,544,842,140,51,,,532,465,2.9100000000,31,22,46,4317,1253,78,404,1100,115,127,0.98,New York Mets,Shea Stadium,3055445,95,94,NYM,NYN,NYN
+1988,NL,PHI,PHI,E,6,162,81,65,96,N,,N,N,597,5403,1294,246,31,106,489,981,112,49,,,734,659,4.1400000000,16,6,36,4299,1447,118,628,859,145,139,0.97,Philadelphia Phillies,Veterans Stadium,1990041,101,103,PHI,PHI,PHI
+1988,NL,PIT,PIT,E,2,160,81,85,75,N,,N,N,651,5379,1327,240,45,110,553,947,119,60,,,616,555,3.4700000000,12,11,46,4320,1349,108,469,790,124,128,0.98,Pittsburgh Pirates,Three Rivers Stadium,1866713,98,98,PIT,PIT,PIT
+1988,NL,SDN,SDP,W,3,161,81,83,78,N,,N,N,594,5366,1325,205,35,94,494,892,123,50,,,583,528,3.2800000000,30,9,39,4347,1332,112,439,885,116,147,0.98,San Diego Padres,Jack Murphy Stadium,1506896,99,99,SDP,SDN,SDN
+1988,NL,SFN,SFG,W,4,162,81,83,79,N,,N,N,670,5450,1353,227,44,113,550,1023,121,78,,,626,551,3.3900000000,25,13,42,4386,1323,99,422,875,129,145,0.98,San Francisco Giants,Candlestick Park,1785297,96,95,SFG,SFN,SFN
+1988,NL,SLN,STL,E,5,162,81,76,86,N,,N,N,578,5518,1373,207,33,71,484,827,234,64,,,633,567,3.4700000000,17,14,42,4410,1387,91,486,881,121,131,0.98,St. Louis Cardinals,Busch Stadium II,2892799,101,101,STL,SLN,SLN
+1989,AL,BAL,BAL,E,2,162,81,87,75,N,,N,N,708,5440,1369,238,33,129,593,957,118,55,,,686,644,4.0000000000,16,7,44,4344,1518,134,486,676,87,163,0.98,Baltimore Orioles,Memorial Stadium,2535208,96,97,BAL,BAL,BAL
+1989,AL,BOS,BOS,E,3,162,81,83,79,N,,N,N,774,5666,1571,326,30,108,643,755,56,35,,,735,651,4.0100000000,14,9,42,4380,1448,131,548,1054,127,162,0.98,Boston Red Sox,Fenway Park II,2510012,107,106,BOS,BOS,BOS
+1989,AL,CAL,ANA,W,3,162,81,91,71,N,,N,N,669,5545,1422,208,37,145,429,1011,89,40,,,578,530,3.2800000000,32,20,38,4362,1384,113,465,897,96,173,0.98,California Angels,Anaheim Stadium,2647291,98,98,CAL,CAL,CAL
+1989,AL,CHA,CHW,W,7,161,80,69,92,N,,N,N,693,5504,1493,262,36,94,464,873,97,52,,,750,668,4.2300000000,9,5,46,4266,1472,144,539,778,151,176,0.97,Chicago White Sox,Comiskey Park,1045651,97,98,CHW,CHA,CHA
+1989,AL,CLE,CLE,E,6,162,81,73,89,N,,N,N,604,5463,1340,221,26,127,499,934,74,51,,,654,589,3.6500000000,23,13,38,4359,1423,107,452,844,118,126,0.98,Cleveland Indians,Cleveland Stadium,1285542,101,102,CLE,CLE,CLE
+1989,AL,DET,DET,E,7,162,81,59,103,N,,N,N,617,5432,1315,198,24,116,585,899,103,50,,,816,718,4.5300000000,24,4,26,4281,1514,150,652,831,130,153,0.97,Detroit Tigers,Tiger Stadium,1543656,98,99,DET,DET,DET
+1989,AL,KCA,KCR,W,2,162,81,92,70,N,,N,N,690,5475,1428,227,41,101,554,897,154,51,,,635,572,3.5500000000,27,13,38,4353,1415,86,455,978,111,139,0.98,Kansas City Royals,Royals Stadium,2477700,100,100,KCR,KCA,KCA
+1989,AL,MIN,MIN,W,5,162,81,80,82,N,,N,N,740,5581,1542,278,35,117,478,743,111,53,,,738,680,4.2800000000,19,8,38,4287,1495,139,500,851,107,141,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2277438,107,107,MIN,MIN,MIN
+1989,AL,ML4,MIL,E,4,162,81,81,81,N,,N,N,707,5473,1415,235,32,126,455,791,165,62,,,679,605,3.8000000000,16,8,45,4296,1463,129,457,812,155,164,0.97,Milwaukee Brewers,County Stadium,1970735,99,99,MIL,MIL,MIL
+1989,AL,NYA,NYY,E,5,161,81,74,87,N,,N,N,698,5458,1470,229,23,130,502,831,137,60,,,792,707,4.5000000000,15,9,44,4242,1550,150,521,787,122,183,0.98,New York Yankees,Yankee Stadium II,2170485,99,99,NYY,NYA,NYA
+1989,AL,OAK,OAK,W,1,162,81,99,63,Y,,Y,Y,712,5416,1414,220,25,127,562,855,157,55,,,576,497,3.0900000000,17,20,57,4344,1287,103,510,930,129,159,0.97,Oakland Athletics,Oakland Coliseum,2667225,97,95,OAK,OAK,OAK
+1989,AL,SEA,SEA,W,6,162,81,73,89,N,,N,N,694,5512,1417,237,29,134,489,838,81,55,,,728,639,4.0000000000,15,10,44,4314,1422,114,560,897,143,168,0.97,Seattle Mariners,Kingdome,1298443,103,104,SEA,SEA,SEA
+1989,AL,TEX,TEX,W,4,162,81,83,79,N,,N,N,695,5458,1433,260,46,122,503,989,101,49,,,714,623,3.9100000000,26,7,44,4302,1279,119,654,1112,136,137,0.97,Texas Rangers,Arlington Stadium,2043993,102,102,TEX,TEX,TEX
+1989,AL,TOR,TOR,E,1,162,81,89,73,Y,,N,N,731,5581,1449,265,40,142,521,923,144,58,,,651,584,3.5800000000,12,12,38,4401,1408,99,478,849,126,164,0.98,Toronto Blue Jays,Exhibition Stadium /Skydome,3375883,94,94,TOR,TOR,TOR
+1989,NL,ATL,ATL,W,6,161,79,63,97,N,,N,N,584,5463,1281,201,22,128,485,996,83,54,,,680,595,3.7000000000,15,8,33,4341,1370,114,468,966,152,124,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,984930,102,104,ATL,ATL,ATL
+1989,NL,CHN,CHC,E,1,162,81,93,69,Y,,N,N,702,5513,1438,235,45,124,472,921,136,57,,,623,556,3.4300000000,18,10,55,4380,1369,106,532,918,119,130,0.98,Chicago Cubs,Wrigley Field,2491942,108,108,CHC,CHN,CHN
+1989,NL,CIN,CIN,W,5,162,81,75,87,N,,N,N,632,5520,1362,243,28,128,493,1028,128,71,,,691,607,3.7300000000,16,9,37,4392,1404,125,559,981,121,108,0.98,Cincinnati Reds,Riverfront Stadium,1979320,104,103,CIN,CIN,CIN
+1989,NL,HOU,HOU,W,3,162,82,86,76,N,,N,N,647,5516,1316,239,28,97,530,860,144,62,,,669,598,3.6400000000,19,12,38,4437,1379,105,551,965,140,121,0.97,Houston Astros,Astrodome,1834908,97,97,HOU,HOU,HOU
+1989,NL,LAN,LAD,W,4,160,81,77,83,N,,N,N,554,5465,1313,241,17,89,507,885,81,54,,,536,480,2.9500000000,25,19,36,4389,1278,95,504,1052,118,153,0.98,Los Angeles Dodgers,Dodger Stadium,2944653,99,98,LAD,LAN,LAN
+1989,NL,MON,WSN,E,4,162,81,81,81,N,,N,N,632,5482,1353,267,30,100,572,958,160,70,,,630,568,3.4800000000,20,13,35,4404,1344,120,519,1059,136,126,0.97,Montreal Expos,Stade Olympique,1783533,102,101,MON,MON,MON
+1989,NL,NYN,NYM,E,2,162,81,87,75,N,,N,N,683,5489,1351,280,21,147,504,934,158,53,,,595,532,3.2900000000,24,12,38,4362,1260,115,532,1108,144,110,0.97,New York Mets,Shea Stadium,2918710,95,93,NYM,NYN,NYN
+1989,NL,PHI,PHI,E,6,163,81,67,95,N,,N,N,629,5447,1324,215,36,123,558,926,106,50,,,735,643,4.0400000000,10,10,33,4299,1408,127,613,899,133,136,0.97,Philadelphia Phillies,Veterans Stadium,1861985,99,101,PHI,PHI,PHI
+1989,NL,PIT,PIT,E,5,164,81,74,88,N,,N,N,637,5539,1334,263,53,95,563,914,155,69,,,680,601,3.6400000000,20,9,40,4461,1394,121,539,827,160,130,0.97,Pittsburgh Pirates,Three Rivers Stadium,1374141,96,96,PIT,PIT,PIT
+1989,NL,SDN,SDP,W,2,162,81,89,73,N,,N,N,642,5422,1360,215,32,120,552,1013,136,67,,,626,547,3.3800000000,21,11,52,4371,1359,133,481,933,152,147,0.97,San Diego Padres,Jack Murphy Stadium,2009031,101,101,SDP,SDN,SDN
+1989,NL,SFN,SFG,W,1,162,81,92,70,Y,,Y,N,699,5469,1365,241,52,141,508,1071,87,54,,,600,534,3.3000000000,12,16,47,4371,1320,120,471,802,113,135,0.98,San Francisco Giants,Candlestick Park,2059701,97,96,SFG,SFN,SFN
+1989,NL,SLN,STL,E,3,164,83,86,76,N,,N,N,632,5492,1418,263,47,73,507,848,155,54,,,608,545,3.3600000000,18,18,43,4383,1330,84,482,844,111,134,0.98,St. Louis Cardinals,Busch Stadium II,3080980,103,103,STL,SLN,SLN
+1990,AL,BAL,BAL,E,5,161,80,76,85,N,,N,N,669,5410,1328,234,22,132,660,962,94,52,,,698,644,4.0400000000,10,5,43,4305,1445,161,537,776,91,151,0.98,Baltimore Orioles,Memorial Stadium,2415189,97,98,BAL,BAL,BAL
+1990,AL,BOS,BOS,E,1,162,81,88,74,Y,,N,N,699,5516,1502,298,31,106,598,795,53,52,,,664,596,3.7200000000,15,13,44,4326,1439,92,519,997,123,154,0.98,Boston Red Sox,Fenway Park II,2528986,105,105,BOS,BOS,BOS
+1990,AL,CAL,ANA,W,4,162,81,80,82,N,,N,N,690,5570,1448,237,27,147,566,1000,69,43,,,706,612,3.7900000000,21,13,42,4362,1482,106,544,944,140,186,0.97,California Angels,Anaheim Stadium,2555688,97,97,CAL,CAL,CAL
+1990,AL,CHA,CHW,W,2,162,80,94,68,N,,N,N,682,5402,1393,251,44,106,478,903,140,90,,,633,581,3.6100000000,17,10,68,4347,1313,106,548,914,124,169,0.98,Chicago White Sox,Comiskey Park,2002357,98,98,CHW,CHA,CHA
+1990,AL,CLE,CLE,E,4,162,81,77,85,N,,N,N,732,5485,1465,266,41,110,458,836,107,52,,,737,675,4.2600000000,12,10,47,4281,1491,163,518,860,117,146,0.98,Cleveland Indians,Cleveland Stadium,1225240,100,100,CLE,CLE,CLE
+1990,AL,DET,DET,E,3,162,81,79,83,N,,N,N,750,5479,1418,241,32,172,634,952,82,57,,,754,698,4.3900000000,15,12,45,4290,1401,154,661,856,131,178,0.97,Detroit Tigers,Tiger Stadium,1495785,101,102,DET,DET,DET
+1990,AL,KCA,KCR,W,6,161,81,75,86,N,,N,N,707,5488,1465,316,44,100,498,879,107,62,,,709,620,3.9300000000,18,8,33,4260,1449,116,560,1006,122,161,0.98,Kansas City Royals,Royals Stadium,2244956,98,98,KCR,KCA,KCA
+1990,AL,MIN,MIN,W,7,162,81,74,88,N,,N,N,666,5499,1458,281,39,100,445,749,96,53,,,729,657,4.1200000000,13,13,43,4305,1509,134,489,872,101,161,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1751584,107,107,MIN,MIN,MIN
+1990,AL,ML4,MIL,E,6,162,81,74,88,N,,N,N,732,5503,1408,247,36,128,519,821,164,72,,,760,655,4.0800000000,23,13,42,4335,1558,121,469,771,149,152,0.97,Milwaukee Brewers,County Stadium,1752900,99,99,MIL,MIL,MIL
+1990,AL,NYA,NYY,E,7,162,81,67,95,N,,N,N,603,5483,1322,208,19,147,427,1027,119,45,,,749,675,4.2100000000,15,6,41,4332,1430,144,618,909,126,164,0.98,New York Yankees,Yankee Stadium II,2006436,100,102,NYY,NYA,NYA
+1990,AL,OAK,OAK,W,1,162,81,103,59,Y,,Y,N,733,5433,1379,209,22,164,651,992,141,54,,,570,514,3.1800000000,18,16,64,4368,1287,123,494,831,87,152,0.98,Oakland Athletics,Oakland Coliseum,2900217,96,95,OAK,OAK,OAK
+1990,AL,SEA,SEA,W,5,162,81,77,85,N,,N,N,640,5474,1419,251,26,107,596,749,105,51,,,680,592,3.6900000000,21,7,41,4329,1319,120,606,1064,130,152,0.97,Seattle Mariners,Kingdome,1509727,101,101,SEA,SEA,SEA
+1990,AL,TEX,TEX,W,3,162,82,83,79,N,,N,N,676,5469,1416,257,27,110,575,1054,115,48,,,696,615,3.8300000000,25,9,36,4332,1343,113,623,997,133,161,0.97,Texas Rangers,Arlington Stadium,2057911,100,101,TEX,TEX,TEX
+1990,AL,TOR,TOR,E,2,162,81,86,76,N,,N,N,767,5589,1479,263,50,167,526,970,111,52,,,661,620,3.8400000000,6,9,48,4362,1434,143,445,892,86,144,0.98,Toronto Blue Jays,Skydome,3885284,106,105,TOR,TOR,TOR
+1990,NL,ATL,ATL,W,6,162,81,65,97,N,,N,N,682,5504,1376,263,26,162,473,1010,92,55,,,821,727,4.5800000000,17,8,30,4287,1527,128,579,938,158,133,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,980129,105,106,ATL,ATL,ATL
+1990,NL,CHN,CHC,E,4,162,81,77,85,N,,N,N,690,5600,1474,240,36,136,406,869,151,50,,,774,695,4.3400000000,13,7,42,4326,1510,121,572,877,122,136,0.98,Chicago Cubs,Wrigley Field,2243791,108,108,CHC,CHN,CHN
+1990,NL,CIN,CIN,W,1,162,81,91,71,Y,,Y,Y,693,5525,1466,284,40,125,466,913,166,66,,,597,548,3.3900000000,14,12,50,4368,1338,124,543,1029,102,126,0.98,Cincinnati Reds,Riverfront Stadium,2400892,105,105,CIN,CIN,CIN
+1990,NL,HOU,HOU,W,4,162,81,75,87,N,,N,N,573,5379,1301,209,32,94,548,997,179,83,,,656,582,3.6100000000,12,6,37,4350,1396,130,496,854,131,124,0.97,Houston Astros,Astrodome,1310927,97,98,HOU,HOU,HOU
+1990,NL,LAN,LAD,W,2,162,81,86,76,N,,N,N,728,5491,1436,222,27,129,538,952,141,65,,,685,596,3.7200000000,29,12,29,4326,1364,137,478,1021,130,123,0.97,Los Angeles Dodgers,Dodger Stadium,3002396,98,97,LAD,LAN,LAN
+1990,NL,MON,WSN,E,3,162,81,85,77,N,,N,N,662,5453,1363,227,43,114,576,1024,235,99,,,598,552,3.3700000000,18,11,50,4419,1349,127,510,991,110,134,0.98,Montreal Expos,Stade Olympique,1373087,96,96,MON,MON,MON
+1990,NL,NYN,NYM,E,2,162,81,91,71,N,,N,N,775,5504,1410,278,21,172,536,851,110,33,,,613,547,3.4200000000,18,14,41,4320,1339,119,444,1217,132,107,0.97,New York Mets,Shea Stadium,2732745,100,99,NYM,NYN,NYN
+1990,NL,PHI,PHI,E,4,162,81,77,85,N,,N,N,646,5535,1410,237,27,103,582,915,108,35,,,729,655,4.0700000000,18,7,35,4347,1381,124,651,840,117,150,0.98,Philadelphia Phillies,Veterans Stadium,1992484,99,100,PHI,PHI,PHI
+1990,NL,PIT,PIT,E,1,162,81,95,67,Y,,N,N,733,5388,1395,288,42,138,582,914,137,52,,,619,547,3.4000000000,18,8,43,4341,1367,135,413,848,134,125,0.97,Pittsburgh Pirates,Three Rivers Stadium,2049908,96,95,PIT,PIT,PIT
+1990,NL,SDN,SDP,W,4,162,81,75,87,N,,N,N,673,5554,1429,243,35,123,509,902,138,59,,,673,597,3.6800000000,21,12,35,4383,1437,147,507,928,141,141,0.97,San Diego Padres,Jack Murphy Stadium,1856396,101,101,SDP,SDN,SDN
+1990,NL,SFN,SFG,W,3,162,81,85,77,N,,N,N,719,5573,1459,221,35,152,488,973,109,56,,,710,656,4.0800000000,14,6,45,4338,1477,131,553,788,107,148,0.98,San Francisco Giants,Candlestick Park,1975528,96,96,SFG,SFN,SFN
+1990,NL,SLN,STL,E,6,162,81,70,92,N,,N,N,599,5462,1398,255,41,73,517,844,221,74,,,698,620,3.8700000000,8,13,39,4329,1432,98,475,833,129,114,0.97,St. Louis Cardinals,Busch Stadium II,2573225,100,100,STL,SLN,SLN
+1991,AL,BAL,BAL,E,6,162,81,67,95,N,,N,N,686,5604,1421,256,29,170,528,974,50,33,,,796,743,4.5900000000,8,8,42,4371,1534,147,504,868,89,172,0.98,Baltimore Orioles,Memorial Stadium,2552753,96,97,BAL,BAL,BAL
+1991,AL,BOS,BOS,E,2,162,81,84,78,N,,N,N,731,5530,1486,305,25,126,593,820,59,39,,,712,641,4.0100000000,15,13,45,4317,1405,147,530,999,116,165,0.98,Boston Red Sox,Fenway Park II,2562435,105,105,BOS,BOS,BOS
+1991,AL,CAL,ANA,W,7,162,81,81,81,N,,N,N,653,5470,1396,245,29,115,448,928,94,56,,,649,591,3.6900000000,18,10,50,4323,1351,141,543,990,102,156,0.98,California Angels,Anaheim Stadium,2416236,99,100,CAL,CAL,CAL
+1991,AL,CHA,CHW,W,2,162,81,87,75,N,,N,N,758,5594,1464,226,39,139,610,896,134,74,,,681,622,3.7900000000,28,8,40,4434,1302,154,601,923,116,151,0.98,Chicago White Sox,Comiskey Park II,2934154,98,97,CHW,CHA,CHA
+1991,AL,CLE,CLE,E,7,162,82,57,105,N,,N,N,576,5470,1390,236,26,79,449,888,84,58,,,759,677,4.2300000000,22,8,33,4323,1551,110,441,862,142,150,0.97,Cleveland Indians,Cleveland Stadium,1051863,101,102,CLE,CLE,CLE
+1991,AL,DET,DET,E,2,162,81,84,78,N,,N,N,817,5547,1372,259,26,209,699,1185,109,47,,,794,727,4.5100000000,18,8,38,4350,1570,148,593,739,104,171,0.98,Detroit Tigers,Tiger Stadium,1641661,102,102,DET,DET,DET
+1991,AL,KCA,KCR,W,6,162,81,82,80,N,,N,N,727,5584,1475,290,41,117,523,969,119,68,,,722,639,3.9200000000,17,12,41,4398,1473,105,529,1004,125,141,0.98,Kansas City Royals,Royals Stadium,2161537,100,101,KCR,KCA,KCA
+1991,AL,MIN,MIN,W,1,162,81,95,67,Y,,Y,Y,776,5556,1557,270,42,140,526,747,107,68,,,652,594,3.6900000000,21,12,53,4347,1402,139,488,876,94,161,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2293842,105,104,MIN,MIN,MIN
+1991,AL,ML4,MIL,E,4,162,80,83,79,N,,N,N,799,5611,1523,247,53,116,556,802,106,68,,,744,673,4.1400000000,23,11,41,4389,1498,147,527,859,118,176,0.98,Milwaukee Brewers,County Stadium,1478729,98,98,MIL,MIL,MIL
+1991,AL,NYA,NYY,E,5,162,81,71,91,N,,N,N,674,5541,1418,249,19,147,473,861,109,36,,,777,709,4.4200000000,3,11,37,4332,1510,152,506,936,133,181,0.97,New York Yankees,Yankee Stadium II,1863733,100,101,NYY,NYA,NYA
+1991,AL,OAK,OAK,W,4,162,81,84,78,N,,N,N,760,5410,1342,246,19,159,642,981,151,64,,,776,733,4.5700000000,14,10,49,4332,1425,155,655,892,107,150,0.98,Oakland Athletics,Oakland Coliseum,2713493,94,93,OAK,OAK,OAK
+1991,AL,SEA,SEA,W,5,162,81,83,79,N,,N,N,702,5494,1400,268,29,126,588,811,97,44,,,674,617,3.7900000000,10,13,48,4392,1387,136,628,1003,110,187,0.98,Seattle Mariners,Kingdome,2147905,100,100,SEA,SEA,SEA
+1991,AL,TEX,TEX,W,3,162,81,85,77,N,,N,N,829,5703,1539,288,31,177,596,1039,102,50,,,814,735,4.4700000000,9,10,41,4437,1486,151,662,1022,134,138,0.97,Texas Rangers,Arlington Stadium,2297720,98,99,TEX,TEX,TEX
+1991,AL,TOR,TOR,E,1,162,81,91,71,Y,,N,N,684,5489,1412,295,45,133,499,1043,148,53,,,622,569,3.5000000000,10,16,60,4386,1301,121,523,971,127,115,0.98,Toronto Blue Jays,Skydome,4001527,104,103,TOR,TOR,TOR
+1991,NL,ATL,ATL,W,1,162,81,94,68,Y,,Y,N,749,5456,1407,255,30,141,563,906,165,76,,,644,563,3.4900000000,18,7,48,4356,1304,118,481,969,138,122,0.97,Atlanta Braves,Atlanta-Fulton County Stadium,2140217,106,106,ATL,ATL,ATL
+1991,NL,CHN,CHC,E,4,160,83,77,83,N,,N,N,695,5522,1395,232,26,159,442,879,123,64,,,734,652,4.0300000000,12,4,40,4368,1415,117,542,927,113,120,0.98,Chicago Cubs,Wrigley Field,2314250,104,105,CHC,CHN,CHN
+1991,NL,CIN,CIN,W,5,162,81,74,88,N,,N,N,689,5501,1419,250,27,164,488,1006,124,56,,,691,613,3.8300000000,7,11,43,4320,1372,127,560,997,125,131,0.97,Cincinnati Reds,Riverfront Stadium,2372377,104,104,CIN,CIN,CIN
+1991,NL,HOU,HOU,W,6,162,81,65,97,N,,N,N,605,5504,1345,240,43,79,502,1027,125,68,,,717,646,4.0000000000,7,13,36,4359,1347,129,651,1033,161,129,0.97,Houston Astros,Astrodome,1196152,93,94,HOU,HOU,HOU
+1991,NL,LAN,LAD,W,2,162,81,93,69,N,,N,N,665,5408,1366,191,29,108,583,957,126,68,,,565,496,3.0600000000,15,14,40,4374,1312,96,500,1028,123,126,0.98,Los Angeles Dodgers,Dodger Stadium,3348170,98,97,LAD,LAN,LAN
+1991,NL,MON,WSN,E,6,161,68,71,90,N,,N,N,579,5412,1329,236,42,95,484,1056,221,100,,,655,582,3.6400000000,12,14,39,4320,1304,111,584,909,131,128,0.97,Montreal Expos,Stade Olympique,934742,99,99,MON,MON,MON
+1991,NL,NYN,NYM,E,5,161,82,77,84,N,,N,N,640,5359,1305,250,24,117,578,789,153,70,,,646,568,3.5600000000,12,11,39,4311,1403,108,410,1028,143,112,0.97,New York Mets,Shea Stadium,2284484,99,99,NYM,NYN,NYN
+1991,NL,PHI,PHI,E,3,162,83,78,84,N,,N,N,629,5521,1332,248,33,111,490,1026,92,30,,,680,627,3.8600000000,16,11,35,4389,1346,111,670,988,116,111,0.98,Philadelphia Phillies,Veterans Stadium,2050012,99,99,PHI,PHI,PHI
+1991,NL,PIT,PIT,E,1,162,84,98,64,Y,,N,N,768,5449,1433,259,50,126,620,901,124,46,,,632,557,3.4400000000,18,11,51,4368,1411,117,401,919,120,134,0.98,Pittsburgh Pirates,Three Rivers Stadium,2065302,99,98,PIT,PIT,PIT
+1991,NL,SDN,SDP,W,3,162,81,84,78,N,,N,N,636,5408,1321,204,36,121,501,1069,101,64,,,646,576,3.5700000000,14,11,47,4356,1385,139,457,921,113,130,0.98,San Diego Padres,Jack Murphy Stadium,1804289,103,103,SDP,SDN,SDN
+1991,NL,SFN,SFG,W,4,162,81,75,87,N,,N,N,649,5463,1345,215,48,141,471,973,95,57,,,697,646,4.0300000000,10,10,45,4326,1397,143,544,905,108,151,0.98,San Francisco Giants,Candlestick Park,1737478,96,97,SFG,SFN,SFN
+1991,NL,SLN,STL,E,2,162,84,84,78,N,,N,N,651,5362,1366,239,53,68,532,857,202,110,,,648,588,3.6900000000,9,5,51,4305,1367,114,454,822,105,133,0.98,St. Louis Cardinals,Busch Stadium II,2448699,100,100,STL,SLN,SLN
+1992,AL,BAL,BAL,E,3,162,81,89,73,N,,N,N,705,5485,1423,243,36,148,647,827,89,48,,,656,617,3.7900000000,20,16,48,4392,1419,124,518,846,93,168,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3567819,102,101,BAL,BAL,BAL
+1992,AL,BOS,BOS,E,7,162,81,73,89,N,,N,N,599,5461,1343,259,21,84,591,865,44,48,,,669,576,3.5800000000,22,13,39,4344,1403,107,535,943,139,170,0.97,Boston Red Sox,Fenway Park II,2468574,106,107,BOS,BOS,BOS
+1992,AL,CAL,ANA,W,5,162,81,72,90,N,,N,N,579,5364,1306,202,20,88,416,882,160,101,,,671,617,3.8400000000,26,13,42,4338,1449,130,532,888,134,172,0.97,California Angels,Anaheim Stadium,2065444,100,101,CAL,CAL,CAL
+1992,AL,CHA,CHW,W,3,162,82,86,76,N,,N,N,738,5498,1434,269,36,110,622,784,160,57,,,690,620,3.8200000000,21,5,52,4383,1400,123,550,810,129,134,0.97,Chicago White Sox,Comiskey Park II,2681156,99,99,CHW,CHA,CHA
+1992,AL,CLE,CLE,E,4,162,81,76,86,N,,N,N,674,5620,1495,227,24,127,448,885,144,67,,,746,671,4.1100000000,13,7,46,4410,1507,159,566,890,141,176,0.97,Cleveland Indians,Cleveland Stadium,1224094,99,100,CLE,CLE,CLE
+1992,AL,DET,DET,E,6,162,80,75,87,N,,N,N,791,5515,1411,256,16,182,675,1055,66,45,,,794,733,4.6000000000,10,4,36,4305,1534,155,564,693,116,164,0.98,Detroit Tigers,Tiger Stadium,1423963,101,100,DET,DET,DET
+1992,AL,KCA,KCR,W,5,162,81,72,90,N,,N,N,610,5501,1411,284,42,75,439,741,131,71,,,667,613,3.8100000000,9,12,44,4341,1426,106,512,834,122,164,0.98,Kansas City Royals,Royals Stadium,1867689,102,103,KCR,KCA,KCA
+1992,AL,MIN,MIN,W,2,162,81,90,72,N,,N,N,747,5582,1544,275,27,104,527,834,123,74,,,653,597,3.7000000000,16,13,50,4359,1391,121,479,923,94,155,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2482428,103,102,MIN,MIN,MIN
+1992,AL,ML4,MIL,E,2,162,81,92,70,N,,N,N,740,5504,1477,272,35,82,511,779,256,115,,,604,555,3.4300000000,19,14,39,4371,1344,127,435,793,89,146,0.98,Milwaukee Brewers,County Stadium,1857351,99,98,MIL,MIL,MIL
+1992,AL,NYA,NYY,E,4,162,81,76,86,N,,N,N,733,5593,1462,281,18,163,536,903,78,37,,,746,679,4.2100000000,20,9,44,4356,1453,129,612,851,112,165,0.98,New York Yankees,Yankee Stadium II,1748737,100,100,NYY,NYA,NYA
+1992,AL,OAK,OAK,W,1,162,81,96,66,Y,,N,N,745,5387,1389,219,24,142,707,831,143,59,,,672,600,3.7300000000,8,9,58,4341,1396,129,601,843,125,158,0.97,Oakland Athletics,Oakland Coliseum,2494160,94,95,OAK,OAK,OAK
+1992,AL,SEA,SEA,W,7,162,81,64,98,N,,N,N,679,5564,1466,278,24,149,474,841,100,55,,,799,731,4.5500000000,21,9,30,4335,1467,129,661,894,112,170,0.98,Seattle Mariners,Kingdome,1651367,100,100,SEA,SEA,SEA
+1992,AL,TEX,TEX,W,4,162,81,77,85,N,,N,N,682,5537,1387,266,23,159,550,1036,81,44,,,753,663,4.0900000000,19,3,42,4380,1471,113,598,1034,153,153,0.97,Texas Rangers,Arlington Stadium,2198231,97,97,TEX,TEX,TEX
+1992,AL,TOR,TOR,E,1,162,81,96,66,Y,,Y,Y,780,5536,1458,265,40,163,561,933,129,39,,,682,626,3.9100000000,18,14,49,4320,1346,124,541,954,93,109,0.98,Toronto Blue Jays,Skydome,4028318,105,104,TOR,TOR,TOR
+1992,NL,ATL,ATL,W,1,162,81,98,64,Y,,Y,N,682,5480,1391,223,48,138,493,924,126,60,,,569,509,3.1400000000,26,24,41,4380,1321,89,489,948,109,121,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,3077400,107,105,ATL,ATL,ATL
+1992,NL,CHN,CHC,E,4,162,81,78,84,N,,N,N,593,5590,1420,221,41,104,417,816,77,51,,,624,553,3.3900000000,16,11,37,4407,1337,107,575,901,114,142,0.98,Chicago Cubs,Wrigley Field,2126720,102,103,CHC,CHN,CHN
+1992,NL,CIN,CIN,W,2,162,81,90,72,N,,N,N,660,5460,1418,281,44,99,563,888,125,65,,,609,557,3.4600000000,9,11,55,4347,1362,109,470,1060,96,128,0.98,Cincinnati Reds,Riverfront Stadium,2315946,103,103,CIN,CIN,CIN
+1992,NL,HOU,HOU,W,4,162,81,81,81,N,,N,N,608,5480,1350,255,38,96,506,1025,139,54,,,668,603,3.7200000000,5,12,45,4377,1386,114,539,978,112,125,0.98,Houston Astros,Astrodome,1211412,95,95,HOU,HOU,HOU
+1992,NL,LAN,LAD,W,6,162,81,63,99,N,,N,N,548,5368,1333,201,34,72,503,899,142,78,,,636,545,3.4100000000,18,13,29,4314,1401,82,553,981,173,136,0.97,Los Angeles Dodgers,Dodger Stadium,2473266,99,99,LAD,LAN,LAN
+1992,NL,MON,WSN,E,2,162,81,87,75,N,,N,N,648,5477,1381,263,37,102,463,976,196,63,,,581,530,3.2500000000,11,14,49,4404,1296,92,525,1014,124,113,0.98,Montreal Expos,Stade Olympique,1669127,99,99,MON,MON,MON
+1992,NL,NYN,NYM,E,5,162,81,72,90,N,,N,N,599,5340,1254,259,17,93,572,956,129,52,,,653,588,3.6600000000,17,13,34,4338,1404,98,482,1025,116,134,0.98,New York Mets,Shea Stadium,1779534,99,99,NYM,NYN,NYN
+1992,NL,PHI,PHI,E,6,162,81,70,92,N,,N,N,686,5500,1392,255,36,118,509,1059,127,31,,,717,652,4.1100000000,27,7,34,4284,1387,113,549,851,131,128,0.97,Philadelphia Phillies,Veterans Stadium,1927448,100,100,PHI,PHI,PHI
+1992,NL,PIT,PIT,E,1,162,81,96,66,Y,,N,N,693,5527,1409,272,54,106,569,872,110,53,,,595,551,3.3500000000,20,20,43,4437,1410,101,455,844,101,144,0.98,Pittsburgh Pirates,Three Rivers Stadium,1829395,99,98,PIT,PIT,PIT
+1992,NL,SDN,SDP,W,3,162,81,82,80,N,,N,N,617,5476,1396,255,30,135,453,864,69,52,,,636,578,3.5600000000,9,11,46,4383,1444,111,439,971,115,127,0.98,San Diego Padres,Jack Murphy Stadium,1721406,101,102,SDP,SDN,SDN
+1992,NL,SFN,SFG,W,5,162,81,72,90,N,,N,N,574,5456,1330,220,36,105,435,1067,112,64,,,647,586,3.6100000000,9,12,30,4383,1385,128,502,927,111,174,0.98,San Francisco Giants,Candlestick Park,1560998,94,94,SFG,SFN,SFN
+1992,NL,SLN,STL,E,3,162,81,83,79,N,,N,N,631,5594,1464,262,44,94,495,996,208,118,,,604,556,3.3800000000,10,9,47,4440,1405,118,400,842,91,146,0.98,St. Louis Cardinals,Busch Stadium II,2418483,97,97,STL,SLN,SLN
+1993,AL,BAL,BAL,E,3,162,81,85,77,N,,N,N,786,5508,1470,287,24,157,655,930,73,54,,,745,691,4.3100000000,21,10,42,4326,1427,153,579,900,100,171,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3644965,104,103,BAL,BAL,BAL
+1993,AL,BOS,BOS,E,5,162,81,80,82,N,,N,N,686,5496,1451,319,29,114,508,871,73,38,,,698,608,3.7700000000,9,11,44,4356,1379,127,552,997,122,155,0.98,Boston Red Sox,Fenway Park II,2422021,106,107,BOS,BOS,BOS
+1993,AL,CAL,ANA,W,5,162,81,71,91,N,,N,N,684,5391,1399,259,24,114,564,930,169,100,,,770,690,4.3400000000,26,6,41,4290,1482,153,550,843,120,161,0.98,California Angels,Anaheim Stadium,2057460,103,104,CAL,CAL,CAL
+1993,AL,CHA,CHW,W,1,162,81,94,68,Y,,N,N,776,5483,1454,228,44,162,604,834,106,57,,,664,598,3.7000000000,16,11,48,4362,1398,125,566,974,112,153,0.98,Chicago White Sox,Comiskey Park II,2581091,98,97,CHW,CHA,CHA
+1993,AL,CLE,CLE,E,6,162,81,76,86,N,,N,N,790,5619,1547,264,31,141,488,843,159,55,,,813,735,4.5800000000,7,8,45,4335,1591,182,591,888,148,174,0.97,Cleveland Indians,Cleveland Stadium,2177908,100,101,CLE,CLE,CLE
+1993,AL,DET,DET,E,3,162,81,85,77,N,,N,N,899,5620,1546,282,38,178,765,1122,104,63,,,837,742,4.6500000000,11,7,36,4308,1547,188,542,828,132,148,0.97,Detroit Tigers,Tiger Stadium,1971421,99,99,DET,DET,DET
+1993,AL,KCA,KCR,W,3,162,81,84,78,N,,N,N,675,5522,1455,294,35,125,428,936,100,75,,,694,649,4.0400000000,16,6,48,4335,1379,105,571,985,96,150,0.98,Kansas City Royals,Kauffman Stadium,1934578,106,106,KCR,KCA,KCA
+1993,AL,MIN,MIN,W,5,162,81,71,91,N,,N,N,693,5601,1480,261,27,121,493,850,83,59,,,830,756,4.7100000000,5,3,44,4332,1591,148,514,901,100,160,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2048673,100,100,MIN,MIN,MIN
+1993,AL,ML4,MIL,E,7,162,81,69,93,N,,N,N,733,5525,1426,240,25,125,555,932,138,93,,,792,715,4.4500000000,26,6,29,4341,1511,153,522,810,131,148,0.97,Milwaukee Brewers,County Stadium,1688080,99,99,MIL,MIL,MIL
+1993,AL,NYA,NYY,E,2,162,81,88,74,N,,N,N,821,5615,1568,294,24,178,629,910,39,35,,,761,695,4.3500000000,11,13,38,4314,1467,170,552,899,101,166,0.98,New York Yankees,Yankee Stadium II,2416942,97,96,NYY,NYA,NYA
+1993,AL,OAK,OAK,W,7,162,81,68,94,N,,N,N,715,5543,1408,260,21,158,622,1048,131,59,,,846,791,4.9000000000,8,2,42,4356,1551,157,680,864,111,161,0.98,Oakland Athletics,Oakland Coliseum,2035025,94,94,OAK,OAK,OAK
+1993,AL,SEA,SEA,W,4,162,81,82,80,N,,N,N,734,5494,1429,272,24,161,624,901,91,68,,,731,678,4.2000000000,22,10,41,4359,1421,135,605,1083,90,173,0.98,Seattle Mariners,Kingdome,2052638,101,102,SEA,SEA,SEA
+1993,AL,TEX,TEX,W,2,162,81,86,76,N,,N,N,835,5510,1472,284,39,181,483,984,113,67,,,751,684,4.2800000000,20,6,45,4314,1476,144,562,957,130,145,0.97,Texas Rangers,Arlington Stadium,2244616,96,96,TEX,TEX,TEX
+1993,AL,TOR,TOR,E,1,162,81,95,67,Y,,Y,Y,847,5579,1556,317,42,159,588,861,170,49,,,742,674,4.2100000000,11,11,50,4323,1441,134,620,1023,107,144,0.98,Toronto Blue Jays,Skydome,4057947,101,100,TOR,TOR,TOR
+1993,NL,ATL,ATL,W,1,162,81,104,58,Y,,N,N,767,5515,1444,239,29,169,560,946,125,48,,,559,508,3.1400000000,18,16,46,4365,1297,101,480,1036,108,146,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,3884720,101,100,ATL,ATL,ATL
+1993,NL,CHN,CHC,E,4,163,82,84,78,N,,N,N,738,5627,1521,259,32,161,446,923,100,43,,,739,673,4.1800000000,8,5,56,4347,1514,153,470,905,115,162,0.98,Chicago Cubs,Wrigley Field,2653763,98,98,CHC,CHN,CHN
+1993,NL,CIN,CIN,W,5,162,81,73,89,N,,N,N,722,5517,1457,261,28,137,485,1025,142,59,,,785,719,4.5100000000,11,8,37,4302,1510,158,508,996,120,133,0.98,Cincinnati Reds,Riverfront Stadium,2453232,101,100,CIN,CIN,CIN
+1993,NL,COL,COL,W,6,162,81,67,95,N,,N,N,758,5517,1507,278,59,142,388,944,146,90,,,967,860,5.4100000000,9,0,35,4293,1664,181,609,913,167,149,0.97,Colorado Rockies,Mile High Stadium,4483350,117,118,COL,COL,COL
+1993,NL,FLO,FLA,E,6,162,81,64,98,N,,N,N,581,5475,1356,197,31,94,498,1054,117,56,,,724,661,4.1300000000,4,5,48,4320,1437,135,598,945,122,130,0.98,Florida Marlins,Joe Robbie Stadium,3064847,104,106,FLA,FLO,FLO
+1993,NL,HOU,HOU,W,3,162,81,85,77,N,,N,N,716,5464,1459,288,37,138,497,911,103,60,,,630,559,3.4900000000,18,14,42,4323,1363,117,476,1056,125,141,0.97,Houston Astros,Astrodome,2084618,96,96,HOU,HOU,HOU
+1993,NL,LAN,LAD,W,4,162,81,81,81,N,,N,N,675,5588,1458,234,28,130,492,937,126,61,,,662,572,3.5000000000,17,9,36,4416,1406,103,567,1043,132,141,0.97,Los Angeles Dodgers,Dodger Stadium,3170393,95,95,LAD,LAN,LAN
+1993,NL,MON,WSN,E,2,163,81,94,68,N,,N,N,732,5493,1410,270,36,122,542,860,228,56,,,682,574,3.5500000000,8,7,61,4368,1369,119,521,934,159,144,0.97,Montreal Expos,Stade Olympique,1641437,105,104,MON,MON,MON
+1993,NL,NYN,NYM,E,7,162,81,59,103,N,,N,N,672,5448,1350,228,37,158,448,879,79,50,,,744,647,4.0500000000,16,8,22,4314,1483,139,434,867,156,143,0.97,New York Mets,Shea Stadium,1873183,99,100,NYM,NYN,NYN
+1993,NL,PHI,PHI,E,1,162,81,97,65,Y,,Y,N,877,5685,1555,297,51,156,665,1049,91,32,,,740,646,3.9500000000,24,11,46,4416,1419,129,573,1117,141,123,0.97,Philadelphia Phillies,Veterans Stadium,3137674,99,98,PHI,PHI,PHI
+1993,NL,PIT,PIT,E,5,162,81,75,87,N,,N,N,707,5549,1482,267,50,110,536,972,92,55,,,806,766,4.7700000000,12,5,34,4335,1557,153,485,832,105,161,0.98,Pittsburgh Pirates,Three Rivers Stadium,1650593,99,100,PIT,PIT,PIT
+1993,NL,SDN,SDP,W,7,162,81,61,101,N,,N,N,679,5503,1386,239,28,153,443,1046,92,41,,,772,675,4.2300000000,8,6,32,4311,1470,148,558,957,160,129,0.97,San Diego Padres,Jack Murphy Stadium,1375432,102,102,SDP,SDN,SDN
+1993,NL,SFN,SFG,W,2,162,81,103,59,N,,N,N,808,5557,1534,269,33,168,516,930,120,65,,,636,584,3.6100000000,4,9,50,4368,1385,168,442,982,101,169,0.98,San Francisco Giants,Candlestick Park,2606354,97,96,SFG,SFN,SFN
+1993,NL,SLN,STL,E,3,162,81,87,75,N,,N,N,758,5551,1508,262,34,118,588,882,153,72,,,744,660,4.0900000000,5,7,54,4359,1553,152,383,775,159,157,0.97,St. Louis Cardinals,Busch Stadium II,2844977,98,98,STL,SLN,SLN
+1994,AL,BAL,BAL,E,2,112,55,63,49,,,,,589,3856,1047,185,20,139,438,655,69,13,,,497,477,4.3100000000,13,3,37,2991,1005,131,351,666,57,103,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2535359,105,104,BAL,BAL,BAL
+1994,AL,BOS,BOS,E,4,115,64,54,61,,,,,552,3940,1038,222,19,120,404,723,81,38,,,621,564,4.9300000000,6,1,30,3087,1104,120,450,729,81,124,0.98,Boston Red Sox,Fenway Park II,1775818,105,105,BOS,BOS,BOS
+1994,AL,CAL,ANA,W,4,115,63,47,68,,,,,543,3943,1042,178,16,120,402,715,65,54,,,660,618,5.4200000000,11,3,21,3081,1149,150,436,682,76,110,0.98,California Angels,Anaheim Stadium,1512622,101,101,CAL,CAL,CAL
+1994,AL,CHA,CHW,C,1,113,53,67,46,,,,,633,3942,1133,175,39,121,497,568,77,27,,,498,444,3.9500000000,13,6,20,3034,964,115,377,754,79,91,0.98,Chicago White Sox,Comiskey Park II,1697398,99,98,CHW,CHA,CHA
+1994,AL,CLE,CLE,C,2,113,51,66,47,,,,,679,4022,1165,240,20,167,382,629,131,48,,,562,493,4.3600000000,17,5,21,3054,1097,94,404,666,90,119,0.98,Cleveland Indians,Jacobs Field,1995174,99,97,CLE,CLE,CLE
+1994,AL,DET,DET,E,5,115,58,53,62,,,,,652,3955,1048,216,25,161,520,897,46,33,,,671,609,5.3800000000,15,1,20,3054,1139,148,449,560,82,90,0.98,Detroit Tigers,Tiger Stadium,1184783,101,101,DET,DET,DET
+1994,AL,KCA,KCR,C,3,115,59,64,51,,,,,574,3911,1051,211,38,100,376,698,140,62,,,532,485,4.2300000000,5,3,38,3093,1018,95,392,717,80,102,0.98,Kansas City Royals,Kauffman Stadium,1400494,104,104,KCR,KCA,KCA
+1994,AL,MIN,MIN,C,4,113,59,53,60,,,,,594,3952,1092,239,23,103,359,635,94,30,,,688,634,5.6800000000,6,2,29,3015,1197,153,388,602,75,99,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1398565,100,102,MIN,MIN,MIN
+1994,AL,ML4,MIL,C,5,115,56,53,62,,,,,547,3978,1045,238,21,99,417,680,59,37,,,586,532,4.6200000000,11,1,23,3108,1071,127,421,577,85,130,0.98,Milwaukee Brewers,County Stadium,1268399,104,105,MIL,MIL,MIL
+1994,AL,NYA,NYY,E,1,113,57,70,43,,,,,670,3986,1155,238,16,139,530,660,55,40,,,534,491,4.3400000000,8,0,31,3057,1045,120,398,656,80,122,0.98,New York Yankees,Yankee Stadium II,1675556,97,96,NYY,NYA,NYA
+1994,AL,OAK,OAK,W,2,114,56,51,63,,,,,549,3885,1009,178,13,113,417,686,91,39,,,589,537,4.8200000000,12,3,23,3009,979,128,510,732,88,105,0.97,Oakland Athletics,Oakland Coliseum,1242692,91,92,OAK,OAK,OAK
+1994,AL,SEA,SEA,W,3,112,44,49,63,,,,,569,3883,1045,211,18,153,372,652,48,21,,,616,546,4.9900000000,13,4,21,2952,1051,109,486,763,95,102,0.97,Seattle Mariners,Kingdome,1104206,102,102,SEA,SEA,SEA
+1994,AL,TEX,TEX,W,1,114,63,52,62,,,,,613,3983,1114,198,27,124,437,730,82,35,,,697,619,5.4500000000,10,3,26,3069,1176,157,394,683,105,106,0.97,Texas Rangers,The Ballpark at Arlington,2503198,100,101,TEX,TEX,TEX
+1994,AL,TOR,TOR,E,3,115,59,55,60,,,,,566,3962,1064,210,30,115,387,691,79,26,,,579,535,4.7000000000,13,4,26,3075,1053,127,482,832,80,105,0.98,Toronto Blue Jays,Skydome,2907933,100,100,TOR,TOR,TOR
+1994,NL,ATL,ATL,E,2,114,55,68,46,,,,,542,3861,1031,198,18,137,377,668,48,31,,,448,407,3.5700000000,16,4,26,3078,929,76,378,865,81,85,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,2539240,102,100,ATL,ATL,ATL
+1994,NL,CHN,CHC,C,5,113,59,49,64,,,,,500,3918,1015,189,26,109,364,750,69,53,,,549,508,4.4700000000,5,1,27,3069,1054,120,392,717,81,110,0.98,Chicago Cubs,Wrigley Field,1845208,99,99,CHC,CHN,CHN
+1994,NL,CIN,CIN,C,1,115,60,66,48,,,,,609,3999,1142,211,36,124,388,738,119,51,,,490,436,3.7800000000,6,2,27,3114,1037,117,339,799,73,91,0.98,Cincinnati Reds,Riverfront Stadium,1897681,99,99,CIN,CIN,CIN
+1994,NL,COL,COL,W,3,117,57,53,64,,,,,573,4006,1098,206,39,125,378,761,91,53,,,638,590,5.1500000000,4,1,28,3093,1185,120,448,703,84,117,0.98,Colorado Rockies,Mile High Stadium,3281511,117,118,COL,COL,COL
+1994,NL,FLO,FLA,E,5,115,59,51,64,,,,,468,3926,1043,180,24,94,349,746,65,26,,,576,508,4.5000000000,5,3,30,3045,1069,120,428,649,95,111,0.97,Florida Marlins,Joe Robbie Stadium,1937467,102,103,FLA,FLO,FLO
+1994,NL,HOU,HOU,C,2,115,59,66,49,,,,,602,3955,1099,252,25,120,394,718,124,44,,,503,454,3.9700000000,9,3,29,3087,1043,102,367,739,72,110,0.98,Houston Astros,Astrodome,1561136,95,94,HOU,HOU,HOU
+1994,NL,LAN,LAD,W,1,114,55,58,56,,,,,532,3904,1055,160,29,115,366,687,74,37,,,509,477,4.2300000000,14,4,20,3042,1041,90,354,732,88,104,0.98,Los Angeles Dodgers,Dodger Stadium,2279355,94,94,LAD,LAN,LAN
+1994,NL,MON,WSN,E,1,114,52,74,40,,,,,585,4000,1111,246,30,108,379,669,137,36,,,454,410,3.5600000000,4,2,46,3108,970,100,288,805,94,90,0.97,Montreal Expos,Stade Olympique,1276250,101,101,MON,MON,MON
+1994,NL,NYN,NYM,E,3,113,53,55,58,,,,,506,3869,966,164,21,117,336,807,25,26,,,526,469,4.1300000000,7,2,35,3069,1069,117,332,640,89,112,0.98,New York Mets,Shea Stadium,1151471,99,99,NYM,NYN,NYN
+1994,NL,PHI,PHI,E,4,115,60,54,61,,,,,521,3927,1028,208,28,80,396,711,67,24,,,497,438,3.8500000000,7,1,30,3072,1028,98,377,699,94,96,0.97,Philadelphia Phillies,Veterans Stadium,2290971,102,102,PHI,PHI,PHI
+1994,NL,PIT,PIT,C,3,114,61,53,61,,,,,466,3864,1001,198,23,80,349,725,53,25,,,580,518,4.6400000000,8,1,24,3015,1094,117,370,650,89,131,0.98,Pittsburgh Pirates,Three Rivers Stadium,1222520,101,102,PIT,PIT,PIT
+1994,NL,SDN,SDP,W,4,117,57,47,70,,,,,479,4068,1117,200,19,92,319,762,79,37,,,531,474,4.0800000000,8,3,27,3135,1008,99,393,862,111,82,0.97,San Diego Padres,Jack Murphy Stadium,953857,97,98,SDP,SDN,SDN
+1994,NL,SFN,SFG,W,2,115,60,55,60,,,,,504,3869,963,159,32,123,364,719,114,40,,,500,454,3.9900000000,2,0,33,3075,1014,122,372,655,68,113,0.98,San Francisco Giants,Candlestick Park,1704608,94,94,SFG,SFN,SFN
+1994,NL,SLN,STL,C,3,115,56,53,61,,,,,535,3902,1026,213,27,108,434,686,76,46,,,621,581,5.1400000000,7,3,29,3054,1154,134,355,632,80,119,0.98,St. Louis Cardinals,Busch Stadium II,1866544,98,99,STL,SLN,SLN
+1995,AL,BAL,BAL,E,3,144,72,71,73,N,N,N,N,704,4837,1267,229,27,173,574,803,92,45,,,640,607,4.3100000000,19,10,29,3801,1165,149,523,930,72,141,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3098475,102,101,BAL,BAL,BAL
+1995,AL,BOS,BOS,E,1,144,72,86,58,Y,N,N,N,791,4997,1399,286,31,175,560,923,99,44,,,698,630,4.3900000000,7,9,39,3876,1338,127,476,888,120,151,0.97,Boston Red Sox,Fenway Park II,2164410,103,103,BOS,BOS,BOS
+1995,AL,CAL,ANA,W,2,145,72,78,67,N,N,N,N,801,5019,1390,252,25,186,564,889,58,39,,,697,645,4.5200000000,8,9,42,3852,1310,163,486,901,95,120,0.98,California Angels,Anaheim Stadium,1748680,99,99,CAL,CAL,CAL
+1995,AL,CHA,CHW,C,3,145,72,68,76,N,N,N,N,755,5060,1417,252,37,146,576,767,110,39,,,758,692,4.8500000000,12,4,36,3852,1374,164,617,892,108,131,0.98,Chicago White Sox,Comiskey Park II,1609773,96,95,CHW,CHA,CHA
+1995,AL,CLE,CLE,C,1,144,72,100,44,Y,N,Y,N,840,5028,1461,279,23,207,542,766,132,53,,,607,554,3.8300000000,10,10,50,3903,1261,135,445,926,101,142,0.98,Cleveland Indians,Jacobs Field,2842745,101,99,CLE,CLE,CLE
+1995,AL,DET,DET,E,4,144,72,60,84,N,N,N,N,654,4865,1204,228,29,159,551,987,73,36,,,844,778,5.4900000000,5,3,38,3825,1509,170,536,729,106,143,0.98,Detroit Tigers,Tiger Stadium,1180979,100,101,DET,DET,DET
+1995,AL,KCA,KCR,C,2,144,72,70,74,N,N,N,N,629,4903,1275,240,35,119,475,849,120,53,,,691,643,4.4900000000,11,10,37,3864,1323,142,503,763,90,168,0.98,Kansas City Royals,Kauffman Stadium,1233530,101,101,KCR,KCA,KCA
+1995,AL,MIN,MIN,C,5,144,72,56,88,N,N,N,N,703,5005,1398,270,34,120,471,916,105,57,,,889,814,5.7600000000,7,2,27,3816,1450,210,533,790,100,141,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1057667,101,102,MIN,MIN,MIN
+1995,AL,ML4,MIL,C,4,144,72,65,79,N,N,N,N,740,5000,1329,249,42,128,502,800,105,40,,,747,689,4.8200000000,7,4,31,3858,1391,146,603,699,105,186,0.98,Milwaukee Brewers,County Stadium,1087560,105,105,MIL,MIL,MIL
+1995,AL,NYA,NYY,E,2,145,73,79,65,N,Y,N,N,749,4947,1365,280,34,122,625,851,50,30,,,688,651,4.5600000000,18,5,35,3852,1286,159,535,908,73,121,0.98,New York Yankees,Yankee Stadium II,1705263,99,98,NYY,NYA,NYA
+1995,AL,OAK,OAK,W,4,144,72,67,77,N,N,N,N,730,4916,1296,228,18,169,565,911,112,46,,,761,697,4.9300000000,8,4,34,3819,1320,153,556,890,101,151,0.98,Oakland Athletics,Oakland Coliseum,1174310,91,91,OAK,OAK,OAK
+1995,AL,SEA,SEA,W,1,145,73,79,66,Y,N,N,N,796,4996,1377,276,20,182,549,871,110,41,,,708,644,4.5000000000,9,8,39,3868,1343,149,591,1068,104,108,0.98,Seattle Mariners,Kingdome,1643203,101,101,SEA,SEA,SEA
+1995,AL,TEX,TEX,W,3,144,72,74,70,N,N,N,N,691,4913,1304,247,24,138,526,877,90,47,,,720,665,4.6600000000,14,4,34,3855,1385,152,514,838,98,156,0.98,Texas Rangers,The Ballpark at Arlington,1985910,103,103,TEX,TEX,TEX
+1995,AL,TOR,TOR,E,5,144,72,56,88,N,N,N,N,642,5036,1309,275,27,140,492,906,75,16,,,777,701,4.8800000000,16,8,22,3876,1336,145,654,894,97,131,0.98,Toronto Blue Jays,Skydome,2826483,99,100,TOR,TOR,TOR
+1995,NL,ATL,ATL,E,1,144,72,90,54,Y,N,Y,Y,645,4814,1202,210,27,168,520,933,73,43,,,540,493,3.4400000000,18,11,34,3873,1184,107,436,1087,100,113,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,2561831,103,102,ATL,ATL,ATL
+1995,NL,CHN,CHC,C,3,144,72,73,71,N,N,N,N,693,4963,1315,267,39,158,440,953,105,37,,,671,597,4.1300000000,6,12,45,3903,1313,162,518,926,115,115,0.97,Chicago Cubs,Wrigley Field,1918265,98,98,CHC,CHN,CHN
+1995,NL,CIN,CIN,C,1,144,72,85,59,Y,N,N,N,747,4903,1326,277,35,161,519,946,190,68,,,623,577,4.0300000000,8,10,38,3867,1270,131,424,903,79,140,0.98,Cincinnati Reds,Riverfront Stadium,1837649,100,99,CIN,CIN,CIN
+1995,NL,COL,COL,W,2,144,72,77,67,N,Y,N,N,785,4994,1406,259,43,200,484,943,125,59,,,783,711,4.9700000000,1,1,43,3864,1443,160,512,891,107,146,0.98,Colorado Rockies,Coors Field,3390037,129,129,COL,COL,COL
+1995,NL,FLO,FLA,E,4,143,71,67,76,N,N,N,N,673,4886,1278,214,29,144,517,916,131,53,,,673,610,4.2700000000,12,7,29,3858,1299,139,562,994,115,143,0.97,Florida Marlins,Joe Robbie Stadium,1700466,101,101,FLA,FLO,FLO
+1995,NL,HOU,HOU,C,2,144,72,76,68,N,N,N,N,747,5097,1403,260,22,109,566,992,176,60,,,674,595,4.0600000000,6,8,32,3960,1357,118,460,1056,121,120,0.97,Houston Astros,Astrodome,1363801,93,93,HOU,HOU,HOU
+1995,NL,LAN,LAD,W,1,144,72,78,66,Y,N,N,N,634,4942,1303,191,31,140,468,1023,127,45,,,609,527,3.6600000000,16,11,37,3885,1188,125,462,1060,130,120,0.97,Los Angeles Dodgers,Dodger Stadium,2766251,91,91,LAD,LAN,LAN
+1995,NL,MON,WSN,E,5,144,72,66,78,N,N,N,N,621,4905,1268,265,24,118,400,901,120,49,,,638,586,4.1100000000,7,9,42,3849,1286,128,416,950,109,119,0.98,Montreal Expos,Stade Olympique,1309618,104,103,MON,MON,MON
+1995,NL,NYN,NYM,E,2,144,72,69,75,N,N,N,N,657,4958,1323,218,34,125,446,994,58,39,,,618,557,3.8800000000,9,9,36,3873,1296,133,401,901,115,125,0.97,New York Mets,Shea Stadium,1273183,96,97,NYM,NYN,NYN
+1995,NL,PHI,PHI,E,2,144,72,69,75,N,N,N,N,615,4950,1296,263,30,94,497,884,72,25,,,658,603,4.2100000000,8,8,41,3870,1241,134,538,980,96,139,0.98,Philadelphia Phillies,Veterans Stadium,2043598,100,101,PHI,PHI,PHI
+1995,NL,PIT,PIT,C,5,144,72,58,86,N,N,N,N,629,4937,1281,245,27,125,456,972,84,55,,,736,666,4.7000000000,11,7,29,3825,1407,130,477,871,121,138,0.97,Pittsburgh Pirates,Three Rivers Stadium,905517,102,103,PIT,PIT,PIT
+1995,NL,SDN,SDP,W,3,144,72,70,74,N,N,N,N,668,4950,1345,231,20,116,447,872,124,46,,,672,589,4.1300000000,6,10,35,3852,1242,142,512,1047,108,130,0.98,San Diego Padres,Jack Murphy Stadium,1041805,97,97,SDP,SDN,SDN
+1995,NL,SFN,SFG,W,4,144,72,67,77,N,N,N,N,652,4971,1256,229,33,152,472,1060,138,46,,,776,698,4.8600000000,12,5,34,3879,1368,173,505,801,106,142,0.98,San Francisco Giants,Candlestick Park,1241500,96,97,SFG,SFN,SFN
+1995,NL,SLN,STL,C,4,143,72,62,81,N,N,N,N,563,4779,1182,238,24,107,436,920,79,46,,,658,575,4.0900000000,4,6,38,3795,1290,135,445,842,113,156,0.98,St. Louis Cardinals,Busch Stadium II,1756727,99,100,STL,SLN,SLN
+1996,AL,BAL,BAL,E,2,163,82,88,74,N,Y,N,N,949,5689,1557,299,29,257,645,915,76,40,,,903,840,5.1500000000,13,2,44,4404,1604,209,597,1047,97,173,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3646950,100,99,BAL,BAL,BAL
+1996,AL,BOS,BOS,E,3,162,81,85,77,N,N,N,N,928,5756,1631,308,31,209,642,1020,91,44,,,921,810,5.0000000000,17,5,37,4374,1606,185,722,1165,135,152,0.97,Boston Red Sox,Fenway Park II,2315231,101,101,BOS,BOS,BOS
+1996,AL,CAL,ANA,W,4,161,81,70,91,N,N,N,N,762,5686,1571,256,24,192,527,974,53,39,,,943,849,5.3100000000,12,8,38,4317,1546,219,662,1052,128,156,0.97,California Angels,Anaheim Stadium,1820521,98,98,CAL,CAL,CAL
+1996,AL,CHA,CHW,C,2,162,81,85,77,N,N,N,N,898,5644,1586,284,33,195,701,927,105,41,,,794,735,4.5300000000,7,5,43,4383,1529,174,616,1039,109,145,0.98,Chicago White Sox,Comiskey Park II,1676403,95,95,CHW,CHA,CHA
+1996,AL,CLE,CLE,C,1,161,80,99,62,Y,N,N,N,952,5681,1665,335,23,218,671,844,160,50,,,769,702,4.3500000000,13,9,46,4356,1530,173,484,1033,124,156,0.98,Cleveland Indians,Jacobs Field,3318174,99,98,CLE,CLE,CLE
+1996,AL,DET,DET,E,5,162,81,53,109,N,N,N,N,783,5530,1413,257,21,204,546,1268,87,50,,,1103,1015,6.3800000000,10,4,22,4296,1699,241,784,957,135,157,0.97,Detroit Tigers,Tiger Stadium,1168610,100,102,DET,DET,DET
+1996,AL,KCA,KCR,C,5,161,80,75,86,N,N,N,N,746,5542,1477,286,38,123,529,943,195,85,,,786,733,4.5500000000,17,8,35,4350,1563,176,460,926,111,184,0.98,Kansas City Royals,Kauffman Stadium,1435997,99,100,KCR,KCA,KCA
+1996,AL,MIN,MIN,C,4,162,82,78,84,N,N,N,N,877,5673,1633,332,47,118,576,958,143,53,,,900,847,5.3000000000,13,5,31,4317,1561,233,581,959,94,142,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1437352,101,102,MIN,MIN,MIN
+1996,AL,ML4,MIL,C,3,162,81,80,82,N,N,N,N,894,5662,1578,304,40,178,624,986,101,48,,,899,831,5.1700000000,6,5,42,4341,1570,213,635,846,134,180,0.97,Milwaukee Brewers,County Stadium,1327155,104,104,MIL,MIL,MIL
+1996,AL,NYA,NYY,E,1,162,80,92,70,Y,N,Y,Y,871,5628,1621,293,28,162,632,909,96,46,,,787,744,4.6500000000,6,9,52,4320,1469,143,610,1139,91,146,0.98,New York Yankees,Yankee Stadium II,2250877,101,100,NYY,NYA,NYA
+1996,AL,OAK,OAK,W,3,162,81,78,84,N,N,N,N,861,5630,1492,283,21,243,640,1114,58,35,,,900,841,5.2000000000,7,5,34,4368,1638,205,644,884,102,195,0.98,Oakland Athletics,Oakland Coliseum,1148380,101,102,OAK,OAK,OAK
+1996,AL,SEA,SEA,W,2,161,81,85,76,N,N,N,N,993,5668,1625,343,19,245,670,1052,90,39,,,895,828,5.2100000000,4,4,34,4293,1562,216,605,1000,110,155,0.98,Seattle Mariners,Kingdome,2723850,100,99,SEA,SEA,SEA
+1996,AL,TEX,TEX,W,1,163,81,90,72,Y,N,N,N,928,5702,1622,323,32,221,660,1041,83,26,,,799,750,4.6600000000,19,6,43,4347,1569,168,582,976,87,150,0.98,Texas Rangers,The Ballpark at Arlington,2889020,105,105,TEX,TEX,TEX
+1996,AL,TOR,TOR,E,4,162,81,74,88,N,N,N,N,766,5599,1451,302,35,177,529,1105,116,38,,,809,735,4.5800000000,19,7,35,4335,1476,187,610,1033,110,187,0.98,Toronto Blue Jays,Skydome,2559573,99,100,TOR,TOR,TOR
+1996,NL,ATL,ATL,E,1,162,81,96,66,Y,N,Y,N,773,5614,1514,264,28,197,530,1032,83,43,,,648,578,3.5400000000,14,9,46,4407,1372,120,451,1245,130,143,0.98,Atlanta Braves,Atlanta-Fulton County Stadium,2901242,106,104,ATL,ATL,ATL
+1996,NL,CHN,CHC,C,4,162,81,76,86,N,N,N,N,772,5531,1388,267,19,175,523,1090,108,50,,,771,705,4.3600000000,10,11,34,4368,1447,184,546,1027,104,147,0.98,Chicago Cubs,Wrigley Field,2219110,103,103,CHC,CHN,CHN
+1996,NL,CIN,CIN,C,3,162,81,81,81,N,N,N,N,778,5455,1398,259,36,191,604,1134,171,63,,,773,694,4.3300000000,6,8,52,4329,1447,167,591,1089,121,145,0.98,Cincinnati Reds,Riverfront Stadium,1861428,101,101,CIN,CIN,CIN
+1996,NL,COL,COL,W,3,162,81,83,79,N,N,N,N,961,5590,1607,297,37,221,527,1108,201,66,,,964,885,5.6000000000,5,5,34,4266,1597,198,624,932,149,167,0.97,Colorado Rockies,Coors Field,3891014,123,124,COL,COL,COL
+1996,NL,FLO,FLA,E,3,162,81,80,82,N,N,N,N,688,5498,1413,240,30,150,553,1122,99,46,,,703,633,3.9500000000,8,13,41,4329,1386,113,598,1050,111,187,0.98,Florida Marlins,Joe Robbie Stadium,1746767,97,97,FLA,FLO,FLO
+1996,NL,HOU,HOU,C,2,162,81,82,80,N,N,N,N,753,5508,1445,297,29,129,554,1057,180,63,,,792,704,4.3800000000,13,4,35,4341,1541,154,539,1163,138,130,0.97,Houston Astros,Astrodome,1975888,92,92,HOU,HOU,HOU
+1996,NL,LAN,LAD,W,2,162,81,90,72,N,Y,N,N,703,5538,1396,215,33,150,516,1190,124,40,,,652,567,3.4800000000,6,9,50,4398,1378,125,534,1212,125,143,0.98,Los Angeles Dodgers,Dodger Stadium,3188454,93,92,LAD,LAN,LAN
+1996,NL,MON,WSN,E,2,162,81,88,74,N,N,N,N,741,5505,1441,297,27,148,492,1077,108,34,,,668,605,3.7800000000,11,7,43,4324,1353,152,482,1206,126,121,0.98,Montreal Expos,Stade Olympique,1616709,102,102,MON,MON,MON
+1996,NL,NYN,NYM,E,4,162,81,71,91,N,N,N,N,746,5618,1515,267,47,147,445,1069,97,48,,,779,675,4.2200000000,10,10,41,4320,1517,159,532,999,157,163,0.97,New York Mets,Shea Stadium,1588323,95,95,NYM,NYN,NYN
+1996,NL,PHI,PHI,E,5,162,81,67,95,N,N,N,N,650,5499,1405,249,39,132,536,1092,117,41,,,790,710,4.4900000000,12,6,42,4269,1463,160,510,1044,115,145,0.98,Philadelphia Phillies,Veterans Stadium,1801677,100,101,PHI,PHI,PHI
+1996,NL,PIT,PIT,C,5,162,80,73,89,N,N,N,N,776,5665,1509,319,33,138,510,989,126,49,,,833,750,4.6400000000,5,7,37,4360,1602,183,479,1044,128,144,0.98,Pittsburgh Pirates,Three Rivers Stadium,1332150,104,104,PIT,PIT,PIT
+1996,NL,SDN,SDP,W,1,162,81,91,71,Y,N,N,N,771,5655,1499,285,24,147,601,1014,109,55,,,682,617,3.7300000000,5,11,47,4467,1395,138,506,1194,118,136,0.98,San Diego Padres,Jack Murphy Stadium,2187886,95,95,SDP,SDN,SDN
+1996,NL,SFN,SFG,W,4,162,82,68,94,N,N,N,N,752,5533,1400,245,21,153,615,1189,113,53,,,862,756,4.7200000000,9,8,35,4326,1520,194,570,997,134,165,0.97,San Francisco Giants,Candlestick Park,1413922,95,96,SFG,SFN,SFN
+1996,NL,SLN,STL,C,1,162,81,88,74,Y,N,N,N,759,5502,1468,281,31,142,495,1089,149,58,,,706,642,3.9800000000,13,11,43,4356,1380,173,539,1050,125,139,0.98,St. Louis Cardinals,Busch Stadium II,2654718,100,100,STL,SLN,SLN
+1997,AL,ANA,ANA,W,2,162,82,84,78,N,N,N,N,829,5628,1531,279,25,161,617,953,126,72,,,794,730,4.5200000000,9,5,39,4362,1506,202,605,1050,126,140,0.98,Anaheim Angels,Edison International Field,1767330,102,102,ANA,ANA,ANA
+1997,AL,BAL,BAL,E,1,162,81,98,64,Y,N,N,N,812,5584,1498,264,22,196,586,952,63,26,,,681,635,3.9100000000,8,10,59,4383,1404,164,563,1139,97,148,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3711132,97,96,BAL,BAL,BAL
+1997,AL,BOS,BOS,E,4,162,81,78,84,N,N,N,N,851,5781,1684,373,32,185,514,1044,68,48,,,857,785,4.8700000000,7,4,40,4355,1567,149,610,987,136,179,0.97,Boston Red Sox,Fenway Park II,2226136,102,102,BOS,BOS,BOS
+1997,AL,CHA,CHW,C,2,161,81,80,81,N,N,N,N,779,5491,1498,260,28,158,569,901,106,52,,,833,749,4.7400000000,6,7,52,4266,1505,175,575,961,125,131,0.97,Chicago White Sox,Comiskey Park II,1864782,96,96,CHW,CHA,CHA
+1997,AL,CLE,CLE,C,1,161,81,86,75,Y,N,Y,N,868,5556,1589,301,22,220,617,955,118,59,,,815,749,4.7300000000,4,3,39,4275,1528,181,575,1036,108,159,0.98,Cleveland Indians,Jacobs Field,3404750,103,102,CLE,CLE,CLE
+1997,AL,DET,DET,E,3,162,81,79,83,N,N,N,N,784,5481,1415,268,32,176,578,1164,161,72,,,790,732,4.5600000000,13,8,42,4335,1476,178,552,982,91,146,0.98,Detroit Tigers,Tiger Stadium,1365157,99,100,DET,DET,DET
+1997,AL,KCA,KCR,C,5,161,80,67,94,N,N,N,N,747,5599,1478,256,35,158,561,1061,130,66,,,820,755,4.7100000000,11,5,29,4329,1530,186,531,961,88,168,0.98,Kansas City Royals,Kauffman Stadium,1517638,101,102,KCR,KCA,KCA
+1997,AL,MIN,MIN,C,4,162,81,68,94,N,N,N,N,772,5634,1522,305,40,132,495,1121,151,52,,,861,800,5.0200000000,10,4,30,4302,1596,187,495,908,100,170,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1411064,101,101,MIN,MIN,MIN
+1997,AL,ML4,MIL,C,3,161,80,78,83,N,N,N,N,681,5444,1415,294,27,135,494,967,103,55,,,742,670,4.2200000000,6,8,44,4282,1419,177,542,1012,125,171,0.98,Milwaukee Brewers,County Stadium,1444027,101,102,MIL,MIL,MIL
+1997,AL,NYA,NYY,E,2,162,80,96,66,N,Y,N,N,891,5710,1636,325,23,161,676,954,99,58,,,688,626,3.8400000000,11,10,51,4401,1463,144,532,1165,105,156,0.98,New York Yankees,Yankee Stadium II,2580325,100,98,NYY,NYA,NYA
+1997,AL,OAK,OAK,W,4,162,81,65,97,N,N,N,N,764,5589,1451,274,23,197,642,1181,71,36,,,946,881,5.4900000000,2,1,38,4335,1734,197,642,953,121,170,0.98,Oakland Athletics,Oakland Coliseum,1264218,96,97,OAK,OAK,OAK
+1997,AL,SEA,SEA,W,1,162,81,90,72,Y,N,N,N,925,5614,1574,312,21,264,626,1110,89,40,,,833,770,4.7900000000,9,8,38,4341,1500,192,598,1207,123,143,0.98,Seattle Mariners,Kingdome,3192237,98,98,SEA,SEA,SEA
+1997,AL,TEX,TEX,W,3,162,81,77,85,N,N,N,N,807,5651,1547,311,27,187,500,1116,72,37,,,823,744,4.6800000000,8,9,33,4289,1598,169,541,925,122,155,0.98,Texas Rangers,The Ballpark at Arlington,2945228,105,105,TEX,TEX,TEX
+1997,AL,TOR,TOR,E,5,162,81,76,86,N,N,N,N,654,5473,1333,275,41,147,487,1138,134,50,,,694,628,3.9200000000,19,16,34,4326,1453,167,497,1150,97,150,0.98,Toronto Blue Jays,Skydome,2589297,99,99,TOR,TOR,TOR
+1997,NL,ATL,ATL,E,1,162,81,101,61,Y,N,N,N,791,5528,1490,268,37,174,597,1160,108,58,,,581,518,3.1800000000,21,17,37,4395,1319,111,450,1196,114,136,0.98,Atlanta Braves,Turner Field,3464488,102,99,ATL,ATL,ATL
+1997,NL,CHN,CHC,C,5,162,81,68,94,N,N,N,N,687,5489,1444,269,39,127,451,1003,116,60,,,759,705,4.4400000000,6,4,37,4287,1451,185,590,1072,115,117,0.98,Chicago Cubs,Wrigley Field,2190308,102,102,CHC,CHN,CHN
+1997,NL,CIN,CIN,C,3,162,81,76,86,N,N,N,N,651,5484,1386,269,27,142,518,1113,190,67,,,764,712,4.4200000000,5,8,49,4347,1408,173,558,1159,106,129,0.98,Cincinnati Reds,Cinergy Field,1785788,102,102,CIN,CIN,CIN
+1997,NL,COL,COL,W,3,162,81,83,79,N,N,N,N,923,5603,1611,269,40,239,562,1060,137,65,,,908,835,5.2500000000,9,5,38,4296,1697,196,566,870,111,202,0.98,Colorado Rockies,Coors Field,3888453,122,123,COL,COL,COL
+1997,NL,FLO,FLA,E,2,162,81,92,70,N,Y,Y,Y,740,5439,1410,272,28,136,686,1074,115,58,,,669,615,3.8300000000,12,10,39,4338,1353,131,639,1188,119,167,0.98,Florida Marlins,Joe Robbie Stadium,2364387,95,96,FLA,FLO,FLO
+1997,NL,HOU,HOU,C,1,162,81,84,78,Y,N,N,N,777,5502,1427,314,40,133,633,1085,171,74,,,660,595,3.6700000000,16,12,37,4377,1379,134,511,1138,131,169,0.97,Houston Astros,Astrodome,2046781,96,95,HOU,HOU,HOU
+1997,NL,LAN,LAD,W,2,162,81,88,74,N,N,N,N,742,5544,1488,242,33,174,498,1079,131,64,,,645,588,3.6300000000,6,6,45,4377,1325,163,546,1232,116,104,0.98,Los Angeles Dodgers,Dodger Stadium,3319504,93,92,LAD,LAN,LAN
+1997,NL,MON,WSN,E,4,162,81,78,84,N,N,N,N,691,5526,1423,339,34,172,420,1084,75,46,,,740,666,4.1400000000,27,14,37,4341,1365,149,557,1138,131,150,0.97,Montreal Expos,Stade Olympique,1497609,99,99,MON,MON,MON
+1997,NL,NYN,NYM,E,3,162,81,88,74,N,N,N,N,777,5524,1448,274,28,153,550,1029,97,74,,,709,640,3.9500000000,7,8,49,4377,1452,160,504,982,117,165,0.98,New York Mets,Shea Stadium,1766174,97,97,NYM,NYN,NYN
+1997,NL,PHI,PHI,E,5,162,81,68,94,N,N,N,N,668,5443,1390,290,35,116,519,1032,92,56,,,840,768,4.8700000000,13,7,35,4260,1441,171,616,1209,105,134,0.98,Philadelphia Phillies,Veterans Stadium,1490638,100,101,PHI,PHI,PHI
+1997,NL,PIT,PIT,C,2,162,81,79,83,N,N,N,N,725,5503,1440,291,52,129,481,1161,160,50,,,760,683,4.2800000000,6,8,41,4308,1503,143,560,1080,131,149,0.97,Pittsburgh Pirates,Three Rivers Stadium,1657022,103,103,PIT,PIT,PIT
+1997,NL,SDN,SDP,W,4,162,81,76,86,N,N,N,N,795,5609,1519,275,16,152,604,1129,140,60,,,891,804,4.9900000000,5,2,43,4350,1581,172,596,1059,125,132,0.98,San Diego Padres,Qualcomm Stadium,2089333,93,93,SDP,SDN,SDN
+1997,NL,SFN,SFG,W,1,162,81,90,72,Y,N,N,N,784,5485,1415,266,37,172,642,1120,121,49,,,793,709,4.4100000000,5,9,45,4338,1494,160,578,1044,120,157,0.98,San Francisco Giants,3Com Park,1690869,98,98,SFG,SFN,SFN
+1997,NL,SLN,STL,C,4,162,81,73,89,N,N,N,N,689,5524,1409,269,39,144,543,1191,164,60,,,708,631,3.9000000000,5,3,39,4367,1422,124,536,1130,123,156,0.98,St. Louis Cardinals,Busch Stadium II,2634014,99,99,STL,SLN,SLN
+1998,AL,ANA,ANA,W,2,162,81,85,77,N,N,N,N,787,5630,1530,314,27,147,510,1028,93,45,,,783,720,4.4900000000,3,5,52,4332,1481,164,630,1091,106,146,0.98,Anaheim Angels,Edison International Field,2519280,102,102,ANA,ANA,ANA
+1998,AL,BAL,BAL,E,4,162,81,79,83,N,N,N,N,817,5565,1520,303,11,214,593,903,86,48,,,785,752,4.7300000000,16,10,37,4293,1505,169,535,1065,81,144,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3684650,98,97,BAL,BAL,BAL
+1998,AL,BOS,BOS,E,2,162,81,92,70,N,Y,N,N,876,5601,1568,338,35,205,541,1049,72,39,,,729,669,4.1900000000,5,8,53,4308,1406,168,504,1025,105,128,0.98,Boston Red Sox,Fenway Park II,2314704,102,101,BOS,BOS,BOS
+1998,AL,CHA,CHW,C,2,163,81,80,82,N,N,N,N,861,5585,1516,291,38,198,551,916,127,46,,,931,837,5.2400000000,8,4,42,4315,1569,211,580,911,140,161,0.97,Chicago White Sox,Comiskey Park II,1391146,98,98,CHW,CHA,CHA
+1998,AL,CLE,CLE,C,1,162,81,89,73,Y,N,N,N,850,5616,1530,334,30,198,630,1061,143,60,,,779,722,4.4500000000,9,4,47,4380,1552,171,563,1037,110,146,0.98,Cleveland Indians,Jacobs Field,3467299,103,102,CLE,CLE,CLE
+1998,AL,DET,DET,C,5,162,81,65,97,N,N,N,N,722,5664,1494,306,29,165,455,1070,122,62,,,863,792,4.9300000000,9,4,32,4338,1551,185,595,947,115,164,0.98,Detroit Tigers,Tiger Stadium,1409391,100,101,DET,DET,DET
+1998,AL,KCA,KCR,C,3,161,80,72,89,N,N,N,N,714,5546,1459,274,40,134,475,984,135,50,,,899,823,5.1600000000,6,7,46,4308,1590,196,568,999,125,172,0.98,Kansas City Royals,Kauffman Stadium,1494875,101,102,KCR,KCA,KCA
+1998,AL,MIN,MIN,C,4,162,81,70,92,N,N,N,N,734,5641,1499,285,32,115,506,915,112,54,,,818,765,4.7600000000,7,9,42,4342,1622,180,457,952,108,135,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1165976,101,102,MIN,MIN,MIN
+1998,AL,NYA,NYY,E,1,162,81,114,48,Y,N,Y,Y,965,5643,1625,290,31,207,653,1025,153,63,,,656,618,3.8200000000,22,16,48,4369,1357,156,466,1080,98,146,0.98,New York Yankees,Yankee Stadium II,2955193,97,95,NYY,NYA,NYA
+1998,AL,OAK,OAK,W,4,162,81,74,88,N,N,N,N,804,5490,1413,295,13,149,633,1122,131,47,,,866,770,4.8300000000,12,4,39,4302,1555,179,529,922,141,155,0.97,Oakland Athletics,Oakland Coliseum,1232343,96,97,OAK,OAK,OAK
+1998,AL,SEA,SEA,W,3,161,81,76,85,N,N,N,N,859,5628,1553,321,28,234,558,1081,115,39,,,855,783,4.9500000000,17,7,31,4272,1530,196,528,1156,125,139,0.97,Seattle Mariners,Kingdome,2651511,99,99,SEA,SEA,SEA
+1998,AL,TBA,TBD,E,5,162,81,63,99,N,N,N,N,620,5555,1450,267,43,111,473,1107,120,73,,,751,697,4.3500000000,7,8,28,4329,1425,171,643,1008,94,178,0.98,Tampa Bay Devil Rays,Tropicana Field,2506293,101,102,TBD,TBA,TBA
+1998,AL,TEX,TEX,W,1,162,81,88,74,Y,N,N,N,940,5672,1637,314,32,201,595,1045,82,47,,,871,795,5.0000000000,10,8,46,4293,1624,164,519,994,122,140,0.98,Texas Rangers,The Ballpark at Arlington,2927399,104,103,TEX,TEX,TEX
+1998,AL,TOR,TOR,E,3,163,81,88,74,N,N,N,N,816,5580,1482,316,19,221,564,1132,184,81,,,768,698,4.2900000000,10,11,47,4395,1443,169,587,1154,125,131,0.97,Toronto Blue Jays,Skydome,2454303,100,99,TOR,TOR,TOR
+1998,NL,ARI,ARI,W,5,162,81,65,97,N,N,N,N,665,5491,1353,235,46,159,489,1239,73,38,,,812,738,4.6400000000,7,6,37,4296,1463,188,489,908,100,125,0.98,Arizona Diamondbacks,Bank One Ballpark,3610290,100,99,ARI,ARI,ARI
+1998,NL,ATL,ATL,E,1,162,81,106,56,Y,N,N,N,826,5484,1489,297,26,215,548,1062,98,43,,,581,519,3.2500000000,24,23,45,4315,1291,117,467,1232,91,139,0.98,Atlanta Braves,Turner Field,3360860,100,98,ATL,ATL,ATL
+1998,NL,CHN,CHC,C,2,163,82,90,73,N,Y,N,N,831,5649,1494,250,34,212,601,1223,65,44,,,792,739,4.5000000000,7,7,56,4431,1528,180,575,1207,101,107,0.98,Chicago Cubs,Wrigley Field,2623194,103,103,CHC,CHN,CHN
+1998,NL,CIN,CIN,C,4,162,81,77,85,N,N,N,N,750,5496,1441,298,28,138,608,1107,95,42,,,760,711,4.4400000000,6,8,42,4323,1400,170,573,1098,122,142,0.98,Cincinnati Reds,Cinergy Field,1793649,102,102,CIN,CIN,CIN
+1998,NL,COL,COL,W,4,162,81,77,85,N,N,N,N,826,5632,1640,333,36,183,469,949,67,47,,,855,796,5.0000000000,9,5,36,4297,1583,174,562,951,102,193,0.98,Colorado Rockies,Coors Field,3792683,121,122,COL,COL,COL
+1998,NL,FLO,FLA,E,5,162,81,54,108,N,N,N,N,667,5558,1381,277,36,114,525,1120,115,57,,,923,837,5.2000000000,11,3,24,4348,1617,182,715,1016,129,177,0.97,Florida Marlins,Joe Robbie Stadium,1730384,94,95,FLA,FLO,FLO
+1998,NL,HOU,HOU,C,1,162,81,102,60,Y,N,N,N,874,5641,1578,326,28,166,621,1122,155,51,,,620,572,3.5000000000,12,11,44,4413,1435,147,465,1187,108,144,0.98,Houston Astros,Astrodome,2458451,98,97,HOU,HOU,HOU
+1998,NL,LAN,LAD,W,3,162,81,83,79,N,N,N,N,669,5459,1374,209,27,159,447,1056,137,53,,,678,613,3.8100000000,16,10,47,4341,1332,135,587,1178,134,154,0.97,Los Angeles Dodgers,Dodger Stadium,3089222,95,95,LAD,LAN,LAN
+1998,NL,MIL,MIL,C,5,162,81,74,88,N,N,N,N,707,5541,1439,266,17,152,532,1039,81,59,,,812,746,4.6300000000,2,2,39,4353,1538,188,550,1063,110,192,0.98,Milwaukee Brewers,County Stadium,1811593,100,101,MIL,ML4,MIL
+1998,NL,MON,WSN,E,4,162,81,65,97,N,N,N,N,644,5418,1348,280,32,147,439,1058,91,46,,,783,696,4.3900000000,4,5,39,4281,1448,156,533,1017,155,127,0.97,Montreal Expos,Stade Olympique,914909,98,99,MON,MON,MON
+1998,NL,NYN,NYM,E,2,162,81,88,74,N,N,N,N,706,5510,1425,289,24,136,572,1049,62,46,,,645,611,3.7700000000,9,16,46,4374,1381,152,532,1129,101,151,0.98,New York Mets,Shea Stadium,2287948,99,99,NYM,NYN,NYN
+1998,NL,PHI,PHI,E,3,162,81,75,87,N,N,N,N,713,5617,1482,286,36,126,508,1080,97,45,,,808,754,4.6400000000,21,11,32,4389,1476,188,544,1176,110,131,0.98,Philadelphia Phillies,Veterans Stadium,1715722,102,103,PHI,PHI,PHI
+1998,NL,PIT,PIT,C,6,163,80,69,93,N,N,N,N,650,5493,1395,271,35,107,393,1060,159,51,,,718,630,3.9100000000,7,10,41,4347,1433,147,530,1112,140,161,0.97,Pittsburgh Pirates,Three Rivers Stadium,1560950,102,103,PIT,PIT,PIT
+1998,NL,SDN,SDP,W,1,162,81,98,64,Y,N,Y,N,749,5490,1390,292,30,167,604,1072,79,37,,,635,587,3.6300000000,14,11,59,4363,1384,139,501,1217,104,155,0.98,San Diego Padres,Qualcomm Stadium,2555874,92,92,SDP,SDN,SDN
+1998,NL,SFN,SFG,W,2,163,81,89,74,N,N,N,N,845,5628,1540,292,26,161,678,1040,102,51,,,739,688,4.1900000000,6,6,44,4431,1457,171,562,1089,101,157,0.98,San Francisco Giants,3Com Park,1925364,95,95,SFG,SFN,SFN
+1998,NL,SLN,STL,C,3,163,82,83,79,N,N,N,N,810,5593,1444,292,30,223,676,1179,133,41,,,782,705,4.3200000000,6,10,44,4409,1513,151,558,972,142,160,0.97,St. Louis Cardinals,Busch Stadium II,3195691,100,100,STL,SLN,SLN
+1999,AL,ANA,ANA,W,4,162,81,70,92,N,N,N,N,711,5494,1404,248,22,158,511,1022,71,45,,,826,762,4.7900000000,4,7,37,4293,1472,177,624,877,106,156,0.98,Anaheim Angels,Edison International Field,2253123,99,100,ANA,ANA,ANA
+1999,AL,BAL,BAL,E,4,162,81,78,84,N,N,N,N,851,5637,1572,299,21,203,615,890,107,46,,,815,761,4.7700000000,17,11,33,4305,1468,198,647,982,89,192,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3433150,96,96,BAL,BAL,BAL
+1999,AL,BOS,BOS,E,2,162,81,94,68,N,Y,N,N,836,5579,1551,334,42,176,597,928,67,39,,,718,638,4.0000000000,6,12,50,4309,1396,160,469,1131,127,131,0.97,Boston Red Sox,Fenway Park II,2446162,104,103,BOS,BOS,BOS
+1999,AL,CHA,CHW,C,2,162,81,75,86,N,N,N,N,777,5644,1563,298,37,162,499,810,110,50,,,870,786,4.9200000000,6,3,39,4314,1608,210,596,968,136,148,0.97,Chicago White Sox,Comiskey Park II,1338851,101,101,CHW,CHA,CHA
+1999,AL,CLE,CLE,C,1,162,81,97,65,Y,N,N,N,1009,5634,1629,309,32,209,743,1099,147,50,,,860,789,4.9000000000,3,6,46,4350,1503,197,634,1120,106,153,0.98,Cleveland Indians,Jacobs Field,3468456,104,103,CLE,CLE,CLE
+1999,AL,DET,DET,C,3,161,81,69,92,N,N,N,N,747,5481,1433,289,34,212,458,1049,108,70,,,882,817,5.1800000000,4,6,33,4261,1528,209,583,976,106,155,0.98,Detroit Tigers,Tiger Stadium,2026441,99,101,DET,DET,DET
+1999,AL,KCA,KCR,C,4,161,80,64,97,N,N,N,N,856,5624,1584,294,52,151,535,932,127,39,,,921,844,5.3500000000,11,3,29,4261,1607,202,643,831,125,189,0.98,Kansas City Royals,Kauffman Stadium,1506068,102,103,KCR,KCA,KCA
+1999,AL,MIN,MIN,C,5,161,81,63,97,N,N,N,N,686,5495,1450,285,30,105,500,978,118,60,,,845,794,5.0200000000,12,8,34,4269,1591,208,487,927,92,144,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1202829,103,104,MIN,MIN,MIN
+1999,AL,NYA,NYY,E,1,162,81,98,64,Y,N,Y,Y,900,5568,1568,302,36,193,718,978,104,57,,,731,660,4.1300000000,6,10,50,4318,1402,158,581,1111,111,130,0.98,New York Yankees,Yankee Stadium II,3292736,98,97,NYY,NYA,NYA
+1999,AL,OAK,OAK,W,2,162,81,87,75,N,N,N,N,893,5519,1430,287,20,235,770,1129,70,37,,,846,749,4.6900000000,6,5,48,4314,1537,160,569,967,122,162,0.98,Oakland Athletics,Oakland Coliseum,1434610,94,94,OAK,OAK,OAK
+1999,AL,SEA,SEA,W,3,162,81,79,83,N,N,N,N,859,5572,1499,263,21,244,610,1095,130,45,,,905,834,5.2400000000,7,6,40,4300,1613,191,684,980,113,180,0.98,Seattle Mariners,Kingdome / Safeco Field,2916346,102,103,SEA,SEA,SEA
+1999,AL,TBA,TBD,E,5,162,81,69,93,N,N,N,N,772,5586,1531,272,29,145,544,1042,73,49,,,913,805,5.0600000000,6,5,45,4297,1606,172,695,1055,135,198,0.97,Tampa Bay Devil Rays,Tropicana Field,1562827,100,102,TBD,TBA,TBA
+1999,AL,TEX,TEX,W,1,162,81,95,67,Y,N,N,N,945,5651,1653,304,29,230,611,937,111,54,,,859,809,5.0700000000,6,9,47,4306,1626,186,509,979,119,167,0.98,Texas Rangers,The Ballpark at Arlington,2771469,105,105,TEX,TEX,TEX
+1999,AL,TOR,TOR,E,3,162,81,84,78,N,N,N,N,883,5642,1580,337,14,212,578,1077,119,48,,,862,786,4.9200000000,14,9,39,4315,1582,191,575,1009,106,164,0.98,Toronto Blue Jays,Skydome,2163464,101,101,TOR,TOR,TOR
+1999,NL,ARI,ARI,W,1,162,81,100,62,Y,N,N,N,908,5658,1566,289,46,216,588,1045,137,39,,,676,615,3.7700000000,16,9,42,4401,1387,176,543,1198,104,129,0.98,Arizona Diamondbacks,Bank One Ballpark,3019654,101,101,ARI,ARI,ARI
+1999,NL,ATL,ATL,E,1,162,81,103,59,Y,N,Y,N,840,5569,1481,309,23,197,608,962,148,66,,,661,593,3.6300000000,9,9,45,4413,1398,142,507,1197,111,122,0.98,Atlanta Braves,Turner Field,3284897,100,98,ATL,ATL,ATL
+1999,NL,CHN,CHC,C,6,162,81,67,95,N,N,N,N,747,5482,1411,255,35,189,571,1170,60,44,,,920,837,5.2700000000,11,6,32,4291,1619,221,529,980,139,135,0.97,Chicago Cubs,Wrigley Field,2813854,97,98,CHC,CHN,CHN
+1999,NL,CIN,CIN,C,2,163,82,96,67,N,N,N,N,865,5649,1536,312,37,209,569,1125,164,54,,,711,648,3.9900000000,6,11,55,4384,1309,190,636,1081,105,137,0.98,Cincinnati Reds,Cinergy Field,2061222,103,103,CIN,CIN,CIN
+1999,NL,COL,COL,W,5,162,81,72,90,N,N,N,N,906,5716,1644,305,39,223,508,863,70,43,,,1028,955,6.0200000000,12,2,33,4285,1700,237,737,1032,118,186,0.98,Colorado Rockies,Coors Field,3481065,127,127,COL,COL,COL
+1999,NL,FLO,FLA,E,5,162,80,64,98,N,N,N,N,691,5578,1465,266,44,128,479,1145,92,46,,,852,781,4.9000000000,6,5,33,4306,1560,171,655,943,127,150,0.97,Florida Marlins,Pro Player Stadium,1369421,93,95,FLA,FLO,FLO
+1999,NL,HOU,HOU,C,1,162,82,97,65,Y,N,N,N,823,5485,1463,293,23,168,728,1138,166,75,,,675,622,3.8400000000,12,8,48,4375,1485,128,478,1204,106,168,0.98,Houston Astros,Astrodome,2706017,100,98,HOU,HOU,HOU
+1999,NL,LAN,LAD,W,3,162,81,77,85,N,N,N,N,793,5567,1480,253,23,187,594,1030,167,68,,,787,718,4.4500000000,8,6,37,4357,1438,192,594,1077,137,134,0.97,Los Angeles Dodgers,Dodger Stadium,3095346,95,94,LAD,LAN,LAN
+1999,NL,MIL,MIL,C,5,161,80,74,87,N,N,N,N,815,5582,1524,299,30,165,658,1065,81,33,,,886,812,5.0700000000,2,5,40,4327,1618,213,616,987,127,142,0.97,Milwaukee Brewers,County Stadium,1701796,99,99,MIL,ML4,MIL
+1999,NL,MON,WSN,E,4,162,81,68,94,N,N,N,N,718,5559,1473,320,47,163,438,939,70,51,,,853,747,4.6900000000,6,4,44,4302,1505,152,572,1043,160,126,0.97,Montreal Expos,Stade Olympique,773277,97,98,MON,MON,MON
+1999,NL,NYN,NYM,E,2,163,81,97,66,N,Y,N,N,853,5572,1553,297,14,181,717,994,150,61,,,711,691,4.2700000000,5,7,49,4369,1372,167,617,1172,68,147,0.98,New York Mets,Shea Stadium,2725668,98,97,NYM,NYN,NYN
+1999,NL,PHI,PHI,E,3,162,81,77,85,N,N,N,N,841,5598,1539,302,44,161,631,1081,125,35,,,846,788,4.9300000000,11,6,32,4314,1494,212,627,1030,100,143,0.98,Philadelphia Phillies,Veterans Stadium,1825337,105,105,PHI,PHI,PHI
+1999,NL,PIT,PIT,C,3,161,81,78,83,N,N,N,N,775,5468,1417,282,40,171,573,1197,112,44,,,782,689,4.3300000000,8,3,34,4297,1444,160,633,1083,147,174,0.97,Pittsburgh Pirates,Three Rivers Stadium,1638023,101,101,PIT,PIT,PIT
+1999,NL,SDN,SDP,W,4,162,81,74,88,N,N,N,N,710,5394,1360,256,22,153,631,1169,174,67,,,781,705,4.4700000000,5,6,43,4260,1454,193,529,1078,129,151,0.97,San Diego Padres,Qualcomm Stadium,2523538,92,92,SDP,SDN,SDN
+1999,NL,SFN,SFG,W,2,162,81,86,76,N,N,N,N,872,5563,1507,307,18,188,696,1028,109,56,,,831,762,4.7100000000,6,3,42,4368,1486,194,655,1076,105,150,0.98,San Francisco Giants,3Com Park,2078399,95,94,SFG,SFN,SFN
+1999,NL,SLN,STL,C,4,161,80,75,86,N,N,N,N,809,5570,1461,274,27,194,613,1202,134,48,,,838,761,4.7400000000,5,3,38,4335,1519,161,667,1025,132,161,0.97,St. Louis Cardinals,Busch Stadium II,3225334,101,101,STL,SLN,SLN
+2000,AL,ANA,ANA,W,3,162,81,82,80,N,N,N,N,864,5628,1574,309,34,236,608,1024,93,52,47,43,869,805,5.0000000000,5,3,46,4344,1534,228,662,846,134,184,0.97,Anaheim Angels,Edison International Field,2066982,102,103,ANA,ANA,ANA
+2000,AL,BAL,BAL,E,4,162,81,74,88,N,N,N,N,794,5549,1508,310,22,184,558,900,126,65,49,54,913,855,5.3700000000,14,6,33,4299,1547,202,665,1017,116,151,0.98,Baltimore Orioles,Oriole Park at Camden Yards,3297031,95,96,BAL,BAL,BAL
+2000,AL,BOS,BOS,E,2,162,81,85,77,N,N,N,N,792,5630,1503,316,32,167,611,1019,43,30,42,48,745,683,4.2300000000,7,12,46,4357,1433,173,499,1121,109,120,0.98,Boston Red Sox,Fenway Park II,2585895,104,103,BOS,BOS,BOS
+2000,AL,CHA,CHW,C,1,162,81,95,67,Y,N,N,N,978,5646,1615,325,33,216,591,960,119,42,53,61,839,751,4.6600000000,5,7,43,4350,1509,195,614,1037,133,190,0.97,Chicago White Sox,Comiskey Park II,1947799,102,102,CHW,CHA,CHA
+2000,AL,CLE,CLE,C,2,162,81,90,72,N,N,N,N,950,5683,1639,310,30,221,685,1057,113,34,51,52,816,775,4.8400000000,6,5,34,4326,1511,173,666,1213,72,149,0.98,Cleveland Indians,Jacobs Field,3456278,101,100,CLE,CLE,CLE
+2000,AL,DET,DET,C,3,162,81,79,83,N,N,N,N,823,5644,1553,307,41,177,562,982,83,38,43,49,827,755,4.7100000000,6,6,44,4329,1583,177,496,978,105,171,0.98,Detroit Tigers,Comerica Park,2438617,95,95,DET,DET,DET
+2000,AL,KCA,KCR,C,4,162,81,77,85,N,N,N,N,879,5709,1644,281,27,150,511,840,121,35,48,70,930,876,5.4800000000,10,6,29,4317,1585,239,693,927,102,185,0.98,Kansas City Royals,Kauffman Stadium,1564847,103,103,KCR,KCA,KCA
+2000,AL,MIN,MIN,C,5,162,81,69,93,N,N,N,N,748,5615,1516,325,49,116,556,1021,90,45,35,51,880,819,5.1500000000,6,4,35,4297,1634,212,516,1042,102,155,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1000760,104,105,MIN,MIN,MIN
+2000,AL,NYA,NYY,E,1,161,80,87,74,Y,N,Y,Y,871,5556,1541,294,25,205,631,1007,99,48,57,50,814,753,4.7600000000,9,6,40,4272,1458,177,577,1040,109,135,0.98,New York Yankees,Yankee Stadium II,3055435,99,98,NYY,NYA,NYA
+2000,AL,OAK,OAK,W,1,161,81,91,70,Y,N,N,N,947,5560,1501,281,23,239,750,1159,40,15,52,44,813,730,4.5800000000,7,11,43,4305,1535,158,615,963,134,164,0.97,Oakland Athletics,Oakland Coliseum,1603744,96,95,OAK,OAK,OAK
+2000,AL,SEA,SEA,W,2,162,81,91,71,N,Y,N,N,907,5497,1481,300,26,198,775,1073,122,56,48,61,780,720,4.5000000000,4,10,44,4324,1442,167,634,998,99,178,0.98,Seattle Mariners,Safeco Field,2914624,95,93,SEA,SEA,SEA
+2000,AL,TBA,TBD,E,5,161,80,69,92,N,N,N,N,733,5505,1414,253,22,162,559,1022,90,46,48,40,842,773,4.8600000000,10,8,38,4293,1553,198,533,955,118,171,0.98,Tampa Bay Devil Rays,Tropicana Field,1449673,99,100,TBD,TBA,TBA
+2000,AL,TEX,TEX,W,4,162,81,71,91,N,N,N,N,848,5648,1601,330,35,173,580,922,69,47,39,48,974,876,5.5200000000,3,4,39,4287,1683,202,661,918,135,162,0.97,Texas Rangers,The Ballpark at Arlington,2588401,102,102,TEX,TEX,TEX
+2000,AL,TOR,TOR,E,3,162,81,83,79,N,N,N,N,861,5677,1562,328,21,244,526,1026,89,34,60,34,908,821,5.1400000000,15,4,37,4311,1615,195,560,978,100,176,0.98,Toronto Blue Jays,Skydome,1705712,103,103,TOR,TOR,TOR
+2000,NL,ARI,ARI,W,3,162,81,85,77,N,N,N,N,792,5527,1466,282,44,179,535,975,97,44,59,58,754,698,4.3500000000,16,8,38,4330,1441,190,500,1220,107,138,0.98,Arizona Diamondbacks,Bank One Ballpark,2942251,105,103,ARI,ARI,ARI
+2000,NL,ATL,ATL,E,1,162,81,95,67,Y,N,N,N,810,5489,1490,274,26,179,595,1010,148,56,59,45,714,648,4.0500000000,13,9,53,4320,1428,165,484,1093,129,138,0.97,Atlanta Braves,Turner Field,3234304,101,99,ATL,ATL,ATL
+2000,NL,CHN,CHC,C,6,162,81,65,97,N,N,N,N,764,5577,1426,272,23,183,632,1120,93,37,54,45,904,849,5.2500000000,10,5,39,4363,1505,231,658,1143,100,139,0.98,Chicago Cubs,Wrigley Field,2789511,97,98,CHC,CHN,CHN
+2000,NL,CIN,CIN,C,2,163,82,85,77,N,N,N,N,825,5635,1545,302,36,200,559,995,100,38,64,58,765,700,4.3300000000,8,7,42,4368,1446,190,659,1015,111,156,0.98,Cincinnati Reds,Cinergy Field,2577371,102,102,CIN,CIN,CIN
+2000,NL,COL,COL,W,4,162,81,82,80,N,N,N,N,968,5660,1664,320,53,161,601,907,131,61,42,75,897,835,5.2600000000,7,2,33,4290,1568,221,588,1001,94,176,0.98,Colorado Rockies,Coors Field,3295129,125,125,COL,COL,COL
+2000,NL,FLO,FLA,E,3,161,81,79,82,N,N,N,N,731,5509,1441,274,29,160,540,1184,168,55,60,51,797,729,4.5900000000,5,4,48,4288,1477,169,650,1051,125,144,0.98,Florida Marlins,Pro Player Stadium,1218326,94,95,FLA,FLO,FLO
+2000,NL,HOU,HOU,C,4,162,81,72,90,N,N,N,N,938,5570,1547,289,36,249,673,1129,114,52,83,61,944,864,5.4100000000,8,2,30,4312,1596,234,598,1064,133,149,0.97,Houston Astros,Enron Field,3056139,107,107,HOU,HOU,HOU
+2000,NL,LAN,LAD,W,2,162,81,86,76,N,N,N,N,798,5481,1408,265,28,211,668,1083,95,42,51,46,729,659,4.1000000000,9,11,36,4335,1379,176,600,1154,135,151,0.97,Los Angeles Dodgers,Dodger Stadium,2880242,94,94,LAD,LAN,LAN
+2000,NL,MIL,MIL,C,3,163,81,73,89,N,N,N,N,740,5563,1366,297,25,177,620,1245,72,44,61,49,826,755,4.6400000000,2,7,29,4398,1501,174,728,967,118,187,0.98,Milwaukee Brewers,County Stadium,1573621,97,98,MIL,ML4,MIL
+2000,NL,MON,WSN,E,4,162,81,67,95,N,N,N,N,738,5535,1475,310,35,178,476,1048,58,48,29,34,902,812,5.1300000000,4,7,39,4273,1575,181,579,1011,132,151,0.97,Montreal Expos,Stade Olympique,926272,103,104,MON,MON,MON
+2000,NL,NYN,NYM,E,2,162,81,94,68,N,Y,Y,N,807,5486,1445,282,20,198,675,1037,66,46,45,51,738,670,4.1600000000,8,10,49,4350,1398,164,574,1164,118,121,0.98,New York Mets,Shea Stadium,2820530,96,96,NYM,NYN,NYN
+2000,NL,PHI,PHI,E,5,162,81,65,97,N,N,N,N,708,5511,1386,304,40,144,611,1117,102,30,44,37,830,763,4.7700000000,8,6,34,4315,1458,201,640,1123,100,136,0.98,Philadelphia Phillies,Veterans Stadium,1612769,100,101,PHI,PHI,PHI
+2000,NL,PIT,PIT,C,5,162,81,69,93,N,N,N,N,793,5643,1506,320,31,168,564,1032,86,40,66,37,888,794,4.9300000000,5,7,27,4347,1554,163,711,1070,132,169,0.97,Pittsburgh Pirates,Three Rivers Stadium,1748908,99,100,PIT,PIT,PIT
+2000,NL,SDN,SDP,W,5,162,81,76,86,N,N,N,N,752,5560,1413,279,37,157,602,1177,131,53,46,43,815,733,4.5200000000,5,5,46,4377,1443,191,649,1071,141,155,0.97,San Diego Padres,Qualcomm Stadium,2352443,92,92,SDP,SDN,SDN
+2000,NL,SFN,SFG,W,1,162,81,97,65,Y,N,N,N,925,5519,1535,304,44,226,709,1032,79,39,51,66,747,675,4.2100000000,9,15,47,4332,1452,151,623,1076,93,173,0.98,San Francisco Giants,PacBell Park,3318800,93,92,SFG,SFN,SFN
+2000,NL,SLN,STL,C,1,162,81,95,67,Y,N,N,N,887,5478,1481,259,25,235,675,1253,87,51,84,53,771,698,4.3800000000,10,7,37,4300,1403,196,606,1100,111,148,0.98,St. Louis Cardinals,Busch Stadium II,3336493,102,101,STL,SLN,SLN
+2001,AL,ANA,ANA,W,3,162,81,75,87,N,N,N,N,691,5551,1447,275,26,158,494,1001,116,52,77,53,730,671,4.2000000000,6,1,43,4313,1452,168,525,947,103,142,0.98,Anaheim Angels,Edison International Field,2000919,101,101,ANA,ANA,ANA
+2001,AL,BAL,BAL,E,4,162,80,63,98,N,N,N,N,687,5472,1359,262,24,136,514,989,133,53,77,49,829,744,4.6700000000,10,6,31,4297,1504,194,528,938,125,137,0.97,Baltimore Orioles,Oriole Park at Camden Yards,3094841,95,96,BAL,BAL,BAL
+2001,AL,BOS,BOS,E,2,161,81,82,79,N,N,N,N,772,5605,1493,316,29,198,520,1131,46,35,70,41,745,667,4.1500000000,3,9,48,4344,1412,146,544,1259,113,129,0.98,Boston Red Sox,Fenway Park II,2625333,102,101,BOS,BOS,BOS
+2001,AL,CHA,CHW,C,3,162,81,83,79,N,N,N,N,798,5464,1463,300,29,214,520,998,123,59,52,51,795,725,4.5500000000,8,7,51,4300,1465,181,500,921,118,149,0.98,Chicago White Sox,Comiskey Park II,1766172,104,103,CHW,CHA,CHA
+2001,AL,CLE,CLE,C,1,162,80,91,71,Y,N,N,N,897,5600,1559,294,37,212,577,1076,79,41,69,62,821,746,4.6400000000,3,4,42,4340,1512,148,573,1218,107,137,0.98,Cleveland Indians,Jacobs Field,3175523,100,100,CLE,CLE,CLE
+2001,AL,DET,DET,C,4,162,81,66,96,N,N,N,N,724,5537,1439,291,60,139,466,972,133,61,51,49,876,795,5.0100000000,16,2,34,4288,1624,180,553,859,131,165,0.97,Detroit Tigers,Comerica Park,1921305,93,95,DET,DET,DET
+2001,AL,KCA,KCR,C,5,162,81,65,97,N,N,N,N,729,5643,1503,277,37,152,406,898,100,42,44,47,858,779,4.8700000000,5,1,30,4320,1537,209,576,911,117,204,0.98,Kansas City Royals,Kauffman Stadium,1536371,107,108,KCR,KCA,KCA
+2001,AL,MIN,MIN,C,2,162,81,85,77,N,N,N,N,771,5560,1514,328,38,164,495,1083,146,67,64,38,766,722,4.5100000000,12,8,45,4324,1494,192,445,965,108,121,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1782929,102,102,MIN,MIN,MIN
+2001,AL,NYA,NYY,E,1,161,80,95,65,Y,N,Y,N,804,5577,1488,289,20,203,519,1035,161,53,64,43,713,649,4.0200000000,7,9,57,4354,1429,158,465,1266,109,132,0.98,New York Yankees,Yankee Stadium II,3264907,102,100,NYY,NYA,NYA
+2001,AL,OAK,OAK,W,2,162,81,102,60,N,Y,N,N,884,5573,1469,334,22,199,640,1021,68,29,88,59,645,583,3.5900000000,13,9,44,4390,1384,153,440,1117,125,151,0.98,Oakland Athletics,Oakland Coliseum,2133277,99,97,OAK,OAK,OAK
+2001,AL,SEA,SEA,W,1,162,81,116,46,Y,N,N,N,927,5680,1637,310,38,169,614,989,174,42,62,70,627,576,3.5400000000,8,14,56,4395,1293,160,465,1051,83,137,0.98,Seattle Mariners,Safeco Field,3507326,94,93,SEA,SEA,SEA
+2001,AL,TBA,TBD,E,5,162,81,62,100,N,N,N,N,672,5524,1426,311,21,121,456,1116,115,52,54,25,887,781,4.9400000000,1,6,30,4271,1513,207,569,1030,139,144,0.97,Tampa Bay Devil Rays,Tropicana Field,1298365,98,100,TBD,TBA,TBA
+2001,AL,TEX,TEX,W,4,162,82,73,89,N,N,N,N,890,5685,1566,326,23,246,548,1093,97,32,75,55,968,913,5.7100000000,4,3,37,4315,1670,222,596,951,114,167,0.98,Texas Rangers,The Ballpark at Arlington,2831021,104,105,TEX,TEX,TEX
+2001,AL,TOR,TOR,E,3,162,82,80,82,N,N,N,N,767,5663,1489,287,36,195,470,1094,156,55,74,43,753,696,4.2800000000,7,10,41,4388,1553,165,490,1041,97,184,0.98,Toronto Blue Jays,Skydome,1915438,102,103,TOR,TOR,TOR
+2001,NL,ARI,ARI,W,1,162,81,92,70,Y,N,Y,Y,818,5595,1494,284,35,208,587,1052,71,38,57,36,677,627,3.8700000000,12,13,34,4379,1352,195,461,1297,84,148,0.98,Arizona Diamondbacks,Bank One Ballpark,2736451,108,107,ARI,ARI,ARI
+2001,NL,ATL,ATL,E,1,162,81,88,74,Y,N,N,N,729,5498,1432,263,24,174,493,1039,85,46,45,52,643,578,3.5900000000,5,13,41,4342,1363,153,499,1133,103,133,0.98,Atlanta Braves,Turner Field,2823530,103,102,ATL,ATL,ATL
+2001,NL,CHN,CHC,C,3,162,81,88,74,N,N,N,N,777,5406,1409,268,32,194,577,1077,67,36,66,53,701,643,4.0300000000,8,6,41,4311,1357,164,550,1344,109,113,0.98,Chicago Cubs,Wrigley Field,2779465,95,95,CHC,CHN,CHN
+2001,NL,CIN,CIN,C,5,162,81,66,96,N,N,N,N,735,5583,1464,304,22,176,468,1172,103,54,65,40,850,765,4.7700000000,2,2,35,4328,1572,198,515,943,138,136,0.97,Cincinnati Reds,Cinergy Field,1879757,105,105,CIN,CIN,CIN
+2001,NL,COL,COL,W,5,162,81,73,89,N,N,N,N,923,5690,1663,324,61,213,511,1027,132,54,61,50,906,841,5.2900000000,8,8,26,4290,1522,239,598,1058,96,167,0.98,Colorado Rockies,Coors Field,3166821,122,122,COL,COL,COL
+2001,NL,FLO,FLA,E,4,162,80,76,86,N,N,N,N,742,5542,1461,325,30,166,470,1145,89,40,67,45,744,691,4.3200000000,5,11,32,4314,1397,151,617,1119,103,174,0.98,Florida Marlins,Pro Player Stadium,1261226,97,97,FLA,FLO,FLO
+2001,NL,HOU,HOU,C,1,162,81,93,69,Y,N,N,N,847,5528,1500,313,29,208,581,1119,64,49,89,56,769,707,4.3700000000,7,6,48,4364,1453,221,486,1228,110,138,0.98,Houston Astros,Enron Field,2904277,107,106,HOU,HOU,HOU
+2001,NL,LAN,LAD,W,3,162,81,86,76,N,N,N,N,758,5493,1399,264,27,206,519,1062,89,42,56,44,744,685,4.2500000000,3,5,46,4352,1387,184,524,1212,116,138,0.98,Los Angeles Dodgers,Dodger Stadium,3017143,92,91,LAD,LAN,LAN
+2001,NL,MIL,MIL,C,4,162,81,68,94,N,N,N,N,740,5488,1378,273,30,209,488,1399,66,36,72,35,806,740,4.6400000000,3,8,28,4309,1452,197,667,1057,103,156,0.98,Milwaukee Brewers,Miller Park,2811041,98,99,MIL,ML4,MIL
+2001,NL,MON,WSN,E,5,162,81,68,94,N,N,N,N,670,5379,1361,320,28,131,478,1071,101,51,60,45,812,745,4.6800000000,5,11,28,4294,1509,190,525,1103,108,139,0.98,Montreal Expos,Stade Olympique,642745,101,102,MON,MON,MON
+2001,NL,NYN,NYM,E,3,162,81,82,80,N,N,N,N,642,5459,1361,273,18,147,545,1062,66,48,65,35,713,654,4.0700000000,6,14,48,4337,1418,186,438,1191,101,132,0.98,New York Mets,Shea Stadium,2658330,96,96,NYM,NYN,NYN
+2001,NL,PHI,PHI,E,2,162,81,86,76,N,N,N,N,746,5497,1431,295,29,164,551,1125,153,47,43,61,719,667,4.1500000000,8,7,47,4336,1417,170,527,1086,91,145,0.98,Philadelphia Phillies,Veterans Stadium,1782054,98,98,PHI,PHI,PHI
+2001,NL,PIT,PIT,C,6,162,81,62,100,N,N,N,N,657,5398,1333,256,25,161,467,1106,93,73,67,35,858,794,5.0500000000,8,9,36,4249,1493,167,549,908,133,168,0.97,Pittsburgh Pirates,PNC Park,2464870,103,105,PIT,PIT,PIT
+2001,NL,SDN,SDP,W,4,162,81,79,83,N,N,N,N,789,5482,1379,273,26,161,678,1273,129,44,41,48,812,724,4.5200000000,5,6,46,4322,1519,219,476,1088,145,127,0.97,San Diego Padres,Qualcomm Stadium,2378128,91,92,SDP,SDN,SDN
+2001,NL,SFN,SFG,W,2,162,81,90,72,N,N,N,N,799,5612,1493,304,40,235,625,1090,57,42,50,54,748,680,4.1800000000,3,8,47,4390,1437,145,579,1080,118,170,0.98,San Francisco Giants,PacBell Park,3311958,93,92,SFG,SFN,SFN
+2001,NL,SLN,STL,C,2,162,82,93,69,N,Y,N,N,814,5450,1469,274,32,199,529,1089,91,35,65,50,684,627,3.9300000000,8,11,38,4306,1389,196,526,1083,110,156,0.98,St. Louis Cardinals,Busch Stadium II,3109578,100,99,STL,SLN,SLN
+2002,AL,ANA,ANA,W,2,162,81,99,63,N,Y,Y,Y,851,5678,1603,333,32,152,462,805,117,51,74,64,644,595,3.6900000000,7,14,54,4357,1345,169,509,999,87,151,0.98,Anaheim Angels,Edison International Field,2305547,100,99,ANA,ANA,ANA
+2002,AL,BAL,BAL,E,4,162,81,67,95,N,N,N,N,667,5491,1353,311,27,165,452,993,110,48,64,49,773,719,4.4600000000,8,3,31,4352,1491,208,549,967,91,173,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2682439,95,96,BAL,BAL,BAL
+2002,AL,BOS,BOS,E,2,162,81,93,69,N,N,N,N,859,5640,1560,348,33,177,545,944,80,28,72,53,665,603,3.7500000000,5,17,51,4338,1339,146,430,1157,104,140,0.98,Boston Red Sox,Fenway Park II,2650862,103,102,BOS,BOS,BOS
+2002,AL,CHA,CHW,C,2,162,81,81,81,N,N,N,N,856,5502,1475,289,29,217,555,952,75,31,49,53,798,716,4.5300000000,7,7,35,4269,1422,190,528,945,97,157,0.98,Chicago White Sox,Comiskey Park II,1676911,102,101,CHW,CHA,CHA
+2002,AL,CLE,CLE,C,3,162,81,74,88,N,N,N,N,739,5423,1349,255,26,192,542,1000,52,37,56,39,837,777,4.9100000000,9,4,34,4274,1508,142,603,1058,113,161,0.98,Cleveland Indians,Jacobs Field,2616940,97,98,CLE,CLE,CLE
+2002,AL,DET,DET,C,5,161,80,55,106,N,N,N,N,575,5406,1340,265,37,124,363,1035,65,44,64,57,864,774,4.9300000000,11,7,33,4242,1593,163,463,794,142,148,0.97,Detroit Tigers,Comerica Park,1503623,92,95,DET,DET,DET
+2002,AL,KCA,KCR,C,4,162,77,62,100,N,N,N,N,737,5535,1415,285,42,140,524,921,140,65,52,51,891,834,5.2100000000,12,6,30,4323,1587,212,572,909,130,153,0.97,Kansas City Royals,Kauffman Stadium,1323036,110,111,KCR,KCA,KCA
+2002,AL,MIN,MIN,C,1,161,81,94,67,Y,N,N,N,768,5582,1518,348,36,167,472,1089,79,62,56,52,712,662,4.1200000000,8,9,47,4334,1454,184,439,1026,74,124,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1924473,100,100,MIN,MIN,MIN
+2002,AL,NYA,NYY,E,1,161,80,103,58,Y,N,N,N,897,5601,1540,314,12,223,640,1171,100,38,72,41,697,625,3.8700000000,9,11,53,4356,1441,144,403,1135,127,117,0.97,New York Yankees,Yankee Stadium II,3465807,100,99,NYY,NYA,NYA
+2002,AL,OAK,OAK,W,1,162,81,103,59,Y,N,N,N,800,5558,1450,279,28,205,609,1008,46,20,68,36,654,593,3.6800000000,9,19,48,4356,1391,135,474,1021,102,144,0.98,Oakland Athletics,Oakland Coliseum,2169811,98,97,OAK,OAK,OAK
+2002,AL,SEA,SEA,W,3,162,81,93,69,N,N,N,N,814,5569,1531,285,31,152,629,1003,137,58,51,72,699,654,4.0700000000,8,12,43,4336,1422,178,441,1063,88,134,0.98,Seattle Mariners,Safeco Field,3542938,97,95,SEA,SEA,SEA
+2002,AL,TBA,TBD,E,5,161,81,55,106,N,N,N,N,673,5604,1418,297,35,133,456,1115,102,45,58,36,918,846,5.2900000000,12,3,25,4321,1567,215,620,925,126,168,0.97,Tampa Bay Devil Rays,Tropicana Field,1065742,97,99,TBD,TBA,TBA
+2002,AL,TEX,TEX,W,4,162,80,72,90,N,N,N,N,843,5618,1510,304,27,230,554,1055,62,34,62,50,882,824,5.1500000000,4,4,33,4319,1528,194,669,1030,99,152,0.98,Texas Rangers,The Ballpark at Arlington,2352397,106,107,TEX,TEX,TEX
+2002,AL,TOR,TOR,E,3,162,81,78,84,N,N,N,N,813,5581,1457,305,38,187,522,1142,71,18,53,57,828,767,4.8000000000,6,6,41,4315,1504,177,590,991,107,159,0.98,Toronto Blue Jays,Skydome,1637900,104,104,TOR,TOR,TOR
+2002,NL,ARI,ARI,W,1,162,81,98,64,Y,N,N,N,819,5508,1471,283,41,165,643,1016,92,46,50,53,674,630,3.9200000000,14,10,40,4340,1361,170,421,1303,89,116,0.98,Arizona Diamondbacks,Bank One Ballpark,3198977,111,111,ARI,ARI,ARI
+2002,NL,ATL,ATL,E,1,161,81,101,59,Y,N,N,N,708,5495,1428,280,25,164,558,1028,76,39,54,49,565,511,3.1300000000,3,15,57,4402,1302,123,554,1058,114,170,0.98,Atlanta Braves,Turner Field,2603484,102,101,ATL,ATL,ATL
+2002,NL,CHN,CHC,C,5,162,78,67,95,N,N,N,N,706,5496,1351,259,29,200,585,1269,63,21,44,39,759,687,4.2900000000,11,9,23,4324,1373,167,606,1333,114,144,0.98,Chicago Cubs,Wrigley Field,2693096,98,98,CHC,CHN,CHN
+2002,NL,CIN,CIN,C,3,162,80,78,84,N,N,N,N,709,5470,1386,297,21,169,583,1188,116,52,66,40,774,690,4.2700000000,2,8,42,4361,1502,173,550,980,120,169,0.98,Cincinnati Reds,Cinergy Field,1855787,104,105,CIN,CIN,CIN
+2002,NL,COL,COL,W,4,162,81,73,89,N,N,N,N,778,5512,1508,283,41,152,497,1043,103,53,56,50,898,825,5.2000000000,1,8,43,4280,1554,225,582,920,112,158,0.98,Colorado Rockies,Coors Field,2737838,116,116,COL,COL,COL
+2002,NL,FLO,FLA,E,4,162,81,79,83,N,N,N,N,699,5496,1433,280,32,146,595,1130,177,73,61,49,763,706,4.3600000000,11,12,36,4369,1449,151,631,1104,106,163,0.98,Florida Marlins,Pro Player Stadium,813118,97,98,FLA,FLO,FLO
+2002,NL,HOU,HOU,C,2,162,81,84,78,N,N,N,N,749,5503,1441,291,32,167,589,1120,71,27,59,37,695,643,4.0000000000,2,11,43,4335,1423,151,546,1219,83,149,0.98,Houston Astros,Minute Maid Park,2517357,106,105,HOU,HOU,HOU
+2002,NL,LAN,LAD,W,3,162,81,92,70,N,N,N,N,713,5554,1464,286,29,155,428,940,96,37,53,44,643,598,3.6900000000,4,15,56,4373,1311,165,555,1132,90,134,0.98,Los Angeles Dodgers,Dodger Stadium,3131255,92,92,LAD,LAN,LAN
+2002,NL,MIL,MIL,C,6,162,81,56,106,N,N,N,N,627,5415,1369,269,29,139,500,1125,94,50,55,34,821,752,4.7300000000,7,4,32,4297,1468,199,666,1026,103,154,0.98,Milwaukee Brewers,Miller Park,1969153,98,99,MIL,ML4,MIL
+2002,NL,MON,WSN,E,2,162,81,83,79,N,N,N,N,735,5479,1432,300,36,162,575,1104,118,64,46,42,718,641,3.9700000000,9,3,39,4359,1475,165,508,1088,139,160,0.97,Montreal Expos,Stade Olympique,812045,103,103,MON,MON,MON
+2002,NL,NYN,NYM,E,5,161,78,75,86,N,N,N,N,690,5496,1409,238,22,160,486,1044,87,42,63,30,703,624,3.8900000000,9,10,36,4328,1408,163,543,1107,144,138,0.97,New York Mets,Shea Stadium,2804838,97,97,NYM,NYN,NYN
+2002,NL,PHI,PHI,E,3,161,79,80,81,N,N,N,N,710,5523,1428,325,41,165,640,1095,104,43,53,39,724,671,4.1700000000,5,9,47,4349,1381,153,570,1075,88,156,0.98,Philadelphia Phillies,Veterans Stadium,1618467,94,94,PHI,PHI,PHI
+2002,NL,PIT,PIT,C,4,161,79,72,89,N,N,N,N,641,5330,1300,263,20,142,537,1109,86,49,73,41,730,664,4.2300000000,2,7,47,4238,1447,163,572,920,115,177,0.98,Pittsburgh Pirates,PNC Park,1784988,102,103,PIT,PIT,PIT
+2002,NL,SDN,SDP,W,5,162,81,66,96,N,N,N,N,662,5515,1393,243,29,136,547,1062,71,44,30,41,815,737,4.6200000000,5,10,40,4309,1522,177,582,1108,128,162,0.97,San Diego Padres,Qualcomm Stadium,2220601,90,91,SDP,SDN,SDN
+2002,NL,SFN,SFG,W,2,162,81,95,66,N,Y,Y,N,783,5497,1465,300,35,198,616,961,74,21,65,52,616,566,3.5400000000,10,13,43,4312,1349,116,523,992,90,166,0.98,San Francisco Giants,PacBell Park,3253203,95,94,SFG,SFN,SFN
+2002,NL,SLN,STL,C,1,162,81,97,65,Y,N,N,N,787,5505,1475,285,26,175,542,927,86,42,67,49,648,595,3.7000000000,4,9,42,4339,1355,141,547,1009,103,168,0.98,St. Louis Cardinals,Busch Stadium II,3011756,98,97,STL,SLN,SLN
+2003,AL,ANA,ANA,W,3,162,82,77,85,N,N,N,N,736,5487,1473,276,33,150,476,838,129,61,56,50,743,680,4.2800000000,5,9,39,4294,1444,190,486,980,105,138,0.98,Anaheim Angels,Edison International Field,3061094,98,97,ANA,ANA,ANA
+2003,AL,BAL,BAL,E,4,163,81,71,91,N,N,N,N,743,5665,1516,277,24,152,431,902,89,36,54,40,820,767,4.7600000000,9,3,41,4349,1579,198,526,981,105,164,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2454523,99,99,BAL,BAL,BAL
+2003,AL,BOS,BOS,E,2,162,81,95,67,N,Y,N,N,961,5769,1667,371,40,238,620,943,88,35,53,64,809,729,4.4800000000,5,6,36,4394,1503,153,488,1141,113,130,0.98,Boston Red Sox,Fenway Park II,2724165,105,103,BOS,BOS,BOS
+2003,AL,CHA,CHW,C,2,162,81,86,76,N,N,N,N,791,5487,1445,303,19,220,519,916,77,29,58,41,715,663,4.1700000000,12,4,36,4293,1364,162,518,1056,93,154,0.98,Chicago White Sox,U.S. Cellular Field,1939524,102,102,CHW,CHA,CHA
+2003,AL,CLE,CLE,C,4,162,81,68,94,N,N,N,N,699,5572,1413,296,26,158,466,1062,86,61,62,41,778,682,4.2100000000,5,7,34,4378,1477,179,501,943,126,178,0.98,Cleveland Indians,Jacobs Field,1730002,96,97,CLE,CLE,CLE
+2003,AL,DET,DET,C,5,162,81,43,119,N,N,N,N,591,5466,1312,201,39,153,443,1099,98,63,47,49,928,847,5.3000000000,3,5,27,4316,1616,195,557,764,138,194,0.97,Detroit Tigers,Comerica Park,1368245,93,95,DET,DET,DET
+2003,AL,KCA,KCR,C,3,162,80,83,79,N,N,N,N,836,5568,1526,288,39,162,476,926,120,42,75,57,867,809,5.0600000000,7,10,36,4316,1569,190,566,865,108,143,0.98,Kansas City Royals,Kauffman Stadium,1779895,107,108,KCR,KCA,KCA
+2003,AL,MIN,MIN,C,1,162,81,90,72,Y,N,N,N,801,5655,1567,318,45,155,512,1027,94,44,63,52,758,716,4.4100000000,7,8,45,4385,1526,187,402,997,87,114,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1946011,101,100,MIN,MIN,MIN
+2003,AL,NYA,NYY,E,1,163,82,101,61,Y,N,Y,N,877,5605,1518,304,14,230,684,1042,98,33,81,35,716,653,4.0200000000,8,12,49,4386,1512,145,375,1119,114,126,0.98,New York Yankees,Yankee Stadium II,3465600,98,97,NYY,NYA,NYA
+2003,AL,OAK,OAK,W,1,162,81,96,66,Y,N,N,N,768,5497,1398,317,24,176,556,898,48,14,59,53,643,582,3.6300000000,16,14,48,4325,1336,140,499,1018,107,145,0.98,Oakland Athletics,Oakland Coliseum,2216596,99,98,OAK,OAK,OAK
+2003,AL,SEA,SEA,W,2,162,81,93,69,N,N,N,N,795,5561,1509,290,33,139,586,989,108,37,53,46,637,602,3.7600000000,8,15,38,4323,1340,173,466,1001,65,159,0.98,Seattle Mariners,Safeco Field,3268509,95,95,SEA,SEA,SEA
+2003,AL,TBA,TBD,E,5,162,81,63,99,N,N,N,N,715,5654,1501,298,38,137,420,1030,142,42,56,50,852,787,4.9300000000,7,7,30,4310,1454,196,639,877,103,158,0.98,Tampa Bay Devil Rays,Tropicana Field,1058695,95,97,TBD,TBA,TBA
+2003,AL,TEX,TEX,W,4,162,81,71,91,N,N,N,N,826,5664,1506,274,36,239,488,1052,65,25,75,42,969,903,5.6700000000,4,3,43,4300,1625,208,603,1009,94,168,0.98,Texas Rangers,The Ballpark at Arlington,2094394,111,111,TEX,TEX,TEX
+2003,AL,TOR,TOR,E,3,162,81,86,76,N,N,N,N,894,5661,1580,357,33,190,546,1081,37,25,90,56,826,748,4.6900000000,14,6,36,4305,1560,184,485,984,117,161,0.98,Toronto Blue Jays,Skydome,1799458,104,104,TOR,TOR,TOR
+2003,NL,ARI,ARI,W,3,162,81,84,78,N,N,N,N,717,5570,1467,303,47,152,531,1006,76,38,45,52,685,621,3.8400000000,7,11,42,4365,1379,150,526,1291,107,132,0.98,Arizona Diamondbacks,Bank One Ballpark,2805542,108,109,ARI,ARI,ARI
+2003,NL,ATL,ATL,E,1,162,81,101,61,Y,N,N,N,907,5670,1608,321,31,235,545,933,68,22,49,49,740,663,4.1000000000,4,7,51,4369,1425,147,555,992,121,166,0.98,Atlanta Braves,Turner Field,2401084,101,100,ATL,ATL,ATL
+2003,NL,CHN,CHC,C,1,162,81,88,74,Y,N,N,N,724,5519,1431,302,24,172,492,1158,73,31,50,46,683,619,3.8300000000,13,14,36,4369,1304,143,617,1404,106,157,0.98,Chicago Cubs,Wrigley Field,2962630,101,101,CHC,CHN,CHN
+2003,NL,CIN,CIN,C,5,162,81,69,93,N,N,N,N,694,5509,1349,239,21,182,524,1326,80,34,79,32,886,818,5.0900000000,4,5,38,4339,1578,209,590,932,141,152,0.97,Cincinnati Reds,Great American Ball Park,2355259,95,96,CIN,CIN,CIN
+2003,NL,COL,COL,W,4,162,81,74,88,N,N,N,N,853,5518,1472,330,31,198,619,1134,63,37,52,38,892,821,5.2000000000,3,4,34,4260,1629,200,552,866,116,165,0.98,Colorado Rockies,Coors Field,2334085,115,116,COL,COL,COL
+2003,NL,FLO,FLA,E,2,162,81,91,71,N,Y,Y,Y,751,5490,1459,292,44,157,515,978,150,74,57,41,692,648,4.0400000000,7,11,36,4336,1415,128,530,1132,78,162,0.98,Florida Marlins,Pro Player Stadium,1303215,98,98,FLA,FLO,FLO
+2003,NL,HOU,HOU,C,2,162,81,87,75,N,N,N,N,805,5583,1466,308,30,191,557,1021,66,30,81,38,677,622,3.8600000000,1,5,50,4350,1350,161,565,1139,95,149,0.98,Houston Astros,Minute Maid Park,2454241,103,102,HOU,HOU,HOU
+2003,NL,LAN,LAD,W,2,162,81,85,77,N,N,N,N,574,5458,1328,260,25,124,407,985,80,36,72,28,556,511,3.1600000000,3,17,58,4373,1254,127,526,1289,119,164,0.98,Los Angeles Dodgers,Dodger Stadium,3138626,94,94,LAD,LAN,LAN
+2003,NL,MIL,MIL,C,6,162,81,68,94,N,N,N,N,714,5548,1423,266,24,196,547,1221,99,39,71,40,873,810,5.0200000000,5,3,44,4356,1590,219,575,1034,114,142,0.98,Milwaukee Brewers,Miller Park,1700354,98,100,MIL,ML4,MIL
+2003,NL,MON,WSN,E,4,162,81,83,79,N,N,N,N,711,5437,1404,294,25,144,522,990,100,39,45,40,716,640,4.0100000000,15,10,42,4313,1467,181,463,1028,102,152,0.98,Montreal Expos,Stade Olympique/Hiram Bithorn Stadium,1025639,105,105,MON,MON,MON
+2003,NL,NYN,NYM,E,5,161,80,66,95,N,N,N,N,642,5341,1317,262,24,124,489,1035,70,31,54,45,754,704,4.4800000000,3,10,38,4240,1497,168,576,907,118,158,0.98,New York Mets,Shea Stadium,2140599,97,98,NYM,NYN,NYN
+2003,NL,PHI,PHI,E,3,162,81,86,76,N,N,N,N,791,5543,1448,325,27,166,651,1155,72,29,55,38,697,648,4.0400000000,9,13,33,4331,1386,142,536,1060,97,146,0.98,Philadelphia Phillies,Veterans Stadium,2259948,93,93,PHI,PHI,PHI
+2003,NL,PIT,PIT,C,4,162,81,75,87,N,N,N,N,753,5581,1492,275,45,163,529,1049,86,37,87,38,801,744,4.6400000000,7,10,44,4333,1527,178,502,926,123,159,0.98,Pittsburgh Pirates,PNC Park,1636751,102,102,PIT,PIT,PIT
+2003,NL,SDN,SDP,W,5,162,81,64,98,N,N,N,N,678,5531,1442,257,32,128,565,1073,76,39,57,42,831,774,4.8700000000,2,10,31,4294,1458,208,611,1091,102,141,0.98,San Diego Padres,Qualcomm Stadium,2030084,91,92,SDP,SDN,SDN
+2003,NL,SFN,SFG,W,1,161,81,100,61,Y,N,N,N,755,5456,1440,281,29,180,593,980,53,37,40,39,638,595,3.7300000000,7,10,43,4312,1349,136,546,1006,80,163,0.98,San Francisco Giants,PacBell Park,3264898,99,98,SFG,SFN,SFN
+2003,NL,SLN,STL,C,3,162,81,85,77,N,N,N,N,876,5672,1580,342,32,196,580,952,82,32,73,54,796,748,4.6000000000,9,10,41,4391,1544,210,508,969,77,138,0.98,St. Louis Cardinals,Busch Stadium II,2910386,97,96,STL,SLN,SLN
+2004,AL,ANA,ANA,W,1,162,81,92,70,Y,N,N,N,836,5675,1603,272,37,162,450,942,143,46,73,41,734,692,4.2800000000,2,11,50,4363,1476,170,502,1164,90,126,0.98,Anaheim Angels,Angels Stadium of Anaheim,3375677,97,97,ANA,ANA,ANA
+2004,AL,BAL,BAL,E,3,162,81,78,84,N,N,N,N,842,5736,1614,319,18,169,528,949,101,41,57,62,830,760,4.7000000000,8,10,27,4366,1488,159,687,1090,110,161,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2744018,98,99,BAL,BAL,BAL
+2004,AL,BOS,BOS,E,2,162,81,98,64,N,Y,Y,Y,949,5720,1613,373,25,222,659,1189,68,30,69,55,768,674,4.1800000000,4,12,36,4354,1430,159,447,1132,118,129,0.98,Boston Red Sox,Fenway Park II,2837294,106,105,BOS,BOS,BOS
+2004,AL,CHA,CHW,C,2,162,81,83,79,N,N,N,N,865,5534,1481,284,19,242,499,1030,78,51,63,42,831,782,4.9100000000,8,8,34,4297,1505,224,527,1013,100,167,0.98,Chicago White Sox,U.S. Cellular Field,1930537,102,102,CHW,CHA,CHA
+2004,AL,CLE,CLE,C,3,162,81,80,82,N,N,N,N,858,5676,1565,345,29,184,606,1009,94,55,78,42,857,784,4.8100000000,8,8,32,4400,1553,201,579,1115,106,152,0.98,Cleveland Indians,Jacobs Field,1814401,94,94,CLE,CLE,CLE
+2004,AL,DET,DET,C,4,162,81,72,90,N,N,N,N,827,5623,1531,284,54,201,518,1144,86,50,50,43,844,788,4.9300000000,7,9,35,4319,1542,190,530,995,144,160,0.97,Detroit Tigers,Comerica Park,1917004,95,96,DET,DET,DET
+2004,AL,KCA,KCR,C,5,162,80,58,104,N,N,N,N,720,5538,1432,261,29,150,461,1057,67,48,76,38,905,813,5.1500000000,6,3,25,4261,1638,208,518,887,131,169,0.97,Kansas City Royals,Kauffman Stadium,1661478,102,103,KCR,KCA,KCA
+2004,AL,MIN,MIN,C,1,162,81,92,70,Y,N,N,N,780,5623,1494,310,24,191,513,982,116,46,64,40,715,661,4.0300000000,4,9,48,4428,1523,167,431,1123,101,158,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,1911490,103,102,MIN,MIN,MIN
+2004,AL,NYA,NYY,E,1,162,81,101,61,Y,N,N,N,897,5527,1483,281,20,242,670,982,84,33,80,50,808,752,4.6900000000,1,5,59,4331,1532,182,445,1058,99,148,0.98,New York Yankees,Yankee Stadium II,3775292,98,97,NYY,NYA,NYA
+2004,AL,OAK,OAK,W,2,162,81,91,71,N,N,N,N,793,5728,1545,336,15,189,608,1061,47,22,55,43,742,682,4.1700000000,10,8,35,4414,1466,164,544,1034,91,172,0.98,Oakland Athletics,Network Associates Coliseum,2201516,99,98,OAK,OAK,OAK
+2004,AL,SEA,SEA,W,4,162,82,63,99,N,N,N,N,698,5722,1544,276,20,136,492,1058,110,42,54,48,823,772,4.7600000000,7,7,28,4378,1498,212,575,1036,103,140,0.98,Seattle Mariners,Safeco Field,2940731,97,98,SEA,SEA,SEA
+2004,AL,TBA,TBD,E,4,161,80,70,91,N,N,N,N,714,5483,1416,278,46,145,469,944,132,42,55,56,842,757,4.8100000000,3,5,35,4251,1459,192,580,923,119,139,0.98,Tampa Bay Devil Rays,Tropicana Field,1274911,96,98,TBD,TBA,TBA
+2004,AL,TEX,TEX,W,3,162,81,89,73,N,N,N,N,860,5615,1492,323,34,227,500,1099,69,36,61,57,794,724,4.5300000000,5,9,52,4319,1536,182,547,979,117,152,0.98,Texas Rangers,The Ballpark at Arlington,2513685,108,109,TEX,TEX,TEX
+2004,AL,TOR,TOR,E,5,161,81,67,94,N,N,N,N,719,5531,1438,290,34,145,513,1083,58,31,71,42,823,775,4.9100000000,6,11,37,4263,1505,181,608,956,91,150,0.98,Toronto Blue Jays,Skydome,1900041,104,104,TOR,TOR,TOR
+2004,NL,ARI,ARI,W,5,162,81,51,111,N,N,N,N,615,5544,1401,295,38,135,441,1022,53,32,35,37,899,794,4.9800000000,5,6,33,4308,1480,197,668,1153,139,144,0.97,Arizona Diamondbacks,Bank One Ballpark,2519560,105,107,ARI,ARI,ARI
+2004,NL,ATL,ATL,E,1,162,81,96,66,Y,N,N,N,803,5570,1503,304,37,178,587,1158,86,32,59,48,668,603,3.7400000000,4,13,48,4350,1475,154,523,1025,116,171,0.98,Atlanta Braves,Turner Field,2327565,101,100,ATL,ATL,ATL
+2004,NL,CHN,CHC,C,3,162,82,89,73,N,N,N,N,789,5628,1508,308,29,235,489,1080,66,28,38,48,665,621,3.8100000000,3,6,42,4396,1363,169,545,1346,86,126,0.98,Chicago Cubs,Wrigley Field,3170154,103,102,CHC,CHN,CHN
+2004,NL,CIN,CIN,C,4,162,81,76,86,N,N,N,N,750,5518,1380,287,28,194,599,1335,77,25,81,25,907,832,5.1900000000,5,8,47,4331,1595,236,572,992,113,123,0.98,Cincinnati Reds,Great American Ball Park,2287250,98,99,CIN,CIN,CIN
+2004,NL,COL,COL,W,4,162,81,68,94,N,N,N,N,833,5577,1531,331,34,202,568,1181,44,33,54,37,923,883,5.5400000000,3,2,36,4306,1634,198,697,947,89,161,0.98,Colorado Rockies,Coors Field,2338069,113,114,COL,COL,COL
+2004,NL,FLO,FLA,E,3,162,80,83,79,N,N,N,N,718,5486,1447,275,32,148,499,968,96,43,58,40,700,655,4.1000000000,6,14,53,4317,1395,166,513,1116,86,153,0.98,Florida Marlins,Pro Player Stadium,1723105,95,95,FLA,FLO,FLO
+2004,NL,HOU,HOU,C,2,162,81,92,70,N,Y,N,N,803,5468,1458,294,36,187,590,999,89,30,61,52,698,650,4.0500000000,2,13,47,4329,1416,174,525,1282,101,136,0.98,Houston Astros,Minute Maid Park,3087872,102,101,HOU,HOU,HOU
+2004,NL,LAN,LAD,W,1,162,81,93,69,Y,N,N,N,761,5542,1450,226,30,203,536,1092,102,41,62,35,684,647,4.0100000000,2,6,51,4360,1386,178,521,1066,73,145,0.98,Los Angeles Dodgers,Dodger Stadium,3488283,95,95,LAD,LAN,LAN
+2004,NL,MIL,MIL,C,6,161,81,67,94,N,N,N,N,634,5483,1358,295,32,135,540,1312,138,40,68,40,757,679,4.2400000000,6,10,42,4326,1440,164,476,1098,117,132,0.98,Milwaukee Brewers,Miller Park,2062382,100,101,MIL,ML4,MIL
+2004,NL,MON,WSN,E,5,162,80,67,95,N,N,N,N,635,5474,1361,276,27,151,496,925,109,38,35,33,769,696,4.3300000000,11,11,31,4341,1477,191,582,1032,99,171,0.98,Montreal Expos,Stade Olympique/Hiram Bithorn Stadium,749550,105,105,MON,MON,MON
+2004,NL,NYN,NYM,E,4,162,81,71,91,N,N,N,N,684,5532,1376,289,20,185,512,1159,107,23,61,34,731,658,4.0900000000,2,6,31,4347,1452,156,592,977,137,144,0.97,New York Mets,Shea Stadium,2318951,99,99,NYM,NYN,NYN
+2004,NL,PHI,PHI,E,2,162,81,86,76,N,N,N,N,840,5643,1505,303,23,215,645,1133,100,27,58,46,781,724,4.4500000000,4,5,43,4388,1488,214,502,1070,81,142,0.98,Philadelphia Phillies,Citizens Bank Park,3250092,105,104,PHI,PHI,PHI
+2004,NL,PIT,PIT,C,5,161,80,72,89,N,N,N,N,680,5483,1428,267,39,142,415,1066,63,40,95,42,744,680,4.2900000000,3,8,46,4284,1451,149,576,1079,103,189,0.98,Pittsburgh Pirates,PNC Park,1580031,99,100,PIT,PIT,PIT
+2004,NL,SDN,SDP,W,3,162,81,87,75,N,N,N,N,768,5573,1521,304,32,139,566,910,52,25,56,66,705,645,4.0300000000,3,8,44,4323,1460,184,422,1079,108,146,0.98,San Diego Padres,Petco Park,3016752,90,90,SDP,SDN,SDN
+2004,NL,SFN,SFG,W,2,162,82,91,71,N,N,N,N,850,5546,1500,314,33,183,705,874,43,23,72,51,770,695,4.2900000000,8,8,46,4371,1481,161,548,1020,101,153,0.98,San Francisco Giants,SBC Park,3256854,101,101,SFG,SFN,SFN
+2004,NL,SLN,STL,C,1,162,81,105,57,Y,N,Y,N,855,5555,1544,319,24,214,548,1085,111,47,51,70,659,605,3.7500000000,4,12,57,4361,1378,169,440,1041,97,154,0.98,St. Louis Cardinals,Busch Stadium II,3048427,100,99,STL,SLN,SLN
+2005,AL,BAL,BAL,E,4,162,81,74,88,N,N,N,N,729,5551,1492,296,27,189,447,902,83,37,54,42,800,724,4.5600000000,2,9,38,4283,1458,180,580,1052,107,154,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2624740,99,99,BAL,BAL,BAL
+2005,AL,BOS,BOS,E,2,162,81,95,67,N,Y,N,N,910,5626,1579,339,21,199,653,1044,45,12,47,63,805,752,4.7400000000,6,8,38,4287,1550,164,440,959,109,135,0.98,Boston Red Sox,Fenway Park II,2847888,104,104,BOS,BOS,BOS
+2005,AL,CHA,CHW,C,1,162,81,99,63,Y,N,Y,Y,741,5529,1450,253,23,200,435,1002,137,67,79,49,645,592,3.6100000000,9,10,54,4427,1392,167,459,1040,94,166,0.98,Chicago White Sox,U.S. Cellular Field,2342833,103,103,CHW,CHA,CHA
+2005,AL,CLE,CLE,C,2,162,81,93,69,N,N,N,N,790,5609,1522,337,30,207,503,1093,62,36,54,50,642,582,3.6100000000,6,10,51,4358,1363,157,413,1050,106,156,0.98,Cleveland Indians,Jacobs Field,2013763,96,96,CLE,CLE,CLE
+2005,AL,DET,DET,C,4,162,81,71,91,N,N,N,N,723,5602,1521,283,45,168,384,1038,66,28,53,52,787,719,4.5100000000,7,2,37,4307,1504,193,461,907,110,171,0.98,Detroit Tigers,Comerica Park,2024431,98,98,DET,DET,DET
+2005,AL,KCA,KCR,C,5,162,81,56,106,N,N,N,N,701,5503,1445,289,34,126,424,1008,53,33,63,50,935,862,5.4900000000,4,4,25,4240,1640,178,580,924,125,163,0.97,Kansas City Royals,Kauffman Stadium,1371181,99,101,KCR,KCA,KCA
+2005,AL,LAA,ANA,W,1,162,81,95,67,Y,N,N,N,761,5624,1520,278,30,147,447,848,161,57,29,39,643,598,3.6800000000,7,11,54,4393,1419,158,443,1126,87,139,0.98,Los Angeles Angels of Anaheim,Angel Stadium,3404686,98,97,LAA,ANA,ANA
+2005,AL,MIN,MIN,C,3,162,81,83,79,N,N,N,N,688,5564,1441,269,32,134,485,978,102,44,59,42,662,604,3.7100000000,9,8,44,4393,1458,169,348,965,102,171,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2034243,102,102,MIN,MIN,MIN
+2005,AL,NYA,NYY,E,1,162,81,95,67,Y,N,N,N,886,5624,1552,259,16,229,637,989,84,27,73,43,789,718,4.5200000000,8,14,46,4292,1495,164,463,985,95,151,0.98,New York Yankees,Yankee Stadium II,4090696,98,97,NYY,NYA,NYA
+2005,AL,OAK,OAK,W,2,162,81,88,74,N,N,N,N,772,5627,1476,310,20,155,537,819,31,22,52,40,658,594,3.6900000000,9,12,38,4351,1315,154,504,1075,88,166,0.98,Oakland Athletics,McAfee Coliseum,2109118,101,100,OAK,OAK,OAK
+2005,AL,SEA,SEA,W,4,162,81,69,93,N,N,N,N,699,5507,1408,289,34,130,466,986,102,47,48,37,751,712,4.4900000000,6,7,39,4283,1483,179,496,892,86,144,0.98,Seattle Mariners,Safeco Field,2725459,95,96,SEA,SEA,SEA
+2005,AL,TBA,TBD,E,5,162,81,67,95,N,N,N,N,750,5552,1519,289,40,157,412,990,151,49,69,51,936,851,5.3900000000,1,4,43,4265,1570,194,615,949,124,139,0.97,Tampa Bay Devil Rays,Tropicana Field,1141669,99,100,TBD,TBA,TBA
+2005,AL,TEX,TEX,W,3,162,81,79,83,N,N,N,N,865,5716,1528,311,29,260,495,1112,67,15,48,32,858,794,4.9600000000,2,6,46,4320,1589,159,522,932,108,149,0.98,Texas Rangers,Ameriquest Field,2525221,106,106,TEX,TEX,TEX
+2005,AL,TOR,TOR,E,3,162,81,80,82,N,N,N,N,775,5581,1480,307,39,136,486,955,72,35,89,56,705,653,4.0600000000,9,8,35,4341,1475,185,444,958,95,154,0.98,Toronto Blue Jays,Rogers Centre,2014995,102,102,TOR,TOR,TOR
+2005,NL,ARI,ARI,W,2,162,81,77,85,N,N,N,N,696,5550,1419,291,27,191,606,1094,67,26,55,45,856,783,4.8400000000,6,10,45,4369,1580,193,537,1038,94,159,0.98,Arizona Diamondbacks,Bank One Ballpark,2059424,103,105,ARI,ARI,ARI
+2005,NL,ATL,ATL,E,1,162,81,90,72,Y,N,N,N,769,5486,1453,308,37,184,534,1084,92,32,45,46,674,639,3.9800000000,8,12,38,4331,1487,145,520,929,86,170,0.98,Atlanta Braves,Turner Field,2521167,101,100,ATL,ATL,ATL
+2005,NL,CHN,CHC,C,4,162,81,79,83,N,N,N,N,703,5584,1506,323,23,194,419,920,65,39,50,37,714,671,4.1900000000,8,10,39,4320,1357,186,576,1256,101,136,0.98,Chicago Cubs,Wrigley Field,3099992,104,104,CHC,CHN,CHN
+2005,NL,CIN,CIN,C,5,163,82,73,89,N,N,N,N,820,5565,1453,335,15,222,611,1303,72,23,62,39,889,820,5.1500000000,2,1,31,4299,1657,219,492,955,104,133,0.98,Cincinnati Reds,Great American Ball Park,1943067,100,101,CIN,CIN,CIN
+2005,NL,COL,COL,W,5,162,81,67,95,N,N,N,N,740,5542,1477,280,34,150,509,1103,65,32,64,34,862,808,5.1300000000,4,4,37,4256,1600,175,604,981,118,158,0.98,Colorado Rockies,Coors Field,1914389,112,113,COL,COL,COL
+2005,NL,FLO,FLA,E,3,162,81,83,79,N,N,N,N,717,5502,1499,306,32,128,512,918,96,38,67,50,732,666,4.1600000000,14,15,42,4327,1459,116,563,1125,103,177,0.98,Florida Marlins,Dolphin Stadium,1852608,94,94,FLA,FLO,FLO
+2005,NL,HOU,HOU,C,2,163,81,89,73,N,Y,Y,N,693,5462,1400,281,32,161,481,1037,115,44,72,42,609,563,3.5100000000,6,11,45,4329,1336,155,440,1164,89,146,0.98,Houston Astros,Minute Maid Park,2804760,101,100,HOU,HOU,HOU
+2005,NL,LAN,LAD,W,4,162,81,71,91,N,N,N,N,685,5433,1374,284,21,149,541,1094,58,35,67,33,755,695,4.3800000000,6,9,40,4282,1434,182,471,1004,106,141,0.98,Los Angeles Dodgers,Dodger Stadium,3603646,98,97,LAD,LAN,LAN
+2005,NL,MIL,MIL,C,3,162,81,81,81,N,N,N,N,726,5448,1413,327,19,175,531,1162,79,34,73,38,697,635,3.9700000000,7,6,46,4314,1382,169,569,1173,119,139,0.98,Milwaukee Brewers,Miller Park,2211023,101,101,MIL,ML4,MIL
+2005,NL,NYN,NYM,E,3,162,81,83,79,N,N,N,N,722,5505,1421,279,32,175,486,1075,153,40,48,38,648,599,3.7600000000,8,11,38,4307,1390,135,491,1012,106,146,0.98,New York Mets,Shea Stadium,2829929,98,97,NYM,NYN,NYN
+2005,NL,PHI,PHI,E,2,162,81,88,74,N,N,N,N,807,5542,1494,282,35,167,639,1083,116,27,56,46,726,672,4.2100000000,4,6,40,4305,1379,189,487,1159,90,132,0.98,Philadelphia Phillies,Citizens Bank Park,2665304,105,104,PHI,PHI,PHI
+2005,NL,PIT,PIT,C,6,162,81,67,95,N,N,N,N,680,5573,1445,292,38,139,471,1092,73,30,72,49,769,706,4.4200000000,4,14,35,4308,1456,162,612,958,117,193,0.98,Pittsburgh Pirates,PNC Park,1817245,99,100,PIT,PIT,PIT
+2005,NL,SDN,SDP,W,1,162,81,82,80,Y,N,N,N,684,5502,1416,269,39,130,600,977,99,44,49,48,726,668,4.1300000000,4,8,45,4366,1452,146,503,1133,109,136,0.98,San Diego Padres,Petco Park,2869787,92,91,SDP,SDN,SDN
+2005,NL,SFN,SFG,W,3,162,81,75,87,N,N,N,N,649,5462,1427,299,26,128,431,901,71,35,49,44,745,695,4.3300000000,4,8,46,4333,1456,151,592,972,90,146,0.98,San Francisco Giants,SBC Park,3181023,101,101,SFG,SFN,SFN
+2005,NL,SLN,STL,C,1,162,81,100,62,Y,N,N,N,805,5538,1494,287,26,170,534,947,83,36,62,35,634,560,3.4900000000,15,14,48,4337,1399,153,443,974,100,196,0.98,St. Louis Cardinals,Busch Stadium II,3538988,101,100,STL,SLN,SLN
+2005,NL,WAS,WSN,E,5,162,81,81,81,N,N,N,N,639,5426,1367,311,32,117,491,1090,45,45,89,45,673,627,3.8700000000,4,9,51,4374,1456,140,539,997,92,156,0.98,Washington Nationals,R.F.K. Stadium,2731993,95,96,WSN,MON,WAS
+2006,AL,BAL,BAL,E,4,162,81,70,92,N,N,N,N,768,5610,1556,288,20,164,474,878,121,32,73,41,899,843,5.3500000000,5,9,35,4257,1579,216,613,1016,102,156,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2153139,99,100,BAL,BAL,BAL
+2006,AL,BOS,BOS,E,3,162,81,86,76,N,N,N,N,820,5619,1510,327,16,192,672,1056,51,23,66,56,825,773,4.8300000000,3,6,46,4324,1570,181,509,1070,66,174,0.98,Boston Red Sox,Fenway Park II,2930588,105,104,BOS,BOS,BOS
+2006,AL,CHA,CHW,C,3,162,81,90,72,N,N,N,N,868,5657,1586,291,20,236,502,1056,93,48,58,57,794,743,4.6100000000,5,11,46,4347,1534,200,433,1012,90,145,0.98,Chicago White Sox,U.S. Cellular Field,2957414,104,104,CHW,CHA,CHA
+2006,AL,CLE,CLE,C,4,162,81,78,84,N,N,N,N,870,5619,1576,351,27,196,556,1204,55,23,54,43,782,698,4.4100000000,13,13,24,4270,1583,166,429,948,118,165,0.98,Cleveland Indians,Jacobs Field,1997995,99,98,CLE,CLE,CLE
+2006,AL,DET,DET,C,2,162,81,95,67,N,Y,Y,N,822,5642,1548,294,40,203,430,1133,60,40,45,36,675,618,3.8400000000,3,16,46,4344,1420,160,489,1003,106,162,0.98,Detroit Tigers,Comerica Park,2595937,100,100,DET,DET,DET
+2006,AL,KCA,KCR,C,5,162,81,62,100,N,N,N,N,757,5589,1515,335,37,124,474,1040,65,34,64,48,971,896,5.6500000000,3,5,35,4279,1648,213,637,904,98,189,0.98,Kansas City Royals,Kauffman Stadium,1372638,101,103,KCR,KCA,KCA
+2006,AL,LAA,ANA,W,2,162,81,89,73,N,N,N,N,766,5609,1539,309,29,159,486,914,148,57,42,53,732,652,4.0400000000,5,12,50,4358,1410,158,471,1164,124,154,0.97,Los Angeles Angels of Anaheim,Angel Stadium,3406790,100,100,LAA,ANA,ANA
+2006,AL,MIN,MIN,C,1,162,81,96,66,Y,N,N,N,801,5602,1608,275,34,143,490,872,101,42,50,55,683,632,3.9500000000,1,6,40,4318,1490,182,356,1164,84,135,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2285018,98,98,MIN,MIN,MIN
+2006,AL,NYA,NYY,E,1,162,81,97,65,Y,N,N,N,930,5651,1608,327,21,210,649,1053,139,35,72,49,767,708,4.4100000000,5,8,43,4331,1463,170,496,1019,104,145,0.98,New York Yankees,Yankee Stadium II,4248067,101,99,NYY,NYA,NYA
+2006,AL,OAK,OAK,W,1,162,81,93,69,Y,N,N,N,771,5500,1429,266,22,175,650,976,61,20,50,56,727,679,4.2100000000,5,11,54,4355,1525,162,529,1003,84,173,0.98,Oakland Athletics,McAfee Coliseum,1976625,97,97,OAK,OAK,OAK
+2006,AL,SEA,SEA,W,4,162,81,78,84,N,N,N,N,756,5670,1540,266,42,172,404,974,106,37,63,38,792,739,4.6000000000,6,6,47,4340,1500,183,560,1067,88,150,0.98,Seattle Mariners,Safeco Field,2481165,97,97,SEA,SEA,SEA
+2006,AL,TBA,TBD,E,5,162,81,61,101,N,N,N,N,689,5474,1395,267,33,190,441,1106,134,52,47,43,856,782,4.9600000000,3,7,33,4261,1600,180,606,979,116,156,0.98,Tampa Bay Devil Rays,Tropicana Field,1368950,99,101,TBD,TBA,TBA
+2006,AL,TEX,TEX,W,3,162,81,80,82,N,N,N,N,835,5659,1571,357,23,183,505,1061,53,24,40,50,784,731,4.6000000000,3,8,42,4294,1558,162,496,972,98,174,0.98,Texas Rangers,Ameriquest Field,2388757,101,101,TEX,TEX,TEX
+2006,AL,TOR,TOR,E,2,162,81,87,75,N,N,N,N,809,5596,1591,348,27,199,514,906,65,33,63,52,754,694,4.3700000000,6,6,42,4285,1447,185,504,1076,99,157,0.98,Toronto Blue Jays,Rogers Centre,2302212,100,100,TOR,TOR,TOR
+2006,NL,ARI,ARI,W,4,162,81,76,86,N,N,N,N,773,5645,1506,331,38,160,504,965,76,30,67,53,788,727,4.4800000000,8,9,34,4379,1503,168,536,1115,104,172,0.98,Arizona Diamondbacks,Chase Field,2091685,105,105,ARI,ARI,ARI
+2006,NL,ATL,ATL,E,3,162,81,79,83,N,N,N,N,849,5583,1510,312,26,222,526,1169,52,35,52,44,805,736,4.6000000000,6,6,38,4324,1529,183,572,1049,99,146,0.98,Atlanta Braves,Turner Field,2550524,100,99,ATL,ATL,ATL
+2006,NL,CHN,CHC,C,6,162,81,66,96,N,N,N,N,716,5587,1496,271,46,166,395,928,121,49,43,37,834,758,4.7400000000,2,7,29,4317,1396,210,687,1250,106,122,0.98,Chicago Cubs,Wrigley Field,3123215,103,103,CHC,CHN,CHN
+2006,NL,CIN,CIN,C,3,162,82,80,82,N,N,N,N,749,5515,1419,291,12,217,614,1192,124,33,59,38,801,725,4.5100000000,9,10,36,4337,1576,213,464,1053,128,139,0.97,Cincinnati Reds,Great American Ball Park,2134607,104,104,CIN,CIN,CIN
+2006,NL,COL,COL,W,4,162,81,76,86,N,N,N,N,813,5562,1504,325,54,157,561,1108,85,50,60,45,812,749,4.6600000000,5,8,34,4342,1549,155,553,952,91,190,0.98,Colorado Rockies,Coors Field,2104362,109,109,COL,COL,COL
+2006,NL,FLO,FLA,E,4,162,81,78,84,N,N,N,N,758,5502,1454,309,42,182,497,1249,110,58,74,42,772,696,4.3700000000,6,6,41,4300,1465,166,622,1088,126,166,0.97,Florida Marlins,Dolphin Stadium,1164134,95,96,FLA,FLO,FLO
+2006,NL,HOU,HOU,C,2,162,81,82,80,N,N,N,N,735,5521,1407,275,27,174,585,1076,79,36,73,46,719,666,4.0800000000,5,12,42,4406,1425,182,480,1160,80,164,0.98,Houston Astros,Minute Maid Park,3022763,100,99,HOU,HOU,HOU
+2006,NL,LAN,LAD,W,2,162,81,88,74,N,Y,N,N,820,5628,1552,307,58,153,601,959,128,49,51,48,751,686,4.2300000000,1,10,40,4381,1524,152,492,1068,115,174,0.98,Los Angeles Dodgers,Dodger Stadium,3758545,101,100,LAD,LAN,LAN
+2006,NL,MIL,MIL,C,4,162,81,75,87,N,N,N,N,730,5433,1400,301,20,180,502,1233,71,37,82,53,833,763,4.8200000000,7,8,43,4277,1454,177,514,1145,117,126,0.98,Milwaukee Brewers,Miller Park,2335643,101,101,MIL,ML4,MIL
+2006,NL,NYN,NYM,E,1,162,81,97,65,Y,N,N,N,834,5558,1469,323,41,200,547,1071,146,35,62,47,731,673,4.1400000000,5,12,43,4384,1402,180,527,1161,104,131,0.98,New York Mets,Shea Stadium,3379535,98,97,NYM,NYN,NYN
+2006,NL,PHI,PHI,E,2,162,81,85,77,N,N,N,N,865,5687,1518,294,41,216,626,1203,92,25,95,44,812,747,4.6000000000,4,6,42,4381,1561,211,512,1138,104,153,0.98,Philadelphia Phillies,Citizens Bank Park,2701815,105,104,PHI,PHI,PHI
+2006,NL,PIT,PIT,C,5,162,81,67,95,N,N,N,N,691,5558,1462,286,17,141,459,1200,68,23,89,49,797,720,4.5200000000,2,10,39,4305,1545,156,620,1060,104,168,0.98,Pittsburgh Pirates,PNC Park,1861549,98,99,PIT,PIT,PIT
+2006,NL,SDN,SDP,W,1,162,81,88,74,Y,N,N,N,731,5576,1465,298,38,161,564,1104,123,31,40,47,679,629,3.8700000000,4,11,50,4391,1385,176,468,1097,92,138,0.98,San Diego Padres,Petco Park,2659757,91,90,SDP,SDN,SDN
+2006,NL,SFN,SFG,W,3,161,81,76,85,N,N,N,N,746,5472,1418,297,52,163,494,891,58,25,53,37,790,735,4.6300000000,7,9,37,4289,1422,153,584,992,91,132,0.98,San Francisco Giants,AT&T Park,3130313,100,100,SFG,SFN,SFN
+2006,NL,SLN,STL,C,1,161,80,83,78,Y,N,Y,Y,781,5522,1484,292,27,184,531,922,59,32,61,40,762,721,4.5400000000,6,9,38,4289,1475,193,504,970,98,170,0.98,St. Louis Cardinals,Busch Stadium III,3407104,99,99,STL,SLN,SLN
+2006,NL,WAS,WSN,E,5,162,81,71,91,N,N,N,N,746,5495,1437,322,22,164,594,1156,123,62,69,49,872,803,5.0300000000,1,3,32,4309,1535,193,584,960,131,123,0.97,Washington Nationals,R.F.K. Stadium,2153056,94,95,WSN,MON,WAS
+2007,AL,BAL,BAL,E,4,162,,69,93,N,N,N,N,756,5631,1529,306,30,142,500,939,144,42,47,47,868,827,5.1700000000,4,9,30,4316,1491,161,696,1087,79,155,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2164822,101,102,BAL,BAL,BAL
+2007,AL,BOS,BOS,E,1,162,,96,66,Y,N,Y,Y,867,5589,1561,352,35,166,689,1042,96,24,64,54,657,618,3.8700000000,5,13,45,4316,1350,151,482,1149,81,145,0.98,Boston Red Sox,Fenway Park II,2970755,106,105,BOS,BOS,BOS
+2007,AL,CHA,CHW,C,4,162,,72,90,N,N,N,N,693,5441,1341,249,20,190,532,1149,78,45,52,35,839,763,4.7700000000,9,9,42,4322,1556,174,499,1015,108,166,0.98,Chicago White Sox,U.S. Cellular Field,2684395,104,104,CHW,CHA,CHA
+2007,AL,CLE,CLE,C,1,162,,96,66,Y,N,N,N,811,5604,1504,305,27,178,590,1202,72,41,80,59,704,658,4.0500000000,9,9,49,4388,1519,146,410,1047,92,166,0.98,Cleveland Indians,Jacobs Field,2275912,101,100,CLE,CLE,CLE
+2007,AL,DET,DET,C,2,162,,88,74,N,N,N,N,887,5757,1652,352,50,177,474,1054,103,30,56,45,797,735,4.5700000000,1,9,44,4342,1498,174,566,1047,99,147,0.98,Detroit Tigers,Comerica Park,3047133,102,101,DET,DET,DET
+2007,AL,KCA,KCR,C,5,162,,69,93,N,N,N,N,706,5534,1447,300,46,102,428,1069,78,44,89,47,778,716,4.4800000000,2,6,36,4312,1547,168,520,993,106,159,0.98,Kansas City Royals,Kauffman Stadium,1616867,100,101,KCR,KCA,KCA
+2007,AL,LAA,ANA,W,1,162,,94,68,Y,N,N,N,822,5554,1578,324,23,123,507,883,139,55,40,65,731,674,4.2300000000,5,9,43,4305,1480,151,477,1156,101,154,0.98,Los Angeles Angels of Anaheim,Angel Stadium,3365632,101,100,LAA,ANA,ANA
+2007,AL,MIN,MIN,C,3,162,,79,83,N,N,N,N,718,5522,1460,273,36,118,512,839,112,30,48,45,725,663,4.1500000000,5,8,38,4310,1505,185,420,1094,95,149,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2296383,95,95,MIN,MIN,MIN
+2007,AL,NYA,NYY,E,2,162,,94,68,N,Y,N,N,968,5717,1656,326,32,201,637,991,123,40,78,54,777,724,4.4900000000,1,5,34,4352,1498,150,578,1009,88,173,0.98,New York Yankees,Yankee Stadium II,4271083,101,100,NYY,NYA,NYA
+2007,AL,OAK,OAK,W,3,162,,76,86,N,N,N,N,741,5577,1430,295,16,171,664,1119,52,20,49,56,758,689,4.2800000000,4,9,36,4344,1468,138,530,1036,90,151,0.98,Oakland Athletics,McAfee Coliseum,1921844,94,94,OAK,OAK,OAK
+2007,AL,SEA,SEA,W,2,162,,88,74,N,N,N,N,794,5684,1629,284,22,153,389,861,81,30,62,40,813,754,4.7300000000,6,12,43,4303,1578,147,546,1020,90,167,0.98,Seattle Mariners,Safeco Field,2672223,96,97,SEA,SEA,SEA
+2007,AL,TBA,TBD,E,5,162,,66,96,N,N,N,N,782,5593,1500,291,36,187,545,1324,131,48,53,52,944,879,5.5300000000,2,2,28,4289,1649,199,568,1194,117,155,0.98,Tampa Bay Devil Rays,Tropicana Field,1387603,98,100,TBD,TBA,TBA
+2007,AL,TEX,TEX,W,4,162,,75,87,N,N,N,N,816,5555,1460,298,36,179,503,1224,88,25,56,42,844,755,4.7500000000,0,6,42,4290,1525,155,668,976,124,178,0.98,Texas Rangers,Rangers Ballpark in Arlington,2353862,101,101,TEX,TEX,TEX
+2007,AL,TOR,TOR,E,3,162,,83,79,N,N,N,N,753,5536,1434,344,24,165,533,1044,57,22,47,48,699,644,4.0000000000,11,9,44,4346,1383,157,479,1067,102,160,0.98,Toronto Blue Jays,Rogers Centre,2360644,100,99,TOR,TOR,TOR
+2007,NL,ARI,ARI,W,1,162,,90,72,Y,N,N,N,712,5398,1350,286,40,171,532,1111,109,24,57,58,732,662,4.1300000000,7,12,51,4323,1446,169,546,1088,106,157,0.98,Arizona Diamondbacks,Chase Field,2325249,107,107,ARI,ARI,ARI
+2007,NL,ATL,ATL,E,3,162,,84,78,N,N,N,N,810,5689,1562,328,27,176,534,1149,64,30,49,47,733,665,4.1100000000,1,6,36,4369,1442,172,537,1106,107,140,0.98,Atlanta Braves,Turner Field,2745207,98,98,ATL,ATL,ATL
+2007,NL,CHN,CHC,C,1,162,,85,77,Y,N,N,N,752,5643,1530,340,28,151,500,1054,86,33,40,37,690,650,4.0400000000,2,10,39,4340,1340,165,573,1211,94,134,0.98,Chicago Cubs,Wrigley Field,3252462,105,104,CHC,CHN,CHN
+2007,NL,CIN,CIN,C,5,162,,72,90,N,N,N,N,783,5607,1496,293,23,204,536,1113,97,31,66,46,853,796,4.9400000000,6,7,34,4349,1605,198,482,1068,95,153,0.98,Cincinnati Reds,Great American Ball Park,2058593,104,104,CIN,CIN,CIN
+2007,NL,COL,COL,W,2,163,,90,73,N,Y,Y,N,860,5691,1591,313,36,171,622,1152,100,31,58,44,758,706,4.3200000000,4,7,39,4416,1497,164,504,967,68,179,0.98,Colorado Rockies,Coors Field,2376250,107,108,COL,COL,COL
+2007,NL,FLO,FLA,E,5,162,,71,91,N,N,N,N,790,5627,1504,340,38,201,521,1332,105,34,82,42,891,793,4.9400000000,0,4,40,4331,1617,176,661,1142,137,159,0.97,Florida Marlins,Dolphin Stadium,1370511,97,98,FLA,FLO,FLO
+2007,NL,HOU,HOU,C,4,162,,73,89,N,N,N,N,723,5605,1457,293,30,167,547,1043,65,33,55,40,813,761,4.6800000000,2,6,38,4394,1566,206,510,1109,103,128,0.98,Houston Astros,Minute Maid Park,3020405,100,100,HOU,HOU,HOU
+2007,NL,LAN,LAD,W,4,162,,82,80,N,N,N,N,735,5613,1544,276,35,129,511,864,137,50,41,55,727,677,4.2000000000,4,6,43,4350,1443,146,518,1184,114,160,0.98,Los Angeles Dodgers,Dodger Stadium,3857036,101,100,LAD,LAN,LAN
+2007,NL,MIL,MIL,C,2,162,,83,79,N,N,N,N,801,5554,1455,310,37,231,501,1137,96,32,76,47,776,708,4.4100000000,3,6,49,4333,1513,161,507,1174,109,143,0.98,Milwaukee Brewers,Miller Park,2869144,100,100,MIL,ML4,MIL
+2007,NL,NYN,NYM,E,2,162,,88,74,N,N,N,N,804,5605,1543,294,27,177,549,981,200,46,54,58,750,687,4.2600000000,2,10,39,4357,1415,165,570,1134,101,124,0.98,New York Mets,Shea Stadium,3853955,98,97,NYM,NYN,NYN
+2007,NL,PHI,PHI,E,1,162,,89,73,Y,N,N,N,892,5688,1558,326,41,213,641,1205,138,19,90,52,821,767,4.7300000000,5,5,42,4375,1555,198,558,1050,89,164,0.98,Philadelphia Phillies,Citizens Bank Park,3108325,104,103,PHI,PHI,PHI
+2007,NL,PIT,PIT,C,6,162,,68,94,N,N,N,N,724,5569,1463,322,31,148,463,1135,68,30,71,51,846,793,4.9300000000,4,5,32,4343,1627,174,518,997,83,189,0.98,Pittsburgh Pirates,PNC Park,1749142,97,98,PIT,PIT,PIT
+2007,NL,SDN,SDP,W,3,163,,89,74,N,N,N,N,741,5612,1408,322,31,171,557,1229,55,24,49,44,666,611,3.7000000000,1,20,45,4454,1406,119,474,1136,92,147,0.98,San Diego Padres,Petco Park,2790074,90,90,SDP,SDN,SDN
+2007,NL,SFN,SFG,W,5,162,,71,91,N,N,N,N,683,5538,1407,267,37,131,532,907,119,33,39,36,720,677,4.1900000000,5,10,37,4361,1442,133,593,1057,88,146,0.98,San Francisco Giants,AT&T Park,3223215,101,101,SFG,SFN,SFN
+2007,NL,SLN,STL,C,3,162,,78,84,N,N,N,N,725,5529,1513,279,13,141,506,909,56,33,54,54,829,741,4.6500000000,2,8,34,4307,1514,168,509,945,121,155,0.98,St. Louis Cardinals,Busch Stadium III,3552180,99,99,STL,SLN,SLN
+2007,NL,WAS,WSN,E,4,162,,73,89,N,N,N,N,673,5520,1415,309,31,123,524,1128,69,23,53,41,783,736,4.5800000000,0,6,46,4340,1502,187,580,931,109,151,0.98,Washington Nationals,R.F.K. Stadium,1943812,94,95,WSN,MON,WAS
+2008,AL,BAL,BAL,E,5,161,,68,93,N,N,N,N,782,5559,1486,322,30,172,533,990,81,37,42,48,869,810,5.1500000000,4,4,35,4266,1538,184,687,922,100,163,0.98,Baltimore Orioles,Oriole Park at Camden Yards,1950075,101,102,BAL,BAL,BAL
+2008,AL,BOS,BOS,E,2,162,,95,67,N,Y,N,N,845,5596,1565,353,33,173,646,1068,120,35,70,62,694,645,4.0100000000,5,16,47,4339,1369,147,548,1185,85,147,0.98,Boston Red Sox,Fenway Park II,3048250,108,106,BOS,BOS,BOS
+2008,AL,CHA,CHW,C,1,163,,89,74,Y,N,N,N,811,5553,1458,296,13,235,540,1016,67,34,63,47,729,658,4.1100000000,4,10,34,4373,1471,156,460,1147,108,154,0.98,Chicago White Sox,U.S. Cellular Field,2500648,105,105,CHW,CHA,CHA
+2008,AL,CLE,CLE,C,3,162,,81,81,N,N,N,N,805,5543,1455,339,22,171,560,1213,77,29,103,49,761,711,4.4600000000,10,13,31,4311,1530,170,444,986,94,183,0.98,Cleveland Indians,Jacobs Field,2169760,98,98,CLE,CLE,CLE
+2008,AL,DET,DET,C,5,162,,74,88,N,N,N,N,821,5641,1529,293,41,200,572,1076,63,31,44,44,857,786,4.9100000000,1,2,34,4335,1541,172,644,991,113,172,0.98,Detroit Tigers,Comerica Park,3202645,103,103,DET,DET,DET
+2008,AL,KCA,KCR,C,4,162,,75,87,N,N,N,N,691,5608,1507,303,28,120,392,1005,79,38,50,36,781,720,4.5000000000,2,8,44,4337,1473,159,515,1085,96,159,0.98,Kansas City Royals,Kauffman Stadium,1578922,98,100,KCR,KCA,KCA
+2008,AL,LAA,ANA,W,1,162,,100,62,Y,N,N,N,765,5540,1486,274,25,159,481,987,129,48,52,50,697,644,4.0000000000,7,10,66,4354,1455,160,457,1106,91,159,0.98,Los Angeles Angels of Anaheim,Angel Stadium,3336747,103,102,LAA,ANA,ANA
+2008,AL,MIN,MIN,C,2,163,,88,75,N,N,N,N,829,5641,1572,298,49,111,529,979,102,42,36,72,745,675,4.1800000000,5,10,42,4377,1568,183,406,995,108,168,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2302431,96,96,MIN,MIN,MIN
+2008,AL,NYA,NYY,E,3,162,,89,73,N,N,N,N,789,5572,1512,289,20,180,535,1015,118,39,80,39,727,685,4.2800000000,1,11,42,4325,1478,143,489,1141,83,141,0.98,New York Yankees,Yankee Stadium II,4298655,103,102,NYY,NYA,NYA
+2008,AL,OAK,OAK,W,3,161,,75,86,N,N,N,N,646,5451,1318,270,23,125,574,1226,88,21,48,35,690,640,4.0100000000,4,7,33,4305,1364,135,576,1061,98,169,0.98,Oakland Athletics,McAfee Coliseum,1665256,95,95,OAK,OAK,OAK
+2008,AL,SEA,SEA,W,4,162,,61,101,N,N,N,N,671,5643,1498,285,20,124,417,890,90,32,38,42,811,754,4.7300000000,4,4,36,4306,1544,161,626,1016,99,159,0.98,Seattle Mariners,Safeco Field,2329702,97,97,SEA,SEA,SEA
+2008,AL,TBA,TBD,E,1,162,,97,65,Y,N,Y,N,774,5541,1443,284,37,180,626,1224,142,50,68,52,671,618,3.8200000000,7,12,52,4373,1349,166,526,1143,90,153,0.98,Tampa Bay Rays,Tropicana Field,1811986,101,101,TBR,TBA,TBA
+2008,AL,TEX,TEX,W,2,162,,79,83,N,N,N,N,901,5728,1619,376,35,194,595,1207,81,25,63,54,967,860,5.3700000000,6,8,36,4326,1647,176,625,963,132,191,0.97,Texas Rangers,Rangers Ballpark in Arlington,1945677,102,102,TEX,TEX,TEX
+2008,AL,TOR,TOR,E,4,162,,86,76,N,N,N,N,714,5503,1453,303,32,126,521,938,80,27,59,56,610,561,3.4900000000,15,13,44,4340,1330,134,467,1184,84,137,0.98,Toronto Blue Jays,Rogers Centre,2399786,98,97,TOR,TOR,TOR
+2008,NL,ARI,ARI,W,2,162,,82,80,N,N,N,N,720,5409,1355,318,47,159,587,1287,58,23,49,43,706,635,3.9900000000,6,9,39,4304,1403,147,451,1229,113,136,0.98,Arizona Diamondbacks,Chase Field,2509924,108,108,ARI,ARI,ARI
+2008,NL,ATL,ATL,E,4,162,,72,90,N,N,N,N,753,5604,1514,316,33,130,618,1023,58,27,42,34,778,714,4.4700000000,2,7,26,4322,1439,156,586,1076,107,149,0.98,Atlanta Braves,Turner Field,2532834,98,98,ATL,ATL,ATL
+2008,NL,CHN,CHC,C,1,161,,97,64,Y,N,N,N,855,5588,1552,329,21,184,636,1186,87,34,50,45,671,624,3.8700000000,2,8,44,4352,1329,160,548,1264,99,118,0.98,Chicago Cubs,Wrigley Field,3300200,108,107,CHC,CHN,CHN
+2008,NL,CIN,CIN,C,5,162,,74,88,N,N,N,N,704,5465,1351,269,24,187,560,1125,85,47,50,41,800,729,4.5500000000,2,6,34,4327,1542,201,557,1227,114,155,0.98,Cincinnati Reds,Great American Ball Park,2058632,102,103,CIN,CIN,CIN
+2008,NL,COL,COL,W,3,162,,74,88,N,N,N,N,747,5557,1462,310,28,160,570,1209,141,37,57,38,822,766,4.7700000000,3,8,36,4338,1547,148,562,1041,96,176,0.98,Colorado Rockies,Coors Field,2650218,109,109,COL,COL,COL
+2008,NL,FLO,FLA,E,3,161,,84,77,N,N,N,N,770,5499,1397,302,28,208,543,1371,76,28,69,46,767,707,4.4400000000,2,8,36,4306,1421,161,586,1127,117,122,0.98,Florida Marlins,Dolphin Stadium,1335076,101,101,FLA,FLO,FLO
+2008,NL,HOU,HOU,C,3,161,,86,75,N,N,N,N,712,5451,1432,284,22,167,449,1051,114,52,52,41,743,691,4.3900000000,4,13,48,4276,1453,197,492,1095,67,141,0.98,Houston Astros,Minute Maid Park,2779487,98,98,HOU,HOU,HOU
+2008,NL,LAN,LAD,W,1,162,,84,78,Y,N,N,N,700,5506,1455,271,29,137,543,1032,126,43,43,38,648,591,3.6800000000,5,11,35,4342,1381,123,480,1205,101,137,0.98,Los Angeles Dodgers,Dodger Stadium,3730553,98,97,LAD,LAN,LAN
+2008,NL,MIL,MIL,C,2,162,,90,72,N,Y,N,N,750,5535,1398,324,35,198,550,1203,108,38,69,43,689,623,3.8700000000,12,10,45,4367,1415,175,528,1110,101,160,0.98,Milwaukee Brewers,Miller Park,3068458,98,98,MIL,ML4,MIL
+2008,NL,NYN,NYM,E,2,162,,89,73,N,N,N,N,799,5606,1491,274,38,172,619,1024,138,36,39,49,715,662,4.0700000000,5,12,43,4393,1415,163,590,1181,83,125,0.98,New York Mets,Shea Stadium,4042045,99,98,NYM,NYN,NYN
+2008,NL,PHI,PHI,E,1,162,,92,70,Y,N,Y,Y,799,5509,1407,291,36,214,586,1117,136,25,67,40,680,625,3.8900000000,4,11,47,4349,1444,160,533,1081,90,142,0.98,Philadelphia Phillies,Citizens Bank Park,3422583,103,102,PHI,PHI,PHI
+2008,NL,PIT,PIT,C,6,162,,67,95,N,N,N,N,735,5628,1454,314,21,153,474,1039,57,19,59,51,884,822,5.1000000000,3,7,34,4365,1631,176,657,963,107,178,0.98,Pittsburgh Pirates,PNC Park,1609076,96,98,PIT,PIT,PIT
+2008,NL,SDN,SDP,W,5,162,,63,99,N,N,N,N,637,5568,1390,264,27,154,518,1259,36,17,53,46,764,714,4.4100000000,3,6,30,4375,1466,165,561,1100,85,148,0.98,San Diego Padres,Petco Park,2427535,88,88,SDP,SDN,SDN
+2008,NL,SFN,SFG,W,4,162,,72,90,N,N,N,N,640,5543,1452,311,37,94,452,1044,108,46,48,44,759,701,4.3800000000,4,12,41,4326,1416,147,652,1240,96,130,0.98,San Francisco Giants,AT&T Park,2863837,102,103,SFG,SFN,SFN
+2008,NL,SLN,STL,C,4,162,,86,76,N,N,N,N,779,5636,1585,283,26,174,577,985,73,32,42,44,725,677,4.2000000000,2,7,42,4362,1517,163,496,957,85,156,0.98,St. Louis Cardinals,Busch Stadium III,3432917,99,99,STL,SLN,SLN
+2008,NL,WAS,WSN,E,5,161,,59,102,N,N,N,N,641,5491,1376,269,26,117,534,1095,81,43,67,36,825,742,4.6600000000,2,8,28,4302,1496,190,588,1063,123,141,0.98,Washington Nationals,Nationals Park,2320400,99,100,WSN,MON,WAS
+2009,AL,BAL,BAL,E,5,162,,64,98,N,N,N,N,741,5618,1508,307,19,160,517,1013,76,37,39,46,876,817,5.1600000000,2,3,31,4287,1633,218,546,933,108,151,0.98,Baltimore Orioles,Oriole Park at Camden Yards,1907163,101,102,BAL,BAL,BAL
+2009,AL,BOS,BOS,E,2,162,,95,67,N,Y,N,N,872,5543,1495,335,25,212,659,1120,126,39,70,51,736,695,4.3500000000,8,11,41,4310,1494,167,530,1230,92,119,0.98,Boston Red Sox,Fenway Park II,3062699,106,105,BOS,BOS,BOS
+2009,AL,CHA,CHW,C,3,162,,79,83,N,N,N,N,724,5463,1410,246,20,184,534,1022,113,49,62,39,732,663,4.1600000000,4,11,36,4319,1438,169,507,1119,128,156,0.98,Chicago White Sox,U.S. Cellular Field,2284163,105,105,CHW,CHA,CHA
+2009,AL,CLE,CLE,C,4,162,,65,97,N,N,N,N,773,5568,1468,314,28,161,582,1211,84,31,81,50,865,806,5.0700000000,5,6,25,4302,1570,183,598,986,114,169,0.98,Cleveland Indians,Jacobs Field,1766242,95,95,CLE,CLE,CLE
+2009,AL,DET,DET,C,2,163,,86,77,N,N,N,N,743,5540,1443,245,35,183,540,1114,72,33,61,39,745,690,4.3400000000,4,9,42,4341,1449,182,594,1102,106,164,0.98,Detroit Tigers,Comerica Park,2567165,101,102,DET,DET,DET
+2009,AL,KCA,KCR,C,4,162,,65,97,N,N,N,N,686,5532,1432,276,51,144,457,1091,88,29,42,32,842,765,4.8300000000,10,9,34,4278,1486,166,600,1153,127,159,0.98,Kansas City Royals,Kauffman Stadium,1797891,97,99,KCR,KCA,KCA
+2009,AL,LAA,ANA,W,1,162,,97,65,Y,N,N,N,883,5622,1604,293,33,173,547,1054,148,63,41,52,761,715,4.4500000000,9,13,51,4335,1513,180,523,1062,99,174,0.98,Los Angeles Angels of Anaheim,Angel Stadium,3240386,99,98,LAA,ANA,ANA
+2009,AL,MIN,MIN,C,1,163,,87,76,Y,N,N,N,817,5608,1539,271,40,172,585,1021,85,32,45,57,765,726,4.5000000000,4,7,48,4359,1542,185,466,1052,89,133,0.98,Minnesota Twins,Hubert H Humphrey Metrodome,2416237,99,98,MIN,MIN,MIN
+2009,AL,NYA,NYY,E,1,162,,103,59,Y,N,Y,Y,915,5660,1604,325,21,244,663,1014,111,28,54,39,753,687,4.2800000000,3,8,51,4350,1386,181,574,1260,101,131,0.98,New York Yankees,Yankee Stadium III,3719358,105,103,NYY,NYA,NYA
+2009,AL,OAK,OAK,W,4,162,,75,87,N,N,N,N,759,5584,1464,307,21,135,527,1046,133,48,50,54,761,685,4.2900000000,2,10,38,4342,1486,156,523,1124,121,153,0.98,Oakland Athletics,Oakland-Alameda Country Coliseum,1408783,99,99,OAK,OAK,OAK
+2009,AL,SEA,SEA,W,3,162,,85,77,N,N,N,N,640,5543,1430,280,19,160,421,1093,89,33,49,44,692,625,3.8700000000,4,10,49,4358,1359,172,534,1043,120,150,0.98,Seattle Mariners,Safeco Field,2195533,94,96,SEA,SEA,SEA
+2009,AL,TBA,TBD,E,3,162,,84,78,N,N,N,N,803,5462,1434,297,36,199,642,1229,194,61,49,45,754,686,4.3600000000,3,5,41,4282,1421,183,515,1125,111,135,0.98,Tampa Bay Rays,Tropicana Field,1874962,98,97,TBR,TBA,TBA
+2009,AL,TEX,TEX,W,2,162,,87,75,N,N,N,N,784,5526,1436,296,27,224,472,1253,149,36,37,51,740,698,4.3800000000,8,11,45,4304,1432,171,531,1016,120,166,0.98,Texas Rangers,Rangers Ballpark in Arlington,2156016,104,104,TEX,TEX,TEX
+2009,AL,TOR,TOR,E,4,162,,75,87,N,N,N,N,798,5696,1516,339,13,209,548,1028,73,23,45,49,771,720,4.4700000000,10,10,25,4353,1509,181,551,1181,88,167,0.98,Toronto Blue Jays,Rogers Centre,1876129,100,99,TOR,TOR,TOR
+2009,NL,ARI,ARI,W,5,162,,70,92,N,N,N,N,720,5565,1408,307,45,173,571,1298,102,40,37,41,782,711,4.4400000000,4,12,36,4343,1470,168,525,1158,151,132,0.97,Arizona Diamondbacks,Chase Field,2128765,105,106,ARI,ARI,ARI
+2009,NL,ATL,ATL,E,3,162,,86,76,N,N,N,N,735,5539,1459,300,20,149,602,1064,58,26,52,47,641,581,3.5700000000,3,10,38,4388,1399,119,530,1232,107,158,0.98,Atlanta Braves,Turner Field,2373631,99,98,ATL,ATL,ATL
+2009,NL,CHN,CHC,C,2,161,,83,78,N,N,N,N,707,5486,1398,293,29,161,592,1185,56,34,59,42,672,616,3.8400000000,3,8,40,4336,1329,160,586,1272,127,144,0.98,Chicago Cubs,Wrigley Field,3168859,107,106,CHC,CHN,CHN
+2009,NL,CIN,CIN,C,4,162,,78,84,N,N,N,N,673,5462,1349,280,25,158,531,1129,96,40,53,41,723,677,4.1800000000,6,12,41,4375,1420,188,577,1069,104,161,0.98,Cincinnati Reds,Great American Ball Park,1747919,100,100,CIN,CIN,CIN
+2009,NL,COL,COL,W,2,162,,92,70,N,Y,N,N,804,5398,1408,300,50,190,660,1277,106,55,47,60,715,675,4.2400000000,5,7,45,4315,1427,141,528,1154,103,144,0.98,Colorado Rockies,Coors Field,2665080,112,112,COL,COL,COL
+2009,NL,FLO,FLA,E,2,162,,87,75,N,N,N,N,772,5572,1493,296,25,159,568,1226,75,35,63,39,766,690,4.3200000000,5,5,45,4339,1425,160,601,1248,118,129,0.98,Florida Marlins,Dolphin Stadium,1464109,102,102,FLA,FLO,FLO
+2009,NL,HOU,HOU,C,5,162,,74,88,N,N,N,N,643,5436,1415,270,32,142,448,990,113,44,43,45,770,722,4.5400000000,5,10,39,4290,1521,176,546,1144,88,161,0.98,Houston Astros,Minute Maid Park,2521076,98,98,HOU,HOU,HOU
+2009,NL,LAN,LAD,W,1,162,,95,67,Y,N,N,N,780,5592,1511,278,39,145,607,1068,116,48,63,44,611,558,3.4100000000,1,9,44,4420,1265,127,584,1272,97,134,0.98,Los Angeles Dodgers,Dodger Stadium,3761655,96,95,LAD,LAN,LAN
+2009,NL,MIL,MIL,C,3,162,,80,82,N,N,N,N,785,5510,1447,281,37,182,610,1231,68,37,71,47,818,770,4.8400000000,1,8,44,4305,1498,207,607,1104,111,150,0.98,Milwaukee Brewers,Miller Park,3037451,98,98,MIL,ML4,MIL
+2009,NL,NYN,NYM,E,4,162,,70,92,N,N,N,N,671,5453,1472,295,49,95,526,928,122,44,36,55,757,705,4.4600000000,3,12,39,4278,1452,158,616,1031,108,134,0.98,New York Mets,Citi Field,3168571,97,97,NYM,NYN,NYN
+2009,NL,PHI,PHI,E,1,162,,93,69,Y,N,Y,N,820,5578,1439,312,35,224,589,1155,119,28,71,45,709,673,4.1600000000,8,9,44,4367,1479,189,489,1153,86,132,0.98,Philadelphia Phillies,Citizens Bank Park,3600693,101,100,PHI,PHI,PHI
+2009,NL,PIT,PIT,C,6,161,,62,99,N,N,N,N,636,5417,1364,289,34,125,499,1142,90,32,46,36,768,723,4.5900000000,5,7,28,4255,1491,152,563,919,80,169,0.98,Pittsburgh Pirates,PNC Park,1577853,98,99,PIT,PIT,PIT
+2009,NL,SDN,SDP,W,4,162,,75,87,N,N,N,N,638,5425,1315,265,31,141,586,1182,82,29,57,36,769,704,4.3700000000,2,9,45,4352,1422,167,603,1187,109,144,0.98,San Diego Padres,Petco Park,1919603,90,90,SDP,SDN,SDN
+2009,NL,SFN,SFG,W,3,162,,88,74,N,N,N,N,657,5493,1411,275,43,122,392,1158,78,28,50,55,611,571,3.5500000000,11,18,41,4338,1268,140,584,1302,99,138,0.98,San Francisco Giants,AT&T Park,2862110,102,102,SFG,SFN,SFN
+2009,NL,SLN,STL,C,1,162,,91,71,Y,N,N,N,730,5465,1436,294,29,160,528,1041,75,31,61,43,640,586,3.6600000000,8,11,43,4322,1407,123,460,1049,113,167,0.98,St. Louis Cardinals,Busch Stadium III,3343252,98,97,STL,SLN,SLN
+2009,NL,WAS,WSN,E,5,162,,59,103,N,N,N,N,710,5493,1416,271,38,156,617,1208,73,40,56,42,874,791,5.0200000000,6,3,33,4273,1533,173,629,911,170,154,0.97,Washington Nationals,Nationals Park,1817226,99,101,WSN,MON,WAS
+2010,AL,BAL,BAL,E,5,162,,66,96,N,N,N,N,613,5554,1440,264,21,133,424,1056,76,34,54,45,785,733,4.5900000000,3,7,35,4309,1508,186,520,1007,123,141,0.98,Baltimore Orioles,Oriole Park at Camden Yards,,101,102,BAL,BAL,BAL
+2010,AL,BOS,BOS,E,3,162,,89,73,N,N,N,N,818,5646,1511,358,22,211,587,1140,68,17,47,46,744,679,4.2000000000,3,9,44,4370,1402,152,580,1207,127,132,0.98,Boston Red Sox,Fenway Park II,,106,105,BOS,BOS,BOS
+2010,AL,CHA,CHW,C,2,162,,88,74,N,N,N,N,752,5484,1467,263,21,177,467,922,160,74,79,38,704,658,4.0900000000,6,11,43,4339,1471,136,490,1149,120,157,0.98,Chicago White Sox,U.S. Cellular Field,,105,105,CHW,CHA,CHA
+2010,AL,CLE,CLE,C,4,162,,69,93,N,N,N,N,646,5487,1362,290,20,128,545,1184,91,33,64,33,752,684,4.3000000000,10,4,34,4299,1477,147,572,967,126,179,0.98,Cleveland Indians,Jacobs Field,,93,93,CLE,CLE,CLE
+2010,AL,DET,DET,C,3,162,,81,81,N,N,N,N,751,5643,1515,308,32,152,546,1147,69,30,41,41,743,690,4.3000000000,6,5,32,4333,1445,142,537,1056,136,171,0.98,Detroit Tigers,Comerica Park,,101,101,DET,DET,DET
+2010,AL,KCA,KCR,C,5,162,,67,95,N,N,N,N,676,5604,1534,279,31,121,471,905,115,50,35,53,845,794,4.9700000000,7,3,44,4310,1553,176,551,1035,138,138,0.98,Kansas City Royals,Kauffman Stadium,,99,101,KCR,KCA,KCA
+2010,AL,LAA,ANA,W,3,162,,80,82,N,N,N,N,681,5488,1363,276,19,155,466,1070,104,52,52,37,702,651,4.0400000000,10,9,39,4348,1422,148,565,1130,131,116,0.98,Los Angeles Angels of Anaheim,Angel Stadium,,98,98,LAA,ANA,ANA
+2010,AL,MIN,MIN,C,1,162,,94,68,Y,N,N,N,781,5568,1521,318,41,142,559,967,68,28,39,53,671,638,3.9500000000,9,13,40,4358,1493,155,383,1048,94,149,0.98,Minnesota Twins,Target Field,,101,100,MIN,MIN,MIN
+2010,AL,NYA,NYY,E,2,162,,95,67,N,Y,N,N,859,5567,1485,275,32,201,662,1136,103,30,73,44,693,651,4.0600000000,3,8,39,4327,1349,179,540,1154,79,161,0.98,New York Yankees,Yankee Stadium III,,105,103,NYY,NYA,NYA
+2010,AL,OAK,OAK,W,2,162,,81,81,N,N,N,N,663,5448,1396,276,30,109,527,1061,156,38,47,51,626,566,3.5800000000,7,17,38,4295,1315,153,512,1070,110,146,0.98,Oakland Athletics,Oakland-Alameda Country Coliseum,,100,100,OAK,OAK,OAK
+2010,AL,SEA,SEA,W,4,162,,61,101,N,N,N,N,513,5409,1274,227,16,101,459,1184,142,39,39,40,698,628,3.9500000000,11,10,38,4314,1402,157,452,973,122,146,0.98,Seattle Mariners,Safeco Field,,93,95,SEA,SEA,SEA
+2010,AL,TBA,TBD,E,1,162,,96,66,Y,N,N,N,802,5439,1343,295,37,160,672,1292,172,47,57,57,649,611,3.7800000000,6,12,51,4361,1347,175,478,1189,95,134,0.98,Tampa Bay Rays,Tropicana Field,,96,95,TBR,TBA,TBA
+2010,AL,TEX,TEX,W,1,162,,90,72,Y,N,Y,N,787,5635,1556,268,25,162,511,986,123,48,45,54,687,636,3.9300000000,7,8,46,4366,1355,162,551,1181,123,132,0.98,Texas Rangers,Rangers Ballpark in Arlington,,105,104,TEX,TEX,TEX
+2010,AL,TOR,TOR,E,4,162,,85,77,N,N,N,N,755,5495,1364,319,21,257,471,1164,58,20,55,34,728,676,4.2300000000,5,11,45,4322,1407,150,539,1184,102,172,0.98,Toronto Blue Jays,Rogers Centre,,100,100,TOR,TOR,TOR
+2010,NL,ARI,ARI,W,5,162,,65,97,N,N,N,N,713,5473,1366,301,34,180,589,1529,86,41,39,41,836,765,4.8100000000,3,3,35,4296,1503,210,548,1070,121,152,0.98,Arizona Diamondbacks,Chase Field,,104,105,ARI,ARI,ARI
+2010,NL,ATL,ATL,E,2,162,,91,71,N,Y,N,N,738,5463,1411,312,25,139,634,1140,63,29,51,35,629,569,3.5700000000,2,9,41,4318,1326,126,505,1241,145,165,0.98,Atlanta Braves,Turner Field,,98,97,ATL,ATL,ATL
+2010,NL,CHN,CHC,C,5,162,,75,87,N,N,N,N,685,5512,1414,298,27,149,479,1236,55,31,50,38,767,668,4.2400000000,1,14,40,4310,1409,154,605,1268,144,135,0.98,Chicago Cubs,Wrigley Field,,108,108,CHC,CHN,CHN
+2010,NL,CIN,CIN,C,1,162,,91,71,Y,N,N,N,790,5579,1515,293,30,188,522,1218,93,43,68,50,685,648,4.0200000000,4,9,43,4359,1404,158,524,1130,86,140,0.98,Cincinnati Reds,Great American Ball Park,,99,99,CIN,CIN,CIN
+2010,NL,COL,COL,W,3,162,,83,79,N,N,N,N,770,5530,1452,270,54,173,585,1274,99,42,47,47,717,663,4.1400000000,6,12,35,4326,1405,139,525,1234,113,182,0.98,Colorado Rockies,Coors Field,,115,115,COL,COL,COL
+2010,NL,FLO,FLA,E,3,162,,80,82,N,N,N,N,719,5531,1403,294,37,152,514,1375,92,26,55,43,717,652,4.0900000000,5,17,39,4315,1433,134,549,1168,141,130,0.98,Florida Marlins,Dolphin Stadium,,105,104,FLA,FLO,FLO
+2010,NL,HOU,HOU,C,4,162,,76,86,N,N,N,N,611,5452,1348,252,25,108,415,1025,100,36,33,29,729,654,4.0900000000,4,11,45,4318,1446,140,548,1210,118,135,0.98,Houston Astros,Minute Maid Park,,95,96,HOU,HOU,HOU
+2010,NL,LAN,LAD,W,4,162,,80,82,N,N,N,N,667,5426,1368,270,29,120,533,1184,92,50,46,50,692,643,4.0100000000,4,16,41,4325,1323,134,539,1274,114,122,0.98,Los Angeles Dodgers,Dodger Stadium,,95,95,LAD,LAN,LAN
+2010,NL,MIL,MIL,C,3,162,,77,85,N,N,N,N,750,5606,1471,293,33,182,546,1216,81,26,81,35,804,733,4.5900000000,3,7,35,4317,1487,173,582,1258,115,141,0.98,Milwaukee Brewers,Miller Park,,98,98,MIL,ML4,MIL
+2010,NL,NYN,NYM,E,4,162,,79,83,N,N,N,N,656,5465,1361,266,40,128,502,1095,130,44,46,57,652,597,3.7300000000,8,19,36,4359,1438,135,545,1106,96,160,0.98,New York Mets,Citi Field,,97,97,NYM,NYN,NYN
+2010,NL,PHI,PHI,E,1,162,,97,65,Y,N,N,N,772,5581,1451,290,34,166,560,1064,108,21,63,43,640,594,3.6800000000,14,21,40,4369,1402,168,416,1183,93,156,0.98,Philadelphia Phillies,Citizens Bank Park,,101,100,PHI,PHI,PHI
+2010,NL,PIT,PIT,C,6,162,,57,105,N,N,N,N,587,5386,1303,276,27,126,463,1207,87,36,33,33,866,784,5.0000000000,1,6,31,4235,1567,167,538,1026,142,119,0.98,Pittsburgh Pirates,PNC Park,,99,101,PIT,PIT,PIT
+2010,NL,SDN,SDP,W,2,162,,90,72,N,N,N,N,665,5434,1338,236,24,132,538,1183,124,50,50,46,581,549,3.4100000000,2,20,49,4369,1305,139,517,1295,85,142,0.98,San Diego Padres,Petco Park,,91,91,SDP,SDN,SDN
+2010,NL,SFN,SFG,W,1,162,,92,70,Y,N,Y,Y,697,5488,1411,284,30,162,487,1099,55,32,50,41,583,546,3.3600000000,6,17,57,4383,1279,134,578,1331,80,110,0.98,San Francisco Giants,AT&T Park,,101,101,SFG,SFN,SFN
+2010,NL,SLN,STL,C,2,162,,86,76,N,N,N,N,736,5542,1456,285,18,150,541,1027,79,41,50,40,641,577,3.5700000000,7,16,32,4361,1412,133,477,1094,109,170,0.98,St. Louis Cardinals,Busch Stadium III,,97,97,STL,SLN,SLN
+2010,NL,WAS,WSN,E,5,162,,69,93,N,N,N,N,655,5418,1355,250,31,149,503,1220,110,41,60,47,742,658,4.1300000000,2,5,37,4305,1469,151,512,1068,142,146,0.98,Washington Nationals,Nationals Park,,99,100,WSN,MON,WAS
+2011,AL,BAL,BAL,E,5,162,,69,93,N,N,N,N,708,5585,1434,273,13,191,452,1120,81,25,52,43,860,786,4.9200000000,3,7,32,4340,1568,210,535,1044,110,159,0.98,Baltimore Orioles,Oriole Park at Camden Yards,1755461,96,97,BAL,BAL,BAL
+2011,AL,BOS,BOS,E,3,162,,90,72,N,N,N,N,875,5710,1600,352,35,203,578,1108,102,42,50,50,737,680,4.2000000000,2,13,36,4372,1366,156,540,1213,92,120,0.99,Boston Red Sox,Fenway Park II,3054001,106,105,BOS,BOS,BOS
+2011,AL,CHA,CHW,C,3,162,,79,83,N,N,N,N,654,5502,1387,252,16,154,475,989,81,53,84,46,706,665,4.1000000000,6,14,42,4380,1463,147,439,1220,79,128,0.99,Chicago White Sox,U.S. Cellular Field,2001117,99,100,CHW,CHA,CHA
+2011,AL,CLE,CLE,C,2,162,,80,82,N,N,N,N,704,5509,1380,290,26,154,494,1269,89,42,65,43,760,683,4.2400000000,2,4,38,4360,1482,153,463,1024,110,131,0.98,Cleveland Indians,Jacobs Field,1840835,96,97,CLE,CLE,CLE
+2011,AL,DET,DET,C,1,162,,95,67,Y,N,N,N,787,5563,1540,297,34,169,521,1143,49,20,39,58,711,647,4.0400000000,4,14,52,4320,1406,149,492,1115,103,146,0.98,Detroit Tigers,Comerica Park,2642045,103,102,DET,DET,DET
+2011,AL,KCA,KCR,C,4,162,,71,91,N,N,N,N,730,5672,1560,325,41,129,442,1006,153,58,39,57,762,716,4.4500000000,2,6,37,4354,1487,163,557,1080,95,149,0.99,Kansas City Royals,Kauffman Stadium,1724450,101,101,KCR,KCA,KCA
+2011,AL,LAA,ANA,W,2,162,,86,76,N,N,N,N,667,5513,1394,289,34,155,442,1086,135,52,51,32,633,581,3.5700000000,12,11,39,4395,1388,142,476,1058,93,157,0.99,Los Angeles Angels of Anaheim,Angel Stadium,3166321,93,93,LAA,ANA,ANA
+2011,AL,MIN,MIN,C,5,162,,63,99,N,N,N,N,619,5487,1357,259,25,103,440,1048,92,39,37,25,804,724,4.6000000000,7,8,32,4265,1564,161,480,940,119,153,0.98,Minnesota Twins,Target Field,3168116,95,97,MIN,MIN,MIN
+2011,AL,NYA,NYY,E,1,162,,97,65,Y,N,N,N,867,5518,1452,267,33,222,627,1138,147,46,74,51,657,605,3.7300000000,5,8,47,4375,1423,152,507,1222,102,140,0.98,New York Yankees,Yankee Stadium III,3653680,108,106,NYY,NYA,NYA
+2011,AL,OAK,OAK,W,3,162,,74,88,N,N,N,N,645,5452,1330,280,29,114,509,1094,117,43,50,57,679,597,3.7100000000,6,12,39,4343,1380,136,519,1160,124,145,0.98,Oakland Athletics,Oakland-Alameda Country Coliseum,1476791,97,98,OAK,OAK,OAK
+2011,AL,SEA,SEA,W,4,162,,67,95,N,N,N,N,556,5421,1263,253,22,109,435,1280,125,40,37,41,675,621,3.9100000000,12,10,39,4299,1369,145,436,1088,108,152,0.98,Seattle Mariners,Safeco Field,1939421,94,95,SEA,SEA,SEA
+2011,AL,TBA,TBD,E,2,162,,91,71,N,Y,N,N,707,5436,1324,273,37,172,571,1193,155,62,73,35,614,577,3.5800000000,15,13,32,4347,1263,161,504,1143,73,139,0.99,Tampa Bay Rays,Tropicana Field,1529188,92,92,TBR,TBA,TBA
+2011,AL,TEX,TEX,W,1,162,,96,66,Y,N,Y,N,855,5659,1599,310,32,210,475,930,143,45,39,49,677,607,3.7900000000,10,19,38,4324,1327,170,461,1179,114,162,0.98,Texas Rangers,Rangers Ballpark in Arlington,2946949,117,115,TEX,TEX,TEX
+2011,AL,TOR,TOR,E,4,162,,81,81,N,N,N,N,743,5559,1384,285,34,186,525,1184,131,52,48,47,761,700,4.3300000000,7,10,33,4376,1433,179,540,1169,110,146,0.98,Toronto Blue Jays,Rogers Centre,1818103,104,104,TOR,TOR,TOR
+2011,NL,ARI,ARI,W,1,162,,94,68,Y,N,N,N,731,5421,1357,293,37,172,531,1249,133,55,61,33,662,609,3.8000000000,5,12,58,4330,1414,159,442,1058,90,130,0.99,Arizona Diamondbacks,Chase Field,2105432,107,106,ARI,ARI,ARI
+2011,NL,ATL,ATL,E,2,162,,89,73,N,N,N,N,641,5528,1345,244,16,173,504,1260,77,44,28,30,605,572,3.4900000000,3,16,52,4439,1332,125,521,1332,83,131,0.99,Atlanta Braves,Turner Field,2372940,98,98,ATL,ATL,ATL
+2011,NL,CHN,CHC,C,5,162,,71,91,N,N,N,N,654,5549,1423,285,36,148,425,1202,69,23,59,35,756,690,4.3400000000,4,5,40,4303,1439,162,580,1224,134,128,0.98,Chicago Cubs,Wrigley Field,3017966,96,97,CHC,CHN,CHN
+2011,NL,CIN,CIN,C,3,162,,79,83,N,N,N,N,735,5612,1438,264,19,183,535,1250,97,50,63,40,720,678,4.1600000000,4,5,39,4403,1414,185,539,1112,91,145,0.99,Cincinnati Reds,Great American Ball Park,2213588,107,106,CIN,CIN,CIN
+2011,NL,COL,COL,W,4,162,,73,89,N,N,N,N,735,5544,1429,274,40,163,555,1201,118,42,57,44,774,713,4.4400000000,5,7,41,4343,1471,176,522,1118,98,156,0.98,Colorado Rockies,Coors Field,2909777,116,116,COL,COL,COL
+2011,NL,FLO,FLA,E,5,162,,72,90,N,N,N,N,625,5508,1358,274,30,149,542,1244,95,41,51,42,702,640,3.9500000000,7,11,40,4379,1403,149,500,1218,93,126,0.99,Florida Marlins,Sun Life Stadium,1477462,99,100,FLA,FLO,FLO
+2011,NL,HOU,HOU,C,6,162,,56,106,N,N,N,N,615,5598,1442,309,28,95,401,1164,118,33,46,37,796,719,4.5100000000,2,6,25,4305,1477,188,560,1191,116,139,0.98,Houston Astros,Minute Maid Park,2067016,102,104,HOU,HOU,HOU
+2011,NL,LAN,LAD,W,3,161,,82,79,N,N,N,N,644,5436,1395,237,28,117,498,1087,126,40,45,43,612,563,3.5600000000,7,17,40,4296,1287,132,507,1265,85,121,0.99,Los Angeles Dodgers,Dodger Stadium,2935139,98,98,LAD,LAN,LAN
+2011,NL,MIL,MIL,C,1,162,,96,66,Y,N,N,N,721,5447,1422,276,31,185,481,1083,94,31,56,44,638,582,3.6400000000,1,13,47,4325,1348,147,440,1257,111,131,0.98,Milwaukee Brewers,Miller Park,3071373,103,102,MIL,ML4,MIL
+2011,NL,NYN,NYM,E,4,162,,77,85,N,N,N,N,718,5600,1477,309,39,108,571,1085,130,35,51,48,742,674,4.1900000000,6,9,43,4344,1482,147,514,1126,116,125,0.98,New York Mets,Citi Field,2352596,98,98,NYM,NYN,NYN
+2011,NL,PHI,PHI,E,1,162,,102,60,Y,N,N,N,713,5579,1409,258,38,153,539,1024,96,24,56,38,529,495,3.0200000000,18,21,47,4431,1320,120,404,1299,74,134,0.99,Philadelphia Phillies,Citizens Bank Park,3680718,105,103,PHI,PHI,PHI
+2011,NL,PIT,PIT,C,4,162,,72,90,N,N,N,N,610,5421,1325,277,35,107,489,1308,108,52,34,44,712,650,4.0500000000,5,11,43,4348,1513,152,535,1031,112,154,0.98,Pittsburgh Pirates,PNC Park,1940429,96,97,PIT,PIT,PIT
+2011,NL,SDN,SDP,W,5,162,,71,91,N,N,N,N,593,5417,1284,247,42,91,501,1320,170,44,48,47,611,551,3.4300000000,0,10,44,4348,1324,125,521,1139,94,138,0.99,San Diego Padres,Petco Park,2143018,92,92,SDP,SDN,SDN
+2011,NL,SFN,SFG,W,2,162,,86,76,N,N,N,N,570,5486,1327,282,24,121,448,1122,85,51,52,43,578,522,3.2100000000,3,12,52,4404,1260,96,559,1316,104,127,0.98,San Francisco Giants,AT&T Park,3387303,89,89,SFG,SFN,SFN
+2011,NL,SLN,STL,C,2,162,,90,72,N,Y,Y,Y,762,5532,1513,308,22,162,542,978,57,39,44,40,692,608,3.7900000000,7,9,47,4386,1461,136,448,1098,116,167,0.98,St. Louis Cardinals,Busch Stadium III,3093954,95,94,STL,SLN,SLN
+2011,NL,WAS,WSN,E,3,161,,80,81,N,N,N,N,624,5441,1319,257,22,154,470,1323,106,38,65,32,643,577,3.5800000000,3,10,49,4348,1403,129,477,1049,104,145,0.98,Washington Nationals,Nationals Park,1940478,100,100,WSN,MON,WAS
+2012,AL,BAL,BAL,E,2,162,81,93,69,N,Y,N,N,712,5560,1375,270,16,214,480,1315,58,29,50,30,705,642,3.9000000000,1,1,55,4449,1433,184,481,1177,106,150,0.98,Baltimore Orioles,Oriole Park at Camden Yards,2102240,102,103,BAL,BAL,BAL
+2012,AL,BOS,BOS,E,5,162,81,69,93,N,N,N,N,734,5604,1459,339,16,165,428,1197,97,31,45,55,806,754,4.7200000000,6,2,35,4329,1449,190,529,1176,101,159,0.98,Boston Red Sox,Fenway Park II,3043003,106,106,BOS,BOS,BOS
+2012,AL,CHA,CHW,C,2,162,81,85,77,N,N,N,N,748,5518,1409,228,29,211,461,1203,109,43,65,36,676,646,4.0200000000,6,2,37,4337,1365,186,503,1246,70,154,0.99,Chicago White Sox,U.S. Cellular Field,1965955,106,106,CHW,CHA,CHA
+2012,AL,CLE,CLE,C,4,162,81,68,94,N,N,N,N,667,5525,1385,266,24,136,555,1087,110,44,59,39,845,766,4.7900000000,2,1,43,4326,1503,174,543,1086,96,156,0.98,Cleveland Indians,Progressive Field,1603596,93,95,CLE,CLE,CLE
+2012,AL,DET,DET,C,1,162,81,88,74,Y,N,Y,N,726,5476,1467,279,39,163,511,1103,59,23,57,39,670,596,3.7700000000,9,3,40,4292,1409,151,438,1318,99,127,0.98,Detroit Tigers,Comerica Park,3028033,104,103,DET,DET,DET
+2012,AL,KCA,KCR,C,3,162,81,72,90,N,N,N,N,676,5636,1492,295,37,131,404,1032,132,38,42,41,746,693,4.3000000000,2,1,44,4354,1504,163,542,1177,113,169,0.98,Kansas City Royals,Kauffman Stadium,1739859,100,100,KCR,KCA,KCA
+2012,AL,LAA,ANA,W,3,162,81,89,73,N,N,N,N,767,5536,1518,273,22,187,449,1113,134,33,47,41,699,640,4.0200000000,6,5,38,4300,1339,186,483,1157,98,138,0.98,Los Angeles Angels of Anaheim,Angel Stadium of Anaheim,3061770,92,92,LAA,ANA,ANA
+2012,AL,MIN,MIN,C,5,162,81,66,96,N,N,N,N,701,5562,1448,270,30,131,505,1069,135,37,53,56,832,762,4.7700000000,3,1,35,4316,1536,198,465,943,107,187,0.98,Minnesota Twins,Target Field,2776354,97,99,MIN,MIN,MIN
+2012,AL,NYA,NYY,E,1,162,81,95,67,Y,N,N,N,804,5524,1462,280,13,245,565,1176,93,27,62,49,668,618,3.8600000000,6,2,51,4336,1401,190,431,1318,74,135,0.99,New York Yankees,Yankee Stadium III,3542406,103,102,NYY,NYA,NYA
+2012,AL,OAK,OAK,W,1,162,81,94,68,Y,N,N,N,713,5527,1315,267,32,195,550,1387,122,32,45,34,614,569,3.5000000000,1,0,47,4410,1360,147,462,1136,111,136,0.98,Oakland Athletics,O.co Coliseum,1679013,97,97,OAK,OAK,OAK
+2012,AL,SEA,SEA,W,4,162,81,75,87,N,N,N,N,619,5494,1285,241,27,149,466,1259,104,35,30,35,651,608,3.7600000000,8,6,43,4370,1359,166,449,1166,72,153,0.99,Seattle Mariners,Safeco Field,1721920,90,91,SEA,SEA,SEA
+2012,AL,TBA,TBD,E,3,162,81,90,72,N,N,N,N,697,5398,1293,250,30,175,571,1323,134,44,58,42,577,518,3.1900000000,7,4,50,4379,1233,139,469,1383,114,154,0.98,Tampa Bay Rays,Tropicana Field,1559681,94,93,TBR,TBA,TBA
+2012,AL,TEX,TEX,W,2,162,81,93,69,N,Y,N,N,808,5590,1526,303,32,200,478,1103,91,44,57,53,707,639,4.0200000000,7,2,43,4326,1378,175,446,1286,85,136,0.99,Texas Rangers,Rangers Ballpark in Arlington,3460280,112,111,TEX,TEX,TEX
+2012,AL,TOR,TOR,E,4,162,81,73,89,N,N,N,N,716,5487,1346,247,22,198,473,1251,123,41,55,45,784,745,4.6400000000,5,4,29,4331,1439,204,574,1142,101,168,0.98,Toronto Blue Jays,Rogers Centre,2099663,103,104,TOR,TOR,TOR
+2012,NL,ARI,ARI,W,3,162,81,81,81,N,N,N,N,734,5462,1416,307,33,165,539,1266,93,51,41,45,688,626,3.9400000000,4,2,39,4301,1432,155,417,1200,90,144,0.99,Arizona Diamondbacks,Chase Field,2177617,105,106,ARI,ARI,ARI
+2012,NL,ATL,ATL,E,2,162,81,94,68,N,Y,N,N,700,5425,1341,263,30,149,567,1289,101,32,34,46,600,549,3.4200000000,5,4,47,4336,1310,145,464,1232,86,146,0.99,Atlanta Braves,Turner Field,2420171,102,101,ATL,ATL,ATL
+2012,NL,CHN,CHC,C,5,162,81,61,101,N,N,N,N,613,5411,1297,265,36,137,447,1235,94,45,43,24,759,708,4.5100000000,1,0,28,4241,1399,175,573,1128,105,148,0.98,Chicago Cubs,Wrigley Field,2882756,98,99,CHC,CHN,CHN
+2012,NL,CIN,CIN,C,1,162,81,97,65,Y,N,N,N,669,5477,1377,296,30,172,481,1266,87,27,47,37,588,540,3.3400000000,9,2,56,4359,1356,152,427,1248,89,113,0.99,Cincinnati Reds,Great American Ball Park,2347251,107,107,CIN,CIN,CIN
+2012,NL,COL,COL,W,5,162,81,64,98,N,N,N,N,758,5577,1526,306,52,166,450,1213,100,40,36,39,890,824,5.2200000000,0,0,36,4266,1637,198,566,1144,122,138,0.98,Colorado Rockies,Coors Field,2630458,120,121,COL,COL,COL
+2012,NL,HOU,HOU,C,6,162,81,55,107,N,N,N,N,583,5407,1276,238,28,146,463,1365,105,46,58,30,794,721,4.5700000000,3,2,31,4270,1493,173,540,1170,118,131,0.98,Houston Astros,Minute Maid Park,1607733,99,101,HOU,HOU,HOU
+2012,NL,LAN,LAD,W,2,162,81,86,76,N,N,N,N,637,5438,1369,269,23,116,481,1156,104,44,52,38,597,538,3.3500000000,2,2,40,4349,1277,122,539,1276,98,137,0.98,Los Angeles Dodgers,Dodger Stadium,3324246,96,96,LAD,LAN,LAN
+2012,NL,MIA,FLA,E,5,162,81,69,93,N,N,N,N,609,5437,1327,261,39,137,484,1228,149,41,35,40,724,655,4.1000000000,5,3,38,4322,1448,133,495,1113,103,154,0.98,Miami Marlins,Marlins Park,2219444,100,100,MIA,FLO,MIA
+2012,NL,MIL,MIL,C,3,162,81,83,79,N,N,N,N,776,5557,1442,300,39,202,466,1240,158,39,90,35,733,682,4.2200000000,0,0,44,4361,1458,169,525,1402,99,132,0.98,Milwaukee Brewers,Miller Park,2831385,104,104,MIL,ML4,MIL
+2012,NL,NYN,NYM,E,4,162,81,74,88,N,N,N,N,650,5450,1357,286,21,139,503,1250,79,38,42,30,709,651,4.0900000000,7,5,36,4302,1368,161,488,1240,101,135,0.98,New York Mets,Citi Field,2242803,96,97,NYM,NYN,NYN
+2012,NL,PHI,PHI,E,3,162,81,81,81,N,N,N,N,684,5544,1414,271,28,158,454,1094,116,23,63,39,680,618,3.8600000000,5,4,42,4354,1387,178,409,1385,101,118,0.98,Philadelphia Phillies,Citizens Bank Park,3565718,102,101,PHI,PHI,PHI
+2012,NL,PIT,PIT,C,4,162,81,79,83,N,N,N,N,651,5412,1313,241,37,170,444,1354,73,52,51,45,674,615,3.9100000000,2,1,45,4300,1357,153,490,1192,112,126,0.98,Pittsburgh Pirates,PNC Park,2091918,93,94,PIT,PIT,PIT
+2012,NL,SDN,SDP,W,4,162,81,76,86,N,N,N,N,651,5422,1339,272,43,121,539,1238,155,46,54,34,710,640,4.0100000000,4,3,43,4304,1356,162,539,1205,121,97,0.98,San Diego Padres,Petco Park,2123721,92,92,SDP,SDN,SDN
+2012,NL,SFN,SFG,W,1,162,81,94,68,Y,N,Y,Y,718,5558,1495,287,57,103,483,1097,118,39,29,61,649,593,3.6800000000,5,4,53,4353,1361,142,489,1237,115,134,0.98,San Francisco Giants,AT&T Park,3377371,88,88,SFG,SFN,SFN
+2012,NL,SLN,STL,C,2,162,81,88,74,N,Y,N,N,765,5622,1526,290,37,159,533,1192,91,37,53,49,648,603,3.7100000000,4,2,42,4388,1420,134,436,1218,107,149,0.98,St. Louis Cardinals,Busch Stadium III,3262109,98,97,STL,SLN,SLN
+2012,NL,WAS,WSN,E,1,162,81,98,64,Y,N,N,N,731,5615,1468,301,25,194,479,1325,105,35,41,36,594,543,3.3400000000,3,1,51,4405,1296,129,497,1325,94,134,0.99,Washington Nationals,Nationals Park,2370794,99,101,WSN,MON,WAS
diff --git a/pandas/tests/io/json/test_compression.py b/pandas/tests/io/json/test_compression.py
index a752c93a8046a..ab97fb1740496 100644
--- a/pandas/tests/io/json/test_compression.py
+++ b/pandas/tests/io/json/test_compression.py
@@ -6,8 +6,7 @@
 
 import pandas as pd
 import pandas._testing as tm
-
-import pandas.io.common as icom
+from pandas.tests.io.test_compression import _compression_to_extension
 
 
 def test_compression_roundtrip(compression):
@@ -38,6 +37,7 @@ def test_read_zipped_json(datapath):
 
 
 @td.skip_if_not_us_locale
+@pytest.mark.single_cpu
 def test_with_s3_url(https://github.com/compression,%20s3_resource,%20s3so):
     # Bucket "pandas-test" created in tests/io/conftest.py
 
@@ -99,7 +99,7 @@ def test_to_json_compression(compression_only, read_infer, to_infer):
 
     # We'll complete file extension subsequently.
     filename = "test."
-    filename += icom._compression_to_extension[compression]
+    filename += _compression_to_extension[compression]
 
     df = pd.DataFrame({"A": [1]})
 
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index f7aade1f27529..f4c8b9e764d6d 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -24,20 +24,39 @@
 )
 
 
-class TestBuildSchema:
-    def setup_method(self, method):
-        self.df = DataFrame(
-            {
-                "A": [1, 2, 3, 4],
-                "B": ["a", "b", "c", "c"],
-                "C": pd.date_range("2016-01-01", freq="d", periods=4),
-                "D": pd.timedelta_range("1H", periods=4, freq="T"),
-            },
-            index=pd.Index(range(4), name="idx"),
-        )
+@pytest.fixture
+def df_schema():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="d", periods=4),
+            "D": pd.timedelta_range("1H", periods=4, freq="T"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
+
+
+@pytest.fixture
+def df_table():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="d", periods=4),
+            "D": pd.timedelta_range("1H", periods=4, freq="T"),
+            "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
+            "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
+            "G": [1.0, 2.0, 3, 4.0],
+            "H": pd.date_range("2016-01-01", freq="d", periods=4, tz="US/Central"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
 
-    def test_build_table_schema(self):
-        result = build_table_schema(self.df, version=False)
+
+class TestBuildSchema:
+    def test_build_table_schema(self, df_schema):
+        result = build_table_schema(df_schema, version=False)
         expected = {
             "fields": [
                 {"name": "idx", "type": "integer"},
@@ -49,7 +68,7 @@ def test_build_table_schema(self):
             "primaryKey": ["idx"],
         }
         assert result == expected
-        result = build_table_schema(self.df)
+        result = build_table_schema(df_schema)
         assert "pandas_version" in result
 
     def test_series(self):
@@ -77,8 +96,8 @@ def test_series_unnamed(self):
         }
         assert result == expected
 
-    def test_multiindex(self):
-        df = self.df.copy()
+    def test_multiindex(self, df_schema):
+        df = df_schema
         idx = pd.MultiIndex.from_product([("a", "b"), (1, 2)])
         df.index = idx
 
@@ -195,21 +214,6 @@ def test_as_json_table_type_categorical_dtypes(self):
 
 
 class TestTableOrient:
-    def setup_method(self, method):
-        self.df = DataFrame(
-            {
-                "A": [1, 2, 3, 4],
-                "B": ["a", "b", "c", "c"],
-                "C": pd.date_range("2016-01-01", freq="d", periods=4),
-                "D": pd.timedelta_range("1H", periods=4, freq="T"),
-                "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
-                "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
-                "G": [1.0, 2.0, 3, 4.0],
-                "H": pd.date_range("2016-01-01", freq="d", periods=4, tz="US/Central"),
-            },
-            index=pd.Index(range(4), name="idx"),
-        )
-
     def test_build_series(self):
         s = pd.Series([1, 2], name="a")
         s.index.name = "id"
@@ -259,8 +263,8 @@ def test_read_json_from_to_json_results(self):
     @pytest.mark.filterwarnings(
         "ignore:an integer is required (got type float)*:DeprecationWarning"
     )
-    def test_to_json(self):
-        df = self.df.copy()
+    def test_to_json(self, df_table):
+        df = df_table
         df.index.name = "idx"
         result = df.to_json(orient="table", date_format="iso")
         result = json.loads(result, object_pairs_hook=OrderedDict)
@@ -297,7 +301,7 @@ def test_to_json(self):
                     ("idx", 0),
                     ("A", 1),
                     ("B", "a"),
-                    ("C", "2016-01-01T00:00:00.000Z"),
+                    ("C", "2016-01-01T00:00:00.000"),
                     ("D", "P0DT1H0M0S"),
                     ("E", "a"),
                     ("F", "a"),
@@ -310,7 +314,7 @@ def test_to_json(self):
                     ("idx", 1),
                     ("A", 2),
                     ("B", "b"),
-                    ("C", "2016-01-02T00:00:00.000Z"),
+                    ("C", "2016-01-02T00:00:00.000"),
                     ("D", "P0DT1H1M0S"),
                     ("E", "b"),
                     ("F", "b"),
@@ -323,7 +327,7 @@ def test_to_json(self):
                     ("idx", 2),
                     ("A", 3),
                     ("B", "c"),
-                    ("C", "2016-01-03T00:00:00.000Z"),
+                    ("C", "2016-01-03T00:00:00.000"),
                     ("D", "P0DT1H2M0S"),
                     ("E", "c"),
                     ("F", "c"),
@@ -336,7 +340,7 @@ def test_to_json(self):
                     ("idx", 3),
                     ("A", 4),
                     ("B", "c"),
-                    ("C", "2016-01-04T00:00:00.000Z"),
+                    ("C", "2016-01-04T00:00:00.000"),
                     ("D", "P0DT1H3M0S"),
                     ("E", "c"),
                     ("F", "c"),
@@ -393,8 +397,8 @@ def test_to_json_period_index(self):
 
         schema = {"fields": fields, "primaryKey": ["index"]}
         data = [
-            OrderedDict([("index", "2015-11-01T00:00:00.000Z"), ("values", 1)]),
-            OrderedDict([("index", "2016-02-01T00:00:00.000Z"), ("values", 1)]),
+            OrderedDict([("index", "2015-11-01T00:00:00.000"), ("values", 1)]),
+            OrderedDict([("index", "2016-02-01T00:00:00.000"), ("values", 1)]),
         ]
         expected = OrderedDict([("schema", schema), ("data", data)])
 
@@ -438,17 +442,17 @@ def test_to_json_categorical_index(self):
     @pytest.mark.filterwarnings(
         "ignore:an integer is required (got type float)*:DeprecationWarning"
     )
-    def test_date_format_raises(self):
+    def test_date_format_raises(self, df_table):
         msg = (
             "Trying to write with `orient='table'` and `date_format='epoch'`. Table "
             "Schema requires dates to be formatted with `date_format='iso'`"
         )
         with pytest.raises(ValueError, match=msg):
-            self.df.to_json(orient="table", date_format="epoch")
+            df_table.to_json(orient="table", date_format="epoch")
 
         # others work
-        self.df.to_json(orient="table", date_format="iso")
-        self.df.to_json(orient="table")
+        df_table.to_json(orient="table", date_format="iso")
+        df_table.to_json(orient="table")
 
     def test_convert_pandas_type_to_json_field_int(self, index_or_series):
         kind = index_or_series
@@ -631,7 +635,7 @@ def test_timestamp_in_columns(self):
         )
         result = df.to_json(orient="table")
         js = json.loads(result)
-        assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000Z"
+        assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000"
         assert js["schema"]["fields"][2]["name"] == "P0DT0H0M10S"
 
     @pytest.mark.parametrize(
@@ -704,6 +708,44 @@ def test_read_json_table_orient_raises(self, index_nm, vals, recwarn):
         with pytest.raises(NotImplementedError, match="can not yet read "):
             pd.read_json(out, orient="table")
 
+    @pytest.mark.parametrize(
+        "index_nm",
+        [None, "idx", pytest.param("index", marks=pytest.mark.xfail), "level_0"],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"ints": [1, 2, 3, 4]},
+            {"objects": ["a", "b", "c", "d"]},
+            {"objects": ["1", "2", "3", "4"]},
+            {"date_ranges": pd.date_range("2016-01-01", freq="d", periods=4)},
+            {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
+            {
+                "ordered_cats": pd.Series(
+                    pd.Categorical(["a", "b", "c", "c"], ordered=True)
+                )
+            },
+            {"floats": [1.0, 2.0, 3.0, 4.0]},
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"bools": [True, False, False, True]},
+            {
+                "timezones": pd.date_range(
+                    "2016-01-01", freq="d", periods=4, tz="US/Central"
+                )  # added in # GH 35973
+            },
+        ],
+    )
+    def test_read_json_table_period_orient(self, index_nm, vals, recwarn):
+        df = DataFrame(
+            vals,
+            index=pd.Index(
+                (pd.Period(f"2022Q{q}") for q in range(1, 5)), name=index_nm
+            ),
+        )
+        out = df.to_json(orient="table")
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
     @pytest.mark.parametrize(
         "idx",
         [
diff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
index cd760854cb01e..fbf4006066f6b 100644
--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
@@ -30,22 +30,16 @@
 
 
 class TestBuildSchema:
-    def setup_method(self, method):
-        self.da = DateArray([dt.date(2021, 10, 10)])
-        self.dc = DecimalArray([decimal.Decimal(10)])
-        self.sa = array(["pandas"], dtype="string")
-        self.ia = array([10], dtype="Int64")
-        self.df = DataFrame(
+    def test_build_table_schema(self):
+        df = DataFrame(
             {
-                "A": self.da,
-                "B": self.dc,
-                "C": self.sa,
-                "D": self.ia,
+                "A": DateArray([dt.date(2021, 10, 10)]),
+                "B": DecimalArray([decimal.Decimal(10)]),
+                "C": array(["pandas"], dtype="string"),
+                "D": array([10], dtype="Int64"),
             }
         )
-
-    def test_build_table_schema(self):
-        result = build_table_schema(self.df, version=False)
+        result = build_table_schema(df, version=False)
         expected = {
             "fields": [
                 {"name": "index", "type": "integer"},
@@ -57,7 +51,7 @@ def test_build_table_schema(self):
             "primaryKey": ["index"],
         }
         assert result == expected
-        result = build_table_schema(self.df)
+        result = build_table_schema(df)
         assert "pandas_version" in result
 
 
@@ -117,7 +111,7 @@ def test_as_json_table_type_ext_integer_dtype(self):
 
 
 class TestTableOrient:
-    def setup_method(self, method):
+    def setup_method(self):
         self.da = DateArray([dt.date(2021, 10, 10)])
         self.dc = DecimalArray([decimal.Decimal(10)])
         self.sa = array(["pandas"], dtype="string")
@@ -151,7 +145,7 @@ def test_build_date_series(self):
         expected = OrderedDict(
             [
                 ("schema", schema),
-                ("data", [OrderedDict([("id", 0), ("a", "2021-10-10T00:00:00.000Z")])]),
+                ("data", [OrderedDict([("id", 0), ("a", "2021-10-10T00:00:00.000")])]),
             ]
         )
 
@@ -256,7 +250,7 @@ def test_to_json(self):
             OrderedDict(
                 [
                     ("idx", 0),
-                    ("A", "2021-10-10T00:00:00.000Z"),
+                    ("A", "2021-10-10T00:00:00.000"),
                     ("B", 10.0),
                     ("C", "pandas"),
                     ("D", 10),
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 0b8548f98b03b..026c3bc68ce34 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -11,7 +11,6 @@
 
 from pandas.compat import (
     IS64,
-    PY310,
     is_platform_windows,
 )
 import pandas.util._test_decorators as td
@@ -26,16 +25,6 @@
 )
 import pandas._testing as tm
 
-_seriesd = tm.getSeriesData()
-
-_frame = DataFrame(_seriesd)
-
-_cat_frame = _frame.copy()
-cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * (len(_cat_frame) - 15)
-_cat_frame.index = pd.CategoricalIndex(cat, name="E")
-_cat_frame["E"] = list(reversed(cat))
-_cat_frame["sort"] = np.arange(len(_cat_frame), dtype="int64")
-
 
 def assert_json_roundtrip_equal(result, expected, orient):
     if orient == "records" or orient == "values":
@@ -50,11 +39,17 @@ def assert_json_roundtrip_equal(result, expected, orient):
 )
 @pytest.mark.filterwarnings("ignore:the 'numpy' keyword is deprecated:FutureWarning")
 class TestPandasContainer:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.categorical = _cat_frame.copy()
+    @pytest.fixture
+    def categorical_frame(self):
+        _seriesd = tm.getSeriesData()
+
+        _cat_frame = DataFrame(_seriesd)
 
-        yield
+        cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * (len(_cat_frame) - 15)
+        _cat_frame.index = pd.CategoricalIndex(cat, name="E")
+        _cat_frame["E"] = list(reversed(cat))
+        _cat_frame["sort"] = np.arange(len(_cat_frame), dtype="int64")
+        return _cat_frame
 
     @pytest.fixture
     def datetime_series(self):
@@ -216,7 +211,9 @@ def test_roundtrip_str_axes(self, request, orient, convert_axes, numpy, dtype):
 
     @pytest.mark.parametrize("convert_axes", [True, False])
     @pytest.mark.parametrize("numpy", [True, False])
-    def test_roundtrip_categorical(self, request, orient, convert_axes, numpy):
+    def test_roundtrip_categorical(
+        self, request, orient, categorical_frame, convert_axes, numpy
+    ):
         # TODO: create a better frame to test with and improve coverage
         if orient in ("index", "columns"):
             request.node.add_marker(
@@ -225,7 +222,7 @@ def test_roundtrip_categorical(self, request, orient, convert_axes, numpy):
                 )
             )
 
-        data = self.categorical.to_json(orient=orient)
+        data = categorical_frame.to_json(orient=orient)
         if numpy and orient in ("records", "values"):
             request.node.add_marker(
                 pytest.mark.xfail(reason=f"Orient {orient} is broken with numpy=True")
@@ -233,7 +230,7 @@ def test_roundtrip_categorical(self, request, orient, convert_axes, numpy):
 
         result = read_json(data, orient=orient, convert_axes=convert_axes, numpy=numpy)
 
-        expected = self.categorical.copy()
+        expected = categorical_frame.copy()
         expected.index = expected.index.astype(str)  # Categorical not preserved
         expected.index.name = None  # index names aren't preserved in JSON
 
@@ -367,7 +364,7 @@ def test_frame_from_json_missing_data(self, orient, convert_axes, numpy, dtype):
         assert np.isnan(result.iloc[0, 2])
 
     @pytest.mark.parametrize("dtype", [True, False])
-    def test_frame_read_json_dtype_missing_value(self, orient, dtype):
+    def test_frame_read_json_dtype_missing_value(self, dtype):
         # GH28501 Parse missing values using read_json with dtype=False
         # to NaN instead of None
         result = read_json("[null]", dtype=dtype)
@@ -377,7 +374,7 @@ def test_frame_read_json_dtype_missing_value(self, orient, dtype):
 
     @pytest.mark.parametrize("inf", [np.inf, np.NINF])
     @pytest.mark.parametrize("dtype", [True, False])
-    def test_frame_infinity(self, orient, inf, dtype):
+    def test_frame_infinity(self, inf, dtype):
         # infinities get mapped to nulls which get mapped to NaNs during
         # deserialisation
         df = DataFrame([[1, 2], [4, 5, 6]])
@@ -588,7 +585,7 @@ def test_frame_nonprintable_bytes(self):
         # GH14256: failing column caused segfaults, if it is not the last one
 
         class BinaryThing:
-            def __init__(self, hexed):
+            def __init__(self, hexed) -> None:
                 self.hexed = hexed
                 self.binary = bytes.fromhex(hexed)
 
@@ -825,7 +822,7 @@ def test_date_index_and_values(self, date_format, as_object, date_typ):
             expected = '{"1577836800000":1577836800000,"null":null}'
         else:
             expected = (
-                '{"2020-01-01T00:00:00.000Z":"2020-01-01T00:00:00.000Z","null":null}'
+                '{"2020-01-01T00:00:00.000":"2020-01-01T00:00:00.000","null":null}'
             )
 
         if as_object:
@@ -878,8 +875,6 @@ def test_date_format_frame(self, date, date_unit, datetime_frame):
             json = df.to_json(date_format="iso")
         result = read_json(json)
         expected = df.copy()
-        expected.index = expected.index.tz_localize("UTC")
-        expected["date"] = expected["date"].dt.tz_localize("UTC")
         tm.assert_frame_equal(result, expected)
 
     def test_date_format_frame_raises(self, datetime_frame):
@@ -908,8 +903,6 @@ def test_date_format_series(self, date, date_unit, datetime_series):
             json = ts.to_json(date_format="iso")
         result = read_json(json, typ="series")
         expected = ts.copy()
-        expected.index = expected.index.tz_localize("UTC")
-        expected = expected.dt.tz_localize("UTC")
         tm.assert_series_equal(result, expected)
 
     def test_date_format_series_raises(self, datetime_series):
@@ -988,18 +981,19 @@ def test_misc_example(self):
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
         tm.assert_frame_equal(result, expected)
 
-    @tm.network
-    @pytest.mark.single
-    def test_round_trip_exception_(self):
+    def test_round_trip_exception_(self, datapath):
         # GH 3867
-        csv = "https://raw.github.com/hayd/lahman2012/master/csvs/Teams.csv"
-        df = pd.read_csv(csv)
+        path = datapath("io", "json", "data", "teams.csv")
+        df = pd.read_csv(path)
         s = df.to_json()
         result = read_json(s)
         tm.assert_frame_equal(result.reindex(index=df.index, columns=df.columns), df)
 
-    @tm.network
-    @pytest.mark.single
+    @pytest.mark.network
+    @tm.network(
+        url="https://api.github.com/repos/pandas-dev/pandas/issues?per_page=5",
+        check_before_test=True,
+    )
     @pytest.mark.parametrize(
         "field,dtype",
         [
@@ -1177,7 +1171,6 @@ def test_sparse(self):
         expected = s.to_json()
         assert expected == ss.to_json()
 
-    @pytest.mark.skipif(PY310, reason="segfault GH 42130")
     @pytest.mark.parametrize(
         "ts",
         [
@@ -1195,7 +1188,16 @@ def test_tz_is_utc(self, ts):
         dt = ts.to_pydatetime()
         assert dumps(dt, iso_dates=True) == exp
 
-    @pytest.mark.skipif(PY310, reason="segfault GH 42130")
+    def test_tz_is_naive(self):
+        from pandas.io.json import dumps
+
+        ts = Timestamp("2013-01-10 05:00:00")
+        exp = '"2013-01-10T05:00:00.000"'
+
+        assert dumps(ts, iso_dates=True) == exp
+        dt = ts.to_pydatetime()
+        assert dumps(dt, iso_dates=True) == exp
+
     @pytest.mark.parametrize(
         "tz_range",
         [
@@ -1216,10 +1218,31 @@ def test_tz_range_is_utc(self, tz_range):
 
         assert dumps(tz_range, iso_dates=True) == exp
         dti = DatetimeIndex(tz_range)
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
+        assert dumps(dti, iso_dates=True) == exp
+        assert dumps(dti.astype(object), iso_dates=True) == exp
+        df = DataFrame({"DT": dti})
+        result = dumps(df, iso_dates=True)
+        assert result == dfexp
+        assert dumps(df.astype({"DT": object}), iso_dates=True)
+
+    def test_tz_range_is_naive(self):
+        from pandas.io.json import dumps
+
+        dti = pd.date_range("2013-01-01 05:00:00", periods=2)
+
+        exp = '["2013-01-01T05:00:00.000","2013-01-02T05:00:00.000"]'
+        dfexp = '{"DT":{"0":"2013-01-01T05:00:00.000","1":"2013-01-02T05:00:00.000"}}'
+
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
         assert dumps(dti, iso_dates=True) == exp
+        assert dumps(dti.astype(object), iso_dates=True) == exp
         df = DataFrame({"DT": dti})
         result = dumps(df, iso_dates=True)
         assert result == dfexp
+        assert dumps(df.astype({"DT": object}), iso_dates=True)
 
     def test_read_inline_jsonl(self):
         # GH9180
@@ -1227,6 +1250,7 @@ def test_read_inline_jsonl(self):
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.single_cpu
     @td.skip_if_not_us_locale
     def test_read_s3_jsonl(self, s3_resource, s3so):
         # GH17200
@@ -1276,7 +1300,7 @@ def test_to_json_large_numbers(self, bigNum):
         expected = '{"0":{"articleId":' + str(bigNum) + "}}"
         assert json == expected
 
-    @pytest.mark.parametrize("bigNum", [-(2 ** 63) - 1, 2 ** 64])
+    @pytest.mark.parametrize("bigNum", [-(2**63) - 1, 2**64])
     def test_read_json_large_numbers(self, bigNum):
         # GH20599, 26068
         json = StringIO('{"articleId":' + str(bigNum) + "}")
@@ -1542,6 +1566,20 @@ def test_read_json_with_url_value(self, url):
         expected = DataFrame({"url": [url]})
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "compression",
+        ["", ".gz", ".bz2", ".tar"],
+    )
+    def test_read_json_with_very_long_file_path(self, compression):
+        # GH 46718
+        long_json_path = f'{"a" * 1000}.json{compression}'
+        with pytest.raises(
+            FileNotFoundError, match=f"File {long_json_path} does not exist"
+        ):
+            # path too long for Windows is handled in file_exists() but raises in
+            # _get_data_from_filepath()
+            read_json(long_json_path)
+
     @pytest.mark.parametrize(
         "date_format,key", [("epoch", 86400000), ("iso", "P1DT0H0M0S")]
     )
@@ -1558,9 +1596,20 @@ def test_timedelta_as_label(self, date_format, key):
             ("index", "{\"('a', 'b')\":{\"('c', 'd')\":1}}"),
             ("columns", "{\"('c', 'd')\":{\"('a', 'b')\":1}}"),
             # TODO: the below have separate encoding procedures
-            # They produce JSON but not in a consistent manner
-            pytest.param("split", "", marks=pytest.mark.skip),
-            pytest.param("table", "", marks=pytest.mark.skip),
+            pytest.param(
+                "split",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
+            pytest.param(
+                "table",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
         ],
     )
     def test_tuple_labels(self, orient, expected):
@@ -1754,6 +1803,7 @@ def test_json_multiindex(self, dataframe, expected):
         result = series.to_json(orient="index")
         assert result == expected
 
+    @pytest.mark.single_cpu
     def test_to_s3(self, s3_resource, s3so):
         import time
 
@@ -1808,7 +1858,7 @@ def test_to_json_multiindex_escape(self):
 
     def test_to_json_series_of_objects(self):
         class _TestObject:
-            def __init__(self, a, b, _c, d):
+            def __init__(self, a, b, _c, d) -> None:
                 self.a = a
                 self.b = b
                 self._c = _c
@@ -1858,3 +1908,13 @@ def test_complex_data_tojson(self, data, expected):
         # GH41174
         result = data.to_json()
         assert result == expected
+
+    def test_json_uint64(self):
+        # GH21073
+        expected = (
+            '{"columns":["col1"],"index":[0,1],'
+            '"data":[[13342205958987758245],[12388075603347835679]]}'
+        )
+        df = DataFrame(data={"col1": [13342205958987758245, 12388075603347835679]})
+        result = df.to_json(orient="split")
+        assert result == expected
diff --git a/pandas/tests/io/json/test_readlines.py b/pandas/tests/io/json/test_readlines.py
index 4ba9f48a40fbc..6fa0c4d5c51a1 100644
--- a/pandas/tests/io/json/test_readlines.py
+++ b/pandas/tests/io/json/test_readlines.py
@@ -281,7 +281,7 @@ def test_chunksize_is_incremental():
     )
 
     class MyReader:
-        def __init__(self, contents):
+        def __init__(self, contents) -> None:
             self.read_count = 0
             self.stringio = StringIO(contents)
 
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index b4ae54d48dc68..ae13d8d5fb180 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -15,7 +15,6 @@
 import pandas._libs.json as ujson
 from pandas.compat import (
     IS64,
-    PY310,
     is_platform_windows,
 )
 
@@ -24,6 +23,7 @@
     DatetimeIndex,
     Index,
     NaT,
+    PeriodIndex,
     Series,
     Timedelta,
     Timestamp,
@@ -253,14 +253,8 @@ def test_double_precision(self):
         [
             20,
             -1,
-            pytest.param(
-                "9",
-                marks=pytest.mark.xfail(PY310, reason="Failing on Python 3.10 GH41940"),
-            ),
-            pytest.param(
-                None,
-                marks=pytest.mark.xfail(PY310, reason="Failing on Python 3.10 GH41940"),
-            ),
+            "9",
+            None,
         ],
     )
     def test_invalid_double_precision(self, invalid_val):
@@ -268,7 +262,8 @@ def test_invalid_double_precision(self, invalid_val):
         expected_exception = ValueError if isinstance(invalid_val, int) else TypeError
         msg = (
             r"Invalid value '.*' for option 'double_precision', max is '15'|"
-            r"an integer is required \(got type "
+            r"an integer is required \(got type |"
+            r"object cannot be interpreted as an integer"
         )
         with pytest.raises(expected_exception, match=msg):
             ujson.encode(double_input, double_precision=invalid_val)
@@ -428,13 +423,13 @@ def test_datetime_units(self):
         stamp = Timestamp(val)
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit="s"))
-        assert roundtrip == stamp.value // 10 ** 9
+        assert roundtrip == stamp.value // 10**9
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit="ms"))
-        assert roundtrip == stamp.value // 10 ** 6
+        assert roundtrip == stamp.value // 10**6
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit="us"))
-        assert roundtrip == stamp.value // 10 ** 3
+        assert roundtrip == stamp.value // 10**3
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit="ns"))
         assert roundtrip == stamp.value
@@ -606,7 +601,7 @@ def test_encode_long_conversion(self, long_input):
         assert output == json.dumps(long_input)
         assert long_input == ujson.decode(output)
 
-    @pytest.mark.parametrize("bigNum", [2 ** 64, -(2 ** 63) - 1])
+    @pytest.mark.parametrize("bigNum", [2**64, -(2**63) - 1])
     def test_dumps_ints_larger_than_maxsize(self, bigNum):
         encoding = ujson.encode(bigNum)
         assert str(bigNum) == encoding
@@ -628,7 +623,7 @@ def test_loads_non_str_bytes_raises(self):
         with pytest.raises(TypeError, match=msg):
             ujson.loads(None)
 
-    @pytest.mark.parametrize("val", [3590016419, 2 ** 31, 2 ** 32, (2 ** 32) - 1])
+    @pytest.mark.parametrize("val", [3590016419, 2**31, 2**32, (2**32) - 1])
     def test_decode_number_with_32bit_sign_bit(self, val):
         # Test that numbers that fit within 32 bits but would have the
         # sign bit set (2**31 <= x < 2**32) are decoded properly.
@@ -666,7 +661,7 @@ def toDict(self):
 
     def test_default_handler(self):
         class _TestObject:
-            def __init__(self, val):
+            def __init__(self, val) -> None:
                 self.val = val
 
             @property
@@ -720,7 +715,7 @@ def my_obj_handler(_):
 
     def test_encode_object(self):
         class _TestObject:
-            def __init__(self, a, b, _c, d):
+            def __init__(self, a, b, _c, d) -> None:
                 self.a = a
                 self.b = b
                 self._c = _c
@@ -951,9 +946,11 @@ def test_array_numpy_labelled(self):
 
 
 class TestPandasJSONTests:
-    def test_dataframe(self, orient, numpy):
+    def test_dataframe(self, request, orient, numpy):
         if orient == "records" and numpy:
-            pytest.skip("Not idiomatic pandas")
+            request.node.add_marker(
+                pytest.mark.xfail(reason=f"Not idiomatic pandas if orient={orient}")
+            )
 
         dtype = get_int32_compat_dtype(numpy, orient)
 
@@ -1003,9 +1000,11 @@ def test_dataframe_nested(self, orient):
         }
         assert ujson.decode(ujson.encode(nested, **kwargs)) == exp
 
-    def test_dataframe_numpy_labelled(self, orient):
+    def test_dataframe_numpy_labelled(self, orient, request):
         if orient in ("split", "values"):
-            pytest.skip("Incompatible with labelled=True")
+            request.node.add_marker(
+                pytest.mark.xfail(reason=f"{orient} incompatible for labelled=True")
+            )
 
         df = DataFrame(
             [[1, 2, 3], [4, 5, 6]],
@@ -1242,3 +1241,9 @@ def test_encode_timedelta_iso(self, td):
         expected = f'"{td.isoformat()}"'
 
         assert result == expected
+
+    def test_encode_periodindex(self):
+        # GH 46683
+        p = PeriodIndex(["2022-04-06", "2022-04-07"], freq="D")
+        df = DataFrame(index=p)
+        assert df.to_json() == "{}"
diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 8a3f8788a45aa..c8cef56c73902 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -192,8 +192,12 @@ def test_warn_if_chunks_have_mismatched_type(all_parsers):
 
     buf = StringIO(data)
 
-    with tm.assert_produces_warning(warning_type):
-        df = parser.read_csv(buf)
+    df = parser.read_csv_check_warnings(
+        warning_type,
+        r"Columns \(0\) have mixed types. "
+        "Specify dtype option on import or set low_memory=False.",
+        buf,
+    )
 
     assert df.a.dtype == object
 
diff --git a/pandas/tests/io/parser/common/test_common_basic.py b/pandas/tests/io/parser/common/test_common_basic.py
index bde69e365cfd1..359b059252556 100644
--- a/pandas/tests/io/parser/common/test_common_basic.py
+++ b/pandas/tests/io/parser/common/test_common_basic.py
@@ -12,7 +12,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PY310
 from pandas.errors import (
     EmptyDataError,
     ParserError,
@@ -41,7 +40,7 @@ def test_override_set_noconvert_columns():
     # Usecols needs to be sorted in _set_noconvert_columns based
     # on the test_usecols_with_parse_dates test from test_usecols.py
     class MyTextFileReader(TextFileReader):
-        def __init__(self):
+        def __init__(self) -> None:
             self._currow = 0
             self.squeeze = False
 
@@ -676,11 +675,6 @@ def test_read_table_equivalency_to_read_csv(all_parsers):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.skipif(
-    PY310,
-    reason="GH41935 This test is leaking only on Python 3.10,"
-    "causing other tests to fail with a cryptic error.",
-)
 @pytest.mark.parametrize("read_func", ["read_csv", "read_table"])
 def test_read_csv_and_table_sys_setprofile(all_parsers, read_func):
     # GH#41069
@@ -699,7 +693,7 @@ def test_read_csv_and_table_sys_setprofile(all_parsers, read_func):
 def test_first_row_bom(all_parsers):
     # see gh-26545
     parser = all_parsers
-    data = '''\ufeff"Head1"	"Head2"	"Head3"'''
+    data = '''\ufeff"Head1"\t"Head2"\t"Head3"'''
 
     result = parser.read_csv(StringIO(data), delimiter="\t")
     expected = DataFrame(columns=["Head1", "Head2", "Head3"])
@@ -710,7 +704,7 @@ def test_first_row_bom(all_parsers):
 def test_first_row_bom_unquoted(all_parsers):
     # see gh-36343
     parser = all_parsers
-    data = """\ufeffHead1	Head2	Head3"""
+    data = """\ufeffHead1\tHead2\tHead3"""
 
     result = parser.read_csv(StringIO(data), delimiter="\t")
     expected = DataFrame(columns=["Head1", "Head2", "Head3"])
@@ -738,8 +732,15 @@ def test_no_header_two_extra_columns(all_parsers):
     ref = DataFrame([["foo", "bar", "baz"]], columns=column_names)
     stream = StringIO("foo,bar,baz,bam,blah")
     parser = all_parsers
-    with tm.assert_produces_warning(ParserWarning):
-        df = parser.read_csv(stream, header=None, names=column_names, index_col=False)
+    df = parser.read_csv_check_warnings(
+        ParserWarning,
+        "Length of header or names does not match length of data. "
+        "This leads to a loss of data with index_col=False.",
+        stream,
+        header=None,
+        names=column_names,
+        index_col=False,
+    )
     tm.assert_frame_equal(df, ref)
 
 
@@ -812,8 +813,7 @@ def test_read_csv_posargs_deprecation(all_parsers):
         "In a future version of pandas all arguments of read_csv "
         "except for the argument 'filepath_or_buffer' will be keyword-only"
     )
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        parser.read_csv(f, " ")
+    parser.read_csv_check_warnings(FutureWarning, msg, f, " ")
 
 
 @pytest.mark.parametrize("delimiter", [",", "\t"])
@@ -927,5 +927,18 @@ def test_read_table_posargs_deprecation(all_parsers):
         "In a future version of pandas all arguments of read_table "
         "except for the argument 'filepath_or_buffer' will be keyword-only"
     )
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        parser.read_table(data, " ")
+    parser.read_table_check_warnings(FutureWarning, msg, data, " ")
+
+
+def test_read_seek(all_parsers):
+    # GH48646
+    parser = all_parsers
+    prefix = "### DATA\n"
+    content = "nkey,value\ntables,rectangular\n"
+    with tm.ensure_clean() as path:
+        Path(path).write_text(prefix + content)
+        with open(path, encoding="utf-8") as file:
+            file.readline()
+            actual = parser.read_csv(file)
+        expected = parser.read_csv(StringIO(content))
+    tm.assert_frame_equal(actual, expected)
diff --git a/pandas/tests/io/parser/common/test_file_buffer_url.py b/pandas/tests/io/parser/common/test_file_buffer_url.py
index 4a8f734a34abf..e4cd0f1d19a79 100644
--- a/pandas/tests/io/parser/common/test_file_buffer_url.py
+++ b/pandas/tests/io/parser/common/test_file_buffer_url.py
@@ -9,6 +9,7 @@
 import os
 import platform
 from urllib.error import URLError
+import uuid
 
 import pytest
 
@@ -26,13 +27,20 @@
 pytestmark = pytest.mark.usefixtures("pyarrow_skip")
 
 
-@tm.network
+@pytest.mark.network
+@tm.network(
+    url=(
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+        "pandas/tests/io/parser/data/salaries.csv"
+    ),
+    check_before_test=True,
+)
 def test_url(https://github.com/all_parsers,%20csv_dir_path):
     parser = all_parsers
     kwargs = {"sep": "\t"}
 
     url = (
-        "https://raw.github.com/pandas-dev/pandas/master/"
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
         "pandas/tests/io/parser/data/salaries.csv"
     )
     url_result = parser.read_csv(url, **kwargs)
@@ -80,7 +88,7 @@ def test_nonexistent_path(all_parsers):
     # gh-14086: raise more helpful FileNotFoundError
     # GH#29233 "File foo" instead of "File b'foo'"
     parser = all_parsers
-    path = f"{tm.rands(10)}.csv"
+    path = f"{uuid.uuid4()}.csv"
 
     msg = r"\[Errno 2\]"
     with pytest.raises(FileNotFoundError, match=msg) as e:
@@ -248,7 +256,7 @@ def test_internal_eof_byte_to_file(all_parsers):
     parser = all_parsers
     data = b'c1,c2\r\n"test \x1a    test", test\r\n'
     expected = DataFrame([["test \x1a    test", " test"]], columns=["c1", "c2"])
-    path = f"__{tm.rands(10)}__.csv"
+    path = f"__{uuid.uuid4()}__.csv"
 
     with tm.ensure_clean(path) as path:
         with open(path, "wb") as f:
@@ -371,13 +379,13 @@ def test_context_manager(all_parsers, datapath):
     path = datapath("io", "data", "csv", "iris.csv")
 
     reader = parser.read_csv(path, chunksize=1)
-    assert not reader._engine.handles.handle.closed
+    assert not reader.handles.handle.closed
     try:
         with reader:
             next(reader)
             assert False
     except AssertionError:
-        assert reader._engine.handles.handle.closed
+        assert reader.handles.handle.closed
 
 
 def test_context_manageri_user_provided(all_parsers, datapath):
@@ -387,13 +395,13 @@ def test_context_manageri_user_provided(all_parsers, datapath):
     with open(datapath("io", "data", "csv", "iris.csv")) as path:
 
         reader = parser.read_csv(path, chunksize=1)
-        assert not reader._engine.handles.handle.closed
+        assert not reader.handles.handle.closed
         try:
             with reader:
                 next(reader)
                 assert False
         except AssertionError:
-            assert not reader._engine.handles.handle.closed
+            assert not reader.handles.handle.closed
 
 
 def test_file_descriptor_leak(all_parsers):
diff --git a/pandas/tests/io/parser/common/test_ints.py b/pandas/tests/io/parser/common/test_ints.py
index aef2020fe0847..e3159ef3e6a42 100644
--- a/pandas/tests/io/parser/common/test_ints.py
+++ b/pandas/tests/io/parser/common/test_ints.py
@@ -193,7 +193,7 @@ def test_outside_int64_uint64_range(all_parsers, val):
 
 
 @skip_pyarrow
-@pytest.mark.parametrize("exp_data", [[str(-1), str(2 ** 63)], [str(2 ** 63), str(-1)]])
+@pytest.mark.parametrize("exp_data", [[str(-1), str(2**63)], [str(2**63), str(-1)]])
 def test_numeric_range_too_wide(all_parsers, exp_data):
     # No numerical dtype can hold both negative and uint64
     # values, so they should be cast as string.
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index fe00afb4fdc1d..f52af109626e9 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -12,6 +12,7 @@
 import numpy as np
 import pytest
 
+from pandas.compat import PY311
 from pandas.errors import (
     EmptyDataError,
     ParserError,
@@ -224,13 +225,19 @@ def test_read_csv_wrong_num_columns(all_parsers):
         parser.read_csv(StringIO(data))
 
 
-def test_null_byte_char(all_parsers):
+def test_null_byte_char(request, all_parsers):
     # see gh-2741
     data = "\x00,foo"
     names = ["a", "b"]
     parser = all_parsers
 
-    if parser.engine == "c":
+    if parser.engine == "c" or (parser.engine == "python" and PY311):
+        if parser.engine == "python" and PY311:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="In Python 3.11, this is read as an empty character not null"
+                )
+            )
         expected = DataFrame([[np.nan, "foo"]], columns=names)
         out = parser.read_csv(StringIO(data), names=names)
         tm.assert_frame_equal(out, expected)
@@ -241,11 +248,16 @@ def test_null_byte_char(all_parsers):
 
 
 @td.check_file_leaks
-def test_open_file(all_parsers):
+def test_open_file(request, all_parsers):
     # GH 39024
     parser = all_parsers
     if parser.engine == "c":
-        pytest.skip("'c' engine does not support sep=None with delim_whitespace=False")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason=f"{parser.engine} engine does not support sep=None "
+                f"with delim_whitespace=False"
+            )
+        )
 
     with tm.ensure_clean() as path:
         file = Path(path)
@@ -278,3 +290,30 @@ def test_conflict_on_bad_line(all_parsers, error_bad_lines, warn_bad_lines):
         "Please only set on_bad_lines.",
     ):
         parser.read_csv(StringIO(data), on_bad_lines="error", **kwds)
+
+
+def test_on_bad_lines_warn_correct_formatting(all_parsers, capsys):
+    # see gh-15925
+    parser = all_parsers
+    data = """1,2
+a,b
+a,b,c
+a,b,d
+a,b
+"""
+    expected = DataFrame({"1": "a", "2": ["b"] * 2})
+
+    result = parser.read_csv(StringIO(data), on_bad_lines="warn")
+    tm.assert_frame_equal(result, expected)
+
+    captured = capsys.readouterr()
+    if parser.engine == "c":
+        warn = """Skipping line 3: expected 2 fields, saw 3
+Skipping line 4: expected 2 fields, saw 3
+
+"""
+    else:
+        warn = """Skipping line 3: Expected 2 fields in line 3, saw 3
+Skipping line 4: Expected 2 fields in line 4, saw 3
+"""
+    assert captured.err == warn
diff --git a/pandas/tests/io/parser/conftest.py b/pandas/tests/io/parser/conftest.py
index 2070057aff10b..0462d1fe6da0b 100644
--- a/pandas/tests/io/parser/conftest.py
+++ b/pandas/tests/io/parser/conftest.py
@@ -42,6 +42,16 @@ def read_table(self, *args, **kwargs):
         kwargs = self.update_kwargs(kwargs)
         return read_table(*args, **kwargs)
 
+    def read_table_check_warnings(
+        self, warn_type: type[Warning], warn_msg: str, *args, **kwargs
+    ):
+        # We need to check the stacklevel here instead of in the tests
+        # since this is where read_table is called and where the warning
+        # should point to.
+        kwargs = self.update_kwargs(kwargs)
+        with tm.assert_produces_warning(warn_type, match=warn_msg):
+            return read_table(*args, **kwargs)
+
 
 class CParser(BaseParser):
     engine = "c"
@@ -89,7 +99,7 @@ def csv1(datapath):
 
 _py_parsers_only = [_pythonParser]
 _c_parsers_only = [_cParserHighMemory, _cParserLowMemory]
-_pyarrow_parsers_only = [_pyarrowParser]
+_pyarrow_parsers_only = [pytest.param(_pyarrowParser, marks=pytest.mark.single_cpu)]
 
 _all_parsers = [*_c_parsers_only, *_py_parsers_only, *_pyarrow_parsers_only]
 
@@ -108,7 +118,8 @@ def all_parsers(request):
     parser = request.param()
     if parser.engine == "pyarrow":
         pytest.importorskip("pyarrow", VERSIONS["pyarrow"])
-        # Try setting num cpus to 1 to avoid hangs?
+        # Try finding a way to disable threads all together
+        # for more stable CI runs
         import pyarrow
 
         pyarrow.set_cpu_count(1)
@@ -147,8 +158,14 @@ def _get_all_parser_float_precision_combinations():
     params = []
     ids = []
     for parser, parser_id in zip(_all_parsers, _all_parser_ids):
+        if hasattr(parser, "values"):
+            # Wrapped in pytest.param, get the actual parser back
+            parser = parser.values[0]
         for precision in parser.float_precision_choices:
-            params.append((parser(), precision))
+            # Re-wrap in pytest.param for pyarrow
+            mark = pytest.mark.single_cpu if parser.engine == "pyarrow" else ()
+            param = pytest.param((parser(), precision), marks=mark)
+            params.append(param)
             ids.append(f"{parser_id}-{precision}")
 
     return {"params": params, "ids": ids}
diff --git a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
index cdf9c0a1784a4..2c18d461cddf8 100644
--- a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
+++ b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
@@ -2,6 +2,7 @@
 Tests dtype specification during parsing
 for all of the parsers defined in parsers.py
 """
+from collections import defaultdict
 from io import StringIO
 
 import numpy as np
@@ -102,10 +103,14 @@ def test_dtype_with_converters(all_parsers):
 1.2,2.3"""
 
     # Dtype spec ignored if converted specified.
-    with tm.assert_produces_warning(ParserWarning):
-        result = parser.read_csv(
-            StringIO(data), dtype={"a": "i8"}, converters={"a": lambda x: str(x)}
-        )
+    result = parser.read_csv_check_warnings(
+        ParserWarning,
+        "Both a converter and dtype were specified for column a "
+        "- only the converter will be used.",
+        StringIO(data),
+        dtype={"a": "i8"},
+        converters={"a": lambda x: str(x)},
+    )
     expected = DataFrame({"a": ["1.1", "1.2"], "b": [2.2, 2.3]})
     tm.assert_frame_equal(result, expected)
 
@@ -191,33 +196,42 @@ def test_delimiter_with_usecols_and_parse_dates(all_parsers):
 
 
 @pytest.mark.parametrize("thousands", ["_", None])
-def test_decimal_and_exponential(python_parser_only, numeric_decimal, thousands):
+def test_decimal_and_exponential(
+    request, python_parser_only, numeric_decimal, thousands
+):
     # GH#31920
-    decimal_number_check(python_parser_only, numeric_decimal, thousands, None)
+    decimal_number_check(request, python_parser_only, numeric_decimal, thousands, None)
 
 
 @pytest.mark.parametrize("thousands", ["_", None])
 @pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
 def test_1000_sep_decimal_float_precision(
-    c_parser_only, numeric_decimal, float_precision, thousands
+    request, c_parser_only, numeric_decimal, float_precision, thousands
 ):
     # test decimal and thousand sep handling in across 'float_precision'
     # parsers
-    decimal_number_check(c_parser_only, numeric_decimal, thousands, float_precision)
+    decimal_number_check(
+        request, c_parser_only, numeric_decimal, thousands, float_precision
+    )
     text, value = numeric_decimal
     text = " " + text + " "
     if isinstance(value, str):  # the negative cases (parse as text)
         value = " " + value + " "
-    decimal_number_check(c_parser_only, (text, value), thousands, float_precision)
+    decimal_number_check(
+        request, c_parser_only, (text, value), thousands, float_precision
+    )
 
 
-def decimal_number_check(parser, numeric_decimal, thousands, float_precision):
+def decimal_number_check(request, parser, numeric_decimal, thousands, float_precision):
     # GH#31920
     value = numeric_decimal[0]
-    if thousands is None and "_" in value:
-        pytest.skip("Skip test if no thousands sep is defined and sep is in value")
+    if thousands is None and value in ("1_,", "1_234,56", "1_234,56e0"):
+        request.node.add_marker(
+            pytest.mark.xfail(reason=f"thousands={thousands} and sep is in {value}")
+        )
     df = parser.read_csv(
         StringIO(value),
+        float_precision=float_precision,
         sep="|",
         thousands=thousands,
         decimal=",",
@@ -334,3 +348,40 @@ def test_nullable_int_dtype(all_parsers, any_int_ea_dtype):
     )
     actual = parser.read_csv(StringIO(data), dtype=dtype)
     tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize("default", ["float", "float64"])
+def test_dtypes_defaultdict(all_parsers, default):
+    # GH#41574
+    data = """a,b
+1,2
+"""
+    dtype = defaultdict(lambda: default, a="int64")
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    expected = DataFrame({"a": [1], "b": 2.0})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtypes_defaultdict_mangle_dup_cols(all_parsers):
+    # GH#41574
+    data = """a,b,a,b,b.1
+1,2,3,4,5
+"""
+    dtype = defaultdict(lambda: "float64", a="int64")
+    dtype["b.1"] = "int64"
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    expected = DataFrame({"a": [1], "b": [2.0], "a.1": [3], "b.2": [4.0], "b.1": [5]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtypes_defaultdict_invalid(all_parsers):
+    # GH#41574
+    data = """a,b
+1,2
+"""
+    dtype = defaultdict(lambda: "invalid_dtype", a="int64")
+    parser = all_parsers
+    with pytest.raises(TypeError, match="not understood"):
+        parser.read_csv(StringIO(data), dtype=dtype)
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index 5df4470635af5..ecc49ea8adb9f 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -17,7 +17,10 @@
 import numpy as np
 import pytest
 
-from pandas.compat import IS64
+from pandas.compat import (
+    IS64,
+    is_ci_environment,
+)
 from pandas.errors import ParserError
 import pandas.util._test_decorators as td
 
@@ -56,15 +59,17 @@ def test_buffer_rd_bytes(c_parser_only):
     )
     parser = c_parser_only
 
-    with tm.assert_produces_warning(RuntimeWarning):
-        # compression has no effect when passing a non-binary object as input
-        for _ in range(100):
-            try:
-                parser.read_csv(
-                    StringIO(data), compression="gzip", delim_whitespace=True
-                )
-            except Exception:
-                pass
+    for _ in range(100):
+        try:
+            parser.read_csv_check_warnings(
+                RuntimeWarning,
+                "compression has no effect when passing a non-binary object as input",
+                StringIO(data),
+                compression="gzip",
+                delim_whitespace=True,
+            )
+        except Exception:
+            pass
 
 
 def test_delim_whitespace_custom_terminator(c_parser_only):
@@ -141,9 +146,12 @@ def test_dtype_and_names_error(c_parser_only):
             "the dtype timedelta64 is not supported for parsing",
             {"dtype": {"A": "timedelta64", "B": "float64"}},
         ),
-        ("the dtype <U8 is not supported for parsing", {"dtype": {"A": "U8"}}),
+        (
+            f"the dtype {tm.ENDIAN}U8 is not supported for parsing",
+            {"dtype": {"A": "U8"}},
+        ),
     ],
-    ids=["dt64-0", "dt64-1", "td64", "<U8"],
+    ids=["dt64-0", "dt64-1", "td64", f"{tm.ENDIAN}U8"],
 )
 def test_unsupported_dtype(c_parser_only, match, kwargs):
     parser = c_parser_only
@@ -555,7 +563,8 @@ def test_read_tarfile(c_parser_only, csv_dir_path, tar_suffix):
         tm.assert_frame_equal(out, expected)
 
 
-@pytest.mark.high_memory
+@pytest.mark.single_cpu
+@pytest.mark.skipif(is_ci_environment(), reason="Too memory intensive for CI.")
 def test_bytes_exceed_2gb(c_parser_only):
     # see gh-16798
     #
@@ -563,7 +572,7 @@ def test_bytes_exceed_2gb(c_parser_only):
     parser = c_parser_only
 
     if parser.low_memory:
-        pytest.skip("not a high_memory test")
+        pytest.skip("not a low_memory test")
 
     csv = StringIO("strings\n" + "\n".join(["x" * (1 << 20) for _ in range(2100)]))
     df = parser.read_csv(csv)
@@ -592,11 +601,9 @@ def test_file_handles_mmap(c_parser_only, csv1):
     parser = c_parser_only
 
     with open(csv1) as f:
-        m = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
-        parser.read_csv(m)
-
-        assert not m.closed
-        m.close()
+        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as m:
+            parser.read_csv(m)
+            assert not m.closed
 
 
 def test_file_binary_mode(c_parser_only):
diff --git a/pandas/tests/io/parser/test_compression.py b/pandas/tests/io/parser/test_compression.py
index d97b594623023..121784d5a45ed 100644
--- a/pandas/tests/io/parser/test_compression.py
+++ b/pandas/tests/io/parser/test_compression.py
@@ -5,14 +5,14 @@
 
 import os
 from pathlib import Path
+import tarfile
 import zipfile
 
 import pytest
 
 from pandas import DataFrame
 import pandas._testing as tm
-
-import pandas.io.common as icom
+from pandas.tests.io.test_compression import _compression_to_extension
 
 skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
 
@@ -91,15 +91,19 @@ def test_zip_error_invalid_zip(parser_and_data):
 
 @skip_pyarrow
 @pytest.mark.parametrize("filename", [None, "test.{ext}"])
-def test_compression(parser_and_data, compression_only, buffer, filename):
+def test_compression(request, parser_and_data, compression_only, buffer, filename):
     parser, data, expected = parser_and_data
     compress_type = compression_only
 
-    ext = icom._compression_to_extension[compress_type]
+    ext = _compression_to_extension[compress_type]
     filename = filename if filename is None else filename.format(ext=ext)
 
     if filename and buffer:
-        pytest.skip("Cannot deduce compression from buffer of compressed data.")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Cannot deduce compression from buffer of compressed data."
+            )
+        )
 
     with tm.ensure_clean(filename=filename) as path:
         tm.write_to_compressed(compress_type, path, data)
@@ -164,6 +168,14 @@ def test_invalid_compression(all_parsers, invalid_compression):
         parser.read_csv("test_file.zip", **compress_kwargs)
 
 
+@skip_pyarrow
+def test_compression_tar_archive(all_parsers, csv_dir_path):
+    parser = all_parsers
+    path = os.path.join(csv_dir_path, "tar_csv.tar.gz")
+    df = parser.read_csv(path)
+    assert list(df.columns) == ["a"]
+
+
 def test_ignore_compression_extension(all_parsers):
     parser = all_parsers
     df = DataFrame({"a": [0, 1]})
@@ -174,3 +186,26 @@ def test_ignore_compression_extension(all_parsers):
             Path(path_zip).write_text(Path(path_csv).read_text())
 
             tm.assert_frame_equal(parser.read_csv(path_zip, compression=None), df)
+
+
+@skip_pyarrow
+def test_writes_tar_gz(all_parsers):
+    parser = all_parsers
+    data = DataFrame(
+        {
+            "Country": ["Venezuela", "Venezuela"],
+            "Twitter": ["Hugo Chávez Frías", "Henrique Capriles R."],
+        }
+    )
+    with tm.ensure_clean("test.tar.gz") as tar_path:
+        data.to_csv(tar_path, index=False)
+
+        # test that read_csv infers .tar.gz to gzip:
+        tm.assert_frame_equal(parser.read_csv(tar_path), data)
+
+        # test that file is indeed gzipped:
+        with tarfile.open(tar_path, "r:gz") as tar:
+            result = parser.read_csv(
+                tar.extractfile(tar.getnames()[0]), compression="infer"
+            )
+            tm.assert_frame_equal(result, data)
diff --git a/pandas/tests/io/parser/test_converters.py b/pandas/tests/io/parser/test_converters.py
index 21933d83ce3f4..85f3db0398080 100644
--- a/pandas/tests/io/parser/test_converters.py
+++ b/pandas/tests/io/parser/test_converters.py
@@ -152,16 +152,28 @@ def convert_score(x):
     tm.assert_frame_equal(results[0], results[1])
 
 
-def test_converter_index_col_bug(all_parsers):
-    # see gh-1835
+@pytest.mark.parametrize("conv_f", [lambda x: x, str])
+def test_converter_index_col_bug(all_parsers, conv_f):
+    # see gh-1835 , GH#40589
     parser = all_parsers
     data = "A;B\n1;2\n3;4"
 
     rs = parser.read_csv(
-        StringIO(data), sep=";", index_col="A", converters={"A": lambda x: x}
+        StringIO(data), sep=";", index_col="A", converters={"A": conv_f}
     )
 
-    xp = DataFrame({"B": [2, 4]}, index=Index([1, 3], name="A"))
+    xp = DataFrame({"B": [2, 4]}, index=Index(["1", "3"], name="A", dtype="object"))
+    tm.assert_frame_equal(rs, xp)
+
+
+def test_converter_identity_object(all_parsers):
+    # GH#40589
+    parser = all_parsers
+    data = "A,B\n1,2\n3,4"
+
+    rs = parser.read_csv(StringIO(data), converters={"A": lambda x: x})
+
+    xp = DataFrame({"A": ["1", "3"], "B": [2, 4]})
     tm.assert_frame_equal(rs, xp)
 
 
diff --git a/pandas/tests/io/parser/test_dialect.py b/pandas/tests/io/parser/test_dialect.py
index 55b193903bce0..458d4116558e4 100644
--- a/pandas/tests/io/parser/test_dialect.py
+++ b/pandas/tests/io/parser/test_dialect.py
@@ -108,9 +108,14 @@ def test_dialect_conflict_except_delimiter(all_parsers, custom_dialect, arg, val
             kwds[arg] = "blah"
 
     with tm.with_csv_dialect(dialect_name, **dialect_kwargs):
-        with tm.assert_produces_warning(warning_klass):
-            result = parser.read_csv(StringIO(data), dialect=dialect_name, **kwds)
-            tm.assert_frame_equal(result, expected)
+        result = parser.read_csv_check_warnings(
+            warning_klass,
+            "Conflicting values for",
+            StringIO(data),
+            dialect=dialect_name,
+            **kwds,
+        )
+        tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -141,6 +146,11 @@ def test_dialect_conflict_delimiter(all_parsers, custom_dialect, kwargs, warning
     data = "a:b\n1:2"
 
     with tm.with_csv_dialect(dialect_name, **dialect_kwargs):
-        with tm.assert_produces_warning(warning_klass):
-            result = parser.read_csv(StringIO(data), dialect=dialect_name, **kwargs)
-            tm.assert_frame_equal(result, expected)
+        result = parser.read_csv_check_warnings(
+            warning_klass,
+            "Conflicting values for 'delimiter'",
+            StringIO(data),
+            dialect=dialect_name,
+            **kwargs,
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_encoding.py b/pandas/tests/io/parser/test_encoding.py
index 2b27332c7e85b..c06ac9e76bd7f 100644
--- a/pandas/tests/io/parser/test_encoding.py
+++ b/pandas/tests/io/parser/test_encoding.py
@@ -2,10 +2,10 @@
 Tests encoding functionality during parsing
 for all of the parsers defined in parsers.py
 """
-
 from io import BytesIO
 import os
 import tempfile
+import uuid
 
 import numpy as np
 import pytest
@@ -54,7 +54,7 @@ def test_utf16_bom_skiprows(all_parsers, sep, encoding):
 4,5,6""".replace(
         ",", sep
     )
-    path = f"__{tm.rands(10)}__.csv"
+    path = f"__{uuid.uuid4()}__.csv"
     kwargs = {"sep": sep, "skiprows": 2}
     utf8 = "utf-8"
 
@@ -153,9 +153,7 @@ def test_read_csv_utf_aliases(all_parsers, utf_value, encoding_fmt):
         (("io", "parser", "data", "sauron.SHIFT_JIS.csv"), "shiftjis"),
     ],
 )
-def test_binary_mode_file_buffers(
-    all_parsers, csv_dir_path, file_path, encoding, datapath
-):
+def test_binary_mode_file_buffers(all_parsers, file_path, encoding, datapath):
     # gh-23779: Python csv engine shouldn't error on files opened in binary.
     # gh-31575: Python csv engine shouldn't error on files opened in raw binary.
     parser = all_parsers
diff --git a/pandas/tests/io/parser/test_header.py b/pandas/tests/io/parser/test_header.py
index 3fc23525df89e..4ded70db8bae7 100644
--- a/pandas/tests/io/parser/test_header.py
+++ b/pandas/tests/io/parser/test_header.py
@@ -666,3 +666,15 @@ def test_header_none_and_on_bad_lines_skip(all_parsers):
     )
     expected = DataFrame({"a": ["x", "z"], "b": [1, 3]})
     tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_header_missing_rows(all_parsers):
+    # GH#47400
+    parser = all_parsers
+    data = """a,b
+1,2
+"""
+    msg = r"Passed header=\[0,1,2\], len of 3, but only 2 lines in file"
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), header=[0, 1, 2])
diff --git a/pandas/tests/io/parser/test_mangle_dupes.py b/pandas/tests/io/parser/test_mangle_dupes.py
index 3f7b1b5dfa19b..13b419c3390fc 100644
--- a/pandas/tests/io/parser/test_mangle_dupes.py
+++ b/pandas/tests/io/parser/test_mangle_dupes.py
@@ -21,7 +21,15 @@ def test_basic(all_parsers, kwargs):
     parser = all_parsers
 
     data = "a,a,b,b,b\n1,2,3,4,5"
-    result = parser.read_csv(StringIO(data), sep=",", **kwargs)
+    if "mangle_dupe_cols" in kwargs:
+        with tm.assert_produces_warning(
+            FutureWarning,
+            match="the 'mangle_dupe_cols' keyword is deprecated",
+            check_stacklevel=False,
+        ):
+            result = parser.read_csv(StringIO(data), sep=",", **kwargs)
+    else:
+        result = parser.read_csv(StringIO(data), sep=",", **kwargs)
 
     expected = DataFrame([[1, 2, 3, 4, 5]], columns=["a", "a.1", "b", "b.1", "b.2"])
     tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_na_values.py b/pandas/tests/io/parser/test_na_values.py
index f9356dfc7d0e3..9fb096bfeb346 100644
--- a/pandas/tests/io/parser/test_na_values.py
+++ b/pandas/tests/io/parser/test_na_values.py
@@ -469,12 +469,12 @@ def test_na_values_dict_col_index(all_parsers):
     "data,kwargs,expected",
     [
         (
-            str(2 ** 63) + "\n" + str(2 ** 63 + 1),
-            {"na_values": [2 ** 63]},
-            DataFrame([str(2 ** 63), str(2 ** 63 + 1)]),
+            str(2**63) + "\n" + str(2**63 + 1),
+            {"na_values": [2**63]},
+            DataFrame([str(2**63), str(2**63 + 1)]),
         ),
-        (str(2 ** 63) + ",1" + "\n,2", {}, DataFrame([[str(2 ** 63), 1], ["", 2]])),
-        (str(2 ** 63) + "\n1", {"na_values": [2 ** 63]}, DataFrame([np.nan, 1])),
+        (str(2**63) + ",1" + "\n,2", {}, DataFrame([[str(2**63), 1], ["", 2]])),
+        (str(2**63) + "\n1", {"na_values": [2**63]}, DataFrame([np.nan, 1])),
     ],
 )
 def test_na_values_uint64(all_parsers, data, kwargs, expected):
diff --git a/pandas/tests/io/parser/test_network.py b/pandas/tests/io/parser/test_network.py
index 21cdf6f3274df..0b16d1d9ec6b0 100644
--- a/pandas/tests/io/parser/test_network.py
+++ b/pandas/tests/io/parser/test_network.py
@@ -11,43 +11,53 @@
 import numpy as np
 import pytest
 
+from pandas.compat import is_ci_environment
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame
 import pandas._testing as tm
+from pandas.tests.io.test_compression import _compression_to_extension
 
-import pandas.io.common as icom
 from pandas.io.feather_format import read_feather
 from pandas.io.parsers import read_csv
 
 
 @pytest.mark.network
+@tm.network(
+    url=(
+        "https://github.com/pandas-dev/pandas/raw/main/"
+        "pandas/tests/io/parser/data/salaries.csv"
+    ),
+    check_before_test=True,
+)
 @pytest.mark.parametrize("mode", ["explicit", "infer"])
 @pytest.mark.parametrize("engine", ["python", "c"])
 def test_compressed_urls(salaries_table, mode, engine, compression_only):
-    extension = icom._compression_to_extension[compression_only]
-    check_compressed_urls(salaries_table, compression_only, extension, mode, engine)
-
-
-@tm.network
-def check_compressed_urls(salaries_table, compression, extension, mode, engine):
     # test reading compressed urls with various engines and
     # extension inference
+    extension = _compression_to_extension[compression_only]
     base_url = (
-        "https://github.com/pandas-dev/pandas/raw/master/"
+        "https://github.com/pandas-dev/pandas/raw/main/"
         "pandas/tests/io/parser/data/salaries.csv"
     )
 
     url = base_url + extension
 
     if mode != "explicit":
-        compression = mode
+        compression_only = mode
 
-    url_table = read_csv(url, sep="\t", compression=compression, engine=engine)
+    url_table = read_csv(url, sep="\t", compression=compression_only, engine=engine)
     tm.assert_frame_equal(url_table, salaries_table)
 
 
-@tm.network("https://raw.githubusercontent.com/", check_before_test=True)
+@pytest.mark.network
+@tm.network(
+    url=(
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+        "pandas/tests/io/parser/data/unicode_series.csv"
+    ),
+    check_before_test=True,
+)
 def test_url_encoding_csv():
     """
     read_csv should honor the requested encoding for URLs.
@@ -55,7 +65,7 @@ def test_url_encoding_csv():
     GH 10424
     """
     path = (
-        "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
         + "pandas/tests/io/parser/data/unicode_series.csv"
     )
     df = read_csv(path, encoding="latin-1", header=None)
@@ -68,7 +78,13 @@ def tips_df(datapath):
     return read_csv(datapath("io", "data", "csv", "tips.csv"))
 
 
+@pytest.mark.single_cpu
 @pytest.mark.usefixtures("s3_resource")
+@pytest.mark.xfail(
+    reason="CI race condition GH 45433, GH 44584",
+    raises=FileNotFoundError,
+    strict=False,
+)
 @td.skip_if_not_us_locale()
 class TestS3:
     @td.skip_if_no("s3fs")
@@ -244,6 +260,7 @@ def test_write_s3_parquet_fails(self, tips_df, s3so):
                 storage_options=s3so,
             )
 
+    @pytest.mark.single_cpu
     def test_read_csv_handles_boto_s3_object(self, s3_resource, tips_file):
         # see gh-16135
 
@@ -259,6 +276,13 @@ def test_read_csv_handles_boto_s3_object(self, s3_resource, tips_file):
         expected = read_csv(tips_file)
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.single_cpu
+    @pytest.mark.skipif(
+        is_ci_environment(),
+        reason="This test can hang in our CI min_versions build "
+        "and leads to '##[error]The runner has "
+        "received a shutdown signal...' in GHA. GH: 45651",
+    )
     def test_read_csv_chunked_download(self, s3_resource, caplog, s3so):
         # 8 MB, S3FS uses 5MB chunks
         import s3fs
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index 1dfd81366de72..9c8809b6099f9 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -11,17 +11,17 @@
 import warnings
 
 from dateutil.parser import parse as du_parse
-from hypothesis import (
-    given,
-    settings,
-)
+from hypothesis import given
 import numpy as np
 import pytest
 import pytz
 
 from pandas._libs.tslibs import parsing
 from pandas._libs.tslibs.parsing import parse_datetime_string
-from pandas.compat.pyarrow import pa_version_under6p0
+from pandas.compat.pyarrow import (
+    pa_version_under6p0,
+    pa_version_under7p0,
+)
 
 import pandas as pd
 from pandas import (
@@ -45,9 +45,6 @@
 # cause a deadlock instead, so we skip these instead of xfailing
 skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
 
-# constant
-_DEFAULT_DATETIME = datetime(1, 1, 1)
-
 
 @xfail_pyarrow
 def test_read_csv_with_custom_date_parser(all_parsers):
@@ -951,10 +948,11 @@ def test_parse_dates_custom_euro_format(all_parsers, kwargs):
             )
 
 
-@xfail_pyarrow
-def test_parse_tz_aware(all_parsers):
+def test_parse_tz_aware(all_parsers, request):
     # See gh-1693
     parser = all_parsers
+    if parser.engine == "pyarrow" and pa_version_under7p0:
+        request.node.add_marker(pytest.mark.xfail(reason="Fails for pyarrow < 7.0"))
     data = "Date,x\n2012-06-13T01:39:00Z,0.5"
 
     result = parser.read_csv(StringIO(data), index_col=0, parse_dates=True)
@@ -1540,7 +1538,12 @@ def test_date_parser_resolution_if_not_ns(all_parsers):
 """
 
     def date_parser(dt, time):
-        return np.array(dt + "T" + time, dtype="datetime64[s]")
+        try:
+            arr = dt + "T" + time
+        except TypeError:
+            # dt & time are date/time objects
+            arr = [datetime.combine(d, t) for d, t in zip(dt, time)]
+        return np.array(arr, dtype="datetime64[s]")
 
     result = parser.read_csv(
         StringIO(data),
@@ -1674,16 +1677,29 @@ def test_parse_delimited_date_swap_with_warning(
 ):
     parser = all_parsers
     expected = DataFrame({0: [expected]}, dtype="datetime64[ns]")
-    warning_msg = (
-        "Provide format or specify infer_datetime_format=True for consistent parsing"
+    warning_msg = "Specify a format to ensure consistent parsing"
+    result = parser.read_csv_check_warnings(
+        UserWarning,
+        warning_msg,
+        StringIO(date_string),
+        header=None,
+        dayfirst=dayfirst,
+        parse_dates=[0],
     )
-    with tm.assert_produces_warning(UserWarning, match=warning_msg):
-        result = parser.read_csv(
-            StringIO(date_string), header=None, dayfirst=dayfirst, parse_dates=[0]
-        )
     tm.assert_frame_equal(result, expected)
 
 
+def test_parse_multiple_delimited_dates_with_swap_warnings():
+    # GH46210
+    warning_msg = "Specify a format to ensure consistent parsing"
+    with tm.assert_produces_warning(UserWarning, match=warning_msg) as record:
+        pd.to_datetime(["01/01/2000", "31/05/2000", "31/05/2001", "01/02/2000"])
+    assert len({str(warning.message) for warning in record}) == 1
+    # Using set(record) as repetitions of the same warning are suppressed
+    # https://docs.python.org/3/library/warnings.html
+    # and here we care to check that the warning is only shows once to users.
+
+
 def _helper_hypothesis_delimited_date(call, date_string, **kwargs):
     msg, result = None, None
     try:
@@ -1696,21 +1712,22 @@ def _helper_hypothesis_delimited_date(call, date_string, **kwargs):
 
 @skip_pyarrow
 @given(DATETIME_NO_TZ)
-@settings(deadline=None)
 @pytest.mark.parametrize("delimiter", list(" -./"))
 @pytest.mark.parametrize("dayfirst", [True, False])
 @pytest.mark.parametrize(
     "date_format",
     ["%d %m %Y", "%m %d %Y", "%m %Y", "%Y %m %d", "%y %m %d", "%Y%m%d", "%y%m%d"],
 )
-def test_hypothesis_delimited_date(date_format, dayfirst, delimiter, test_datetime):
+def test_hypothesis_delimited_date(
+    request, date_format, dayfirst, delimiter, test_datetime
+):
     if date_format == "%m %Y" and delimiter == ".":
-        pytest.skip(
-            "parse_datetime_string cannot reliably tell whether "
-            "e.g. %m.%Y is a float or a date, thus we skip it"
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="parse_datetime_string cannot reliably tell whether "
+                "e.g. %m.%Y is a float or a date"
+            )
         )
-    result, expected = None, None
-    except_in_dateutil, except_out_dateutil = None, None
     date_string = test_datetime.strftime(date_format.replace(" ", delimiter))
 
     with warnings.catch_warnings():
@@ -1721,7 +1738,7 @@ def test_hypothesis_delimited_date(date_format, dayfirst, delimiter, test_dateti
     except_in_dateutil, expected = _helper_hypothesis_delimited_date(
         du_parse,
         date_string,
-        default=_DEFAULT_DATETIME,
+        default=datetime(1, 1, 1),
         dayfirst=dayfirst,
         yearfirst=False,
     )
@@ -1844,12 +1861,14 @@ def test_parse_dates_and_keep_orgin_column(all_parsers):
 def test_dayfirst_warnings():
     # GH 12585
     warning_msg_day_first = (
-        "Parsing '31/12/2014' in DD/MM/YYYY format. Provide "
-        "format or specify infer_datetime_format=True for consistent parsing."
+        r"Parsing dates in DD/MM/YYYY format when dayfirst=False \(the default\) was "
+        r"specified. This may lead to inconsistently parsed dates! Specify a format "
+        r"to ensure consistent parsing."
     )
     warning_msg_month_first = (
-        "Parsing '03/30/2011' in MM/DD/YYYY format. Provide "
-        "format or specify infer_datetime_format=True for consistent parsing."
+        "Parsing dates in MM/DD/YYYY format when dayfirst=True was "
+        "specified. This may lead to inconsistently parsed dates! Specify a format "
+        "to ensure consistent parsing."
     )
 
     # CASE 1: valid input
@@ -1933,6 +1952,39 @@ def test_dayfirst_warnings():
     tm.assert_index_equal(expected, res8)
 
 
+@pytest.mark.parametrize(
+    "date_string, dayfirst",
+    [
+        pytest.param(
+            "31/1/2014",
+            False,
+            id="second date is single-digit",
+        ),
+        pytest.param(
+            "1/31/2014",
+            True,
+            id="first date is single-digit",
+        ),
+    ],
+)
+def test_dayfirst_warnings_no_leading_zero(date_string, dayfirst):
+    # GH47880
+    initial_value = f"date\n{date_string}"
+    expected = DatetimeIndex(
+        ["2014-01-31"], dtype="datetime64[ns]", freq=None, name="date"
+    )
+    with tm.assert_produces_warning(
+        UserWarning, match=r"may lead to inconsistently parsed dates"
+    ):
+        res = read_csv(
+            StringIO(initial_value),
+            parse_dates=["date"],
+            index_col="date",
+            dayfirst=dayfirst,
+        ).index
+    tm.assert_index_equal(expected, res)
+
+
 @skip_pyarrow
 def test_infer_first_column_as_index(all_parsers):
     # GH#11019
diff --git a/pandas/tests/io/parser/test_python_parser_only.py b/pandas/tests/io/parser/test_python_parser_only.py
index df8be721ec871..1d3392b124895 100644
--- a/pandas/tests/io/parser/test_python_parser_only.py
+++ b/pandas/tests/io/parser/test_python_parser_only.py
@@ -4,6 +4,7 @@
 these tests out of this module as soon as the C parser can accept further
 arguments when parsing.
 """
+from __future__ import annotations
 
 import csv
 from io import (
@@ -13,7 +14,10 @@
 
 import pytest
 
-from pandas.errors import ParserError
+from pandas.errors import (
+    ParserError,
+    ParserWarning,
+)
 
 from pandas import (
     DataFrame,
@@ -163,9 +167,8 @@ def test_decompression_regex_sep(python_parser_only, csv1, compression, klass):
     klass = getattr(module, klass)
 
     with tm.ensure_clean() as path:
-        tmp = klass(path, mode="wb")
-        tmp.write(data)
-        tmp.close()
+        with klass(path, mode="wb") as tmp:
+            tmp.write(data)
 
         result = parser.read_csv(path, sep="::", compression=compression)
         tm.assert_frame_equal(result, expected)
@@ -316,7 +319,7 @@ def test_python_engine_file_no_next(python_parser_only):
     parser = python_parser_only
 
     class NoNextBuffer:
-        def __init__(self, csv_data):
+        def __init__(self, csv_data) -> None:
             self.data = csv_data
 
         def __iter__(self):
@@ -329,3 +332,159 @@ def readline(self):
             return self.data
 
     parser.read_csv(NoNextBuffer("a\n1"))
+
+
+@pytest.mark.parametrize("bad_line_func", [lambda x: ["2", "3"], lambda x: x[:2]])
+def test_on_bad_lines_callable(python_parser_only, bad_line_func):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2
+2,3,4,5,6
+3,4
+"""
+    bad_sio = StringIO(data)
+    result = parser.read_csv(bad_sio, on_bad_lines=bad_line_func)
+    expected = DataFrame({"a": [1, 2, 3], "b": [2, 3, 4]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_on_bad_lines_callable_write_to_external_list(python_parser_only):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2
+2,3,4,5,6
+3,4
+"""
+    bad_sio = StringIO(data)
+    lst = []
+
+    def bad_line_func(bad_line: list[str]) -> list[str]:
+        lst.append(bad_line)
+        return ["2", "3"]
+
+    result = parser.read_csv(bad_sio, on_bad_lines=bad_line_func)
+    expected = DataFrame({"a": [1, 2, 3], "b": [2, 3, 4]})
+    tm.assert_frame_equal(result, expected)
+    assert lst == [["2", "3", "4", "5", "6"]]
+
+
+@pytest.mark.parametrize("bad_line_func", [lambda x: ["foo", "bar"], lambda x: x[:2]])
+@pytest.mark.parametrize("sep", [",", "111"])
+def test_on_bad_lines_callable_iterator_true(python_parser_only, bad_line_func, sep):
+    # GH 5686
+    # iterator=True has a separate code path than iterator=False
+    parser = python_parser_only
+    data = f"""
+0{sep}1
+hi{sep}there
+foo{sep}bar{sep}baz
+good{sep}bye
+"""
+    bad_sio = StringIO(data)
+    result_iter = parser.read_csv(
+        bad_sio, on_bad_lines=bad_line_func, chunksize=1, iterator=True, sep=sep
+    )
+    expecteds = [
+        {"0": "hi", "1": "there"},
+        {"0": "foo", "1": "bar"},
+        {"0": "good", "1": "bye"},
+    ]
+    for i, (result, expected) in enumerate(zip(result_iter, expecteds)):
+        expected = DataFrame(expected, index=range(i, i + 1))
+        tm.assert_frame_equal(result, expected)
+
+
+def test_on_bad_lines_callable_dont_swallow_errors(python_parser_only):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2
+2,3,4,5,6
+3,4
+"""
+    bad_sio = StringIO(data)
+    msg = "This function is buggy."
+
+    def bad_line_func(bad_line):
+        raise ValueError(msg)
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(bad_sio, on_bad_lines=bad_line_func)
+
+
+def test_on_bad_lines_callable_not_expected_length(python_parser_only):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2
+2,3,4,5,6
+3,4
+"""
+    bad_sio = StringIO(data)
+
+    result = parser.read_csv_check_warnings(
+        ParserWarning, "Length of header or names", bad_sio, on_bad_lines=lambda x: x
+    )
+    expected = DataFrame({"a": [1, 2, 3], "b": [2, 3, 4]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_on_bad_lines_callable_returns_none(python_parser_only):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2
+2,3,4,5,6
+3,4
+"""
+    bad_sio = StringIO(data)
+
+    result = parser.read_csv(bad_sio, on_bad_lines=lambda x: None)
+    expected = DataFrame({"a": [1, 3], "b": [2, 4]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_on_bad_lines_index_col_inferred(python_parser_only):
+    # GH 5686
+    parser = python_parser_only
+    data = """a,b
+1,2,3
+4,5,6
+"""
+    bad_sio = StringIO(data)
+
+    result = parser.read_csv(bad_sio, on_bad_lines=lambda x: ["99", "99"])
+    expected = DataFrame({"a": [2, 5], "b": [3, 6]}, index=[1, 4])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_index_col_false_and_header_none(python_parser_only):
+    # GH#46955
+    parser = python_parser_only
+    data = """
+0.5,0.03
+0.1,0.2,0.3,2
+"""
+    result = parser.read_csv_check_warnings(
+        ParserWarning,
+        "Length of header",
+        StringIO(data),
+        sep=",",
+        header=None,
+        index_col=False,
+    )
+    expected = DataFrame({0: [0.5, 0.1], 1: [0.03, 0.2]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_header_int_do_not_infer_multiindex_names_on_different_line(python_parser_only):
+    # GH#46569
+    parser = python_parser_only
+    data = StringIO("a\na,b\nc,d,e\nf,g,h")
+    result = parser.read_csv_check_warnings(
+        ParserWarning, "Length of header", data, engine="python", index_col=False
+    )
+    expected = DataFrame({"a": ["a", "c", "f"]})
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_quoting.py b/pandas/tests/io/parser/test_quoting.py
index 456dd049d2f4a..025a612dc47d2 100644
--- a/pandas/tests/io/parser/test_quoting.py
+++ b/pandas/tests/io/parser/test_quoting.py
@@ -8,6 +8,7 @@
 
 import pytest
 
+from pandas.compat import PY311
 from pandas.errors import ParserError
 
 from pandas import DataFrame
@@ -38,7 +39,7 @@ def test_bad_quote_char(all_parsers, kwargs, msg):
 @pytest.mark.parametrize(
     "quoting,msg",
     [
-        ("foo", '"quoting" must be an integer'),
+        ("foo", '"quoting" must be an integer|Argument'),
         (5, 'bad "quoting" value'),  # quoting must be in the range [0, 3]
     ],
 )
@@ -80,11 +81,16 @@ def test_null_quote_char(all_parsers, quoting, quote_char):
 
     if quoting != csv.QUOTE_NONE:
         # Sanity checking.
-        msg = "quotechar must be set if quoting enabled"
+        msg = (
+            '"quotechar" must be a 1-character string'
+            if PY311 and all_parsers.engine == "python" and quote_char == ""
+            else "quotechar must be set if quoting enabled"
+        )
 
         with pytest.raises(TypeError, match=msg):
             parser.read_csv(StringIO(data), **kwargs)
-    else:
+    elif not (PY311 and all_parsers.engine == "python"):
+        # Python 3.11+ doesn't support null/blank quote chars in their csv parsers
         expected = DataFrame([[1, 2, 3]], columns=["a", "b", "c"])
         result = parser.read_csv(StringIO(data), **kwargs)
         tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_read_fwf.py b/pandas/tests/io/parser/test_read_fwf.py
index 63f783b01d1f3..d6d787df39dfa 100644
--- a/pandas/tests/io/parser/test_read_fwf.py
+++ b/pandas/tests/io/parser/test_read_fwf.py
@@ -21,8 +21,8 @@
     DatetimeIndex,
 )
 import pandas._testing as tm
+from pandas.tests.io.test_compression import _compression_to_extension
 
-import pandas.io.common as icom
 from pandas.io.parsers import (
     read_csv,
     read_fwf,
@@ -656,7 +656,7 @@ def test_fwf_compression(compression_only, infer):
     3333333333""".strip()
 
     compression = compression_only
-    extension = icom._compression_to_extension[compression]
+    extension = _compression_to_extension[compression]
 
     kwargs = {"widths": [5, 5], "names": ["one", "two"]}
     expected = read_fwf(StringIO(data), **kwargs)
@@ -920,3 +920,36 @@ def test_skiprows_passing_as_positional_deprecated():
         result = read_fwf(StringIO(data), [(0, 2)])
     expected = DataFrame({"0": [1, 2]})
     tm.assert_frame_equal(result, expected)
+
+
+def test_names_and_infer_colspecs():
+    # GH#45337
+    data = """X   Y   Z
+      959.0    345   22.2
+    """
+    result = read_fwf(StringIO(data), skiprows=1, usecols=[0, 2], names=["a", "b"])
+    expected = DataFrame({"a": [959.0], "b": 22.2})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_widths_and_usecols():
+    # GH#46580
+    data = """0  1    n -0.4100.1
+0  2    p  0.2 90.1
+0  3    n -0.3140.4"""
+    result = read_fwf(
+        StringIO(data),
+        header=None,
+        usecols=(0, 1, 3),
+        widths=(3, 5, 1, 5, 5),
+        index_col=False,
+        names=("c0", "c1", "c3"),
+    )
+    expected = DataFrame(
+        {
+            "c0": 0,
+            "c1": [1, 2, 3],
+            "c3": [-0.4, 0.2, -0.3],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_skiprows.py b/pandas/tests/io/parser/test_skiprows.py
index 5b722b54da693..c58e27aacfa00 100644
--- a/pandas/tests/io/parser/test_skiprows.py
+++ b/pandas/tests/io/parser/test_skiprows.py
@@ -180,9 +180,9 @@ def test_skip_row_with_newline_and_quote(all_parsers, data, exp_data):
 
 
 @pytest.mark.parametrize(
-    "line_terminator", ["\n", "\r\n", "\r"]  # "LF"  # "CRLF"  # "CR"
+    "lineterminator", ["\n", "\r\n", "\r"]  # "LF"  # "CRLF"  # "CR"
 )
-def test_skiprows_lineterminator(all_parsers, line_terminator, request):
+def test_skiprows_lineterminator(all_parsers, lineterminator, request):
     # see gh-9079
     parser = all_parsers
     data = "\n".join(
@@ -202,11 +202,11 @@ def test_skiprows_lineterminator(all_parsers, line_terminator, request):
         columns=["date", "time", "var", "flag", "oflag"],
     )
 
-    if parser.engine == "python" and line_terminator == "\r":
+    if parser.engine == "python" and lineterminator == "\r":
         mark = pytest.mark.xfail(reason="'CR' not respect with the Python parser yet")
         request.node.add_marker(mark)
 
-    data = data.replace("\n", line_terminator)
+    data = data.replace("\n", lineterminator)
     result = parser.read_csv(
         StringIO(data),
         skiprows=1,
@@ -241,6 +241,17 @@ def test_skip_rows_callable(all_parsers, kwargs, expected):
     tm.assert_frame_equal(result, expected)
 
 
+def test_skip_rows_callable_not_in(all_parsers):
+    parser = all_parsers
+    data = "0,a\n1,b\n2,c\n3,d\n4,e"
+    expected = DataFrame([[1, "b"], [3, "d"]])
+
+    result = parser.read_csv(
+        StringIO(data), header=None, skiprows=lambda x: x not in [1, 3]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
 def test_skip_rows_skip_all(all_parsers):
     parser = all_parsers
     data = "a\n1\n2\n3\n4\n5"
diff --git a/pandas/tests/io/parser/test_textreader.py b/pandas/tests/io/parser/test_textreader.py
index d594bf8a75d49..f150ed3903443 100644
--- a/pandas/tests/io/parser/test_textreader.py
+++ b/pandas/tests/io/parser/test_textreader.py
@@ -6,7 +6,6 @@
     BytesIO,
     StringIO,
 )
-import os
 
 import numpy as np
 import pytest
@@ -25,27 +24,23 @@
 
 
 class TestTextReader:
-    @pytest.fixture(autouse=True)
-    def setup_method(self, datapath):
-        self.dirpath = datapath("io", "parser", "data")
-        csv1_dirpath = datapath("io", "data", "csv")
-        self.csv1 = os.path.join(csv1_dirpath, "test1.csv")
-        self.csv2 = os.path.join(self.dirpath, "test2.csv")
-        self.xls1 = os.path.join(self.dirpath, "test.xls")
-
-    def test_file_handle(self):
-        with open(self.csv1, "rb") as f:
+    @pytest.fixture
+    def csv_path(self, datapath):
+        return datapath("io", "data", "csv", "test1.csv")
+
+    def test_file_handle(self, csv_path):
+        with open(csv_path, "rb") as f:
             reader = TextReader(f)
             reader.read()
 
-    def test_file_handle_mmap(self):
+    def test_file_handle_mmap(self, csv_path):
         # this was never using memory_map=True
-        with open(self.csv1, "rb") as f:
+        with open(csv_path, "rb") as f:
             reader = TextReader(f, header=None)
             reader.read()
 
-    def test_StringIO(self):
-        with open(self.csv1, "rb") as f:
+    def test_StringIO(self, csv_path):
+        with open(csv_path, "rb") as f:
             text = f.read()
         src = BytesIO(text)
         reader = TextReader(src, header=None)
@@ -266,34 +261,32 @@ def _make_reader(**kwds):
         assert (result[1] == exp[1]).all()
         assert (result[2] == exp[2]).all()
 
-    def test_cr_delimited(self):
-        def _test(text, **kwargs):
-            nice_text = text.replace("\r", "\r\n")
-            result = TextReader(StringIO(text), **kwargs).read()
-            expected = TextReader(StringIO(nice_text), **kwargs).read()
-            assert_array_dicts_equal(result, expected)
-
-        data = "a,b,c\r1,2,3\r4,5,6\r7,8,9\r10,11,12"
-        _test(data, delimiter=",")
-
-        data = "a  b  c\r1  2  3\r4  5  6\r7  8  9\r10  11  12"
-        _test(data, delim_whitespace=True)
-
-        data = "a,b,c\r1,2,3\r4,5,6\r,88,9\r10,11,12"
-        _test(data, delimiter=",")
-
-        sample = (
-            "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O\r"
-            "AAAAA,BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0\r"
-            ",BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0"
-        )
-        _test(sample, delimiter=",")
-
-        data = "A  B  C\r  2  3\r4  5  6"
-        _test(data, delim_whitespace=True)
-
-        data = "A B C\r2 3\r4 5 6"
-        _test(data, delim_whitespace=True)
+    @pytest.mark.parametrize(
+        "text, kwargs",
+        [
+            ("a,b,c\r1,2,3\r4,5,6\r7,8,9\r10,11,12", {"delimiter": ","}),
+            (
+                "a  b  c\r1  2  3\r4  5  6\r7  8  9\r10  11  12",
+                {"delim_whitespace": True},
+            ),
+            ("a,b,c\r1,2,3\r4,5,6\r,88,9\r10,11,12", {"delimiter": ","}),
+            (
+                (
+                    "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O\r"
+                    "AAAAA,BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0\r"
+                    ",BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0"
+                ),
+                {"delimiter": ","},
+            ),
+            ("A  B  C\r  2  3\r4  5  6", {"delim_whitespace": True}),
+            ("A B C\r2 3\r4 5 6", {"delim_whitespace": True}),
+        ],
+    )
+    def test_cr_delimited(self, text, kwargs):
+        nice_text = text.replace("\r", "\r\n")
+        result = TextReader(StringIO(text), **kwargs).read()
+        expected = TextReader(StringIO(nice_text), **kwargs).read()
+        assert_array_dicts_equal(result, expected)
 
     def test_empty_field_eof(self):
         data = "a,b,c\n1,2,3\n4,,"
diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index 46ae629d09112..578cea44a8ed6 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -7,9 +7,16 @@
 test suite as new feature support is added to the parsers.
 """
 from io import StringIO
+import os
+from pathlib import Path
 
 import pytest
 
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_mac,
+    is_platform_windows,
+)
 from pandas.errors import ParserError
 
 import pandas._testing as tm
@@ -30,8 +37,11 @@ def test_mangle_dupe_cols_false(self):
         msg = "is not supported"
 
         for engine in ("c", "python"):
-            with pytest.raises(ValueError, match=msg):
-                read_csv(StringIO(data), engine=engine, mangle_dupe_cols=False)
+            with tm.assert_produces_warning(
+                FutureWarning, match="the 'mangle_dupe_cols' keyword is deprecated"
+            ):
+                with pytest.raises(ValueError, match=msg):
+                    read_csv(StringIO(data), engine=engine, mangle_dupe_cols=False)
 
     def test_c_engine(self):
         # see gh-6607
@@ -107,7 +117,7 @@ def test_python_engine(self, python_engine):
     def test_python_engine_file_no_iter(self, python_engine):
         # see gh-16530
         class NoNextBuffer:
-            def __init__(self, csv_data):
+            def __init__(self, csv_data) -> None:
                 self.data = csv_data
 
             def __next__(self):
@@ -149,3 +159,48 @@ def test_pyarrow_engine(self):
                 kwargs[default] = "warn"
             with pytest.raises(ValueError, match=msg):
                 read_csv(StringIO(data), engine="pyarrow", **kwargs)
+
+    def test_on_bad_lines_callable_python_only(self, all_parsers):
+        # GH 5686
+        sio = StringIO("a,b\n1,2")
+        bad_lines_func = lambda x: x
+        parser = all_parsers
+        if all_parsers.engine != "python":
+            msg = "on_bad_line can only be a callable function if engine='python'"
+            with pytest.raises(ValueError, match=msg):
+                parser.read_csv(sio, on_bad_lines=bad_lines_func)
+        else:
+            parser.read_csv(sio, on_bad_lines=bad_lines_func)
+
+
+def test_close_file_handle_on_invalid_usecols(all_parsers):
+    # GH 45384
+    parser = all_parsers
+
+    error = ValueError
+    if parser.engine == "pyarrow":
+        pyarrow = pytest.importorskip("pyarrow")
+        error = pyarrow.lib.ArrowKeyError
+        if is_ci_environment() and (is_platform_windows() or is_platform_mac()):
+            # GH#45547 causes timeouts on windows/mac builds
+            pytest.skip("GH#45547 causing timeouts on windows/mac builds 2022-01-22")
+
+    with tm.ensure_clean("test.csv") as fname:
+        Path(fname).write_text("col1,col2\na,b\n1,2")
+        with tm.assert_produces_warning(False):
+            with pytest.raises(error, match="col3"):
+                parser.read_csv(fname, usecols=["col1", "col2", "col3"])
+        # unlink fails on windows if file handles still point to it
+        os.unlink(fname)
+
+
+def test_invalid_file_inputs(request, all_parsers):
+    # GH#45957
+    parser = all_parsers
+    if parser.engine == "python":
+        request.node.add_marker(
+            pytest.mark.xfail(reason=f"{parser.engine} engine supports lists.")
+        )
+
+    with pytest.raises(ValueError, match="Invalid"):
+        parser.read_csv([])
diff --git a/pandas/tests/io/parser/usecols/test_usecols_basic.py b/pandas/tests/io/parser/usecols/test_usecols_basic.py
index f35caf38c847f..aef1937dcf287 100644
--- a/pandas/tests/io/parser/usecols/test_usecols_basic.py
+++ b/pandas/tests/io/parser/usecols/test_usecols_basic.py
@@ -416,3 +416,21 @@ def test_usecols_indices_out_of_bounds(all_parsers, names):
     if names is None and parser.engine == "python":
         expected = DataFrame({"a": [1]})
     tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_additional_columns(all_parsers):
+    # GH#46997
+    parser = all_parsers
+    usecols = lambda header: header.strip() in ["a", "b", "c"]
+    result = parser.read_csv(StringIO("a,b\nx,y,z"), index_col=False, usecols=usecols)
+    expected = DataFrame({"a": ["x"], "b": "y"})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_additional_columns_integer_columns(all_parsers):
+    # GH#46997
+    parser = all_parsers
+    usecols = lambda header: header.strip() in ["0", "1"]
+    result = parser.read_csv(StringIO("0,1\nx,y,z"), index_col=False, usecols=usecols)
+    expected = DataFrame({"0": ["x"], "1": "y"})
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/pytables/__init__.py b/pandas/tests/io/pytables/__init__.py
index cbf848a401dc4..c94db30adb61d 100644
--- a/pandas/tests/io/pytables/__init__.py
+++ b/pandas/tests/io/pytables/__init__.py
@@ -7,9 +7,9 @@
     ),
     pytest.mark.filterwarnings(r"ignore:tostring\(\) is deprecated:DeprecationWarning"),
     pytest.mark.filterwarnings(
-        r"ignore:`np\.object` is a deprecated alias:DeprecationWarning"
+        r"ignore:`np\.object` is a deprecated alias.*:DeprecationWarning"
     ),
     pytest.mark.filterwarnings(
-        r"ignore:`np\.bool` is a deprecated alias:DeprecationWarning"
+        r"ignore:`np\.bool` is a deprecated alias.*:DeprecationWarning"
     ),
 ]
diff --git a/pandas/tests/io/pytables/conftest.py b/pandas/tests/io/pytables/conftest.py
index 988f78c5ae843..bbd815b9c6309 100644
--- a/pandas/tests/io/pytables/conftest.py
+++ b/pandas/tests/io/pytables/conftest.py
@@ -1,3 +1,5 @@
+import uuid
+
 import pytest
 
 import pandas._testing as tm
@@ -6,7 +8,7 @@
 @pytest.fixture
 def setup_path():
     """Fixture for setup path"""
-    return f"tmp.__{tm.rands(10)}__.h5"
+    return f"tmp.__{uuid.uuid4()}__.h5"
 
 
 @pytest.fixture(scope="module", autouse=True)
diff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py
index 5544b8112627b..40a50c55de2a4 100644
--- a/pandas/tests/io/pytables/test_append.py
+++ b/pandas/tests/io/pytables/test_append.py
@@ -24,7 +24,7 @@
     ensure_clean_store,
 )
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 @pytest.mark.filterwarnings("ignore:object name:tables.exceptions.NaturalNameWarning")
@@ -77,10 +77,10 @@ def test_append(setup_path):
                         np.random.randint(0, high=65535, size=5), dtype=np.uint16
                     ),
                     "u32": Series(
-                        np.random.randint(0, high=2 ** 30, size=5), dtype=np.uint32
+                        np.random.randint(0, high=2**30, size=5), dtype=np.uint32
                     ),
                     "u64": Series(
-                        [2 ** 58, 2 ** 59, 2 ** 60, 2 ** 61, 2 ** 62],
+                        [2**58, 2**59, 2**60, 2**61, 2**62],
                         dtype=np.uint64,
                     ),
                 },
@@ -168,7 +168,7 @@ def test_append_some_nans(setup_path):
 
         # first column
         df1 = df.copy()
-        df1.loc[:, "A1"] = np.nan
+        df1["A1"] = np.nan
         _maybe_remove(store, "df1")
         store.append("df1", df1[:10])
         store.append("df1", df1[10:])
@@ -176,7 +176,7 @@ def test_append_some_nans(setup_path):
 
         # 2nd column
         df2 = df.copy()
-        df2.loc[:, "A2"] = np.nan
+        df2["A2"] = np.nan
         _maybe_remove(store, "df2")
         store.append("df2", df2[:10])
         store.append("df2", df2[10:])
@@ -184,7 +184,7 @@ def test_append_some_nans(setup_path):
 
         # datetimes
         df3 = df.copy()
-        df3.loc[:, "E"] = np.nan
+        df3["E"] = np.nan
         _maybe_remove(store, "df3")
         store.append("df3", df3[:10])
         store.append("df3", df3[10:])
@@ -214,66 +214,66 @@ def test_append_all_nans(setup_path):
         tm.assert_frame_equal(store["df2"], df)
 
         # tests the option io.hdf.dropna_table
-        pd.set_option("io.hdf.dropna_table", False)
-        _maybe_remove(store, "df3")
-        store.append("df3", df[:10])
-        store.append("df3", df[10:])
-        tm.assert_frame_equal(store["df3"], df)
+        with pd.option_context("io.hdf.dropna_table", False):
+            _maybe_remove(store, "df3")
+            store.append("df3", df[:10])
+            store.append("df3", df[10:])
+            tm.assert_frame_equal(store["df3"], df)
 
-        pd.set_option("io.hdf.dropna_table", True)
-        _maybe_remove(store, "df4")
-        store.append("df4", df[:10])
-        store.append("df4", df[10:])
-        tm.assert_frame_equal(store["df4"], df[-4:])
+        with pd.option_context("io.hdf.dropna_table", True):
+            _maybe_remove(store, "df4")
+            store.append("df4", df[:10])
+            store.append("df4", df[10:])
+            tm.assert_frame_equal(store["df4"], df[-4:])
 
-        # nan some entire rows (string are still written!)
-        df = DataFrame(
-            {
-                "A1": np.random.randn(20),
-                "A2": np.random.randn(20),
-                "B": "foo",
-                "C": "bar",
-            },
-            index=np.arange(20),
-        )
+            # nan some entire rows (string are still written!)
+            df = DataFrame(
+                {
+                    "A1": np.random.randn(20),
+                    "A2": np.random.randn(20),
+                    "B": "foo",
+                    "C": "bar",
+                },
+                index=np.arange(20),
+            )
 
-        df.loc[0:15, :] = np.nan
+            df.loc[0:15, :] = np.nan
 
-        _maybe_remove(store, "df")
-        store.append("df", df[:10], dropna=True)
-        store.append("df", df[10:], dropna=True)
-        tm.assert_frame_equal(store["df"], df)
+            _maybe_remove(store, "df")
+            store.append("df", df[:10], dropna=True)
+            store.append("df", df[10:], dropna=True)
+            tm.assert_frame_equal(store["df"], df)
 
-        _maybe_remove(store, "df2")
-        store.append("df2", df[:10], dropna=False)
-        store.append("df2", df[10:], dropna=False)
-        tm.assert_frame_equal(store["df2"], df)
+            _maybe_remove(store, "df2")
+            store.append("df2", df[:10], dropna=False)
+            store.append("df2", df[10:], dropna=False)
+            tm.assert_frame_equal(store["df2"], df)
 
-        # nan some entire rows (but since we have dates they are still
-        # written!)
-        df = DataFrame(
-            {
-                "A1": np.random.randn(20),
-                "A2": np.random.randn(20),
-                "B": "foo",
-                "C": "bar",
-                "D": Timestamp("20010101"),
-                "E": datetime.datetime(2001, 1, 2, 0, 0),
-            },
-            index=np.arange(20),
-        )
+            # nan some entire rows (but since we have dates they are still
+            # written!)
+            df = DataFrame(
+                {
+                    "A1": np.random.randn(20),
+                    "A2": np.random.randn(20),
+                    "B": "foo",
+                    "C": "bar",
+                    "D": Timestamp("20010101"),
+                    "E": datetime.datetime(2001, 1, 2, 0, 0),
+                },
+                index=np.arange(20),
+            )
 
-        df.loc[0:15, :] = np.nan
+            df.loc[0:15, :] = np.nan
 
-        _maybe_remove(store, "df")
-        store.append("df", df[:10], dropna=True)
-        store.append("df", df[10:], dropna=True)
-        tm.assert_frame_equal(store["df"], df)
+            _maybe_remove(store, "df")
+            store.append("df", df[:10], dropna=True)
+            store.append("df", df[10:], dropna=True)
+            tm.assert_frame_equal(store["df"], df)
 
-        _maybe_remove(store, "df2")
-        store.append("df2", df[:10], dropna=False)
-        store.append("df2", df[10:], dropna=False)
-        tm.assert_frame_equal(store["df2"], df)
+            _maybe_remove(store, "df2")
+            store.append("df2", df[:10], dropna=False)
+            store.append("df2", df[10:], dropna=False)
+            tm.assert_frame_equal(store["df2"], df)
 
 
 def test_append_frame_column_oriented(setup_path):
@@ -622,7 +622,7 @@ def check_col(key, name, size):
         df_dc["string"] = "foo"
         df_dc.loc[df_dc.index[4:6], "string"] = np.nan
         df_dc.loc[df_dc.index[7:9], "string"] = "bar"
-        df_dc.loc[:, ["B", "C"]] = df_dc.loc[:, ["B", "C"]].abs()
+        df_dc[["B", "C"]] = df_dc[["B", "C"]].abs()
         df_dc["string2"] = "cool"
 
         # on-disk operations
@@ -898,8 +898,9 @@ def test_append_to_multiple_dropna_false(setup_path):
     df1.iloc[1, df1.columns.get_indexer(["A", "B"])] = np.nan
     df = concat([df1, df2], axis=1)
 
-    with ensure_clean_store(setup_path) as store:
-
+    with ensure_clean_store(setup_path) as store, pd.option_context(
+        "io.hdf.dropna_table", True
+    ):
         # dropna=False shouldn't synchronize row indexes
         store.append_to_multiple(
             {"df1a": ["A", "B"], "df2a": None}, df, selector="df1a", dropna=False
diff --git a/pandas/tests/io/pytables/test_categorical.py b/pandas/tests/io/pytables/test_categorical.py
index dee373000b7d5..3ef685d1132b1 100644
--- a/pandas/tests/io/pytables/test_categorical.py
+++ b/pandas/tests/io/pytables/test_categorical.py
@@ -16,7 +16,7 @@
 )
 
 pytestmark = [
-    pytest.mark.single,
+    pytest.mark.single_cpu,
     # pytables https://github.com/PyTables/PyTables/issues/822
     pytest.mark.filterwarnings(
         "ignore:a closed node found in the registry:UserWarning"
diff --git a/pandas/tests/io/pytables/test_compat.py b/pandas/tests/io/pytables/test_compat.py
index c7200385aa998..5fe55fda8a452 100644
--- a/pandas/tests/io/pytables/test_compat.py
+++ b/pandas/tests/io/pytables/test_compat.py
@@ -23,7 +23,7 @@ def pytables_hdf5_file():
     testsamples = [
         {"c0": t0, "c1": "aaaaa", "c2": 1},
         {"c0": t0 + 1, "c1": "bbbbb", "c2": 2},
-        {"c0": t0 + 2, "c1": "ccccc", "c2": 10 ** 5},
+        {"c0": t0 + 2, "c1": "ccccc", "c2": 10**5},
         {"c0": t0 + 3, "c1": "ddddd", "c2": 4_294_967_295},
     ]
 
diff --git a/pandas/tests/io/pytables/test_errors.py b/pandas/tests/io/pytables/test_errors.py
index dbcd112a28aca..f31c185af0497 100644
--- a/pandas/tests/io/pytables/test_errors.py
+++ b/pandas/tests/io/pytables/test_errors.py
@@ -25,7 +25,7 @@
     _maybe_adjust_name,
 )
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_pass_spec_to_storer(setup_path):
diff --git a/pandas/tests/io/pytables/test_file_handling.py b/pandas/tests/io/pytables/test_file_handling.py
index 027c3d0bd821c..13b6b94dda8d4 100644
--- a/pandas/tests/io/pytables/test_file_handling.py
+++ b/pandas/tests/io/pytables/test_file_handling.py
@@ -4,6 +4,10 @@
 import pytest
 
 from pandas.compat import is_platform_little_endian
+from pandas.errors import (
+    ClosedFileError,
+    PossibleDataLossError,
+)
 
 from pandas import (
     DataFrame,
@@ -20,13 +24,9 @@
 )
 
 from pandas.io import pytables as pytables
-from pandas.io.pytables import (
-    ClosedFileError,
-    PossibleDataLossError,
-    Term,
-)
+from pandas.io.pytables import Term
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 @pytest.mark.parametrize("mode", ["r", "r+", "a", "w"])
diff --git a/pandas/tests/io/pytables/test_keys.py b/pandas/tests/io/pytables/test_keys.py
index 02b79bd0fdbc1..cf412a242b000 100644
--- a/pandas/tests/io/pytables/test_keys.py
+++ b/pandas/tests/io/pytables/test_keys.py
@@ -11,7 +11,7 @@
     tables,
 )
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_keys(setup_path):
diff --git a/pandas/tests/io/pytables/test_put.py b/pandas/tests/io/pytables/test_put.py
index 8e7b31bcf8bca..d4d95186110f8 100644
--- a/pandas/tests/io/pytables/test_put.py
+++ b/pandas/tests/io/pytables/test_put.py
@@ -29,7 +29,7 @@
 )
 from pandas.util import _test_decorators as td
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_format_type(setup_path):
@@ -59,46 +59,41 @@ def test_api_default_format(setup_path):
     with ensure_clean_store(setup_path) as store:
         df = tm.makeDataFrame()
 
-        pd.set_option("io.hdf.default_format", "fixed")
-        _maybe_remove(store, "df")
-        store.put("df", df)
-        assert not store.get_storer("df").is_table
-
-        msg = "Can only append to Tables"
+        with pd.option_context("io.hdf.default_format", "fixed"):
+            _maybe_remove(store, "df")
+            store.put("df", df)
+            assert not store.get_storer("df").is_table
 
-        with pytest.raises(ValueError, match=msg):
-            store.append("df2", df)
+            msg = "Can only append to Tables"
+            with pytest.raises(ValueError, match=msg):
+                store.append("df2", df)
 
-        pd.set_option("io.hdf.default_format", "table")
-        _maybe_remove(store, "df")
-        store.put("df", df)
-        assert store.get_storer("df").is_table
-        _maybe_remove(store, "df2")
-        store.append("df2", df)
-        assert store.get_storer("df").is_table
+        with pd.option_context("io.hdf.default_format", "table"):
+            _maybe_remove(store, "df")
+            store.put("df", df)
+            assert store.get_storer("df").is_table
 
-        pd.set_option("io.hdf.default_format", None)
+            _maybe_remove(store, "df2")
+            store.append("df2", df)
+            assert store.get_storer("df").is_table
 
     with ensure_clean_path(setup_path) as path:
-
         df = tm.makeDataFrame()
 
-        pd.set_option("io.hdf.default_format", "fixed")
-        df.to_hdf(path, "df")
-        with HDFStore(path) as store:
-            assert not store.get_storer("df").is_table
-        with pytest.raises(ValueError, match=msg):
-            df.to_hdf(path, "df2", append=True)
-
-        pd.set_option("io.hdf.default_format", "table")
-        df.to_hdf(path, "df3")
-        with HDFStore(path) as store:
-            assert store.get_storer("df3").is_table
-        df.to_hdf(path, "df4", append=True)
-        with HDFStore(path) as store:
-            assert store.get_storer("df4").is_table
+        with pd.option_context("io.hdf.default_format", "fixed"):
+            df.to_hdf(path, "df")
+            with HDFStore(path) as store:
+                assert not store.get_storer("df").is_table
+            with pytest.raises(ValueError, match=msg):
+                df.to_hdf(path, "df2", append=True)
 
-        pd.set_option("io.hdf.default_format", None)
+        with pd.option_context("io.hdf.default_format", "table"):
+            df.to_hdf(path, "df3")
+            with HDFStore(path) as store:
+                assert store.get_storer("df3").is_table
+            df.to_hdf(path, "df4", append=True)
+            with HDFStore(path) as store:
+                assert store.get_storer("df4").is_table
 
 
 def test_put(setup_path):
@@ -232,8 +227,6 @@ def test_put_mixed_type(setup_path):
         ["fixed", tm.makeDateIndex],
         ["table", tm.makePeriodIndex],  # GH#7796
         ["fixed", tm.makePeriodIndex],
-        ["table", tm.makeUnicodeIndex],
-        ["fixed", tm.makeUnicodeIndex],
     ],
 )
 def test_store_index_types(setup_path, format, index):
diff --git a/pandas/tests/io/pytables/test_read.py b/pandas/tests/io/pytables/test_read.py
index 1c9e63c66aadb..4b57bc8291442 100644
--- a/pandas/tests/io/pytables/test_read.py
+++ b/pandas/tests/io/pytables/test_read.py
@@ -25,7 +25,7 @@
 
 from pandas.io.pytables import TableIterator
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_read_missing_key_close_store(setup_path):
@@ -137,7 +137,7 @@ def test_read_column(setup_path):
         tm.assert_series_equal(result, expected)
 
 
-def test_pytables_native_read(datapath, setup_path):
+def test_pytables_native_read(datapath):
     with ensure_clean_store(
         datapath("io", "data", "legacy_hdf/pytables_native.h5"), mode="r"
     ) as store:
@@ -146,7 +146,7 @@ def test_pytables_native_read(datapath, setup_path):
 
 
 @pytest.mark.skipif(is_platform_windows(), reason="native2 read fails oddly on windows")
-def test_pytables_native2_read(datapath, setup_path):
+def test_pytables_native2_read(datapath):
     with ensure_clean_store(
         datapath("io", "data", "legacy_hdf", "pytables_native2.h5"), mode="r"
     ) as store:
@@ -155,7 +155,7 @@ def test_pytables_native2_read(datapath, setup_path):
         assert isinstance(d1, DataFrame)
 
 
-def test_legacy_table_fixed_format_read_py2(datapath, setup_path):
+def test_legacy_table_fixed_format_read_py2(datapath):
     # GH 24510
     # legacy table with fixed format written in Python 2
     with ensure_clean_store(
@@ -170,7 +170,7 @@ def test_legacy_table_fixed_format_read_py2(datapath, setup_path):
         tm.assert_frame_equal(expected, result)
 
 
-def test_legacy_table_fixed_format_read_datetime_py2(datapath, setup_path):
+def test_legacy_table_fixed_format_read_datetime_py2(datapath):
     # GH 31750
     # legacy table with fixed format and datetime64 column written in Python 2
     with ensure_clean_store(
@@ -186,7 +186,7 @@ def test_legacy_table_fixed_format_read_datetime_py2(datapath, setup_path):
         tm.assert_frame_equal(expected, result)
 
 
-def test_legacy_table_read_py2(datapath, setup_path):
+def test_legacy_table_read_py2(datapath):
     # issue: 24925
     # legacy table written in Python 2
     with ensure_clean_store(
diff --git a/pandas/tests/io/pytables/test_retain_attributes.py b/pandas/tests/io/pytables/test_retain_attributes.py
index 16772d03c6d26..bd02121bd3252 100644
--- a/pandas/tests/io/pytables/test_retain_attributes.py
+++ b/pandas/tests/io/pytables/test_retain_attributes.py
@@ -17,7 +17,7 @@
     ensure_clean_store,
 )
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_retain_index_attributes(setup_path):
diff --git a/pandas/tests/io/pytables/test_round_trip.py b/pandas/tests/io/pytables/test_round_trip.py
index 867525a7146b4..556272b913ff0 100644
--- a/pandas/tests/io/pytables/test_round_trip.py
+++ b/pandas/tests/io/pytables/test_round_trip.py
@@ -30,10 +30,10 @@
 _default_compressor = "blosc"
 
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
-def test_conv_read_write(setup_path):
+def test_conv_read_write():
     with tm.ensure_clean() as path:
 
         def roundtrip(key, obj, **kwargs):
@@ -491,20 +491,6 @@ def _check_roundtrip(obj, comparator, path, compression=False, **kwargs):
         comparator(retrieved, obj, **kwargs)
 
 
-def _check_double_roundtrip(self, obj, comparator, path, compression=False, **kwargs):
-    options = {}
-    if compression:
-        options["complib"] = compression or _default_compressor
-
-    with ensure_clean_store(path, "w", **options) as store:
-        store["obj"] = obj
-        retrieved = store["obj"]
-        comparator(retrieved, obj, **kwargs)
-        store["obj"] = retrieved
-        again = store["obj"]
-        comparator(again, obj, **kwargs)
-
-
 def _check_roundtrip_table(obj, comparator, path, compression=False):
     options = {}
     if compression:
diff --git a/pandas/tests/io/pytables/test_select.py b/pandas/tests/io/pytables/test_select.py
index b644c3420150c..e26b47d6615bd 100644
--- a/pandas/tests/io/pytables/test_select.py
+++ b/pandas/tests/io/pytables/test_select.py
@@ -27,7 +27,7 @@
 
 from pandas.io.pytables import Term
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_select_columns_in_where(setup_path):
@@ -659,7 +659,7 @@ def test_frame_select_complex(setup_path):
         tm.assert_frame_equal(result, expected)
 
 
-def test_frame_select_complex2(setup_path):
+def test_frame_select_complex2():
 
     with ensure_clean_path(["params.hdf", "hist.hdf"]) as paths:
 
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index cbca8bb64e350..db87c8facbfdb 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -40,7 +40,7 @@
     read_hdf,
 )
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_context(setup_path):
@@ -223,7 +223,7 @@ def test_versioning(setup_path):
         ),
     ],
 )
-def test_walk(where, expected, setup_path):
+def test_walk(where, expected):
     # GH10143
     objs = {
         "df1": DataFrame([1, 2, 3]),
@@ -589,7 +589,6 @@ def test_store_series_name(setup_path):
         tm.assert_series_equal(recons, series)
 
 
-@pytest.mark.filterwarnings("ignore:\\nduplicate:pandas.io.pytables.DuplicateWarning")
 def test_overwrite_node(setup_path):
 
     with ensure_clean_store(setup_path) as store:
@@ -809,7 +808,7 @@ def test_select_filter_corner(setup_path):
         tm.assert_frame_equal(result, df.loc[:, df.columns[:75:2]])
 
 
-def test_path_pathlib(setup_path):
+def test_path_pathlib():
     df = tm.makeDataFrame()
 
     result = tm.round_trip_pathlib(
@@ -835,7 +834,7 @@ def test_contiguous_mixed_data_table(start, stop, setup_path):
         tm.assert_frame_equal(df[start:stop], result)
 
 
-def test_path_pathlib_hdfstore(setup_path):
+def test_path_pathlib_hdfstore():
     df = tm.makeDataFrame()
 
     def writer(path):
@@ -850,7 +849,7 @@ def reader(path):
     tm.assert_frame_equal(df, result)
 
 
-def test_pickle_path_localpath(setup_path):
+def test_pickle_path_localpath():
     df = tm.makeDataFrame()
     result = tm.round_trip_pathlib(
         lambda p: df.to_hdf(p, "df"), lambda p: read_hdf(p, "df")
@@ -858,7 +857,7 @@ def test_pickle_path_localpath(setup_path):
     tm.assert_frame_equal(df, result)
 
 
-def test_path_localpath_hdfstore(setup_path):
+def test_path_localpath_hdfstore():
     df = tm.makeDataFrame()
 
     def writer(path):
@@ -873,7 +872,7 @@ def reader(path):
     tm.assert_frame_equal(df, result)
 
 
-def test_copy(setup_path):
+def test_copy():
 
     with catch_warnings(record=True):
 
@@ -993,7 +992,6 @@ def test_to_hdf_with_object_column_names(setup_path):
     types_should_run = [
         tm.makeStringIndex,
         tm.makeCategoricalIndex,
-        tm.makeUnicodeIndex,
     ]
 
     for index in types_should_fail:
@@ -1011,3 +1009,33 @@ def test_to_hdf_with_object_column_names(setup_path):
                 df.to_hdf(path, "df", format="table", data_columns=True)
                 result = read_hdf(path, "df", where=f"index = [{df.index[0]}]")
                 assert len(result)
+
+
+def test_hdfstore_iteritems_deprecated(setup_path):
+    with ensure_clean_path(setup_path) as path:
+        df = DataFrame({"a": [1]})
+        with HDFStore(path, mode="w") as hdf:
+            hdf.put("table", df)
+            with tm.assert_produces_warning(FutureWarning):
+                next(hdf.iteritems())
+
+
+def test_hdfstore_strides(setup_path):
+    # GH22073
+    df = DataFrame({"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]})
+    with ensure_clean_store(setup_path) as store:
+        store.put("df", df)
+        assert df["a"].values.strides == store["df"]["a"].values.strides
+
+
+def test_store_bool_index(setup_path):
+    # GH#48667
+    df = DataFrame([[1]], columns=[True], index=Index([False], dtype="bool"))
+    expected = df.copy()
+
+    # # Test to make sure defaults are to not drop.
+    # # Corresponding to Issue 9382
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "a")
+        result = read_hdf(path, "a")
+        tm.assert_frame_equal(expected, result)
diff --git a/pandas/tests/io/pytables/test_time_series.py b/pandas/tests/io/pytables/test_time_series.py
index 5e42dbde4b9f1..6625984961c11 100644
--- a/pandas/tests/io/pytables/test_time_series.py
+++ b/pandas/tests/io/pytables/test_time_series.py
@@ -10,7 +10,7 @@
 )
 from pandas.tests.io.pytables.common import ensure_clean_store
 
-pytestmark = pytest.mark.single
+pytestmark = pytest.mark.single_cpu
 
 
 def test_store_datetime_fractional_secs(setup_path):
diff --git a/pandas/tests/io/pytables/test_timezones.py b/pandas/tests/io/pytables/test_timezones.py
index 36fa79d0bb7e3..e235c73123eaa 100644
--- a/pandas/tests/io/pytables/test_timezones.py
+++ b/pandas/tests/io/pytables/test_timezones.py
@@ -304,7 +304,7 @@ def test_store_timezone(setup_path):
         tm.assert_frame_equal(result, df)
 
 
-def test_legacy_datetimetz_object(datapath, setup_path):
+def test_legacy_datetimetz_object(datapath):
     # legacy from < 0.17.0
     # 8260
     expected = DataFrame(
@@ -356,7 +356,7 @@ def test_read_with_where_tz_aware_index(setup_path):
         tm.assert_frame_equal(result, expected)
 
 
-def test_py2_created_with_datetimez(datapath, setup_path):
+def test_py2_created_with_datetimez(datapath):
     # The test HDF5 file was created in Python 2, but could not be read in
     # Python 3.
     #
diff --git a/pandas/tests/io/sas/data/0x00controlbyte.sas7bdat.bz2 b/pandas/tests/io/sas/data/0x00controlbyte.sas7bdat.bz2
new file mode 100644
index 0000000000000..ef980fb907694
Binary files /dev/null and b/pandas/tests/io/sas/data/0x00controlbyte.sas7bdat.bz2 differ
diff --git a/pandas/tests/io/sas/data/0x40controlbyte.csv b/pandas/tests/io/sas/data/0x40controlbyte.csv
new file mode 100644
index 0000000000000..e81f5cc3904b7
--- /dev/null
+++ b/pandas/tests/io/sas/data/0x40controlbyte.csv
@@ -0,0 +1,2 @@
+long_string_field1,long_string_field2,long_string_field3
+00000000000000000000000000000000000000000000000000,11111111111111111111111111111111111111111111111111,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
diff --git a/pandas/tests/io/sas/data/0x40controlbyte.sas7bdat b/pandas/tests/io/sas/data/0x40controlbyte.sas7bdat
new file mode 100644
index 0000000000000..013542e282e2f
Binary files /dev/null and b/pandas/tests/io/sas/data/0x40controlbyte.sas7bdat differ
diff --git a/pandas/tests/io/sas/data/airline.sas7bdat.gz b/pandas/tests/io/sas/data/airline.sas7bdat.gz
new file mode 100644
index 0000000000000..7b56e492295f4
Binary files /dev/null and b/pandas/tests/io/sas/data/airline.sas7bdat.gz differ
diff --git a/pandas/tests/io/sas/data/test_meta2_page.sas7bdat b/pandas/tests/io/sas/data/test_meta2_page.sas7bdat
new file mode 100644
index 0000000000000..9732cabc212cf
Binary files /dev/null and b/pandas/tests/io/sas/data/test_meta2_page.sas7bdat differ
diff --git a/pandas/tests/io/sas/data/zero_rows.sas7bdat b/pandas/tests/io/sas/data/zero_rows.sas7bdat
new file mode 100644
index 0000000000000..a5ba95b639507
Binary files /dev/null and b/pandas/tests/io/sas/data/zero_rows.sas7bdat differ
diff --git a/pandas/tests/io/sas/test_sas.py b/pandas/tests/io/sas/test_sas.py
index 5d2643c20ceb2..1e38baf4fc409 100644
--- a/pandas/tests/io/sas/test_sas.py
+++ b/pandas/tests/io/sas/test_sas.py
@@ -20,7 +20,15 @@ def test_sas_buffer_format(self):
 
     def test_sas_read_no_format_or_extension(self):
         # see gh-24548
-        msg = "unable to infer format of SAS file"
+        msg = "unable to infer format of SAS file.+"
         with tm.ensure_clean("test_file_no_extension") as path:
             with pytest.raises(ValueError, match=msg):
                 read_sas(path)
+
+
+def test_sas_archive(datapath):
+    fname_uncompressed = datapath("io", "sas", "data", "airline.sas7bdat")
+    df_uncompressed = read_sas(fname_uncompressed)
+    fname_compressed = datapath("io", "sas", "data", "airline.sas7bdat.gz")
+    df_compressed = read_sas(fname_compressed, format="sas7bdat")
+    tm.assert_frame_equal(df_uncompressed, df_compressed)
diff --git a/pandas/tests/io/sas/test_sas7bdat.py b/pandas/tests/io/sas/test_sas7bdat.py
index 5477559262cb8..2b7ecbcdf9f80 100644
--- a/pandas/tests/io/sas/test_sas7bdat.py
+++ b/pandas/tests/io/sas/test_sas7bdat.py
@@ -1,3 +1,4 @@
+import contextlib
 from datetime import datetime
 import io
 import os
@@ -14,104 +15,98 @@
 import pandas._testing as tm
 
 
+@pytest.fixture
+def dirpath(datapath):
+    return datapath("io", "sas", "data")
+
+
+@pytest.fixture(params=[(1, range(1, 16)), (2, [16])])
+def data_test_ix(request, dirpath):
+    i, test_ix = request.param
+    fname = os.path.join(dirpath, f"test_sas7bdat_{i}.csv")
+    df = pd.read_csv(fname)
+    epoch = datetime(1960, 1, 1)
+    t1 = pd.to_timedelta(df["Column4"], unit="d")
+    df["Column4"] = epoch + t1
+    t2 = pd.to_timedelta(df["Column12"], unit="d")
+    df["Column12"] = epoch + t2
+    for k in range(df.shape[1]):
+        col = df.iloc[:, k]
+        if col.dtype == np.int64:
+            df.isetitem(k, df.iloc[:, k].astype(np.float64))
+    return df, test_ix
+
+
 # https://github.com/cython/cython/issues/1720
 @pytest.mark.filterwarnings("ignore:can't resolve package:ImportWarning")
 class TestSAS7BDAT:
-    @pytest.fixture(autouse=True)
-    def setup_method(self, datapath):
-        self.dirpath = datapath("io", "sas", "data")
-        self.data = []
-        self.test_ix = [list(range(1, 16)), [16]]
-        for j in 1, 2:
-            fname = os.path.join(self.dirpath, f"test_sas7bdat_{j}.csv")
-            df = pd.read_csv(fname)
-            epoch = datetime(1960, 1, 1)
-            t1 = pd.to_timedelta(df["Column4"], unit="d")
-            df["Column4"] = epoch + t1
-            t2 = pd.to_timedelta(df["Column12"], unit="d")
-            df["Column12"] = epoch + t2
-            for k in range(df.shape[1]):
-                col = df.iloc[:, k]
-                if col.dtype == np.int64:
-                    df.iloc[:, k] = df.iloc[:, k].astype(np.float64)
-            self.data.append(df)
-
     @pytest.mark.slow
-    def test_from_file(self):
-        for j in 0, 1:
-            df0 = self.data[j]
-            for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
-                df = pd.read_sas(fname, encoding="utf-8")
-                tm.assert_frame_equal(df, df0)
+    def test_from_file(self, dirpath, data_test_ix):
+        df0, test_ix = data_test_ix
+        for k in test_ix:
+            fname = os.path.join(dirpath, f"test{k}.sas7bdat")
+            df = pd.read_sas(fname, encoding="utf-8")
+            tm.assert_frame_equal(df, df0)
 
     @pytest.mark.slow
-    def test_from_buffer(self):
-        for j in 0, 1:
-            df0 = self.data[j]
-            for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
-                with open(fname, "rb") as f:
-                    byts = f.read()
-                buf = io.BytesIO(byts)
-                with pd.read_sas(
-                    buf, format="sas7bdat", iterator=True, encoding="utf-8"
-                ) as rdr:
-                    df = rdr.read()
-                tm.assert_frame_equal(df, df0, check_exact=False)
+    def test_from_buffer(self, dirpath, data_test_ix):
+        df0, test_ix = data_test_ix
+        for k in test_ix:
+            fname = os.path.join(dirpath, f"test{k}.sas7bdat")
+            with open(fname, "rb") as f:
+                byts = f.read()
+            buf = io.BytesIO(byts)
+            with pd.read_sas(
+                buf, format="sas7bdat", iterator=True, encoding="utf-8"
+            ) as rdr:
+                df = rdr.read()
+            tm.assert_frame_equal(df, df0, check_exact=False)
 
     @pytest.mark.slow
-    def test_from_iterator(self):
-        for j in 0, 1:
-            df0 = self.data[j]
-            for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
-                with pd.read_sas(fname, iterator=True, encoding="utf-8") as rdr:
-                    df = rdr.read(2)
-                    tm.assert_frame_equal(df, df0.iloc[0:2, :])
-                    df = rdr.read(3)
-                    tm.assert_frame_equal(df, df0.iloc[2:5, :])
+    def test_from_iterator(self, dirpath, data_test_ix):
+        df0, test_ix = data_test_ix
+        for k in test_ix:
+            fname = os.path.join(dirpath, f"test{k}.sas7bdat")
+            with pd.read_sas(fname, iterator=True, encoding="utf-8") as rdr:
+                df = rdr.read(2)
+                tm.assert_frame_equal(df, df0.iloc[0:2, :])
+                df = rdr.read(3)
+                tm.assert_frame_equal(df, df0.iloc[2:5, :])
 
     @pytest.mark.slow
-    def test_path_pathlib(self):
-        for j in 0, 1:
-            df0 = self.data[j]
-            for k in self.test_ix[j]:
-                fname = Path(os.path.join(self.dirpath, f"test{k}.sas7bdat"))
-                df = pd.read_sas(fname, encoding="utf-8")
-                tm.assert_frame_equal(df, df0)
+    def test_path_pathlib(self, dirpath, data_test_ix):
+        df0, test_ix = data_test_ix
+        for k in test_ix:
+            fname = Path(os.path.join(dirpath, f"test{k}.sas7bdat"))
+            df = pd.read_sas(fname, encoding="utf-8")
+            tm.assert_frame_equal(df, df0)
 
     @td.skip_if_no("py.path")
     @pytest.mark.slow
-    def test_path_localpath(self):
+    def test_path_localpath(self, dirpath, data_test_ix):
         from py.path import local as LocalPath
 
-        for j in 0, 1:
-            df0 = self.data[j]
-            for k in self.test_ix[j]:
-                fname = LocalPath(os.path.join(self.dirpath, f"test{k}.sas7bdat"))
-                df = pd.read_sas(fname, encoding="utf-8")
-                tm.assert_frame_equal(df, df0)
+        df0, test_ix = data_test_ix
+        for k in test_ix:
+            fname = LocalPath(os.path.join(dirpath, f"test{k}.sas7bdat"))
+            df = pd.read_sas(fname, encoding="utf-8")
+            tm.assert_frame_equal(df, df0)
 
     @pytest.mark.slow
-    def test_iterator_loop(self):
+    @pytest.mark.parametrize("chunksize", (3, 5, 10, 11))
+    @pytest.mark.parametrize("k", range(1, 17))
+    def test_iterator_loop(self, dirpath, k, chunksize):
         # github #13654
-        for j in 0, 1:
-            for k in self.test_ix[j]:
-                for chunksize in (3, 5, 10, 11):
-                    fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
-                    with pd.read_sas(
-                        fname, chunksize=chunksize, encoding="utf-8"
-                    ) as rdr:
-                        y = 0
-                        for x in rdr:
-                            y += x.shape[0]
-                    assert y == rdr.row_count
-
-    def test_iterator_read_too_much(self):
+        fname = os.path.join(dirpath, f"test{k}.sas7bdat")
+        with pd.read_sas(fname, chunksize=chunksize, encoding="utf-8") as rdr:
+            y = 0
+            for x in rdr:
+                y += x.shape[0]
+        assert y == rdr.row_count
+
+    def test_iterator_read_too_much(self, dirpath):
         # github #14734
-        k = self.test_ix[0][0]
-        fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
+        fname = os.path.join(dirpath, "test1.sas7bdat")
         with pd.read_sas(
             fname, format="sas7bdat", iterator=True, encoding="utf-8"
         ) as rdr:
@@ -135,9 +130,8 @@ def test_encoding_options(datapath):
 
     from pandas.io.sas.sas7bdat import SAS7BDATReader
 
-    rdr = SAS7BDATReader(fname, convert_header_text=False)
-    df3 = rdr.read()
-    rdr.close()
+    with contextlib.closing(SAS7BDATReader(fname, convert_header_text=False)) as rdr:
+        df3 = rdr.read()
     for x, y in zip(df1.columns, df3.columns):
         assert x == y.decode()
 
@@ -179,11 +173,12 @@ def test_date_time(datapath):
         fname, parse_dates=["Date1", "Date2", "DateTime", "DateTimeHi", "Taiw"]
     )
     # GH 19732: Timestamps imported from sas will incur floating point errors
-    df.iloc[:, 3] = df.iloc[:, 3].dt.round("us")
+    df[df.columns[3]] = df.iloc[:, 3].dt.round("us")
     tm.assert_frame_equal(df, df0)
 
 
-def test_compact_numerical_values(datapath):
+@pytest.mark.parametrize("column", ["WGT", "CYL"])
+def test_compact_numerical_values(datapath, column):
     # Regression test for #21616
     fname = datapath("io", "sas", "data", "cars.sas7bdat")
     df = pd.read_sas(fname, encoding="latin-1")
@@ -191,11 +186,8 @@ def test_compact_numerical_values(datapath):
     # width < 8 and only contain integral values.
     # Test that pandas doesn't corrupt the numbers by adding
     # decimals.
-    result = df["WGT"]
-    expected = df["WGT"].round()
-    tm.assert_series_equal(result, expected, check_exact=True)
-    result = df["CYL"]
-    expected = df["CYL"].round()
+    result = df[column]
+    expected = df[column].round()
     tm.assert_series_equal(result, expected, check_exact=True)
 
 
@@ -224,6 +216,14 @@ def test_zero_variables(datapath):
         pd.read_sas(fname)
 
 
+def test_zero_rows(datapath):
+    # GH 18198
+    fname = datapath("io", "sas", "data", "zero_rows.sas7bdat")
+    result = pd.read_sas(fname)
+    expected = pd.DataFrame([{"char_field": "a", "num_field": 1.0}]).iloc[:0]
+    tm.assert_frame_equal(result, expected)
+
+
 def test_corrupt_read(datapath):
     # We don't really care about the exact failure, the important thing is
     # that the resource should be cleaned up afterwards (BUG #35566)
@@ -341,3 +341,59 @@ def test_null_date(datapath):
         },
     )
     tm.assert_frame_equal(df, expected)
+
+
+def test_meta2_page(datapath):
+    # GH 35545
+    fname = datapath("io", "sas", "data", "test_meta2_page.sas7bdat")
+    df = pd.read_sas(fname)
+    assert len(df) == 1000
+
+
+@pytest.mark.parametrize("test_file", ["test2.sas7bdat", "test3.sas7bdat"])
+def test_exception_propagation_rdc_rle_decompress(datapath, monkeypatch, test_file):
+    """Errors in RLE/RDC decompression should propagate the same error."""
+    orig_np_zeros = np.zeros
+
+    def _patched_zeros(size, dtype):
+        if isinstance(size, int):
+            # np.zeros() call in {rdc,rle}_decompress
+            raise Exception("Test exception")
+        else:
+            # Other calls to np.zeros
+            return orig_np_zeros(size, dtype)
+
+    monkeypatch.setattr(np, "zeros", _patched_zeros)
+
+    with pytest.raises(Exception, match="^Test exception$"):
+        pd.read_sas(datapath("io", "sas", "data", test_file))
+
+
+def test_exception_propagation_rle_decompress(tmp_path, datapath):
+    """Illegal control byte in RLE decompressor should raise the correct ValueError."""
+    with open(datapath("io", "sas", "data", "test2.sas7bdat"), "rb") as f:
+        data = bytearray(f.read())
+    invalid_control_byte = 0x10
+    page_offset = 0x10000
+    control_byte_pos = 55229
+    data[page_offset + control_byte_pos] = invalid_control_byte
+    tmp_file = tmp_path / "test2.sas7bdat"
+    tmp_file.write_bytes(data)
+    with pytest.raises(ValueError, match="unknown control byte"):
+        pd.read_sas(tmp_file)
+
+
+def test_0x40_control_byte(datapath):
+    # GH 31243
+    fname = datapath("io", "sas", "data", "0x40controlbyte.sas7bdat")
+    df = pd.read_sas(fname, encoding="ascii")
+    fname = datapath("io", "sas", "data", "0x40controlbyte.csv")
+    df0 = pd.read_csv(fname, dtype="object")
+    tm.assert_frame_equal(df, df0)
+
+
+def test_0x00_control_byte(datapath):
+    # GH 47099
+    fname = datapath("io", "sas", "data", "0x00controlbyte.sas7bdat.bz2")
+    df = next(pd.read_sas(fname, chunksize=11_000))
+    assert df.shape == (11_000, 20)
diff --git a/pandas/tests/io/sas/test_xport.py b/pandas/tests/io/sas/test_xport.py
index 9232ea8a25e4d..2046427deeaf0 100644
--- a/pandas/tests/io/sas/test_xport.py
+++ b/pandas/tests/io/sas/test_xport.py
@@ -1,5 +1,3 @@
-import os
-
 import numpy as np
 import pytest
 
@@ -24,113 +22,122 @@ def numeric_as_float(data):
 
 class TestXport:
     @pytest.fixture(autouse=True)
-    def setup_method(self, datapath):
-        self.dirpath = datapath("io", "sas", "data")
-        self.file01 = os.path.join(self.dirpath, "DEMO_G.xpt")
-        self.file02 = os.path.join(self.dirpath, "SSHSV1_A.xpt")
-        self.file03 = os.path.join(self.dirpath, "DRXFCD_G.xpt")
-        self.file04 = os.path.join(self.dirpath, "paxraw_d_short.xpt")
-        self.file05 = os.path.join(self.dirpath, "DEMO_PUF.cpt")
-
+    def setup_method(self):
         with td.file_leak_context():
             yield
 
+    @pytest.fixture
+    def file01(self, datapath):
+        return datapath("io", "sas", "data", "DEMO_G.xpt")
+
+    @pytest.fixture
+    def file02(self, datapath):
+        return datapath("io", "sas", "data", "SSHSV1_A.xpt")
+
+    @pytest.fixture
+    def file03(self, datapath):
+        return datapath("io", "sas", "data", "DRXFCD_G.xpt")
+
+    @pytest.fixture
+    def file04(self, datapath):
+        return datapath("io", "sas", "data", "paxraw_d_short.xpt")
+
+    @pytest.fixture
+    def file05(self, datapath):
+        return datapath("io", "sas", "data", "DEMO_PUF.cpt")
+
     @pytest.mark.slow
-    def test1_basic(self):
+    def test1_basic(self, file01):
         # Tests with DEMO_G.xpt (all numeric file)
 
         # Compare to this
-        data_csv = pd.read_csv(self.file01.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
 
         # Read full file
-        data = read_sas(self.file01, format="xport")
+        data = read_sas(file01, format="xport")
         tm.assert_frame_equal(data, data_csv)
         num_rows = data.shape[0]
 
         # Test reading beyond end of file
-        with read_sas(self.file01, format="xport", iterator=True) as reader:
+        with read_sas(file01, format="xport", iterator=True) as reader:
             data = reader.read(num_rows + 100)
         assert data.shape[0] == num_rows
 
         # Test incremental read with `read` method.
-        with read_sas(self.file01, format="xport", iterator=True) as reader:
+        with read_sas(file01, format="xport", iterator=True) as reader:
             data = reader.read(10)
         tm.assert_frame_equal(data, data_csv.iloc[0:10, :])
 
         # Test incremental read with `get_chunk` method.
-        with read_sas(self.file01, format="xport", chunksize=10) as reader:
+        with read_sas(file01, format="xport", chunksize=10) as reader:
             data = reader.get_chunk()
         tm.assert_frame_equal(data, data_csv.iloc[0:10, :])
 
         # Test read in loop
         m = 0
-        with read_sas(self.file01, format="xport", chunksize=100) as reader:
+        with read_sas(file01, format="xport", chunksize=100) as reader:
             for x in reader:
                 m += x.shape[0]
         assert m == num_rows
 
         # Read full file with `read_sas` method
-        data = read_sas(self.file01)
+        data = read_sas(file01)
         tm.assert_frame_equal(data, data_csv)
 
-    def test1_index(self):
+    def test1_index(self, file01):
         # Tests with DEMO_G.xpt using index (all numeric file)
 
         # Compare to this
-        data_csv = pd.read_csv(self.file01.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         data_csv = data_csv.set_index("SEQN")
         numeric_as_float(data_csv)
 
         # Read full file
-        data = read_sas(self.file01, index="SEQN", format="xport")
+        data = read_sas(file01, index="SEQN", format="xport")
         tm.assert_frame_equal(data, data_csv, check_index_type=False)
 
         # Test incremental read with `read` method.
-        with read_sas(
-            self.file01, index="SEQN", format="xport", iterator=True
-        ) as reader:
+        with read_sas(file01, index="SEQN", format="xport", iterator=True) as reader:
             data = reader.read(10)
         tm.assert_frame_equal(data, data_csv.iloc[0:10, :], check_index_type=False)
 
         # Test incremental read with `get_chunk` method.
-        with read_sas(
-            self.file01, index="SEQN", format="xport", chunksize=10
-        ) as reader:
+        with read_sas(file01, index="SEQN", format="xport", chunksize=10) as reader:
             data = reader.get_chunk()
         tm.assert_frame_equal(data, data_csv.iloc[0:10, :], check_index_type=False)
 
-    def test1_incremental(self):
+    def test1_incremental(self, file01):
         # Test with DEMO_G.xpt, reading full file incrementally
 
-        data_csv = pd.read_csv(self.file01.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         data_csv = data_csv.set_index("SEQN")
         numeric_as_float(data_csv)
 
-        with read_sas(self.file01, index="SEQN", chunksize=1000) as reader:
+        with read_sas(file01, index="SEQN", chunksize=1000) as reader:
             all_data = list(reader)
         data = pd.concat(all_data, axis=0)
 
         tm.assert_frame_equal(data, data_csv, check_index_type=False)
 
-    def test2(self):
+    def test2(self, file02):
         # Test with SSHSV1_A.xpt
 
         # Compare to this
-        data_csv = pd.read_csv(self.file02.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
 
-        data = read_sas(self.file02)
+        data = read_sas(file02)
         tm.assert_frame_equal(data, data_csv)
 
-    def test2_binary(self):
+    def test2_binary(self, file02):
         # Test with SSHSV1_A.xpt, read as a binary file
 
         # Compare to this
-        data_csv = pd.read_csv(self.file02.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
 
-        with open(self.file02, "rb") as fd:
+        with open(file02, "rb") as fd:
             with td.file_leak_context():
                 # GH#35693 ensure that if we pass an open file, we
                 #  dont incorrectly close it in read_sas
@@ -138,31 +145,31 @@ def test2_binary(self):
 
         tm.assert_frame_equal(data, data_csv)
 
-    def test_multiple_types(self):
+    def test_multiple_types(self, file03):
         # Test with DRXFCD_G.xpt (contains text and numeric variables)
 
         # Compare to this
-        data_csv = pd.read_csv(self.file03.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file03.replace(".xpt", ".csv"))
 
-        data = read_sas(self.file03, encoding="utf-8")
+        data = read_sas(file03, encoding="utf-8")
         tm.assert_frame_equal(data, data_csv)
 
-    def test_truncated_float_support(self):
+    def test_truncated_float_support(self, file04):
         # Test with paxraw_d_short.xpt, a shortened version of:
         # http://wwwn.cdc.gov/Nchs/Nhanes/2005-2006/PAXRAW_D.ZIP
         # This file has truncated floats (5 bytes in this case).
 
         # GH 11713
 
-        data_csv = pd.read_csv(self.file04.replace(".xpt", ".csv"))
+        data_csv = pd.read_csv(file04.replace(".xpt", ".csv"))
 
-        data = read_sas(self.file04, format="xport")
+        data = read_sas(file04, format="xport")
         tm.assert_frame_equal(data.astype("int64"), data_csv)
 
-    def test_cport_header_found_raises(self):
+    def test_cport_header_found_raises(self, file05):
         # Test with DEMO_PUF.cpt, the beginning of puf2019_1_fall.xpt
         # from https://www.cms.gov/files/zip/puf2019.zip
         # (despite the extension, it's a cpt file)
         msg = "Header record indicates a CPORT file, which is not readable."
         with pytest.raises(ValueError, match=msg):
-            read_sas(self.file05, format="xport")
+            read_sas(file05, format="xport")
diff --git a/pandas/tests/io/test_clipboard.py b/pandas/tests/io/test_clipboard.py
index 40b2eb1f4114b..db85cb416145f 100644
--- a/pandas/tests/io/test_clipboard.py
+++ b/pandas/tests/io/test_clipboard.py
@@ -3,6 +3,11 @@
 import numpy as np
 import pytest
 
+from pandas.errors import (
+    PyperclipException,
+    PyperclipWindowsException,
+)
+
 from pandas import (
     DataFrame,
     get_option,
@@ -11,6 +16,8 @@
 import pandas._testing as tm
 
 from pandas.io.clipboard import (
+    CheckedCall,
+    _stringifyText,
     clipboard_get,
     clipboard_set,
 )
@@ -110,6 +117,81 @@ def df(request):
         raise ValueError
 
 
+@pytest.fixture
+def mock_ctypes(monkeypatch):
+    """
+    Mocks WinError to help with testing the clipboard.
+    """
+
+    def _mock_win_error():
+        return "Window Error"
+
+    # Set raising to False because WinError won't exist on non-windows platforms
+    with monkeypatch.context() as m:
+        m.setattr("ctypes.WinError", _mock_win_error, raising=False)
+        yield
+
+
+@pytest.mark.usefixtures("mock_ctypes")
+def test_checked_call_with_bad_call(monkeypatch):
+    """
+    Give CheckCall a function that returns a falsey value and
+    mock get_errno so it returns false so an exception is raised.
+    """
+
+    def _return_false():
+        return False
+
+    monkeypatch.setattr("pandas.io.clipboard.get_errno", lambda: True)
+    msg = f"Error calling {_return_false.__name__} \\(Window Error\\)"
+
+    with pytest.raises(PyperclipWindowsException, match=msg):
+        CheckedCall(_return_false)()
+
+
+@pytest.mark.usefixtures("mock_ctypes")
+def test_checked_call_with_valid_call(monkeypatch):
+    """
+    Give CheckCall a function that returns a truthy value and
+    mock get_errno so it returns true so an exception is not raised.
+    The function should return the results from _return_true.
+    """
+
+    def _return_true():
+        return True
+
+    monkeypatch.setattr("pandas.io.clipboard.get_errno", lambda: False)
+
+    # Give CheckedCall a callable that returns a truthy value s
+    checked_call = CheckedCall(_return_true)
+    assert checked_call() is True
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "String_test",
+        True,
+        1,
+        1.0,
+        1j,
+    ],
+)
+def test_stringify_text(text):
+    valid_types = (str, int, float, bool)
+
+    if isinstance(text, valid_types):
+        result = _stringifyText(text)
+        assert result == str(text)
+    else:
+        msg = (
+            "only str, int, float, and bool values "
+            f"can be copied to the clipboard, not {type(text).__name__}"
+        )
+        with pytest.raises(PyperclipException, match=msg):
+            _stringifyText(text)
+
+
 @pytest.fixture
 def mock_clipboard(monkeypatch, request):
     """Fixture mocking clipboard IO.
@@ -148,7 +230,7 @@ def test_mock_clipboard(mock_clipboard):
     assert result == "abc"
 
 
-@pytest.mark.single
+@pytest.mark.single_cpu
 @pytest.mark.clipboard
 @pytest.mark.usefixtures("mock_clipboard")
 class TestClipboard:
@@ -176,7 +258,11 @@ def test_round_trip_frame_string(self, df):
     # Two character separator is not supported in to_clipboard
     # Test that multi-character separators are not silently passed
     def test_excel_sep_warning(self, df):
-        with tm.assert_produces_warning():
+        with tm.assert_produces_warning(
+            UserWarning,
+            match="to_clipboard in excel mode requires a single character separator.",
+            check_stacklevel=False,
+        ):
             df.to_clipboard(excel=True, sep=r"\t")
 
     # Separator is ignored when excel=False and should produce a warning
@@ -209,9 +295,9 @@ def test_read_clipboard_infer_excel(self, request, mock_clipboard):
 
         text = dedent(
             """
-            John James	Charlie Mingus
-            1	2
-            4	Harry Carney
+            John James\tCharlie Mingus
+            1\t2
+            4\tHarry Carney
             """.strip()
         )
         mock_clipboard[request.node.name] = text
@@ -303,11 +389,13 @@ def test_invalid_encoding(self, df):
     def test_round_trip_valid_encodings(self, enc, df):
         self.check_round_trip_frame(df, encoding=enc)
 
-
-@pytest.mark.single
-@pytest.mark.clipboard
-@pytest.mark.parametrize("data", ["\U0001f44d...", "Ωœ∑´...", "abcd..."])
-def test_raw_roundtrip(data):
-    # PR #25040 wide unicode wasn't copied correctly on PY3 on windows
-    clipboard_set(data)
-    assert data == clipboard_get()
+    @pytest.mark.parametrize("data", ["\U0001f44d...", "Ωœ∑´...", "abcd..."])
+    @pytest.mark.xfail(
+        reason="Flaky test in multi-process CI environment: GH 44584",
+        raises=AssertionError,
+        strict=False,
+    )
+    def test_raw_roundtrip(self, data):
+        # PR #25040 wide unicode wasn't copied correctly on PY3 on windows
+        clipboard_set(data)
+        assert data == clipboard_get()
diff --git a/pandas/tests/io/test_common.py b/pandas/tests/io/test_common.py
index b458f3351c860..e9e99f6dd0ad7 100644
--- a/pandas/tests/io/test_common.py
+++ b/pandas/tests/io/test_common.py
@@ -28,7 +28,7 @@
 class CustomFSPath:
     """For testing fspath on unknown objects"""
 
-    def __init__(self, path):
+    def __init__(self, path) -> None:
         self.path = path
 
     def __fspath__(self):
@@ -187,7 +187,7 @@ def test_iterator(self):
             (pd.read_hdf, "tables", FileNotFoundError, "h5"),
             (pd.read_stata, "os", FileNotFoundError, "dta"),
             (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
-            (pd.read_json, "os", ValueError, "json"),
+            (pd.read_json, "os", FileNotFoundError, "json"),
             (pd.read_pickle, "os", FileNotFoundError, "pickle"),
         ],
     )
@@ -195,23 +195,23 @@ def test_read_non_existent(self, reader, module, error_class, fn_ext):
         pytest.importorskip(module)
 
         path = os.path.join(HERE, "data", "does_not_exist." + fn_ext)
-        msg1 = fr"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
-        msg2 = fr"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
+        msg1 = rf"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
+        msg2 = rf"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
         msg3 = "Expected object or value"
         msg4 = "path_or_buf needs to be a string file path or file-like"
         msg5 = (
-            fr"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
-            fr"'.+does_not_exist\.{fn_ext}'"
+            rf"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
+            rf"'.+does_not_exist\.{fn_ext}'"
         )
-        msg6 = fr"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
+        msg6 = rf"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
         msg7 = (
-            fr"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
+            rf"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
         )
-        msg8 = fr"Failed to open local file.+does_not_exist\.{fn_ext}"
+        msg8 = rf"Failed to open local file.+does_not_exist\.{fn_ext}"
 
         with pytest.raises(
             error_class,
-            match=fr"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
+            match=rf"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
         ):
             reader(path)
 
@@ -253,7 +253,7 @@ def test_write_missing_parent_directory(self, method, module, error_class, fn_ex
             (pd.read_hdf, "tables", FileNotFoundError, "h5"),
             (pd.read_stata, "os", FileNotFoundError, "dta"),
             (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
-            (pd.read_json, "os", ValueError, "json"),
+            (pd.read_json, "os", FileNotFoundError, "json"),
             (pd.read_pickle, "os", FileNotFoundError, "pickle"),
         ],
     )
@@ -265,23 +265,23 @@ def test_read_expands_user_home_dir(
         path = os.path.join("~", "does_not_exist." + fn_ext)
         monkeypatch.setattr(icom, "_expand_user", lambda x: os.path.join("foo", x))
 
-        msg1 = fr"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
-        msg2 = fr"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
+        msg1 = rf"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
+        msg2 = rf"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
         msg3 = "Unexpected character found when decoding 'false'"
         msg4 = "path_or_buf needs to be a string file path or file-like"
         msg5 = (
-            fr"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
-            fr"'.+does_not_exist\.{fn_ext}'"
+            rf"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
+            rf"'.+does_not_exist\.{fn_ext}'"
         )
-        msg6 = fr"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
+        msg6 = rf"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
         msg7 = (
-            fr"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
+            rf"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
         )
-        msg8 = fr"Failed to open local file.+does_not_exist\.{fn_ext}"
+        msg8 = rf"Failed to open local file.+does_not_exist\.{fn_ext}"
 
         with pytest.raises(
             error_class,
-            match=fr"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
+            match=rf"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
         ):
             reader(path)
 
@@ -413,39 +413,31 @@ def test_constructor_bad_file(self, mmap_file):
             err = mmap.error
 
         with pytest.raises(err, match=msg):
-            icom._MMapWrapper(non_file)
+            icom._maybe_memory_map(non_file, True)
 
-        target = open(mmap_file)
-        target.close()
+        with open(mmap_file) as target:
+            pass
 
         msg = "I/O operation on closed file"
         with pytest.raises(ValueError, match=msg):
-            icom._MMapWrapper(target)
-
-    def test_get_attr(self, mmap_file):
-        with open(mmap_file) as target:
-            wrapper = icom._MMapWrapper(target)
-
-        attrs = dir(wrapper.mmap)
-        attrs = [attr for attr in attrs if not attr.startswith("__")]
-        attrs.append("__next__")
-
-        for attr in attrs:
-            assert hasattr(wrapper, attr)
-
-        assert not hasattr(wrapper, "foo")
+            icom._maybe_memory_map(target, True)
 
     def test_next(self, mmap_file):
         with open(mmap_file) as target:
-            wrapper = icom._MMapWrapper(target)
             lines = target.readlines()
 
-        for line in lines:
-            next_line = next(wrapper)
-            assert next_line.strip() == line.strip()
+            with icom.get_handle(
+                target, "r", is_text=True, memory_map=True
+            ) as wrappers:
+                wrapper = wrappers.handle
+                assert isinstance(wrapper.buffer.buffer, mmap.mmap)
 
-        with pytest.raises(StopIteration, match=r"^$"):
-            next(wrapper)
+                for line in lines:
+                    next_line = next(wrapper)
+                    assert next_line.strip() == line.strip()
+
+                with pytest.raises(StopIteration, match=r"^$"):
+                    next(wrapper)
 
     def test_unknown_engine(self):
         with tm.ensure_clean() as path:
@@ -600,3 +592,15 @@ def test_fail_mmap():
     with pytest.raises(UnsupportedOperation, match="fileno"):
         with BytesIO() as buffer:
             icom.get_handle(buffer, "rb", memory_map=True)
+
+
+def test_close_on_error():
+    # GH 47136
+    class TestError:
+        def close(self):
+            raise OSError("test")
+
+    with pytest.raises(OSError, match="test"):
+        with BytesIO() as buffer:
+            with icom.get_handle(buffer, "rb") as handles:
+                handles.created_handles.append(TestError())
diff --git a/pandas/tests/io/test_compression.py b/pandas/tests/io/test_compression.py
index 3c278cb48e20f..125d078ff39b1 100644
--- a/pandas/tests/io/test_compression.py
+++ b/pandas/tests/io/test_compression.py
@@ -1,18 +1,27 @@
+import gzip
 import io
 import os
 from pathlib import Path
 import subprocess
 import sys
+import tarfile
 import textwrap
 import time
+import zipfile
 
 import pytest
 
+from pandas.compat import is_platform_windows
+
 import pandas as pd
 import pandas._testing as tm
 
 import pandas.io.common as icom
 
+_compression_to_extension = {
+    value: key for key, value in icom._extension_to_compression.items()
+}
+
 
 @pytest.mark.parametrize(
     "obj",
@@ -26,6 +35,9 @@
 )
 @pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
 def test_compression_size(obj, method, compression_only):
+    if compression_only == "tar":
+        compression_only = {"method": "tar", "mode": "w:gz"}
+
     with tm.ensure_clean() as path:
         getattr(obj, method)(path, compression=compression_only)
         compressed_size = os.path.getsize(path)
@@ -47,7 +59,11 @@ def test_compression_size(obj, method, compression_only):
 @pytest.mark.parametrize("method", ["to_csv", "to_json"])
 def test_compression_size_fh(obj, method, compression_only):
     with tm.ensure_clean() as path:
-        with icom.get_handle(path, "w", compression=compression_only) as handles:
+        with icom.get_handle(
+            path,
+            "w:gz" if compression_only == "tar" else "w",
+            compression=compression_only,
+        ) as handles:
             getattr(obj, method)(handles.handle)
             assert not handles.handle.closed
         compressed_size = os.path.getsize(path)
@@ -72,7 +88,7 @@ def test_dataframe_compression_defaults_to_infer(
 ):
     # GH22004
     input = pd.DataFrame([[1.0, 0, -4], [3.4, 5, 2]], columns=["X", "Y", "Z"])
-    extension = icom._compression_to_extension[compression_only]
+    extension = _compression_to_extension[compression_only]
     with tm.ensure_clean("compressed" + extension) as path:
         getattr(input, write_method)(path, **write_kwargs)
         output = read_method(path, compression=compression_only)
@@ -92,7 +108,7 @@ def test_series_compression_defaults_to_infer(
 ):
     # GH22004
     input = pd.Series([0, 5, -2, 10], name="X")
-    extension = icom._compression_to_extension[compression_only]
+    extension = _compression_to_extension[compression_only]
     with tm.ensure_clean("compressed" + extension) as path:
         getattr(input, write_method)(path, **write_kwargs)
         if "squeeze" in read_kwargs:
@@ -255,3 +271,72 @@ def test_bzip_compression_level(obj, method):
     """
     with tm.ensure_clean() as path:
         getattr(obj, method)(path, compression={"method": "bz2", "compresslevel": 1})
+
+
+@pytest.mark.parametrize(
+    "suffix,archive",
+    [
+        (".zip", zipfile.ZipFile),
+        (".tar", tarfile.TarFile),
+    ],
+)
+def test_empty_archive_zip(suffix, archive):
+    with tm.ensure_clean(filename=suffix) as path:
+        file = archive(path, "w")
+        file.close()
+        with pytest.raises(ValueError, match="Zero files found"):
+            pd.read_csv(path)
+
+
+def test_ambiguous_archive_zip():
+    with tm.ensure_clean(filename=".zip") as path:
+        file = zipfile.ZipFile(path, "w")
+        file.writestr("a.csv", "foo,bar")
+        file.writestr("b.csv", "foo,bar")
+        file.close()
+        with pytest.raises(ValueError, match="Multiple files found in ZIP file"):
+            pd.read_csv(path)
+
+
+def test_ambiguous_archive_tar():
+    with tm.ensure_clean_dir() as dir:
+        csvAPath = os.path.join(dir, "a.csv")
+        with open(csvAPath, "w") as a:
+            a.write("foo,bar\n")
+        csvBPath = os.path.join(dir, "b.csv")
+        with open(csvBPath, "w") as b:
+            b.write("foo,bar\n")
+
+        tarpath = os.path.join(dir, "archive.tar")
+        with tarfile.TarFile(tarpath, "w") as tar:
+            tar.add(csvAPath, "a.csv")
+            tar.add(csvBPath, "b.csv")
+
+        with pytest.raises(ValueError, match="Multiple files found in TAR archive"):
+            pd.read_csv(tarpath)
+
+
+def test_tar_gz_to_different_filename():
+    with tm.ensure_clean(filename=".foo") as file:
+        pd.DataFrame(
+            [["1", "2"]],
+            columns=["foo", "bar"],
+        ).to_csv(file, compression={"method": "tar", "mode": "w:gz"}, index=False)
+        with gzip.open(file) as uncompressed:
+            with tarfile.TarFile(fileobj=uncompressed) as archive:
+                members = archive.getmembers()
+                assert len(members) == 1
+                content = archive.extractfile(members[0]).read().decode("utf8")
+
+                if is_platform_windows():
+                    expected = "foo,bar\r\n1,2\r\n"
+                else:
+                    expected = "foo,bar\n1,2\n"
+
+                assert content == expected
+
+
+def test_tar_no_error_on_close():
+    with io.BytesIO() as buffer:
+        with icom._BytesTarFile(fileobj=buffer, mode="w"):
+            pass
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index 15d41c56c13c1..236a7f9e1a9c1 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -2,8 +2,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat.pyarrow import pa_version_under2p0
-
 import pandas as pd
 import pandas._testing as tm
 
@@ -16,7 +14,7 @@
 
 
 @filter_sparse
-@pytest.mark.single
+@pytest.mark.single_cpu
 @pytest.mark.filterwarnings("ignore:CategoricalBlock is deprecated:DeprecationWarning")
 class TestFeather:
     def check_error_on_write(self, df, exc, err_msg):
@@ -87,11 +85,7 @@ def test_basic(self):
                 ),
             }
         )
-        if not pa_version_under2p0:
-            # older pyarrow incorrectly uses pandas internal API, so
-            #  constructs invalid Block
-            df["periods"] = pd.period_range("2013", freq="M", periods=3)
-
+        df["periods"] = pd.period_range("2013", freq="M", periods=3)
         df["timedeltas"] = pd.timedelta_range("1 day", periods=3)
         df["intervals"] = pd.interval_range(0, 3, 3)
 
@@ -187,11 +181,18 @@ def test_passthrough_keywords(self):
         df = tm.makeDataFrame().reset_index()
         self.check_round_trip(df, write_kwargs={"version": 1})
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+            "pandas/tests/io/data/feather/feather-0_3_1.feather"
+        ),
+        check_before_test=True,
+    )
     def test_http_path(self, feather_file):
         # GH 29055
         url = (
-            "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
             "pandas/tests/io/data/feather/feather-0_3_1.feather"
         )
         expected = read_feather(feather_file)
diff --git a/pandas/tests/io/test_fsspec.py b/pandas/tests/io/test_fsspec.py
index e3e8358aa6340..4f033fd63f978 100644
--- a/pandas/tests/io/test_fsspec.py
+++ b/pandas/tests/io/test_fsspec.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat._optional import VERSIONS
-
 from pandas import (
     DataFrame,
     date_range,
@@ -20,15 +18,17 @@
 import pandas._testing as tm
 from pandas.util import _test_decorators as td
 
-df1 = DataFrame(
-    {
-        "int": [1, 3],
-        "float": [2.0, np.nan],
-        "str": ["t", "s"],
-        "dt": date_range("2018-06-18", periods=2),
-    }
-)
-text = str(df1.to_csv(index=False)).encode()
+
+@pytest.fixture
+def df1():
+    return DataFrame(
+        {
+            "int": [1, 3],
+            "float": [2.0, np.nan],
+            "str": ["t", "s"],
+            "dt": date_range("2018-06-18", periods=2),
+        }
+    )
 
 
 @pytest.fixture
@@ -40,7 +40,8 @@ def cleared_fs():
     memfs.store.clear()
 
 
-def test_read_csv(cleared_fs):
+def test_read_csv(cleared_fs, df1):
+    text = str(df1.to_csv(index=False)).encode()
     with cleared_fs.open("test/test.csv", "wb") as w:
         w.write(text)
     df2 = read_csv("memory://test/test.csv", parse_dates=["dt"])
@@ -65,7 +66,7 @@ def test_reasonable_error(monkeypatch, cleared_fs):
         read_csv("couldexist://test/test.csv")
 
 
-def test_to_csv(cleared_fs):
+def test_to_csv(cleared_fs, df1):
     df1.to_csv("memory://test/test.csv", index=True)
 
     df2 = read_csv("memory://test/test.csv", parse_dates=["dt"], index_col=0)
@@ -74,7 +75,7 @@ def test_to_csv(cleared_fs):
 
 
 @pytest.mark.parametrize("ext", ["xls", "xlsx"])
-def test_to_excel(cleared_fs, ext):
+def test_to_excel(cleared_fs, ext, df1):
     if ext == "xls":
         pytest.importorskip("xlwt")
     else:
@@ -89,7 +90,7 @@ def test_to_excel(cleared_fs, ext):
 
 
 @pytest.mark.parametrize("binary_mode", [False, True])
-def test_to_csv_fsspec_object(cleared_fs, binary_mode):
+def test_to_csv_fsspec_object(cleared_fs, binary_mode, df1):
     fsspec = pytest.importorskip("fsspec")
 
     path = "memory://test/test.csv"
@@ -153,14 +154,14 @@ def test_excel_options(fsspectest, extension):
 
 
 @td.skip_if_no("fastparquet")
-def test_to_parquet_new_file(monkeypatch, cleared_fs):
+def test_to_parquet_new_file(cleared_fs, df1):
     """Regression test for writing to a not-yet-existent GCS Parquet file."""
     df1.to_parquet(
         "memory://test/test.csv", index=True, engine="fastparquet", compression=None
     )
 
 
-@td.skip_if_no("pyarrow")
+@td.skip_if_no("pyarrow", min_version="2")
 def test_arrowparquet_options(fsspectest):
     """Regression test for writing to a not-yet-existent GCS Parquet file."""
     df = DataFrame({"a": [0]})
@@ -199,6 +200,7 @@ def test_fastparquet_options(fsspectest):
     assert fsspectest.test[0] == "parquet_read"
 
 
+@pytest.mark.single_cpu
 @td.skip_if_no("s3fs")
 def test_from_s3_csv(s3_resource, tips_file, s3so):
     tm.assert_equal(
@@ -215,6 +217,7 @@ def test_from_s3_csv(s3_resource, tips_file, s3so):
     )
 
 
+@pytest.mark.single_cpu
 @pytest.mark.parametrize("protocol", ["s3", "s3a", "s3n"])
 @td.skip_if_no("s3fs")
 def test_s3_protocols(s3_resource, tips_file, protocol, s3so):
@@ -224,10 +227,11 @@ def test_s3_protocols(s3_resource, tips_file, protocol, s3so):
     )
 
 
+@pytest.mark.single_cpu
 @td.skip_array_manager_not_yet_implemented  # TODO(ArrayManager) fastparquet
 @td.skip_if_no("s3fs")
 @td.skip_if_no("fastparquet")
-def test_s3_parquet(s3_resource, s3so):
+def test_s3_parquet(s3_resource, s3so, df1):
     fn = "s3://pandas-test/test.parquet"
     df1.to_parquet(
         fn, index=False, engine="fastparquet", compression=None, storage_options=s3so
@@ -291,21 +295,7 @@ def test_stata_options(fsspectest):
 
 
 @td.skip_if_no("tabulate")
-def test_markdown_options(request, fsspectest):
-    import fsspec
-
-    # error: Library stubs not installed for "tabulate"
-    # (or incompatible with Python 3.8)
-    import tabulate  # type: ignore[import]
-
-    request.node.add_marker(
-        pytest.mark.xfail(
-            fsspec.__version__ == VERSIONS["fsspec"]
-            and tabulate.__version__ == VERSIONS["tabulate"],
-            reason="Fails on the min version build",
-            raises=FileNotFoundError,
-        )
-    )
+def test_markdown_options(fsspectest):
     df = DataFrame({"a": [0]})
     df.to_markdown("testmem://afile", storage_options={"test": "md_write"})
     assert fsspectest.test[0] == "md_write"
diff --git a/pandas/tests/io/test_gcs.py b/pandas/tests/io/test_gcs.py
index 5e0da6f3ab3bb..6907d8978e603 100644
--- a/pandas/tests/io/test_gcs.py
+++ b/pandas/tests/io/test_gcs.py
@@ -1,5 +1,6 @@
 from io import BytesIO
 import os
+import tarfile
 import zipfile
 
 import numpy as np
@@ -14,10 +15,9 @@
     read_parquet,
 )
 import pandas._testing as tm
+from pandas.tests.io.test_compression import _compression_to_extension
 from pandas.util import _test_decorators as td
 
-import pandas.io.common as icom
-
 
 @pytest.fixture
 def gcs_buffer(monkeypatch):
@@ -106,6 +106,18 @@ def assert_equal_zip_safe(result: bytes, expected: bytes, compression: str):
         ) as res:
             for res_info, exp_info in zip(res.infolist(), exp.infolist()):
                 assert res_info.CRC == exp_info.CRC
+    elif compression == "tar":
+        with tarfile.open(fileobj=BytesIO(result)) as tar_exp, tarfile.open(
+            fileobj=BytesIO(expected)
+        ) as tar_res:
+            for tar_res_info, tar_exp_info in zip(
+                tar_res.getmembers(), tar_exp.getmembers()
+            ):
+                actual_file = tar_res.extractfile(tar_res_info)
+                expected_file = tar_exp.extractfile(tar_exp_info)
+                assert (actual_file is None) == (expected_file is None)
+                if actual_file is not None and expected_file is not None:
+                    assert actual_file.read() == expected_file.read()
     else:
         assert result == expected
 
@@ -144,7 +156,7 @@ def test_to_csv_compression_encoding_gcs(gcs_buffer, compression_only, encoding)
     tm.assert_frame_equal(df, read_df)
 
     # write compressed file with implicit compression
-    file_ext = icom._compression_to_extension[compression_only]
+    file_ext = _compression_to_extension[compression_only]
     compression["method"] = "infer"
     path_gcs += f".{file_ext}"
     df.to_csv(path_gcs, compression=compression, encoding=encoding)
diff --git a/pandas/tests/io/test_html.py b/pandas/tests/io/test_html.py
index 3aac7e95e6591..de0d4c1b49ea5 100644
--- a/pandas/tests/io/test_html.py
+++ b/pandas/tests/io/test_html.py
@@ -31,8 +31,6 @@
 import pandas.io.html
 from pandas.io.html import read_html
 
-HERE = os.path.dirname(__file__)
-
 
 @pytest.fixture(
     params=[
@@ -105,15 +103,16 @@ def test_same_ordering(datapath):
     scope="class",
 )
 class TestReadHtml:
-    @pytest.fixture(autouse=True)
-    def set_files(self, datapath):
-        self.spam_data = datapath("io", "data", "html", "spam.html")
-        self.spam_data_kwargs = {}
-        self.spam_data_kwargs["encoding"] = "UTF-8"
-        self.banklist_data = datapath("io", "data", "html", "banklist.html")
+    @pytest.fixture
+    def spam_data(self, datapath):
+        return datapath("io", "data", "html", "spam.html")
+
+    @pytest.fixture
+    def banklist_data(self, datapath):
+        return datapath("io", "data", "html", "banklist.html")
 
     @pytest.fixture(autouse=True, scope="function")
-    def set_defaults(self, flavor, request):
+    def set_defaults(self, flavor):
         self.read_html = partial(read_html, flavor=flavor)
         yield
 
@@ -133,9 +132,16 @@ def test_to_html_compat(self):
         res = self.read_html(out, attrs={"class": "dataframe"}, index_col=0)[0]
         tm.assert_frame_equal(res, df)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://www.fdic.gov/resources/resolutions/"
+            "bank-failures/failed-bank-list/index.html"
+        ),
+        check_before_test=True,
+    )
     def test_banklist_url_positional_match(self):
-        url = "http://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list/index.html"  # noqa E501
+        url = "https://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list/index.html"  # noqa E501
         # Passing match argument as positional should cause a FutureWarning.
         with tm.assert_produces_warning(FutureWarning):
             df1 = self.read_html(
@@ -152,9 +158,16 @@ def test_banklist_url_positional_match(self):
 
         assert_framelist_equal(df1, df2)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://www.fdic.gov/resources/resolutions/"
+            "bank-failures/failed-bank-list/index.html"
+        ),
+        check_before_test=True,
+    )
     def test_banklist_url(https://github.com/self):
-        url = "http://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list/index.html"  # noqa E501
+        url = "https://www.fdic.gov/resources/resolutions/bank-failures/failed-bank-list/index.html"  # noqa E501
         df1 = self.read_html(
             # lxml cannot find attrs leave out for now
             url,
@@ -168,10 +181,17 @@ def test_banklist_url(https://github.com/self):
 
         assert_framelist_equal(df1, df2)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+            "pandas/tests/io/data/html/spam.html"
+        ),
+        check_before_test=True,
+    )
     def test_spam_url(https://github.com/self):
         url = (
-            "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
             "pandas/tests/io/data/html/spam.html"
         )
         df1 = self.read_html(url, match=".*Water.*")
@@ -180,126 +200,122 @@ def test_spam_url(https://github.com/self):
         assert_framelist_equal(df1, df2)
 
     @pytest.mark.slow
-    def test_banklist(self):
-        df1 = self.read_html(
-            self.banklist_data, match=".*Florida.*", attrs={"id": "table"}
-        )
-        df2 = self.read_html(
-            self.banklist_data, match="Metcalf Bank", attrs={"id": "table"}
-        )
+    def test_banklist(self, banklist_data):
+        df1 = self.read_html(banklist_data, match=".*Florida.*", attrs={"id": "table"})
+        df2 = self.read_html(banklist_data, match="Metcalf Bank", attrs={"id": "table"})
 
         assert_framelist_equal(df1, df2)
 
-    def test_spam(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*")
-        df2 = self.read_html(self.spam_data, match="Unit")
+    def test_spam(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*")
+        df2 = self.read_html(spam_data, match="Unit")
         assert_framelist_equal(df1, df2)
 
         assert df1[0].iloc[0, 0] == "Proximates"
         assert df1[0].columns[0] == "Nutrient"
 
-    def test_spam_no_match(self):
-        dfs = self.read_html(self.spam_data)
+    def test_spam_no_match(self, spam_data):
+        dfs = self.read_html(spam_data)
         for df in dfs:
             assert isinstance(df, DataFrame)
 
-    def test_banklist_no_match(self):
-        dfs = self.read_html(self.banklist_data, attrs={"id": "table"})
+    def test_banklist_no_match(self, banklist_data):
+        dfs = self.read_html(banklist_data, attrs={"id": "table"})
         for df in dfs:
             assert isinstance(df, DataFrame)
 
-    def test_spam_header(self):
-        df = self.read_html(self.spam_data, match=".*Water.*", header=2)[0]
+    def test_spam_header(self, spam_data):
+        df = self.read_html(spam_data, match=".*Water.*", header=2)[0]
         assert df.columns[0] == "Proximates"
         assert not df.empty
 
-    def test_skiprows_int(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=1)
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=1)
+    def test_skiprows_int(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=1)
+        df2 = self.read_html(spam_data, match="Unit", skiprows=1)
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_range(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=range(2))
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=range(2))
+    def test_skiprows_range(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=range(2))
+        df2 = self.read_html(spam_data, match="Unit", skiprows=range(2))
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_list(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=[1, 2])
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=[2, 1])
+    def test_skiprows_list(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=[1, 2])
+        df2 = self.read_html(spam_data, match="Unit", skiprows=[2, 1])
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_set(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows={1, 2})
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows={2, 1})
+    def test_skiprows_set(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows={1, 2})
+        df2 = self.read_html(spam_data, match="Unit", skiprows={2, 1})
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_slice(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=1)
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=1)
+    def test_skiprows_slice(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=1)
+        df2 = self.read_html(spam_data, match="Unit", skiprows=1)
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_slice_short(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=slice(2))
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=slice(2))
+    def test_skiprows_slice_short(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=slice(2))
+        df2 = self.read_html(spam_data, match="Unit", skiprows=slice(2))
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_slice_long(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=slice(2, 5))
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=slice(4, 1, -1))
+    def test_skiprows_slice_long(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=slice(2, 5))
+        df2 = self.read_html(spam_data, match="Unit", skiprows=slice(4, 1, -1))
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_ndarray(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", skiprows=np.arange(2))
-        df2 = self.read_html(self.spam_data, match="Unit", skiprows=np.arange(2))
+    def test_skiprows_ndarray(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", skiprows=np.arange(2))
+        df2 = self.read_html(spam_data, match="Unit", skiprows=np.arange(2))
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_invalid(self):
+    def test_skiprows_invalid(self, spam_data):
         with pytest.raises(TypeError, match=("is not a valid type for skipping rows")):
-            self.read_html(self.spam_data, match=".*Water.*", skiprows="asdf")
+            self.read_html(spam_data, match=".*Water.*", skiprows="asdf")
 
-    def test_index(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", index_col=0)
-        df2 = self.read_html(self.spam_data, match="Unit", index_col=0)
+    def test_index(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", index_col=0)
+        df2 = self.read_html(spam_data, match="Unit", index_col=0)
         assert_framelist_equal(df1, df2)
 
-    def test_header_and_index_no_types(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", header=1, index_col=0)
-        df2 = self.read_html(self.spam_data, match="Unit", header=1, index_col=0)
+    def test_header_and_index_no_types(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", header=1, index_col=0)
+        df2 = self.read_html(spam_data, match="Unit", header=1, index_col=0)
         assert_framelist_equal(df1, df2)
 
-    def test_header_and_index_with_types(self):
-        df1 = self.read_html(self.spam_data, match=".*Water.*", header=1, index_col=0)
-        df2 = self.read_html(self.spam_data, match="Unit", header=1, index_col=0)
+    def test_header_and_index_with_types(self, spam_data):
+        df1 = self.read_html(spam_data, match=".*Water.*", header=1, index_col=0)
+        df2 = self.read_html(spam_data, match="Unit", header=1, index_col=0)
         assert_framelist_equal(df1, df2)
 
-    def test_infer_types(self):
+    def test_infer_types(self, spam_data):
 
         # 10892 infer_types removed
-        df1 = self.read_html(self.spam_data, match=".*Water.*", index_col=0)
-        df2 = self.read_html(self.spam_data, match="Unit", index_col=0)
+        df1 = self.read_html(spam_data, match=".*Water.*", index_col=0)
+        df2 = self.read_html(spam_data, match="Unit", index_col=0)
         assert_framelist_equal(df1, df2)
 
-    def test_string_io(self):
-        with open(self.spam_data, **self.spam_data_kwargs) as f:
+    def test_string_io(self, spam_data):
+        with open(spam_data, encoding="UTF-8") as f:
             data1 = StringIO(f.read())
 
-        with open(self.spam_data, **self.spam_data_kwargs) as f:
+        with open(spam_data, encoding="UTF-8") as f:
             data2 = StringIO(f.read())
 
         df1 = self.read_html(data1, match=".*Water.*")
         df2 = self.read_html(data2, match="Unit")
         assert_framelist_equal(df1, df2)
 
-    def test_string(self):
-        with open(self.spam_data, **self.spam_data_kwargs) as f:
+    def test_string(self, spam_data):
+        with open(spam_data, encoding="UTF-8") as f:
             data = f.read()
 
         df1 = self.read_html(data, match=".*Water.*")
@@ -307,22 +323,24 @@ def test_string(self):
 
         assert_framelist_equal(df1, df2)
 
-    def test_file_like(self):
-        with open(self.spam_data, **self.spam_data_kwargs) as f:
+    def test_file_like(self, spam_data):
+        with open(spam_data, encoding="UTF-8") as f:
             df1 = self.read_html(f, match=".*Water.*")
 
-        with open(self.spam_data, **self.spam_data_kwargs) as f:
+        with open(spam_data, encoding="UTF-8") as f:
             df2 = self.read_html(f, match="Unit")
 
         assert_framelist_equal(df1, df2)
 
+    @pytest.mark.network
     @tm.network
     def test_bad_url_protocol(self):
         with pytest.raises(URLError, match="urlopen error unknown url type: git"):
             self.read_html("git://github.com", match=".*Water.*")
 
-    @tm.network
     @pytest.mark.slow
+    @pytest.mark.network
+    @tm.network
     def test_invalid_url(https://github.com/self):
         msg = (
             "Name or service not known|Temporary failure in name resolution|"
@@ -332,8 +350,8 @@ def test_invalid_url(https://github.com/self):
             self.read_html("http://www.a23950sdfa908sd.com/", match=".*Water.*")
 
     @pytest.mark.slow
-    def test_file_url(https://github.com/self):
-        url = self.banklist_data
+    def test_file_url(https://github.com/self,%20banklist_data):
+        url = banklist_data
         dfs = self.read_html(
             file_path_to_url(https://github.com/os.path.abspath(url)), match="First", attrs={"id": "table"}
         )
@@ -342,53 +360,55 @@ def test_file_url(https://github.com/self):
             assert isinstance(df, DataFrame)
 
     @pytest.mark.slow
-    def test_invalid_table_attrs(self):
-        url = self.banklist_data
+    def test_invalid_table_attrs(self, banklist_data):
+        url = banklist_data
         with pytest.raises(ValueError, match="No tables found"):
             self.read_html(
                 url, match="First Federal Bank of Florida", attrs={"id": "tasdfable"}
             )
 
-    def _bank_data(self, *args, **kwargs):
+    def _bank_data(self, path, *args, **kwargs):
         return self.read_html(
-            self.banklist_data, match="Metcalf", attrs={"id": "table"}, *args, **kwargs
+            path, match="Metcalf", attrs={"id": "table"}, *args, **kwargs
         )
 
     @pytest.mark.slow
-    def test_multiindex_header(self):
-        df = self._bank_data(header=[0, 1])[0]
+    def test_multiindex_header(self, banklist_data):
+        df = self._bank_data(banklist_data, header=[0, 1])[0]
         assert isinstance(df.columns, MultiIndex)
 
     @pytest.mark.slow
-    def test_multiindex_index(self):
-        df = self._bank_data(index_col=[0, 1])[0]
+    def test_multiindex_index(self, banklist_data):
+        df = self._bank_data(banklist_data, index_col=[0, 1])[0]
         assert isinstance(df.index, MultiIndex)
 
     @pytest.mark.slow
-    def test_multiindex_header_index(self):
-        df = self._bank_data(header=[0, 1], index_col=[0, 1])[0]
+    def test_multiindex_header_index(self, banklist_data):
+        df = self._bank_data(banklist_data, header=[0, 1], index_col=[0, 1])[0]
         assert isinstance(df.columns, MultiIndex)
         assert isinstance(df.index, MultiIndex)
 
     @pytest.mark.slow
-    def test_multiindex_header_skiprows_tuples(self):
-        df = self._bank_data(header=[0, 1], skiprows=1)[0]
+    def test_multiindex_header_skiprows_tuples(self, banklist_data):
+        df = self._bank_data(banklist_data, header=[0, 1], skiprows=1)[0]
         assert isinstance(df.columns, MultiIndex)
 
     @pytest.mark.slow
-    def test_multiindex_header_skiprows(self):
-        df = self._bank_data(header=[0, 1], skiprows=1)[0]
+    def test_multiindex_header_skiprows(self, banklist_data):
+        df = self._bank_data(banklist_data, header=[0, 1], skiprows=1)[0]
         assert isinstance(df.columns, MultiIndex)
 
     @pytest.mark.slow
-    def test_multiindex_header_index_skiprows(self):
-        df = self._bank_data(header=[0, 1], index_col=[0, 1], skiprows=1)[0]
+    def test_multiindex_header_index_skiprows(self, banklist_data):
+        df = self._bank_data(
+            banklist_data, header=[0, 1], index_col=[0, 1], skiprows=1
+        )[0]
         assert isinstance(df.index, MultiIndex)
         assert isinstance(df.columns, MultiIndex)
 
     @pytest.mark.slow
-    def test_regex_idempotency(self):
-        url = self.banklist_data
+    def test_regex_idempotency(self, banklist_data):
+        url = banklist_data
         dfs = self.read_html(
             file_path_to_url(https://github.com/os.path.abspath(url)),
             match=re.compile(re.compile("Florida")),
@@ -398,18 +418,20 @@ def test_regex_idempotency(self):
         for df in dfs:
             assert isinstance(df, DataFrame)
 
-    def test_negative_skiprows(self):
+    def test_negative_skiprows(self, spam_data):
         msg = r"\(you passed a negative value\)"
         with pytest.raises(ValueError, match=msg):
-            self.read_html(self.spam_data, match="Water", skiprows=-1)
+            self.read_html(spam_data, match="Water", skiprows=-1)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(url="https://docs.python.org/2/", check_before_test=True)
     def test_multiple_matches(self):
         url = "https://docs.python.org/2/"
         dfs = self.read_html(url, match="Python")
         assert len(dfs) > 1
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(url="https://docs.python.org/2/", check_before_test=True)
     def test_python_docs_table(self):
         url = "https://docs.python.org/2/"
         dfs = self.read_html(url, match="Python")
@@ -589,7 +611,7 @@ def test_parse_header_of_non_string_column(self):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.slow
-    def test_banklist_header(self, datapath):
+    def test_banklist_header(self, banklist_data, datapath):
         from pandas.io.html import _remove_whitespace
 
         def try_remove_ws(x):
@@ -598,26 +620,24 @@ def try_remove_ws(x):
             except AttributeError:
                 return x
 
-        df = self.read_html(self.banklist_data, match="Metcalf", attrs={"id": "table"})[
-            0
-        ]
+        df = self.read_html(banklist_data, match="Metcalf", attrs={"id": "table"})[0]
         ground_truth = read_csv(
             datapath("io", "data", "csv", "banklist.csv"),
             converters={"Updated Date": Timestamp, "Closing Date": Timestamp},
         )
         assert df.shape == ground_truth.shape
         old = [
-            "First Vietnamese American BankIn Vietnamese",
-            "Westernbank Puerto RicoEn Espanol",
-            "R-G Premier Bank of Puerto RicoEn Espanol",
-            "EurobankEn Espanol",
-            "Sanderson State BankEn Espanol",
-            "Washington Mutual Bank(Including its subsidiary Washington "
+            "First Vietnamese American Bank In Vietnamese",
+            "Westernbank Puerto Rico En Espanol",
+            "R-G Premier Bank of Puerto Rico En Espanol",
+            "Eurobank En Espanol",
+            "Sanderson State Bank En Espanol",
+            "Washington Mutual Bank (Including its subsidiary Washington "
             "Mutual Bank FSB)",
-            "Silver State BankEn Espanol",
-            "AmTrade International BankEn Espanol",
-            "Hamilton Bank, NAEn Espanol",
-            "The Citizens Savings BankPioneer Community Bank, Inc.",
+            "Silver State Bank En Espanol",
+            "AmTrade International Bank En Espanol",
+            "Hamilton Bank, NA En Espanol",
+            "The Citizens Savings Bank Pioneer Community Bank, Inc.",
         ]
         new = [
             "First Vietnamese American Bank",
@@ -639,15 +659,15 @@ def try_remove_ws(x):
         tm.assert_frame_equal(converted, gtnew)
 
     @pytest.mark.slow
-    def test_gold_canyon(self):
+    def test_gold_canyon(self, banklist_data):
         gc = "Gold Canyon"
-        with open(self.banklist_data) as f:
+        with open(banklist_data) as f:
             raw_text = f.read()
 
         assert gc in raw_text
-        df = self.read_html(
-            self.banklist_data, match="Gold Canyon", attrs={"id": "table"}
-        )[0]
+        df = self.read_html(banklist_data, match="Gold Canyon", attrs={"id": "table"})[
+            0
+        ]
         assert gc in df.to_string()
 
     def test_different_number_of_cols(self):
@@ -966,16 +986,16 @@ def test_decimal_rows(self):
         assert result["Header"].dtype == np.dtype("float64")
         tm.assert_frame_equal(result, expected)
 
-    def test_bool_header_arg(self):
+    @pytest.mark.parametrize("arg", [True, False])
+    def test_bool_header_arg(self, spam_data, arg):
         # GH 6114
         msg = re.escape(
             "Passing a bool to header is invalid. Use header=None for no header or "
             "header=int or list-like of ints to specify the row(s) making up the "
             "column names"
         )
-        for arg in [True, False]:
-            with pytest.raises(TypeError, match=msg):
-                self.read_html(self.spam_data, header=arg)
+        with pytest.raises(TypeError, match=msg):
+            self.read_html(spam_data, header=arg)
 
     def test_converters(self):
         # GH 13461
@@ -1128,6 +1148,25 @@ def test_to_html_timestamp(self):
         result = df.to_html()
         assert "2000-01-01" in result
 
+    def test_to_html_borderless(self):
+        df = DataFrame([{"A": 1, "B": 2}])
+        out_border_default = df.to_html()
+        out_border_true = df.to_html(border=True)
+        out_border_explicit_default = df.to_html(border=1)
+        out_border_nondefault = df.to_html(border=2)
+        out_border_zero = df.to_html(border=0)
+
+        out_border_false = df.to_html(border=False)
+
+        assert ' border="1"' in out_border_default
+        assert out_border_true == out_border_default
+        assert out_border_default == out_border_explicit_default
+        assert out_border_default != out_border_nondefault
+        assert ' border="2"' in out_border_nondefault
+        assert ' border="0"' not in out_border_zero
+        assert " border" not in out_border_false
+        assert out_border_zero == out_border_false
+
     @pytest.mark.parametrize(
         "displayed_only,exp0,exp1",
         [
@@ -1223,7 +1262,7 @@ def test_parse_failure_rewinds(self):
         # Issue #17975
 
         class MockFile:
-            def __init__(self, data):
+            def __init__(self, data) -> None:
                 self.data = data
                 self.at_end = False
 
@@ -1282,3 +1321,113 @@ def test_parse_path_object(self, datapath):
         df1 = self.read_html(file_path_string)[0]
         df2 = self.read_html(file_path)[0]
         tm.assert_frame_equal(df1, df2)
+
+    def test_parse_br_as_space(self):
+        # GH 29528: pd.read_html() convert <br> to space
+        result = self.read_html(
+            """
+            <table>
+                <tr>
+                    <th>A</th>
+                </tr>
+                <tr>
+                    <td>word1<br>word2</td>
+                </tr>
+            </table>
+        """
+        )[0]
+
+        expected = DataFrame(data=[["word1 word2"]], columns=["A"])
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("arg", ["all", "body", "header", "footer"])
+    def test_extract_links(self, arg):
+        gh_13141_data = """
+          <table>
+            <tr>
+              <th>HTTP</th>
+              <th>FTP</th>
+              <th><a href="https://en.wiktionary.org/wiki/linkless">Linkless</a></th>
+            </tr>
+            <tr>
+              <td><a href="https://en.wikipedia.org/">Wikipedia</a></td>
+              <td>SURROUNDING <a href="/service/ftp://ftp.us.debian.org/">Debian</a> TEXT</td>
+              <td>Linkless</td>
+            </tr>
+            <tfoot>
+              <tr>
+                <td><a href="https://en.wikipedia.org/wiki/Page_footer">Footer</a></td>
+                <td>
+                  Multiple <a href="https://github.com/1">links:</a> <a href="https://github.com/2">Only first captured.</a>
+                </td>
+              </tr>
+            </tfoot>
+          </table>
+          """
+
+        gh_13141_expected = {
+            "head_ignore": ["HTTP", "FTP", "Linkless"],
+            "head_extract": [
+                ("HTTP", None),
+                ("FTP", None),
+                ("Linkless", "https://en.wiktionary.org/wiki/linkless"),
+            ],
+            "body_ignore": ["Wikipedia", "SURROUNDING Debian TEXT", "Linkless"],
+            "body_extract": [
+                ("Wikipedia", "https://en.wikipedia.org/"),
+                ("SURROUNDING Debian TEXT", "ftp://ftp.us.debian.org/"),
+                ("Linkless", None),
+            ],
+            "footer_ignore": [
+                "Footer",
+                "Multiple links: Only first captured.",
+                None,
+            ],
+            "footer_extract": [
+                ("Footer", "https://en.wikipedia.org/wiki/Page_footer"),
+                ("Multiple links: Only first captured.", "1"),
+                None,
+            ],
+        }
+
+        data_exp = gh_13141_expected["body_ignore"]
+        foot_exp = gh_13141_expected["footer_ignore"]
+        head_exp = gh_13141_expected["head_ignore"]
+        if arg == "all":
+            data_exp = gh_13141_expected["body_extract"]
+            foot_exp = gh_13141_expected["footer_extract"]
+            head_exp = gh_13141_expected["head_extract"]
+        elif arg == "body":
+            data_exp = gh_13141_expected["body_extract"]
+        elif arg == "footer":
+            foot_exp = gh_13141_expected["footer_extract"]
+        elif arg == "header":
+            head_exp = gh_13141_expected["head_extract"]
+
+        result = self.read_html(gh_13141_data, extract_links=arg)[0]
+        expected = DataFrame([data_exp, foot_exp], columns=head_exp)
+        tm.assert_frame_equal(result, expected)
+
+    def test_extract_links_bad(self, spam_data):
+        msg = (
+            "`extract_links` must be one of "
+            '{None, "header", "footer", "body", "all"}, got "incorrect"'
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_html(spam_data, extract_links="incorrect")
+
+    def test_extract_links_all_no_header(self):
+        # GH 48316
+        data = """
+        <table>
+          <tr>
+            <td>
+              <a href='https://google.com/'>Google.com</a>
+            </td>
+          </tr>
+        </table>
+        """
+        result = self.read_html(data, extract_links="all")[0]
+        expected = DataFrame([[("Google.com", "https://google.com/")]])
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index f34e9b940317d..0bb320907b813 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -1,10 +1,13 @@
 """ test orc compat """
 import datetime
+from io import BytesIO
 import os
 
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 import pandas as pd
 from pandas import read_orc
 import pandas._testing as tm
@@ -21,6 +24,27 @@ def dirpath(datapath):
     return datapath("io", "data", "orc")
 
 
+# Examples of dataframes with dtypes for which conversion to ORC
+# hasn't been implemented yet, that is, Category, unsigned integers,
+# interval, period and sparse.
+orc_writer_dtypes_not_supported = [
+    pd.DataFrame({"unimpl": np.array([1, 20], dtype="uint64")}),
+    pd.DataFrame({"unimpl": pd.Series(["a", "b", "a"], dtype="category")}),
+    pd.DataFrame(
+        {"unimpl": [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)]}
+    ),
+    pd.DataFrame(
+        {
+            "unimpl": [
+                pd.Period("2022-01-03", freq="D"),
+                pd.Period("2022-01-04", freq="D"),
+            ]
+        }
+    ),
+    pd.DataFrame({"unimpl": [np.nan] * 50}).astype(pd.SparseDtype("float", np.nan)),
+]
+
+
 def test_orc_reader_empty(dirpath):
     columns = [
         "boolean1",
@@ -224,3 +248,60 @@ def test_orc_reader_snappy_compressed(dirpath):
     got = read_orc(inputfile).iloc[:10]
 
     tm.assert_equal(expected, got)
+
+
+@td.skip_if_no("pyarrow", min_version="7.0.0")
+def test_orc_roundtrip_file(dirpath):
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    with tm.ensure_clean() as path:
+        expected.to_orc(path)
+        got = read_orc(path)
+
+        tm.assert_equal(expected, got)
+
+
+@td.skip_if_no("pyarrow", min_version="7.0.0")
+def test_orc_roundtrip_bytesio():
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    bytes = expected.to_orc()
+    got = read_orc(BytesIO(bytes))
+
+    tm.assert_equal(expected, got)
+
+
+@td.skip_if_no("pyarrow", min_version="7.0.0")
+@pytest.mark.parametrize("df_not_supported", orc_writer_dtypes_not_supported)
+def test_orc_writer_dtypes_not_supported(df_not_supported):
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    msg = "The dtype of one or more columns is not supported yet."
+    with pytest.raises(NotImplementedError, match=msg):
+        df_not_supported.to_orc()
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 0bd291cea894e..9e4e7aded201c 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -13,10 +13,12 @@
 
 from pandas._config import get_option
 
+from pandas.compat import is_platform_windows
 from pandas.compat.pyarrow import (
     pa_version_under2p0,
     pa_version_under5p0,
     pa_version_under6p0,
+    pa_version_under8p0,
 )
 import pandas.util._test_decorators as td
 
@@ -43,6 +45,9 @@
     with catch_warnings():
         # `np.bool` is a deprecated alias...
         filterwarnings("ignore", "`np.bool`", category=DeprecationWarning)
+        # accessing pd.Int64Index in pd namespace
+        filterwarnings("ignore", ".*Int64Index.*", category=FutureWarning)
+
         import fastparquet
 
     _HAVE_FASTPARQUET = True
@@ -349,7 +354,7 @@ def test_cross_engine_pa_fp(df_cross_compat, pa, fp):
         tm.assert_frame_equal(result, df[["a", "d"]])
 
 
-def test_cross_engine_fp_pa(request, df_cross_compat, pa, fp):
+def test_cross_engine_fp_pa(df_cross_compat, pa, fp):
     # cross-compat with differing reading/writing engines
     df = df_cross_compat
     with tm.ensure_clean() as path:
@@ -376,13 +381,20 @@ def check_external_error_on_write(self, df, engine, exc):
             with tm.external_error_raised(exc):
                 to_parquet(df, path, engine, compression=None)
 
-    @tm.network
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://raw.githubusercontent.com/pandas-dev/pandas/"
+            "main/pandas/tests/io/data/parquet/simple.parquet"
+        ),
+        check_before_test=True,
+    )
     def test_parquet_read_from_url(https://github.com/self,%20df_compat,%20engine):
         if engine != "auto":
             pytest.importorskip(engine)
         url = (
             "https://raw.githubusercontent.com/pandas-dev/pandas/"
-            "master/pandas/tests/io/data/parquet/simple.parquet"
+            "main/pandas/tests/io/data/parquet/simple.parquet"
         )
         df = read_parquet(url)
         tm.assert_frame_equal(df, df_compat)
@@ -614,6 +626,9 @@ def test_use_nullable_dtypes(self, engine, request):
                 "d": pyarrow.array([True, False, True, None]),
                 # Test that nullable dtypes used even in absence of nulls
                 "e": pyarrow.array([1, 2, 3, 4], "int64"),
+                # GH 45694
+                "f": pyarrow.array([1.0, 2.0, 3.0, None], "float32"),
+                "g": pyarrow.array([1.0, 2.0, 3.0, None], "float64"),
             }
         )
         with tm.ensure_clean() as path:
@@ -630,6 +645,8 @@ def test_use_nullable_dtypes(self, engine, request):
                 "c": pd.array(["a", "b", "c", None], dtype="string"),
                 "d": pd.array([True, False, True, None], dtype="boolean"),
                 "e": pd.array([1, 2, 3, 4], dtype="Int64"),
+                "f": pd.array([1.0, 2.0, 3.0, None], dtype="Float32"),
+                "g": pd.array([1.0, 2.0, 3.0, None], dtype="Float64"),
             }
         )
         if engine == "fastparquet":
@@ -648,15 +665,7 @@ def test_use_nullable_dtypes(self, engine, request):
             "object",
             "datetime64[ns, UTC]",
             "float",
-            pytest.param(
-                "period[D]",
-                # Note: I don't know exactly what version the cutoff is;
-                #  On the CI it fails with 1.0.1
-                marks=pytest.mark.xfail(
-                    pa_version_under2p0,
-                    reason="pyarrow uses pandas internal API incorrectly",
-                ),
-            ),
+            "period[D]",
             "Float64",
             "string",
         ],
@@ -668,7 +677,17 @@ def test_read_empty_array(self, pa, dtype):
                 "value": pd.array([], dtype=dtype),
             }
         )
-        check_round_trip(df, pa, read_kwargs={"use_nullable_dtypes": True})
+        # GH 45694
+        expected = None
+        if dtype == "float":
+            expected = pd.DataFrame(
+                {
+                    "value": pd.array([], dtype="Float64"),
+                }
+            )
+        check_round_trip(
+            df, pa, read_kwargs={"use_nullable_dtypes": True}, expected=expected
+        )
 
 
 @pytest.mark.filterwarnings("ignore:CategoricalBlock is deprecated:DeprecationWarning")
@@ -715,17 +734,48 @@ def test_duplicate_columns(self, pa):
         df = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list("aaa")).copy()
         self.check_error_on_write(df, pa, ValueError, "Duplicate column names found")
 
-    def test_unsupported(self, pa):
-        # timedelta
+    def test_timedelta(self, pa):
         df = pd.DataFrame({"a": pd.timedelta_range("1 day", periods=3)})
-        self.check_external_error_on_write(df, pa, NotImplementedError)
+        if pa_version_under8p0:
+            self.check_external_error_on_write(df, pa, NotImplementedError)
+        else:
+            check_round_trip(df, pa)
 
+    def test_unsupported(self, pa):
         # mixed python objects
         df = pd.DataFrame({"a": ["a", 1, 2.0]})
         # pyarrow 0.11 raises ArrowTypeError
         # older pyarrows raise ArrowInvalid
         self.check_external_error_on_write(df, pa, pyarrow.ArrowException)
 
+    def test_unsupported_float16(self, pa):
+        # #44847, #44914
+        # Not able to write float 16 column using pyarrow.
+        data = np.arange(2, 10, dtype=np.float16)
+        df = pd.DataFrame(data=data, columns=["fp16"])
+        self.check_external_error_on_write(df, pa, pyarrow.ArrowException)
+
+    @pytest.mark.xfail(
+        is_platform_windows(),
+        reason=(
+            "PyArrow does not cleanup of partial files dumps when unsupported "
+            "dtypes are passed to_parquet function in windows"
+        ),
+    )
+    @pytest.mark.parametrize("path_type", [str, pathlib.Path])
+    def test_unsupported_float16_cleanup(self, pa, path_type):
+        # #44847, #44914
+        # Not able to write float 16 column using pyarrow.
+        # Tests cleanup by pyarrow in case of an error
+        data = np.arange(2, 10, dtype=np.float16)
+        df = pd.DataFrame(data=data, columns=["fp16"])
+
+        with tm.ensure_clean() as path_str:
+            path = path_type(path_str)
+            with tm.external_error_raised(pyarrow.ArrowException):
+                df.to_parquet(path=path, engine=pa)
+            assert not os.path.isfile(path)
+
     def test_categorical(self, pa):
 
         # supported in >= 0.7.0
@@ -745,6 +795,7 @@ def test_categorical(self, pa):
 
         check_round_trip(df, pa)
 
+    @pytest.mark.single_cpu
     def test_s3_roundtrip_explicit_fs(self, df_compat, s3_resource, pa, s3so):
         s3fs = pytest.importorskip("s3fs")
         s3 = s3fs.S3FileSystem(**s3so)
@@ -757,6 +808,7 @@ def test_s3_roundtrip_explicit_fs(self, df_compat, s3_resource, pa, s3so):
             write_kwargs=kw,
         )
 
+    @pytest.mark.single_cpu
     def test_s3_roundtrip(self, df_compat, s3_resource, pa, s3so):
         # GH #19134
         s3so = {"storage_options": s3so}
@@ -768,6 +820,7 @@ def test_s3_roundtrip(self, df_compat, s3_resource, pa, s3so):
             write_kwargs=s3so,
         )
 
+    @pytest.mark.single_cpu
     @td.skip_if_no("s3fs")  # also requires flask
     @pytest.mark.parametrize(
         "partition_col",
@@ -894,18 +947,18 @@ def test_pyarrow_backed_string_array(self, pa, string_storage):
         with pd.option_context("string_storage", string_storage):
             check_round_trip(df, pa, expected=df.astype(f"string[{string_storage}]"))
 
-    @td.skip_if_no("pyarrow")
-    @pytest.mark.xfail(
-        pa_version_under2p0, reason="pyarrow uses pandas internal API incorrectly"
-    )
+    @td.skip_if_no("pyarrow", min_version="2.0.0")
     def test_additional_extension_types(self, pa):
         # test additional ExtensionArrays that are supported through the
         # __arrow_array__ protocol + by defining a custom ExtensionType
         df = pd.DataFrame(
             {
-                # Arrow does not yet support struct in writing to Parquet (ARROW-1644)
-                # "c": pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2), (3, 4)]),
+                "c": pd.IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)]),
                 "d": pd.period_range("2012-01-01", periods=3, freq="D"),
+                # GH-45881 issue with interval with datetime64[ns] subtype
+                "e": pd.IntervalIndex.from_breaks(
+                    pd.date_range("2012-01-01", periods=4, freq="D")
+                ),
             }
         )
         check_round_trip(df, pa)
@@ -921,11 +974,17 @@ def test_timestamp_nanoseconds(self, pa):
         df = pd.DataFrame({"a": pd.date_range("2017-01-01", freq="1n", periods=10)})
         check_round_trip(df, pa, write_kwargs={"version": ver})
 
-    def test_timezone_aware_index(self, pa, timezone_aware_date_list):
-        if not pa_version_under2p0:
-            # temporary skip this test until it is properly resolved
-            # https://github.com/pandas-dev/pandas/issues/37286
-            pytest.skip()
+    def test_timezone_aware_index(self, request, pa, timezone_aware_date_list):
+        if (
+            not pa_version_under2p0
+            and timezone_aware_date_list.tzinfo != datetime.timezone.utc
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="temporary skip this test until it is properly resolved: "
+                    "https://github.com/pandas-dev/pandas/issues/37286"
+                )
+            )
         idx = 5 * [timezone_aware_date_list]
         df = pd.DataFrame(index=idx, data={"index_as_col": idx})
 
@@ -974,7 +1033,6 @@ def test_basic(self, fp, df_full):
         df["timedelta"] = pd.timedelta_range("1 day", periods=3)
         check_round_trip(df, fp)
 
-    @pytest.mark.skip(reason="not supported")
     def test_duplicate_columns(self, fp):
 
         # not currently able to handle duplicate columns
@@ -1013,6 +1071,7 @@ def test_filter_row_groups(self, fp):
             result = read_parquet(path, fp, filters=[("a", "==", 0)])
         assert len(result) == 1
 
+    @pytest.mark.single_cpu
     def test_s3_roundtrip(self, df_compat, s3_resource, fp, s3so):
         # GH #19134
         check_round_trip(
@@ -1108,10 +1167,28 @@ def test_timezone_aware_index(self, fp, timezone_aware_date_list):
         expected.index.name = "index"
         check_round_trip(df, fp, expected=expected)
 
-    def test_use_nullable_dtypes_not_supported(self, monkeypatch, fp):
+    def test_use_nullable_dtypes_not_supported(self, fp):
         df = pd.DataFrame({"a": [1, 2]})
 
         with tm.ensure_clean() as path:
             df.to_parquet(path)
             with pytest.raises(ValueError, match="not supported for the fastparquet"):
                 read_parquet(path, engine="fastparquet", use_nullable_dtypes=True)
+
+    def test_close_file_handle_on_read_error(self):
+        with tm.ensure_clean("test.parquet") as path:
+            pathlib.Path(path).write_bytes(b"breakit")
+            with pytest.raises(Exception, match=""):  # Not important which exception
+                read_parquet(path, engine="fastparquet")
+            # The next line raises an error on Windows if the file is still open
+            pathlib.Path(path).unlink(missing_ok=False)
+
+    def test_bytes_file_name(self, engine):
+        # GH#48944
+        df = pd.DataFrame(data={"A": [0, 1], "B": [1, 0]})
+        with tm.ensure_clean("test.parquet") as path:
+            with open(path.encode(), "wb") as f:
+                df.to_parquet(f)
+
+            result = read_parquet(path, engine=engine)
+        tm.assert_frame_equal(result, df)
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index 4700e307f2407..98f02e14f4f13 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -21,6 +21,8 @@
 from pathlib import Path
 import pickle
 import shutil
+import tarfile
+import uuid
 from warnings import (
     catch_warnings,
     filterwarnings,
@@ -73,14 +75,13 @@ def current_pickle_data():
 # ---------------------
 # comparison functions
 # ---------------------
-def compare_element(result, expected, typ, version=None):
+def compare_element(result, expected, typ):
     if isinstance(expected, Index):
         tm.assert_index_equal(expected, result)
         return
 
     if typ.startswith("sp_"):
-        comparator = tm.assert_equal
-        comparator(result, expected)
+        tm.assert_equal(result, expected)
     elif typ == "timestamp":
         if expected is pd.NaT:
             assert result is pd.NaT
@@ -92,74 +93,7 @@ def compare_element(result, expected, typ, version=None):
         comparator(result, expected)
 
 
-def compare(data, vf, version):
-
-    data = pd.read_pickle(vf)
-
-    m = globals()
-    for typ, dv in data.items():
-        for dt, result in dv.items():
-            expected = data[typ][dt]
-
-            # use a specific comparator
-            # if available
-            comparator = f"compare_{typ}_{dt}"
-
-            comparator = m.get(comparator, m["compare_element"])
-            comparator(result, expected, typ, version)
-    return data
-
-
-def compare_series_ts(result, expected, typ, version):
-    # GH 7748
-    tm.assert_series_equal(result, expected)
-    assert result.index.freq == expected.index.freq
-    assert not result.index.freq.normalize
-    tm.assert_series_equal(result > 0, expected > 0)
-
-    # GH 9291
-    freq = result.index.freq
-    assert freq + Day(1) == Day(2)
-
-    res = freq + pd.Timedelta(hours=1)
-    assert isinstance(res, pd.Timedelta)
-    assert res == pd.Timedelta(days=1, hours=1)
-
-    res = freq + pd.Timedelta(nanoseconds=1)
-    assert isinstance(res, pd.Timedelta)
-    assert res == pd.Timedelta(days=1, nanoseconds=1)
-
-
-def compare_series_dt_tz(result, expected, typ, version):
-    tm.assert_series_equal(result, expected)
-
-
-def compare_series_cat(result, expected, typ, version):
-    tm.assert_series_equal(result, expected)
-
-
-def compare_frame_dt_mixed_tzs(result, expected, typ, version):
-    tm.assert_frame_equal(result, expected)
-
-
-def compare_frame_cat_onecol(result, expected, typ, version):
-    tm.assert_frame_equal(result, expected)
-
-
-def compare_frame_cat_and_float(result, expected, typ, version):
-    compare_frame_cat_onecol(result, expected, typ, version)
-
-
-def compare_index_period(result, expected, typ, version):
-    tm.assert_index_equal(result, expected)
-    assert isinstance(result.freq, MonthEnd)
-    assert result.freq == MonthEnd()
-    assert result.freqstr == "M"
-    tm.assert_index_equal(result.shift(2), expected.shift(2))
-
-
-here = os.path.dirname(__file__)
-legacy_dirname = os.path.join(here, "data", "legacy_pickle")
+legacy_dirname = os.path.join(os.path.dirname(__file__), "data", "legacy_pickle")
 files = glob.glob(os.path.join(legacy_dirname, "*", "*.pickle"))
 
 
@@ -171,14 +105,53 @@ def legacy_pickle(request, datapath):
 # ---------------------
 # tests
 # ---------------------
-def test_pickles(current_pickle_data, legacy_pickle):
+def test_pickles(legacy_pickle):
     if not is_platform_little_endian():
         pytest.skip("known failure on non-little endian")
 
-    version = os.path.basename(os.path.dirname(legacy_pickle))
     with catch_warnings(record=True):
         simplefilter("ignore")
-        compare(current_pickle_data, legacy_pickle, version)
+
+        data = pd.read_pickle(legacy_pickle)
+
+        for typ, dv in data.items():
+            for dt, result in dv.items():
+                expected = data[typ][dt]
+
+                if typ == "series" and dt == "ts":
+                    # GH 7748
+                    tm.assert_series_equal(result, expected)
+                    assert result.index.freq == expected.index.freq
+                    assert not result.index.freq.normalize
+                    tm.assert_series_equal(result > 0, expected > 0)
+
+                    # GH 9291
+                    freq = result.index.freq
+                    assert freq + Day(1) == Day(2)
+
+                    res = freq + pd.Timedelta(hours=1)
+                    assert isinstance(res, pd.Timedelta)
+                    assert res == pd.Timedelta(days=1, hours=1)
+
+                    res = freq + pd.Timedelta(nanoseconds=1)
+                    assert isinstance(res, pd.Timedelta)
+                    assert res == pd.Timedelta(days=1, nanoseconds=1)
+                elif typ == "index" and dt == "period":
+                    tm.assert_index_equal(result, expected)
+                    assert isinstance(result.freq, MonthEnd)
+                    assert result.freq == MonthEnd()
+                    assert result.freqstr == "M"
+                    tm.assert_index_equal(result.shift(2), expected.shift(2))
+                elif typ == "series" and dt in ("dt_tz", "cat"):
+                    tm.assert_series_equal(result, expected)
+                elif typ == "frame" and dt in (
+                    "dt_mixed_tzs",
+                    "cat_onecol",
+                    "cat_and_float",
+                ):
+                    tm.assert_frame_equal(result, expected)
+                else:
+                    compare_element(result, expected, typ)
 
 
 def python_pickler(obj, path):
@@ -208,32 +181,32 @@ def python_unpickler(path):
         ),
     ],
 )
+@pytest.mark.parametrize("writer", [pd.to_pickle, python_pickler])
 @pytest.mark.filterwarnings("ignore:The 'freq' argument in Timestamp:FutureWarning")
-def test_round_trip_current(current_pickle_data, pickle_writer):
+def test_round_trip_current(current_pickle_data, pickle_writer, writer):
     data = current_pickle_data
     for typ, dv in data.items():
         for dt, expected in dv.items():
 
-            for writer in [pd.to_pickle, python_pickler]:
-                with tm.ensure_clean() as path:
-                    # test writing with each pickler
-                    pickle_writer(expected, path)
+            with tm.ensure_clean() as path:
+                # test writing with each pickler
+                pickle_writer(expected, path)
 
-                    # test reading with each unpickler
-                    result = pd.read_pickle(path)
-                    compare_element(result, expected, typ)
+                # test reading with each unpickler
+                result = pd.read_pickle(path)
+                compare_element(result, expected, typ)
 
-                    result = python_unpickler(path)
-                    compare_element(result, expected, typ)
+                result = python_unpickler(path)
+                compare_element(result, expected, typ)
 
-                    # and the same for file objects (GH 35679)
-                    with open(path, mode="wb") as handle:
-                        writer(expected, path)
-                        handle.seek(0)  # shouldn't close file handle
-                    with open(path, mode="rb") as handle:
-                        result = pd.read_pickle(handle)
-                        handle.seek(0)  # shouldn't close file handle
-                    compare_element(result, expected, typ)
+                # and the same for file objects (GH 35679)
+                with open(path, mode="wb") as handle:
+                    writer(expected, path)
+                    handle.seek(0)  # shouldn't close file handle
+                with open(path, mode="rb") as handle:
+                    result = pd.read_pickle(handle)
+                    handle.seek(0)  # shouldn't close file handle
+                compare_element(result, expected, typ)
 
 
 def test_pickle_path_pathlib():
@@ -248,7 +221,8 @@ def test_pickle_path_localpath():
     tm.assert_frame_equal(df, result)
 
 
-def test_legacy_sparse_warning(datapath):
+@pytest.mark.parametrize("typ", ["sparseseries", "sparseframe"])
+def test_legacy_sparse_warning(datapath, typ):
     """
 
     Generated with
@@ -264,14 +238,7 @@ def test_legacy_sparse_warning(datapath):
     with tm.assert_produces_warning(FutureWarning):
         simplefilter("ignore", DeprecationWarning)  # from boto
         pd.read_pickle(
-            datapath("io", "data", "pickle", "sparseseries-0.20.3.pickle.gz"),
-            compression="gzip",
-        )
-
-    with tm.assert_produces_warning(FutureWarning):
-        simplefilter("ignore", DeprecationWarning)  # from boto
-        pd.read_pickle(
-            datapath("io", "data", "pickle", "sparseframe-0.20.3.pickle.gz"),
+            datapath("io", "data", "pickle", f"{typ}-0.20.3.pickle.gz"),
             compression="gzip",
         )
 
@@ -283,14 +250,12 @@ def test_legacy_sparse_warning(datapath):
 
 @pytest.fixture
 def get_random_path():
-    return f"__{tm.rands(10)}__.pickle"
+    return f"__{uuid.uuid4()}__.pickle"
 
 
 class TestCompression:
 
-    _extension_to_compression = {
-        ext: compression for compression, ext in icom._compression_to_extension.items()
-    }
+    _extension_to_compression = icom._extension_to_compression
 
     def compress_file(self, src_path, dest_path, compression):
         if compression is None:
@@ -304,6 +269,11 @@ def compress_file(self, src_path, dest_path, compression):
         elif compression == "zip":
             with zipfile.ZipFile(dest_path, "w", compression=zipfile.ZIP_DEFLATED) as f:
                 f.write(src_path, os.path.basename(src_path))
+        elif compression == "tar":
+            with open(src_path, "rb") as fh:
+                with tarfile.open(dest_path, mode="w") as tar:
+                    tarinfo = tar.gettarinfo(src_path, os.path.basename(src_path))
+                    tar.addfile(tarinfo, fh)
         elif compression == "xz":
             f = get_lzma_file()(dest_path, "w")
         elif compression == "zstd":
@@ -312,7 +282,7 @@ def compress_file(self, src_path, dest_path, compression):
             msg = f"Unrecognized compression type: {compression}"
             raise ValueError(msg)
 
-        if compression != "zip":
+        if compression not in ["zip", "tar"]:
             with open(src_path, "rb") as fh, f:
                 f.write(fh.read())
 
@@ -470,12 +440,12 @@ def python_pickler(obj, path):
             pickle.dump(obj, fh, protocol=-1)
 
     class MockReadResponse:
-        def __init__(self, path):
+        def __init__(self, path) -> None:
             self.file = open(path, "rb")
             if "gzip" in path:
                 self.headers = {"Content-Encoding": "gzip"}
             else:
-                self.headers = {"Content-Encoding": None}
+                self.headers = {"Content-Encoding": ""}
 
         def __enter__(self):
             return self
@@ -512,7 +482,7 @@ def test_pickle_fsspec_roundtrip():
 
 
 class MyTz(datetime.tzinfo):
-    def __init__(self):
+    def __init__(self) -> None:
         pass
 
 
@@ -544,7 +514,7 @@ def test_pickle_binary_object_compression(compression):
     buffer.seek(0)
 
     # gzip  and zip safe the filename: cannot compare the compressed content
-    assert buffer.getvalue() == reference or compression in ("gzip", "zip")
+    assert buffer.getvalue() == reference or compression in ("gzip", "zip", "tar")
 
     # read
     read_df = pd.read_pickle(buffer, compression=compression)
diff --git a/pandas/tests/io/test_s3.py b/pandas/tests/io/test_s3.py
index 0ee6cb0796644..6702d58c139af 100644
--- a/pandas/tests/io/test_s3.py
+++ b/pandas/tests/io/test_s3.py
@@ -21,8 +21,9 @@ def test_streaming_s3_objects():
         read_csv(body)
 
 
-@tm.network
 @td.skip_if_no("s3fs")
+@pytest.mark.network
+@tm.network
 def test_read_without_creds_from_pub_bucket():
     # GH 34626
     # Use Amazon Open Data Registry - https://registry.opendata.aws/gdelt
@@ -30,8 +31,9 @@ def test_read_without_creds_from_pub_bucket():
     assert len(result) == 3
 
 
-@tm.network
 @td.skip_if_no("s3fs")
+@pytest.mark.network
+@tm.network
 def test_read_with_creds_from_pub_bucket():
     # Ensure we can read from a public bucket with credentials
     # GH 34626
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 7a94797543519..1bfb85f369415 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -58,7 +58,6 @@
     SQLAlchemyEngine,
     SQLDatabase,
     SQLiteDatabase,
-    _gt14,
     get_engine,
     pandasSQL_builder,
     read_sql_query,
@@ -369,7 +368,7 @@ def test_frame1():
 def test_frame3():
     columns = ["index", "A", "B"]
     data = [
-        ("2000-01-03 00:00:00", 2 ** 31 - 1, -1.987670),
+        ("2000-01-03 00:00:00", 2**31 - 1, -1.987670),
         ("2000-01-04 00:00:00", -29, -0.0412318367011),
         ("2000-01-05 00:00:00", 20000, 0.731167677815),
         ("2000-01-06 00:00:00", -290867, 1.56762092543),
@@ -385,10 +384,10 @@ def mysql_pymysql_engine(iris_path, types_data):
         "mysql+pymysql://root@localhost:3306/pandas",
         connect_args={"client_flag": pymysql.constants.CLIENT.MULTI_STATEMENTS},
     )
-    check_target = sqlalchemy.inspect(engine) if _gt14() else engine
-    if not check_target.has_table("iris"):
+    insp = sqlalchemy.inspect(engine)
+    if not insp.has_table("iris"):
         create_and_load_iris(engine, iris_path, "mysql")
-    if not check_target.has_table("types"):
+    if not insp.has_table("types"):
         for entry in types_data:
             entry.pop("DateColWithTz")
         create_and_load_types(engine, types_data, "mysql")
@@ -412,10 +411,10 @@ def postgresql_psycopg2_engine(iris_path, types_data):
     engine = sqlalchemy.create_engine(
         "postgresql+psycopg2://postgres:postgres@localhost:5432/pandas"
     )
-    check_target = sqlalchemy.inspect(engine) if _gt14() else engine
-    if not check_target.has_table("iris"):
+    insp = sqlalchemy.inspect(engine)
+    if not insp.has_table("iris"):
         create_and_load_iris(engine, iris_path, "postgresql")
-    if not check_target.has_table("types"):
+    if not insp.has_table("types"):
         create_and_load_types(engine, types_data, "postgresql")
     yield engine
     with engine.connect() as conn:
@@ -499,6 +498,7 @@ def sqlite_buildin_iris(sqlite_buildin, iris_path):
 all_connectable_iris = sqlalchemy_connectable_iris + ["sqlite_buildin_iris"]
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", all_connectable)
 @pytest.mark.parametrize("method", [None, "multi"])
 def test_to_sql(conn, method, test_frame1, request):
@@ -509,6 +509,7 @@ def test_to_sql(conn, method, test_frame1, request):
     assert count_rows(conn, "test_frame") == len(test_frame1)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", all_connectable)
 @pytest.mark.parametrize("mode, num_row_coef", [("replace", 1), ("append", 2)])
 def test_to_sql_exist(conn, mode, num_row_coef, test_frame1, request):
@@ -520,6 +521,7 @@ def test_to_sql_exist(conn, mode, num_row_coef, test_frame1, request):
     assert count_rows(conn, "test_frame") == num_row_coef * len(test_frame1)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", all_connectable)
 def test_to_sql_exist_fail(conn, test_frame1, request):
     conn = request.getfixturevalue(conn)
@@ -532,6 +534,7 @@ def test_to_sql_exist_fail(conn, test_frame1, request):
         pandasSQL.to_sql(test_frame1, "test_frame", if_exists="fail")
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", all_connectable_iris)
 def test_read_iris(conn, request):
     conn = request.getfixturevalue(conn)
@@ -540,6 +543,7 @@ def test_read_iris(conn, request):
     check_iris_frame(iris_frame)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", sqlalchemy_connectable)
 def test_to_sql_callable(conn, test_frame1, request):
     conn = request.getfixturevalue(conn)
@@ -558,6 +562,7 @@ def sample(pd_table, conn, keys, data_iter):
     assert count_rows(conn, "test_frame") == len(test_frame1)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", mysql_connectable)
 def test_default_type_conversion(conn, request):
     conn = request.getfixturevalue(conn)
@@ -576,6 +581,7 @@ def test_default_type_conversion(conn, request):
     assert issubclass(df.BoolColWithNull.dtype.type, np.floating)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", mysql_connectable)
 def test_read_procedure(conn, request):
     conn = request.getfixturevalue(conn)
@@ -612,8 +618,10 @@ def test_read_procedure(conn, request):
     tm.assert_frame_equal(df, res2)
 
 
+@pytest.mark.db
 @pytest.mark.parametrize("conn", postgresql_connectable)
-def test_copy_from_callable_insertion_method(conn, request):
+@pytest.mark.parametrize("expected_count", [2, "Success!"])
+def test_copy_from_callable_insertion_method(conn, expected_count, request):
     # GH 8953
     # Example in io.rst found under _io.sql.method
     # not available in sqlite, mysql
@@ -634,16 +642,24 @@ def psql_insert_copy(table, conn, keys, data_iter):
 
             sql_query = f"COPY {table_name} ({columns}) FROM STDIN WITH CSV"
             cur.copy_expert(sql=sql_query, file=s_buf)
+        return expected_count
 
     conn = request.getfixturevalue(conn)
     expected = DataFrame({"col1": [1, 2], "col2": [0.1, 0.2], "col3": ["a", "n"]})
-    expected.to_sql("test_frame", conn, index=False, method=psql_insert_copy)
+    result_count = expected.to_sql(
+        "test_frame", conn, index=False, method=psql_insert_copy
+    )
+    # GH 46891
+    if not isinstance(expected_count, int):
+        assert result_count is None
+    else:
+        assert result_count == expected_count
     result = sql.read_sql_table("test_frame", conn)
     tm.assert_frame_equal(result, expected)
 
 
 class MixInBase:
-    def teardown_method(self, method):
+    def teardown_method(self):
         # if setup fails, there may not be a connection to close.
         if hasattr(self, "conn"):
             for tbl in self._get_all_tables():
@@ -1269,7 +1285,6 @@ def test_escaped_table_name(self):
         tm.assert_frame_equal(res, df)
 
 
-@pytest.mark.single
 @pytest.mark.skipif(not SQLALCHEMY_INSTALLED, reason="SQLAlchemy not installed")
 class TestSQLApi(SQLAlchemyMixIn, _TestSQLApi):
     """
@@ -1342,10 +1357,17 @@ def test_not_reflect_all_tables(self):
 
     def test_warning_case_insensitive_table_name(self, test_frame1):
         # see gh-7815
-        #
-        # We can't test that this warning is triggered, a the database
-        # configuration would have to be altered. But here we test that
-        # the warning is certainly NOT triggered in a normal case.
+        with tm.assert_produces_warning(
+            UserWarning,
+            match=(
+                r"The provided table name 'TABLE1' is not found exactly as such in "
+                r"the database after writing the table, possibly due to case "
+                r"sensitivity issues. Consider using lower case table names."
+            ),
+        ):
+            sql.SQLDatabase(self.conn).check_case_sensitive("TABLE1", "")
+
+        # Test that the warning is certainly NOT triggered in a normal case.
         with tm.assert_produces_warning(None):
             test_frame1.to_sql("CaseSensitive", self.conn)
 
@@ -1450,8 +1472,7 @@ def test_query_by_select_obj(self):
         )
 
         iris = iris_table_metadata(self.flavor)
-        iris_select = iris if _gt14() else [iris]
-        name_select = select(iris_select).where(iris.c.Name == bindparam("name"))
+        name_select = select(iris).where(iris.c.Name == bindparam("name"))
         iris_df = sql.read_sql(name_select, self.conn, params={"name": "Iris-setosa"})
         all_names = set(iris_df["Name"])
         assert all_names == {"Iris-setosa"}
@@ -1489,12 +1510,10 @@ def setup_method(self, load_iris_data, load_types_data):
         self.pandasSQL = sql.SQLDatabase(self.__engine)
 
 
-@pytest.mark.single
 class TestSQLApiConn(_EngineToConnMixin, TestSQLApi):
     pass
 
 
-@pytest.mark.single
 class TestSQLiteFallbackApi(SQLiteMixIn, _TestSQLApi):
     """
     Test the public sqlite connection fallback API
@@ -1526,9 +1545,25 @@ def test_sql_open_close(self, test_frame3):
     @pytest.mark.skipif(SQLALCHEMY_INSTALLED, reason="SQLAlchemy is installed")
     def test_con_string_import_error(self):
         conn = "mysql://root@localhost/pandas"
-        with pytest.raises(ImportError, match="SQLAlchemy"):
+        msg = "Using URI string without sqlalchemy installed"
+        with pytest.raises(ImportError, match=msg):
             sql.read_sql("SELECT * FROM iris", conn)
 
+    @pytest.mark.skipif(SQLALCHEMY_INSTALLED, reason="SQLAlchemy is installed")
+    def test_con_unknown_dbapi2_class_does_not_error_without_sql_alchemy_installed(
+        self,
+    ):
+        class MockSqliteConnection:
+            def __init__(self, *args, **kwargs) -> None:
+                self.conn = sqlite3.Connection(*args, **kwargs)
+
+            def __getattr__(self, name):
+                return getattr(self.conn, name)
+
+        conn = MockSqliteConnection(":memory:")
+        with tm.assert_produces_warning(UserWarning):
+            sql.read_sql("SELECT 1", conn)
+
     def test_read_sql_delegate(self):
         iris_frame1 = sql.read_sql_query("SELECT * FROM iris", self.conn)
         iris_frame2 = sql.read_sql("SELECT * FROM iris", self.conn)
@@ -1624,46 +1659,33 @@ def test_to_sql_empty(self, test_frame1):
         self._to_sql_empty(test_frame1)
 
     def test_create_table(self):
+        from sqlalchemy import inspect
+
         temp_conn = self.connect()
         temp_frame = DataFrame(
             {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
         )
-
         pandasSQL = sql.SQLDatabase(temp_conn)
         assert pandasSQL.to_sql(temp_frame, "temp_frame") == 4
 
-        if _gt14():
-            from sqlalchemy import inspect
-
-            insp = inspect(temp_conn)
-            assert insp.has_table("temp_frame")
-        else:
-            assert temp_conn.has_table("temp_frame")
+        insp = inspect(temp_conn)
+        assert insp.has_table("temp_frame")
 
     def test_drop_table(self):
-        temp_conn = self.connect()
+        from sqlalchemy import inspect
 
+        temp_conn = self.connect()
         temp_frame = DataFrame(
             {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
         )
-
         pandasSQL = sql.SQLDatabase(temp_conn)
         assert pandasSQL.to_sql(temp_frame, "temp_frame") == 4
 
-        if _gt14():
-            from sqlalchemy import inspect
-
-            insp = inspect(temp_conn)
-            assert insp.has_table("temp_frame")
-        else:
-            assert temp_conn.has_table("temp_frame")
+        insp = inspect(temp_conn)
+        assert insp.has_table("temp_frame")
 
         pandasSQL.drop_table("temp_frame")
-
-        if _gt14():
-            assert not insp.has_table("temp_frame")
-        else:
-            assert not temp_conn.has_table("temp_frame")
+        assert not insp.has_table("temp_frame")
 
     def test_roundtrip(self, test_frame1):
         self._roundtrip(test_frame1)
@@ -1700,7 +1722,7 @@ def test_default_type_conversion(self):
 
     def test_bigint(self):
         # int64 should be converted to BigInteger, GH7433
-        df = DataFrame(data={"i64": [2 ** 62]})
+        df = DataFrame(data={"i64": [2**62]})
         assert df.to_sql("test_bigint", self.conn, index=False) == 1
         result = sql.read_sql_table("test_bigint", self.conn)
 
@@ -1713,7 +1735,7 @@ def test_default_date_load(self):
         # MySQL SHOULD be converted.
         assert issubclass(df.DateCol.dtype.type, np.datetime64)
 
-    def test_datetime_with_timezone(self):
+    def test_datetime_with_timezone(self, request):
         # edge case that converts postgresql datetime with time zone types
         # to datetime64[ns,psycopg2.tz.FixedOffsetTimezone..], which is ok
         # but should be more natural, so coerce to datetime64[ns] for now
@@ -1754,7 +1776,9 @@ def check(col):
         # GH11216
         df = read_sql_query("select * from types", self.conn)
         if not hasattr(df, "DateColWithTz"):
-            pytest.skip("no column with datetime with time zone")
+            request.node.add_marker(
+                pytest.mark.xfail(reason="no column with datetime with time zone")
+            )
 
         # this is parsed on Travis (linux), but not on macosx for some reason
         # even with the same versions of psycopg2 & sqlalchemy, possibly a
@@ -1766,7 +1790,9 @@ def check(col):
             "select * from types", self.conn, parse_dates=["DateColWithTz"]
         )
         if not hasattr(df, "DateColWithTz"):
-            pytest.skip("no column with datetime with time zone")
+            request.node.add_marker(
+                pytest.mark.xfail(reason="no column with datetime with time zone")
+            )
         col = df.DateColWithTz
         assert is_datetime64tz_dtype(col.dtype)
         assert str(col.dt.tz) == "UTC"
@@ -1942,7 +1968,7 @@ def test_datetime_time(self):
 
     def test_mixed_dtype_insert(self):
         # see GH6509
-        s1 = Series(2 ** 25 + 1, dtype=np.int32)
+        s1 = Series(2**25 + 1, dtype=np.int32)
         s2 = Series(0.0, dtype=np.float32)
         df = DataFrame({"s1": s1, "s2": s2})
 
@@ -2156,14 +2182,10 @@ def bar(connection, data):
             data.to_sql(name="test_foo_data", con=connection, if_exists="append")
 
         def baz(conn):
-            if _gt14():
-                # https://github.com/sqlalchemy/sqlalchemy/commit/
-                #  00b5c10846e800304caa86549ab9da373b42fa5d#r48323973
-                foo_data = foo(conn)
-                bar(conn, foo_data)
-            else:
-                foo_data = conn.run_callable(foo)
-                conn.run_callable(bar, foo_data)
+            # https://github.com/sqlalchemy/sqlalchemy/commit/
+            # 00b5c10846e800304caa86549ab9da373b42fa5d#r48323973
+            foo_data = foo(conn)
+            bar(conn, foo_data)
 
         def main(connectable):
             if isinstance(connectable, Engine):
@@ -2216,14 +2238,9 @@ def test_temporary_table(self):
         )
         from sqlalchemy.orm import (
             Session,
-            sessionmaker,
+            declarative_base,
         )
 
-        if _gt14():
-            from sqlalchemy.orm import declarative_base
-        else:
-            from sqlalchemy.ext.declarative import declarative_base
-
         test_data = "Hello, World!"
         expected = DataFrame({"spam": [test_data]})
         Base = declarative_base()
@@ -2234,24 +2251,13 @@ class Temporary(Base):
             id = Column(Integer, primary_key=True)
             spam = Column(Unicode(30), nullable=False)
 
-        if _gt14():
-            with Session(self.conn) as session:
-                with session.begin():
-                    conn = session.connection()
-                    Temporary.__table__.create(conn)
-                    session.add(Temporary(spam=test_data))
-                    session.flush()
-                    df = sql.read_sql_query(sql=select(Temporary.spam), con=conn)
-        else:
-            Session = sessionmaker()
-            session = Session(bind=self.conn)
-            with session.transaction:
+        with Session(self.conn) as session:
+            with session.begin():
                 conn = session.connection()
                 Temporary.__table__.create(conn)
                 session.add(Temporary(spam=test_data))
                 session.flush()
-                df = sql.read_sql_query(sql=select([Temporary.spam]), con=conn)
-
+                df = sql.read_sql_query(sql=select(Temporary.spam), con=conn)
         tm.assert_frame_equal(df, expected)
 
     # -- SQL Engine tests (in the base class for now)
@@ -2289,8 +2295,9 @@ def test_get_engine_auto_error_message(self):
 
 
 class _TestSQLAlchemyConn(_EngineToConnMixin, _TestSQLAlchemy):
+    @pytest.mark.xfail(reason="Nested transactions rollbacks don't work with Pandas")
     def test_transactions(self):
-        pytest.skip("Nested transactions rollbacks don't work with Pandas")
+        super().test_transactions()
 
 
 class _TestSQLiteAlchemy:
@@ -2349,12 +2356,10 @@ def test_row_object_is_named_tuple(self):
             Integer,
             String,
         )
-        from sqlalchemy.orm import sessionmaker
-
-        if _gt14():
-            from sqlalchemy.orm import declarative_base
-        else:
-            from sqlalchemy.ext.declarative import declarative_base
+        from sqlalchemy.orm import (
+            declarative_base,
+            sessionmaker,
+        )
 
         BaseModel = declarative_base()
 
@@ -2516,36 +2521,30 @@ def test_schema_support(self):
             tm.assert_frame_equal(res1, res2)
 
 
-@pytest.mark.single
 @pytest.mark.db
 class TestMySQLAlchemy(_TestMySQLAlchemy, _TestSQLAlchemy):
     pass
 
 
-@pytest.mark.single
 @pytest.mark.db
 class TestMySQLAlchemyConn(_TestMySQLAlchemy, _TestSQLAlchemyConn):
     pass
 
 
-@pytest.mark.single
 @pytest.mark.db
 class TestPostgreSQLAlchemy(_TestPostgreSQLAlchemy, _TestSQLAlchemy):
     pass
 
 
-@pytest.mark.single
 @pytest.mark.db
 class TestPostgreSQLAlchemyConn(_TestPostgreSQLAlchemy, _TestSQLAlchemyConn):
     pass
 
 
-@pytest.mark.single
 class TestSQLiteAlchemy(_TestSQLiteAlchemy, _TestSQLAlchemy):
     pass
 
 
-@pytest.mark.single
 class TestSQLiteAlchemyConn(_TestSQLiteAlchemy, _TestSQLAlchemyConn):
     pass
 
@@ -2554,7 +2553,6 @@ class TestSQLiteAlchemyConn(_TestSQLiteAlchemy, _TestSQLAlchemyConn):
 # -- Test Sqlite / MySQL fallback
 
 
-@pytest.mark.single
 class TestSQLiteFallback(SQLiteMixIn, PandasSQLTest):
     """
     Test the fallback mode against an in-memory sqlite database.
@@ -2613,9 +2611,17 @@ def test_datetime_date(self):
         elif self.flavor == "mysql":
             tm.assert_frame_equal(res, df)
 
-    def test_datetime_time(self):
+    @pytest.mark.parametrize("tz_aware", [False, True])
+    def test_datetime_time(self, tz_aware):
         # test support for datetime.time, GH #8341
-        df = DataFrame([time(9, 0, 0), time(9, 1, 30)], columns=["a"])
+        if not tz_aware:
+            tz_times = [time(9, 0, 0), time(9, 1, 30)]
+        else:
+            tz_dt = date_range("2013-01-01 09:00:00", periods=2, tz="US/Pacific")
+            tz_times = Series(tz_dt.to_pydatetime()).map(lambda dt: dt.timetz())
+
+        df = DataFrame(tz_times, columns=["a"])
+
         assert df.to_sql("test_time", self.conn, index=False) == 2
         res = read_sql_query("SELECT * FROM test_time", self.conn)
         if self.flavor == "sqlite":
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index f0fd391c2a9c4..745d0691e8d86 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -5,6 +5,7 @@
 import io
 import os
 import struct
+import tarfile
 import warnings
 import zipfile
 
@@ -20,8 +21,8 @@
     Series,
 )
 from pandas.core.indexes.api import ensure_index
+from pandas.tests.io.test_compression import _compression_to_extension
 
-import pandas.io.common as icom
 from pandas.io.parsers import read_csv
 from pandas.io.stata import (
     CategoricalConversionWarning,
@@ -36,7 +37,7 @@
 )
 
 
-@pytest.fixture()
+@pytest.fixture
 def mixed_frame():
     return DataFrame(
         {
@@ -48,84 +49,14 @@ def mixed_frame():
 
 
 @pytest.fixture
-def dirpath(datapath):
-    return datapath("io", "data", "stata")
-
-
-@pytest.fixture
-def parsed_114(dirpath):
-    dta14_114 = os.path.join(dirpath, "stata5_114.dta")
+def parsed_114(datapath):
+    dta14_114 = datapath("io", "data", "stata", "stata5_114.dta")
     parsed_114 = read_stata(dta14_114, convert_dates=True)
     parsed_114.index.name = "index"
     return parsed_114
 
 
 class TestStata:
-    @pytest.fixture(autouse=True)
-    def setup_method(self, datapath):
-        self.dirpath = datapath("io", "data", "stata")
-        self.dta1_114 = os.path.join(self.dirpath, "stata1_114.dta")
-        self.dta1_117 = os.path.join(self.dirpath, "stata1_117.dta")
-
-        self.dta2_113 = os.path.join(self.dirpath, "stata2_113.dta")
-        self.dta2_114 = os.path.join(self.dirpath, "stata2_114.dta")
-        self.dta2_115 = os.path.join(self.dirpath, "stata2_115.dta")
-        self.dta2_117 = os.path.join(self.dirpath, "stata2_117.dta")
-
-        self.dta3_113 = os.path.join(self.dirpath, "stata3_113.dta")
-        self.dta3_114 = os.path.join(self.dirpath, "stata3_114.dta")
-        self.dta3_115 = os.path.join(self.dirpath, "stata3_115.dta")
-        self.dta3_117 = os.path.join(self.dirpath, "stata3_117.dta")
-        self.csv3 = os.path.join(self.dirpath, "stata3.csv")
-
-        self.dta4_113 = os.path.join(self.dirpath, "stata4_113.dta")
-        self.dta4_114 = os.path.join(self.dirpath, "stata4_114.dta")
-        self.dta4_115 = os.path.join(self.dirpath, "stata4_115.dta")
-        self.dta4_117 = os.path.join(self.dirpath, "stata4_117.dta")
-
-        self.dta_encoding = os.path.join(self.dirpath, "stata1_encoding.dta")
-        self.dta_encoding_118 = os.path.join(self.dirpath, "stata1_encoding_118.dta")
-
-        self.csv14 = os.path.join(self.dirpath, "stata5.csv")
-        self.dta14_113 = os.path.join(self.dirpath, "stata5_113.dta")
-        self.dta14_114 = os.path.join(self.dirpath, "stata5_114.dta")
-        self.dta14_115 = os.path.join(self.dirpath, "stata5_115.dta")
-        self.dta14_117 = os.path.join(self.dirpath, "stata5_117.dta")
-
-        self.csv15 = os.path.join(self.dirpath, "stata6.csv")
-        self.dta15_113 = os.path.join(self.dirpath, "stata6_113.dta")
-        self.dta15_114 = os.path.join(self.dirpath, "stata6_114.dta")
-        self.dta15_115 = os.path.join(self.dirpath, "stata6_115.dta")
-        self.dta15_117 = os.path.join(self.dirpath, "stata6_117.dta")
-
-        self.dta16_115 = os.path.join(self.dirpath, "stata7_115.dta")
-        self.dta16_117 = os.path.join(self.dirpath, "stata7_117.dta")
-
-        self.dta17_113 = os.path.join(self.dirpath, "stata8_113.dta")
-        self.dta17_115 = os.path.join(self.dirpath, "stata8_115.dta")
-        self.dta17_117 = os.path.join(self.dirpath, "stata8_117.dta")
-
-        self.dta18_115 = os.path.join(self.dirpath, "stata9_115.dta")
-        self.dta18_117 = os.path.join(self.dirpath, "stata9_117.dta")
-
-        self.dta19_115 = os.path.join(self.dirpath, "stata10_115.dta")
-        self.dta19_117 = os.path.join(self.dirpath, "stata10_117.dta")
-
-        self.dta20_115 = os.path.join(self.dirpath, "stata11_115.dta")
-        self.dta20_117 = os.path.join(self.dirpath, "stata11_117.dta")
-
-        self.dta21_117 = os.path.join(self.dirpath, "stata12_117.dta")
-
-        self.dta22_118 = os.path.join(self.dirpath, "stata14_118.dta")
-        self.dta23 = os.path.join(self.dirpath, "stata15.dta")
-
-        self.dta24_111 = os.path.join(self.dirpath, "stata7_111.dta")
-        self.dta25_118 = os.path.join(self.dirpath, "stata16_118.dta")
-
-        self.dta26_119 = os.path.join(self.dirpath, "stata1_119.dta.gz")
-
-        self.stata_dates = os.path.join(self.dirpath, "stata13_dates.dta")
-
     def read_dta(self, file):
         # Legacy default reader configuration
         return read_stata(file, convert_dates=True)
@@ -142,10 +73,10 @@ def test_read_empty_dta(self, version):
             empty_ds2 = read_stata(path)
             tm.assert_frame_equal(empty_ds, empty_ds2)
 
-    @pytest.mark.parametrize("file", ["dta1_114", "dta1_117"])
-    def test_read_dta1(self, file):
+    @pytest.mark.parametrize("file", ["stata1_114", "stata1_117"])
+    def test_read_dta1(self, file, datapath):
 
-        file = getattr(self, file)
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = self.read_dta(file)
 
         # Pandas uses np.nan as missing value.
@@ -161,7 +92,7 @@ def test_read_dta1(self, file):
 
         tm.assert_frame_equal(parsed, expected)
 
-    def test_read_dta2(self):
+    def test_read_dta2(self, datapath):
 
         expected = DataFrame.from_records(
             [
@@ -202,11 +133,19 @@ def test_read_dta2(self):
 
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")
-            parsed_114 = self.read_dta(self.dta2_114)
-            parsed_115 = self.read_dta(self.dta2_115)
-            parsed_117 = self.read_dta(self.dta2_117)
+            parsed_114 = self.read_dta(
+                datapath("io", "data", "stata", "stata2_114.dta")
+            )
+            parsed_115 = self.read_dta(
+                datapath("io", "data", "stata", "stata2_115.dta")
+            )
+            parsed_117 = self.read_dta(
+                datapath("io", "data", "stata", "stata2_117.dta")
+            )
             # 113 is buggy due to limits of date format support in Stata
-            # parsed_113 = self.read_dta(self.dta2_113)
+            # parsed_113 = self.read_dta(
+            # datapath("io", "data", "stata", "stata2_113.dta")
+            # )
 
             # Remove resource warnings
             w = [x for x in w if x.category is UserWarning]
@@ -221,24 +160,28 @@ def test_read_dta2(self):
         tm.assert_frame_equal(parsed_115, expected, check_datetimelike_compat=True)
         tm.assert_frame_equal(parsed_117, expected, check_datetimelike_compat=True)
 
-    @pytest.mark.parametrize("file", ["dta3_113", "dta3_114", "dta3_115", "dta3_117"])
-    def test_read_dta3(self, file):
+    @pytest.mark.parametrize(
+        "file", ["stata3_113", "stata3_114", "stata3_115", "stata3_117"]
+    )
+    def test_read_dta3(self, file, datapath):
 
-        file = getattr(self, file)
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = self.read_dta(file)
 
         # match stata here
-        expected = self.read_csv(self.csv3)
+        expected = self.read_csv(datapath("io", "data", "stata", "stata3.csv"))
         expected = expected.astype(np.float32)
         expected["year"] = expected["year"].astype(np.int16)
         expected["quarter"] = expected["quarter"].astype(np.int8)
 
         tm.assert_frame_equal(parsed, expected)
 
-    @pytest.mark.parametrize("file", ["dta4_113", "dta4_114", "dta4_115", "dta4_117"])
-    def test_read_dta4(self, file):
+    @pytest.mark.parametrize(
+        "file", ["stata4_113", "stata4_114", "stata4_115", "stata4_117"]
+    )
+    def test_read_dta4(self, file, datapath):
 
-        file = getattr(self, file)
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = self.read_dta(file)
 
         expected = DataFrame.from_records(
@@ -281,8 +224,8 @@ def test_read_dta4(self, file):
         tm.assert_frame_equal(parsed, expected)
 
     # File containing strls
-    def test_read_dta12(self):
-        parsed_117 = self.read_dta(self.dta21_117)
+    def test_read_dta12(self, datapath):
+        parsed_117 = self.read_dta(datapath("io", "data", "stata", "stata12_117.dta"))
         expected = DataFrame.from_records(
             [
                 [1, "abc", "abcdefghi"],
@@ -294,8 +237,8 @@ def test_read_dta12(self):
 
         tm.assert_frame_equal(parsed_117, expected, check_dtype=False)
 
-    def test_read_dta18(self):
-        parsed_118 = self.read_dta(self.dta22_118)
+    def test_read_dta18(self, datapath):
+        parsed_118 = self.read_dta(datapath("io", "data", "stata", "stata14_118.dta"))
         parsed_118["Bytes"] = parsed_118["Bytes"].astype("O")
         expected = DataFrame.from_records(
             [
@@ -319,7 +262,7 @@ def test_read_dta18(self):
         for col in parsed_118.columns:
             tm.assert_almost_equal(parsed_118[col], expected[col])
 
-        with StataReader(self.dta22_118) as rdr:
+        with StataReader(datapath("io", "data", "stata", "stata14_118.dta")) as rdr:
             vl = rdr.variable_labels()
             vl_expected = {
                 "Unicode_Cities_Strl": "Here are some strls with Ünicode chars",
@@ -342,19 +285,19 @@ def test_read_write_dta5(self):
         original.index.name = "index"
 
         with tm.ensure_clean() as path:
-            original.to_stata(path, None)
+            original.to_stata(path, convert_dates=None)
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), original)
 
-    def test_write_dta6(self):
-        original = self.read_csv(self.csv3)
+    def test_write_dta6(self, datapath):
+        original = self.read_csv(datapath("io", "data", "stata", "stata3.csv"))
         original.index.name = "index"
         original.index = original.index.astype(np.int32)
         original["year"] = original["year"].astype(np.int32)
         original["quarter"] = original["quarter"].astype(np.int32)
 
         with tm.ensure_clean() as path:
-            original.to_stata(path, None)
+            original.to_stata(path, convert_dates=None)
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(
                 written_and_read_again.set_index("index"),
@@ -374,7 +317,7 @@ def test_read_write_dta10(self, version):
         original["integer"] = original["integer"].astype(np.int32)
 
         with tm.ensure_clean() as path:
-            original.to_stata(path, {"datetime": "tc"}, version=version)
+            original.to_stata(path, convert_dates={"datetime": "tc"}, version=version)
             written_and_read_again = self.read_dta(path)
             # original.index is np.int32, read index is np.int64
             tm.assert_frame_equal(
@@ -399,11 +342,11 @@ def test_write_preserves_original(self):
         tm.assert_frame_equal(df, df_copy)
 
     @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
-    def test_encoding(self, version):
+    def test_encoding(self, version, datapath):
 
         # GH 4626, proper encoding handling
-        raw = read_stata(self.dta_encoding)
-        encoded = read_stata(self.dta_encoding)
+        raw = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
+        encoded = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
         result = encoded.kreis1849[0]
 
         expected = raw.kreis1849[0]
@@ -434,7 +377,7 @@ def test_read_write_dta11(self):
 
         with tm.ensure_clean() as path:
             with tm.assert_produces_warning(InvalidColumnName):
-                original.to_stata(path, None)
+                original.to_stata(path, convert_dates=None)
 
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), formatted)
@@ -469,7 +412,7 @@ def test_read_write_dta12(self, version):
         with tm.ensure_clean() as path:
             with warnings.catch_warnings(record=True) as w:
                 warnings.simplefilter("always", InvalidColumnName)
-                original.to_stata(path, None, version=version)
+                original.to_stata(path, convert_dates=None, version=version)
                 # should get a warning for that format.
                 assert len(w) == 1
 
@@ -477,9 +420,9 @@ def test_read_write_dta12(self, version):
             tm.assert_frame_equal(written_and_read_again.set_index("index"), formatted)
 
     def test_read_write_dta13(self):
-        s1 = Series(2 ** 9, dtype=np.int16)
-        s2 = Series(2 ** 17, dtype=np.int32)
-        s3 = Series(2 ** 33, dtype=np.int64)
+        s1 = Series(2**9, dtype=np.int16)
+        s2 = Series(2**17, dtype=np.int32)
+        s3 = Series(2**33, dtype=np.int64)
         original = DataFrame({"int16": s1, "int32": s2, "int64": s3})
         original.index.name = "index"
 
@@ -493,14 +436,14 @@ def test_read_write_dta13(self):
 
     @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     @pytest.mark.parametrize(
-        "file", ["dta14_113", "dta14_114", "dta14_115", "dta14_117"]
+        "file", ["stata5_113", "stata5_114", "stata5_115", "stata5_117"]
     )
-    def test_read_write_reread_dta14(self, file, parsed_114, version):
-        file = getattr(self, file)
+    def test_read_write_reread_dta14(self, file, parsed_114, version, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = self.read_dta(file)
         parsed.index.name = "index"
 
-        expected = self.read_csv(self.csv14)
+        expected = self.read_csv(datapath("io", "data", "stata", "stata5.csv"))
         cols = ["byte_", "int_", "long_", "float_", "double_"]
         for col in cols:
             expected[col] = expected[col]._convert(datetime=True, numeric=True)
@@ -510,16 +453,16 @@ def test_read_write_reread_dta14(self, file, parsed_114, version):
         tm.assert_frame_equal(parsed_114, parsed)
 
         with tm.ensure_clean() as path:
-            parsed_114.to_stata(path, {"date_td": "td"}, version=version)
+            parsed_114.to_stata(path, convert_dates={"date_td": "td"}, version=version)
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), parsed_114)
 
     @pytest.mark.parametrize(
-        "file", ["dta15_113", "dta15_114", "dta15_115", "dta15_117"]
+        "file", ["stata6_113", "stata6_114", "stata6_115", "stata6_117"]
     )
-    def test_read_write_reread_dta15(self, file):
+    def test_read_write_reread_dta15(self, file, datapath):
 
-        expected = self.read_csv(self.csv15)
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
         expected["byte_"] = expected["byte_"].astype(np.int8)
         expected["int_"] = expected["int_"].astype(np.int16)
         expected["long_"] = expected["long_"].astype(np.int32)
@@ -529,7 +472,7 @@ def test_read_write_reread_dta15(self, file):
             datetime.strptime, args=("%Y-%m-%d",)
         )
 
-        file = getattr(self, file)
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = self.read_dta(file)
 
         tm.assert_frame_equal(expected, parsed)
@@ -610,8 +553,8 @@ def test_string_no_dates(self):
     def test_large_value_conversion(self):
         s0 = Series([1, 99], dtype=np.int8)
         s1 = Series([1, 127], dtype=np.int8)
-        s2 = Series([1, 2 ** 15 - 1], dtype=np.int16)
-        s3 = Series([1, 2 ** 63 - 1], dtype=np.int64)
+        s2 = Series([1, 2**15 - 1], dtype=np.int16)
+        s3 = Series([1, 2**63 - 1], dtype=np.int64)
         original = DataFrame({"s0": s0, "s1": s1, "s2": s2, "s3": s3})
         original.index.name = "index"
         with tm.ensure_clean() as path:
@@ -630,17 +573,17 @@ def test_dates_invalid_column(self):
         original.index.name = "index"
         with tm.ensure_clean() as path:
             with tm.assert_produces_warning(InvalidColumnName):
-                original.to_stata(path, {0: "tc"})
+                original.to_stata(path, convert_dates={0: "tc"})
 
             written_and_read_again = self.read_dta(path)
             modified = original.copy()
             modified.columns = ["_0"]
             tm.assert_frame_equal(written_and_read_again.set_index("index"), modified)
 
-    def test_105(self):
+    def test_105(self, datapath):
         # Data obtained from:
         # http://go.worldbank.org/ZXY29PVJ21
-        dpath = os.path.join(self.dirpath, "S4_EDUC1.dta")
+        dpath = datapath("io", "data", "stata", "S4_EDUC1.dta")
         df = read_stata(dpath)
         df0 = [[1, 1, 3, -2], [2, 1, 2, -2], [4, 1, 1, -2]]
         df0 = DataFrame(df0)
@@ -651,12 +594,12 @@ def test_105(self):
         df0["psch_dis"] = df0["psch_dis"].astype(np.float32)
         tm.assert_frame_equal(df.head(3), df0)
 
-    def test_value_labels_old_format(self):
+    def test_value_labels_old_format(self, datapath):
         # GH 19417
         #
         # Test that value_labels() returns an empty dict if the file format
         # predates supporting value labels.
-        dpath = os.path.join(self.dirpath, "S4_EDUC1.dta")
+        dpath = datapath("io", "data", "stata", "S4_EDUC1.dta")
         reader = StataReader(dpath)
         assert reader.value_labels() == {}
         reader.close()
@@ -680,7 +623,7 @@ def test_date_export_formats(self):
         expected = DataFrame([expected_values], columns=columns)
         expected.index.name = "index"
         with tm.ensure_clean() as path:
-            original.to_stata(path, conversions)
+            original.to_stata(path, convert_dates=conversions)
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
 
@@ -699,10 +642,10 @@ def test_bool_uint(self, byteorder, version):
         s0 = Series([0, 1, True], dtype=np.bool_)
         s1 = Series([0, 1, 100], dtype=np.uint8)
         s2 = Series([0, 1, 255], dtype=np.uint8)
-        s3 = Series([0, 1, 2 ** 15 - 100], dtype=np.uint16)
-        s4 = Series([0, 1, 2 ** 16 - 1], dtype=np.uint16)
-        s5 = Series([0, 1, 2 ** 31 - 100], dtype=np.uint32)
-        s6 = Series([0, 1, 2 ** 32 - 1], dtype=np.uint32)
+        s3 = Series([0, 1, 2**15 - 100], dtype=np.uint16)
+        s4 = Series([0, 1, 2**16 - 1], dtype=np.uint16)
+        s5 = Series([0, 1, 2**31 - 100], dtype=np.uint32)
+        s6 = Series([0, 1, 2**32 - 1], dtype=np.uint32)
 
         original = DataFrame(
             {"s0": s0, "s1": s1, "s2": s2, "s3": s3, "s4": s4, "s5": s5, "s6": s6}
@@ -727,10 +670,10 @@ def test_bool_uint(self, byteorder, version):
             written_and_read_again = written_and_read_again.set_index("index")
             tm.assert_frame_equal(written_and_read_again, expected)
 
-    def test_variable_labels(self):
-        with StataReader(self.dta16_115) as rdr:
+    def test_variable_labels(self, datapath):
+        with StataReader(datapath("io", "data", "stata", "stata7_115.dta")) as rdr:
             sr_115 = rdr.variable_labels()
-        with StataReader(self.dta16_117) as rdr:
+        with StataReader(datapath("io", "data", "stata", "stata7_117.dta")) as rdr:
             sr_117 = rdr.variable_labels()
         keys = ("var1", "var2", "var3")
         labels = ("label1", "label2", "label3")
@@ -808,8 +751,8 @@ def test_missing_value_generator(self):
         )
         assert val.string == ".z"
 
-    @pytest.mark.parametrize("file", ["dta17_113", "dta17_115", "dta17_117"])
-    def test_missing_value_conversion(self, file):
+    @pytest.mark.parametrize("file", ["stata8_113", "stata8_115", "stata8_117"])
+    def test_missing_value_conversion(self, file, datapath):
         columns = ["int8_", "int16_", "int32_", "float32_", "float64_"]
         smv = StataMissingValue(101)
         keys = sorted(smv.MISSING_VALUES.keys())
@@ -819,10 +762,12 @@ def test_missing_value_conversion(self, file):
             data.append(row)
         expected = DataFrame(data, columns=columns)
 
-        parsed = read_stata(getattr(self, file), convert_missing=True)
+        parsed = read_stata(
+            datapath("io", "data", "stata", f"{file}.dta"), convert_missing=True
+        )
         tm.assert_frame_equal(parsed, expected)
 
-    def test_big_dates(self):
+    def test_big_dates(self, datapath):
         yr = [1960, 2000, 9999, 100, 2262, 1677]
         mo = [1, 1, 12, 1, 4, 9]
         dd = [1, 1, 31, 1, 22, 23]
@@ -863,8 +808,8 @@ def test_big_dates(self):
         expected[5][5] = expected[5][6] = datetime(1678, 1, 1)
 
         expected = DataFrame(expected, columns=columns, dtype=object)
-        parsed_115 = read_stata(self.dta18_115)
-        parsed_117 = read_stata(self.dta18_117)
+        parsed_115 = read_stata(datapath("io", "data", "stata", "stata9_115.dta"))
+        parsed_117 = read_stata(datapath("io", "data", "stata", "stata9_117.dta"))
         tm.assert_frame_equal(expected, parsed_115, check_datetimelike_compat=True)
         tm.assert_frame_equal(expected, parsed_117, check_datetimelike_compat=True)
 
@@ -872,7 +817,8 @@ def test_big_dates(self):
         # {c : c[-2:] for c in columns}
         with tm.ensure_clean() as path:
             expected.index.name = "index"
-            expected.to_stata(path, date_conversion)
+            with tm.assert_produces_warning(FutureWarning, match="keyword-only"):
+                expected.to_stata(path, date_conversion)
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(
                 written_and_read_again.set_index("index"),
@@ -880,8 +826,8 @@ def test_big_dates(self):
                 check_datetimelike_compat=True,
             )
 
-    def test_dtype_conversion(self):
-        expected = self.read_csv(self.csv15)
+    def test_dtype_conversion(self, datapath):
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
         expected["byte_"] = expected["byte_"].astype(np.int8)
         expected["int_"] = expected["int_"].astype(np.int16)
         expected["long_"] = expected["long_"].astype(np.int32)
@@ -891,23 +837,27 @@ def test_dtype_conversion(self):
             datetime.strptime, args=("%Y-%m-%d",)
         )
 
-        no_conversion = read_stata(self.dta15_117, convert_dates=True)
+        no_conversion = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"), convert_dates=True
+        )
         tm.assert_frame_equal(expected, no_conversion)
 
         conversion = read_stata(
-            self.dta15_117, convert_dates=True, preserve_dtypes=False
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            preserve_dtypes=False,
         )
 
         # read_csv types are the same
-        expected = self.read_csv(self.csv15)
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
         expected["date_td"] = expected["date_td"].apply(
             datetime.strptime, args=("%Y-%m-%d",)
         )
 
         tm.assert_frame_equal(expected, conversion)
 
-    def test_drop_column(self):
-        expected = self.read_csv(self.csv15)
+    def test_drop_column(self, datapath):
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
         expected["byte_"] = expected["byte_"].astype(np.int8)
         expected["int_"] = expected["int_"].astype(np.int16)
         expected["long_"] = expected["long_"].astype(np.int32)
@@ -919,25 +869,41 @@ def test_drop_column(self):
 
         columns = ["byte_", "int_", "long_"]
         expected = expected[columns]
-        dropped = read_stata(self.dta15_117, convert_dates=True, columns=columns)
+        dropped = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            columns=columns,
+        )
 
         tm.assert_frame_equal(expected, dropped)
 
         # See PR 10757
         columns = ["int_", "long_", "byte_"]
         expected = expected[columns]
-        reordered = read_stata(self.dta15_117, convert_dates=True, columns=columns)
+        reordered = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            columns=columns,
+        )
         tm.assert_frame_equal(expected, reordered)
 
         msg = "columns contains duplicate entries"
         with pytest.raises(ValueError, match=msg):
             columns = ["byte_", "byte_"]
-            read_stata(self.dta15_117, convert_dates=True, columns=columns)
+            read_stata(
+                datapath("io", "data", "stata", "stata6_117.dta"),
+                convert_dates=True,
+                columns=columns,
+            )
 
         msg = "The following columns were not found in the Stata data set: not_found"
         with pytest.raises(ValueError, match=msg):
             columns = ["byte_", "int_", "long_", "not_found"]
-            read_stata(self.dta15_117, convert_dates=True, columns=columns)
+            read_stata(
+                datapath("io", "data", "stata", "stata6_117.dta"),
+                convert_dates=True,
+                columns=columns,
+            )
 
     @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     @pytest.mark.filterwarnings(
@@ -1046,8 +1012,8 @@ def test_categorical_with_stata_missing_values(self, version):
                 expected[col] = cat
             tm.assert_frame_equal(res, expected)
 
-    @pytest.mark.parametrize("file", ["dta19_115", "dta19_117"])
-    def test_categorical_order(self, file):
+    @pytest.mark.parametrize("file", ["stata10_115", "stata10_117"])
+    def test_categorical_order(self, file, datapath):
         # Directly construct using expected codes
         # Format is is_cat, col_name, labels (in order), underlying data
         expected = [
@@ -1070,7 +1036,7 @@ def test_categorical_order(self, file):
         expected = DataFrame.from_dict(dict(cols))
 
         # Read with and with out categoricals, ensure order is identical
-        file = getattr(self, file)
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = read_stata(file)
         tm.assert_frame_equal(expected, parsed)
 
@@ -1082,9 +1048,9 @@ def test_categorical_order(self, file):
                     expected[col].cat.categories, parsed[col].cat.categories
                 )
 
-    @pytest.mark.parametrize("file", ["dta20_115", "dta20_117"])
-    def test_categorical_sorting(self, file):
-        parsed = read_stata(getattr(self, file))
+    @pytest.mark.parametrize("file", ["stata11_115", "stata11_117"])
+    def test_categorical_sorting(self, file, datapath):
+        parsed = read_stata(datapath("io", "data", "stata", f"{file}.dta"))
 
         # Sort based on codes, not strings
         parsed = parsed.sort_values("srh", na_position="first")
@@ -1099,9 +1065,9 @@ def test_categorical_sorting(self, file):
         expected = Series(cat, name="srh")
         tm.assert_series_equal(expected, parsed["srh"])
 
-    @pytest.mark.parametrize("file", ["dta19_115", "dta19_117"])
-    def test_categorical_ordering(self, file):
-        file = getattr(self, file)
+    @pytest.mark.parametrize("file", ["stata10_115", "stata10_117"])
+    def test_categorical_ordering(self, file, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
         parsed = read_stata(file)
 
         parsed_unordered = read_stata(file, order_categoricals=False)
@@ -1114,26 +1080,26 @@ def test_categorical_ordering(self, file):
     @pytest.mark.parametrize(
         "file",
         [
-            "dta1_117",
-            "dta2_117",
-            "dta3_117",
-            "dta4_117",
-            "dta14_117",
-            "dta15_117",
-            "dta16_117",
-            "dta17_117",
-            "dta18_117",
-            "dta19_117",
-            "dta20_117",
+            "stata1_117",
+            "stata2_117",
+            "stata3_117",
+            "stata4_117",
+            "stata5_117",
+            "stata6_117",
+            "stata7_117",
+            "stata8_117",
+            "stata9_117",
+            "stata10_117",
+            "stata11_117",
         ],
     )
     @pytest.mark.parametrize("chunksize", [1, 2])
     @pytest.mark.parametrize("convert_categoricals", [False, True])
     @pytest.mark.parametrize("convert_dates", [False, True])
     def test_read_chunks_117(
-        self, file, chunksize, convert_categoricals, convert_dates
+        self, file, chunksize, convert_categoricals, convert_dates, datapath
     ):
-        fname = getattr(self, file)
+        fname = datapath("io", "data", "stata", f"{file}.dta")
 
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("always")
@@ -1181,9 +1147,8 @@ def _convert_categorical(from_frame: DataFrame) -> DataFrame:
                 from_frame[col] = cat
         return from_frame
 
-    def test_iterator(self):
-
-        fname = self.dta3_117
+    def test_iterator(self, datapath):
+        fname = datapath("io", "data", "stata", "stata3_117.dta")
 
         parsed = read_stata(fname)
 
@@ -1211,25 +1176,25 @@ def test_iterator(self):
     @pytest.mark.parametrize(
         "file",
         [
-            "dta2_115",
-            "dta3_115",
-            "dta4_115",
-            "dta14_115",
-            "dta15_115",
-            "dta16_115",
-            "dta17_115",
-            "dta18_115",
-            "dta19_115",
-            "dta20_115",
+            "stata2_115",
+            "stata3_115",
+            "stata4_115",
+            "stata5_115",
+            "stata6_115",
+            "stata7_115",
+            "stata8_115",
+            "stata9_115",
+            "stata10_115",
+            "stata11_115",
         ],
     )
     @pytest.mark.parametrize("chunksize", [1, 2])
     @pytest.mark.parametrize("convert_categoricals", [False, True])
     @pytest.mark.parametrize("convert_dates", [False, True])
     def test_read_chunks_115(
-        self, file, chunksize, convert_categoricals, convert_dates
+        self, file, chunksize, convert_categoricals, convert_dates, datapath
     ):
-        fname = getattr(self, file)
+        fname = datapath("io", "data", "stata", f"{file}.dta")
 
         # Read the whole file
         with warnings.catch_warnings(record=True):
@@ -1264,8 +1229,8 @@ def test_read_chunks_115(
             pos += chunksize
         itr.close()
 
-    def test_read_chunks_columns(self):
-        fname = self.dta3_117
+    def test_read_chunks_columns(self, datapath):
+        fname = datapath("io", "data", "stata", "stata3_117.dta")
         columns = ["quarter", "cpi", "m1"]
         chunksize = 2
 
@@ -1426,7 +1391,7 @@ def test_unsupported_datetype(self):
             with tm.ensure_clean() as path:
                 original.to_stata(path)
 
-    def test_repeated_column_labels(self):
+    def test_repeated_column_labels(self, datapath):
         # GH 13923, 25772
         msg = """
 Value labels for column ethnicsn are not unique. These cannot be converted to
@@ -1439,13 +1404,16 @@ def test_repeated_column_labels(self):
 The repeated labels are:\n-+\nwolof
 """
         with pytest.raises(ValueError, match=msg):
-            read_stata(self.dta23, convert_categoricals=True)
+            read_stata(
+                datapath("io", "data", "stata", "stata15.dta"),
+                convert_categoricals=True,
+            )
 
-    def test_stata_111(self):
+    def test_stata_111(self, datapath):
         # 111 is an old version but still used by current versions of
         # SAS when exporting to Stata format. We do not know of any
         # on-line documentation for this version.
-        df = read_stata(self.dta24_111)
+        df = read_stata(datapath("io", "data", "stata", "stata7_111.dta"))
         original = DataFrame(
             {
                 "y": [1, 1, 1, 1, 1, 0, 0, np.NaN, 0, 0],
@@ -1473,15 +1441,6 @@ def test_out_of_range_double(self):
             with tm.ensure_clean() as path:
                 df.to_stata(path)
 
-        df.loc[2, "ColumnTooBig"] = np.inf
-        msg = (
-            "Column ColumnTooBig has a maximum value of infinity which is outside "
-            "the range supported by Stata"
-        )
-        with pytest.raises(ValueError, match=msg):
-            with tm.ensure_clean() as path:
-                df.to_stata(path)
-
     def test_out_of_range_float(self):
         original = DataFrame(
             {
@@ -1507,14 +1466,17 @@ def test_out_of_range_float(self):
             original["ColumnTooBig"] = original["ColumnTooBig"].astype(np.float64)
             tm.assert_frame_equal(original, reread.set_index("index"))
 
-        original.loc[2, "ColumnTooBig"] = np.inf
+    @pytest.mark.parametrize("infval", [np.inf, -np.inf])
+    def test_inf(self, infval):
+        # GH 45350
+        df = DataFrame({"WithoutInf": [0.0, 1.0], "WithInf": [2.0, infval]})
         msg = (
-            "Column ColumnTooBig has a maximum value of infinity which "
-            "is outside the range supported by Stata"
+            "Column WithInf contains infinity or -infinity"
+            "which is outside the range supported by Stata."
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
-                original.to_stata(path)
+                df.to_stata(path)
 
     def test_path_pathlib(self):
         df = tm.makeDataFrame()
@@ -1555,7 +1517,7 @@ def test_set_index(self):
     @pytest.mark.parametrize(
         "column", ["ms", "day", "week", "month", "qtr", "half", "yr"]
     )
-    def test_date_parsing_ignores_format_details(self, column):
+    def test_date_parsing_ignores_format_details(self, column, datapath):
         # GH 17797
         #
         # Test that display formats are ignored when determining if a numeric
@@ -1567,7 +1529,7 @@ def test_date_parsing_ignores_format_details(self, column):
         # STATA supports 9 date types which each have distinct units. We test 7
         # of the 9 types, ignoring %tC and %tb. %tC is a variant of %tc that
         # accounts for leap seconds and %tb relies on STATAs business calendar.
-        df = read_stata(self.stata_dates)
+        df = read_stata(datapath("io", "data", "stata", "stata13_dates.dta"))
         unformatted = df.loc[0, column]
         formatted = df.loc[0, column + "_fmt"]
         assert unformatted == formatted
@@ -1703,8 +1665,8 @@ def test_gzip_writing(self):
                 reread = read_stata(gz, index_col="index")
         tm.assert_frame_equal(df, reread)
 
-    def test_unicode_dta_118(self):
-        unicode_df = self.read_dta(self.dta25_118)
+    def test_unicode_dta_118(self, datapath):
+        unicode_df = self.read_dta(datapath("io", "data", "stata", "stata16_118.dta"))
 
         columns = ["utf8", "latin1", "ascii", "utf8_strl", "ascii_strl"]
         values = [
@@ -1733,7 +1695,7 @@ def test_mixed_string_strl(self):
             tm.assert_frame_equal(reread, expected)
 
             # Check strl supports all None (null)
-            output.loc[:, "mixed"] = None
+            output["mixed"] = None
             output.to_stata(
                 path, write_index=False, convert_strl=["mixed"], version=117
             )
@@ -1745,7 +1707,7 @@ def test_mixed_string_strl(self):
     def test_all_none_exception(self, version):
         output = [{"none": "none", "number": 0}, {"none": None, "number": 1}]
         output = DataFrame(output)
-        output.loc[:, "none"] = None
+        output["none"] = None
         with tm.ensure_clean() as path:
             with pytest.raises(ValueError, match="Column `none` cannot be exported"):
                 output.to_stata(path, version=version)
@@ -1786,7 +1748,7 @@ def test_strl_latin1(self):
                     size = gso[gso.find(b"\x82") + 1]
                     assert len(val) == size - 1
 
-    def test_encoding_latin1_118(self):
+    def test_encoding_latin1_118(self, datapath):
         # GH 25960
         msg = """
 One or more strings in the dta file could not be decoded using utf-8, and
@@ -1794,7 +1756,9 @@ def test_encoding_latin1_118(self):
 has been incorrectly encoded by Stata or some other software. You should verify
 the string values returned are correct."""
         with tm.assert_produces_warning(UnicodeWarning) as w:
-            encoded = read_stata(self.dta_encoding_118)
+            encoded = read_stata(
+                datapath("io", "data", "stata", "stata1_encoding_118.dta")
+            )
             assert len(w) == 151
             assert w[0].message.args[0] == msg
 
@@ -1802,9 +1766,11 @@ def test_encoding_latin1_118(self):
         tm.assert_frame_equal(encoded, expected)
 
     @pytest.mark.slow
-    def test_stata_119(self):
+    def test_stata_119(self, datapath):
         # Gzipped since contains 32,999 variables and uncompressed is 20MiB
-        with gzip.open(self.dta26_119, "rb") as gz:
+        with gzip.open(
+            datapath("io", "data", "stata", "stata1_119.dta.gz"), "rb"
+        ) as gz:
             df = read_stata(gz)
         assert df.shape == (1, 32999)
         assert df.iloc[0, 6] == "A" * 3000
@@ -1821,17 +1787,18 @@ def test_utf8_writer(self, version):
                 [2.0, 2, "ᴮ", ""],
                 [3.0, 3, "ᴰ", None],
             ],
-            columns=["a", "β", "ĉ", "strls"],
+            columns=["Å", "β", "ĉ", "strls"],
         )
         data["ᴐᴬᵀ"] = cat
         variable_labels = {
-            "a": "apple",
+            "Å": "apple",
             "β": "ᵈᵉᵊ",
             "ĉ": "ᴎტჄႲႳႴႶႺ",
             "strls": "Long Strings",
             "ᴐᴬᵀ": "",
         }
         data_label = "ᴅaᵀa-label"
+        value_labels = {"β": {1: "label", 2: "æøå", 3: "ŋot valid latin-1"}}
         data["β"] = data["β"].astype(np.int32)
         with tm.ensure_clean() as path:
             writer = StataWriterUTF8(
@@ -1842,11 +1809,16 @@ def test_utf8_writer(self, version):
                 variable_labels=variable_labels,
                 write_index=False,
                 version=version,
+                value_labels=value_labels,
             )
             writer.write_file()
             reread_encoded = read_stata(path)
             # Missing is intentionally converted to empty strl
             data["strls"] = data["strls"].fillna("")
+            # Variable with value labels is reread as categorical
+            data["β"] = (
+                data["β"].replace(value_labels["β"]).astype("category").cat.as_ordered()
+            )
             tm.assert_frame_equal(data, reread_encoded)
             reader = StataReader(path)
             assert reader.data_label == data_label
@@ -1885,7 +1857,7 @@ def test_compression(compression, version, use_dict, infer):
         if use_dict:
             file_ext = compression
         else:
-            file_ext = icom._compression_to_extension[compression]
+            file_ext = _compression_to_extension[compression]
         file_name += f".{file_ext}"
     compression_arg = compression
     if infer:
@@ -1903,6 +1875,9 @@ def test_compression(compression, version, use_dict, infer):
         elif compression == "zip":
             with zipfile.ZipFile(path, "r") as comp:
                 fp = io.BytesIO(comp.read(comp.filelist[0]))
+        elif compression == "tar":
+            with tarfile.open(path) as tar:
+                fp = io.BytesIO(tar.extractfile(tar.getnames()[0]).read())
         elif compression == "bz2":
             with bz2.open(path, "rb") as comp:
                 fp = io.BytesIO(comp.read())
@@ -1954,8 +1929,8 @@ def test_chunked_categorical(version):
             tm.assert_series_equal(block.cats, df.cats.iloc[2 * i : 2 * (i + 1)])
 
 
-def test_chunked_categorical_partial(dirpath):
-    dta_file = os.path.join(dirpath, "stata-dta-partially-labeled.dta")
+def test_chunked_categorical_partial(datapath):
+    dta_file = datapath("io", "data", "stata", "stata-dta-partially-labeled.dta")
     values = ["a", "b", "a", "b", 3.0]
     with StataReader(dta_file, chunksize=2) as reader:
         with tm.assert_produces_warning(CategoricalConversionWarning):
@@ -1973,14 +1948,11 @@ def test_chunked_categorical_partial(dirpath):
     tm.assert_frame_equal(direct, large_chunk)
 
 
-def test_iterator_errors(dirpath):
-    dta_file = os.path.join(dirpath, "stata-dta-partially-labeled.dta")
-    with pytest.raises(ValueError, match="chunksize must be a positive"):
-        StataReader(dta_file, chunksize=-1)
-    with pytest.raises(ValueError, match="chunksize must be a positive"):
-        StataReader(dta_file, chunksize=0)
+@pytest.mark.parametrize("chunksize", (-1, 0, "apple"))
+def test_iterator_errors(datapath, chunksize):
+    dta_file = datapath("io", "data", "stata", "stata-dta-partially-labeled.dta")
     with pytest.raises(ValueError, match="chunksize must be a positive"):
-        StataReader(dta_file, chunksize="apple")
+        StataReader(dta_file, chunksize=chunksize)
 
 
 def test_iterator_value_labels():
@@ -1999,7 +1971,7 @@ def test_iterator_value_labels():
 
 def test_precision_loss():
     df = DataFrame(
-        [[sum(2 ** i for i in range(60)), sum(2 ** i for i in range(52))]],
+        [[sum(2**i for i in range(60)), sum(2**i for i in range(52))]],
         columns=["big", "little"],
     )
     with tm.ensure_clean() as path:
@@ -2040,7 +2012,7 @@ def test_compression_roundtrip(compression):
 def test_stata_compression(compression_only, read_infer, to_infer):
     compression = compression_only
 
-    ext = icom._compression_to_extension[compression]
+    ext = _compression_to_extension[compression]
     filename = f"test.{ext}"
 
     df = DataFrame(
@@ -2086,7 +2058,7 @@ def test_non_categorical_value_labels():
         msg = "Can't create value labels for notY, it wasn't found in the dataset."
         with pytest.raises(KeyError, match=msg):
             value_labels = {"notY": {7: "label1", 8: "label2"}}
-            writer = StataWriter(path, data, value_labels=value_labels)
+            StataWriter(path, data, value_labels=value_labels)
 
         msg = (
             "Can't create value labels for Z, value labels "
@@ -2094,7 +2066,7 @@ def test_non_categorical_value_labels():
         )
         with pytest.raises(ValueError, match=msg):
             value_labels = {"Z": {1: "a", 2: "k", 3: "j", 4: "i"}}
-            writer = StataWriter(path, data, value_labels=value_labels)
+            StataWriter(path, data, value_labels=value_labels)
 
 
 def test_non_categorical_value_label_name_conversion():
diff --git a/pandas/tests/io/test_user_agent.py b/pandas/tests/io/test_user_agent.py
index fb6128bd514f9..ac4ca5dce6dc3 100644
--- a/pandas/tests/io/test_user_agent.py
+++ b/pandas/tests/io/test_user_agent.py
@@ -11,11 +11,19 @@
 
 import pytest
 
+from pandas.compat import is_ci_environment
 import pandas.util._test_decorators as td
 
 import pandas as pd
 import pandas._testing as tm
 
+pytestmark = pytest.mark.skipif(
+    is_ci_environment(),
+    reason="This test can hang in our CI min_versions build "
+    "and leads to '##[error]The runner has "
+    "received a shutdown signal...' in GHA. GH 45651",
+)
+
 
 class BaseUserAgentResponder(http.server.BaseHTTPRequestHandler):
     """
@@ -217,6 +225,7 @@ def responder(request):
     )
     server_process.start()
     yield port
+    server_process.join(10)
     server_process.terminate()
     kill_time = 5
     wait_time = 0
@@ -241,7 +250,9 @@ def responder(request):
             pd.read_parquet,
             "fastparquet",
             # TODO(ArrayManager) fastparquet
-            marks=td.skip_array_manager_not_yet_implemented,
+            marks=[
+                td.skip_array_manager_not_yet_implemented,
+            ],
         ),
         (PickleUserAgentResponder, pd.read_pickle, None),
         (StataUserAgentResponder, pd.read_stata, None),
@@ -276,7 +287,9 @@ def test_server_and_default_headers(responder, read_method, parquet_engine):
             pd.read_parquet,
             "fastparquet",
             # TODO(ArrayManager) fastparquet
-            marks=td.skip_array_manager_not_yet_implemented,
+            marks=[
+                td.skip_array_manager_not_yet_implemented,
+            ],
         ),
         (PickleUserAgentResponder, pd.read_pickle, None),
         (StataUserAgentResponder, pd.read_stata, None),
diff --git a/pandas/tests/io/xml/test_to_xml.py b/pandas/tests/io/xml/test_to_xml.py
index aeec163ed134a..0f42c7e070c4a 100644
--- a/pandas/tests/io/xml/test_to_xml.py
+++ b/pandas/tests/io/xml/test_to_xml.py
@@ -17,8 +17,8 @@
     Index,
 )
 import pandas._testing as tm
+from pandas.tests.io.test_compression import _compression_to_extension
 
-import pandas.io.common as icom
 from pandas.io.common import get_handle
 from pandas.io.xml import read_xml
 
@@ -363,21 +363,21 @@ def test_index_false_with_offset_input_index(parser, offset_index):
 </data>"""
 
 
-def test_na_elem_output(datapath, parser):
+def test_na_elem_output(parser):
     output = geom_df.to_xml(parser=parser)
     output = equalize_decl(output)
 
     assert output == na_expected
 
 
-def test_na_empty_str_elem_option(datapath, parser):
+def test_na_empty_str_elem_option(parser):
     output = geom_df.to_xml(na_rep="", parser=parser)
     output = equalize_decl(output)
 
     assert output == na_expected
 
 
-def test_na_empty_elem_option(datapath, parser):
+def test_na_empty_elem_option(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -410,7 +410,7 @@ def test_na_empty_elem_option(datapath, parser):
 # ATTR_COLS
 
 
-def test_attrs_cols_nan_output(datapath, parser):
+def test_attrs_cols_nan_output(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -425,7 +425,7 @@ def test_attrs_cols_nan_output(datapath, parser):
     assert output == expected
 
 
-def test_attrs_cols_prefix(datapath, parser):
+def test_attrs_cols_prefix(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <doc:data xmlns:doc="http://example.xom/">
@@ -461,7 +461,7 @@ def test_attrs_wrong_type(parser):
 # ELEM_COLS
 
 
-def test_elems_cols_nan_output(datapath, parser):
+def test_elems_cols_nan_output(parser):
     elems_cols_expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -500,7 +500,7 @@ def test_elems_wrong_type(parser):
         geom_df.to_xml(elem_cols='"shape", "degree", "sides"', parser=parser)
 
 
-def test_elems_and_attrs_cols(datapath, parser):
+def test_elems_and_attrs_cols(parser):
     elems_cols_expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -532,7 +532,7 @@ def test_elems_and_attrs_cols(datapath, parser):
 # HIERARCHICAL COLUMNS
 
 
-def test_hierarchical_columns(datapath, parser):
+def test_hierarchical_columns(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -579,7 +579,7 @@ def test_hierarchical_columns(datapath, parser):
     assert output == expected
 
 
-def test_hierarchical_attrs_columns(datapath, parser):
+def test_hierarchical_attrs_columns(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -609,7 +609,7 @@ def test_hierarchical_attrs_columns(datapath, parser):
 # MULTIINDEX
 
 
-def test_multi_index(datapath, parser):
+def test_multi_index(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -648,7 +648,7 @@ def test_multi_index(datapath, parser):
     assert output == expected
 
 
-def test_multi_index_attrs_cols(datapath, parser):
+def test_multi_index_attrs_cols(parser):
     expected = """\
 <?xml version='1.0' encoding='utf-8'?>
 <data>
@@ -1020,7 +1020,7 @@ def test_stylesheet_buffered_reader(datapath, mode):
 
 
 @td.skip_if_no("lxml")
-def test_stylesheet_wrong_path(datapath):
+def test_stylesheet_wrong_path():
     from lxml.etree import XMLSyntaxError
 
     xsl = os.path.join("data", "xml", "row_field_output.xslt")
@@ -1037,9 +1037,16 @@ def test_stylesheet_wrong_path(datapath):
 def test_empty_string_stylesheet(val):
     from lxml.etree import XMLSyntaxError
 
-    with pytest.raises(
-        XMLSyntaxError, match=("Document is empty|Start tag expected, '<' not found")
-    ):
+    msg = "|".join(
+        [
+            "Document is empty",
+            "Start tag expected, '<' not found",
+            # Seen on Mac with lxml 4.9.1
+            r"None \(line 0\)",
+        ]
+    )
+
+    with pytest.raises(XMLSyntaxError, match=msg):
         geom_df.to_xml(stylesheet=val)
 
 
@@ -1102,7 +1109,7 @@ def test_incorrect_xsl_eval():
 
 
 @td.skip_if_no("lxml")
-def test_incorrect_xsl_apply(parser):
+def test_incorrect_xsl_apply():
     from lxml.etree import XSLTApplyError
 
     xsl = """\
@@ -1122,7 +1129,7 @@ def test_incorrect_xsl_apply(parser):
             geom_df.to_xml(path, stylesheet=xsl)
 
 
-def test_stylesheet_with_etree(datapath):
+def test_stylesheet_with_etree():
     xsl = """\
 <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
     <xsl:output method="xml" encoding="utf-8" indent="yes" />
@@ -1160,7 +1167,7 @@ def test_style_to_csv():
     </xsl:template>
 </xsl:stylesheet>"""
 
-    out_csv = geom_df.to_csv(line_terminator="\n")
+    out_csv = geom_df.to_csv(lineterminator="\n")
 
     if out_csv is not None:
         out_csv = out_csv.strip()
@@ -1292,7 +1299,7 @@ def test_compression_output(parser, compression_only):
 
 
 def test_filename_and_suffix_comp(parser, compression_only):
-    compfile = "xml." + icom._compression_to_extension[compression_only]
+    compfile = "xml." + _compression_to_extension[compression_only]
     with tm.ensure_clean(filename=compfile) as path:
         geom_df.to_xml(path, parser=parser, compression=compression_only)
 
@@ -1322,7 +1329,7 @@ def test_ea_dtypes(any_numeric_ea_dtype, parser):
     assert equalize_decl(result).strip() == expected
 
 
-def test_unsuported_compression(datapath, parser):
+def test_unsuported_compression(parser):
     with pytest.raises(ValueError, match="Unrecognized compression type"):
         with tm.ensure_clean() as path:
             geom_df.to_xml(path, parser=parser, compression="7z")
@@ -1331,10 +1338,11 @@ def test_unsuported_compression(datapath, parser):
 # STORAGE OPTIONS
 
 
-@tm.network
+@pytest.mark.single_cpu
 @td.skip_if_no("s3fs")
 @td.skip_if_no("lxml")
-def test_s3_permission_output(parser):
+def test_s3_permission_output(parser, s3_resource):
+    # s3_resource hosts pandas-test
     import s3fs
 
     with pytest.raises(PermissionError, match="Access Denied"):
diff --git a/pandas/tests/io/xml/test_xml.py b/pandas/tests/io/xml/test_xml.py
index 8809c423a29ba..33a98f57310c2 100644
--- a/pandas/tests/io/xml/test_xml.py
+++ b/pandas/tests/io/xml/test_xml.py
@@ -6,18 +6,25 @@
 )
 from lzma import LZMAError
 import os
+from tarfile import ReadError
 from urllib.error import HTTPError
 from zipfile import BadZipFile
 
 import numpy as np
 import pytest
 
+from pandas.compat import is_ci_environment
 from pandas.compat._optional import import_optional_dependency
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+)
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame
 import pandas._testing as tm
 
+from pandas.io.common import get_handle
 from pandas.io.xml import read_xml
 
 """
@@ -242,6 +249,21 @@ def parser(request):
     return request.param
 
 
+def read_xml_iterparse(data, **kwargs):
+    with tm.ensure_clean() as path:
+        with open(path, "w") as f:
+            f.write(data)
+        return read_xml(path, **kwargs)
+
+
+def read_xml_iterparse_comp(comp_path, compression_only, **kwargs):
+    with get_handle(comp_path, "r", compression=compression_only) as handles:
+        with tm.ensure_clean() as path:
+            with open(path, "w") as f:
+                f.write(handles.handle.read())
+            return read_xml(path, **kwargs)
+
+
 # FILE / URL
 
 
@@ -251,21 +273,72 @@ def test_parser_consistency_file(datapath):
     df_file_lxml = read_xml(filename, parser="lxml")
     df_file_etree = read_xml(filename, parser="etree")
 
+    df_iter_lxml = read_xml(
+        filename,
+        parser="lxml",
+        iterparse={"book": ["category", "title", "year", "author", "price"]},
+    )
+    df_iter_etree = read_xml(
+        filename,
+        parser="etree",
+        iterparse={"book": ["category", "title", "year", "author", "price"]},
+    )
+
     tm.assert_frame_equal(df_file_lxml, df_file_etree)
+    tm.assert_frame_equal(df_file_lxml, df_iter_lxml)
+    tm.assert_frame_equal(df_iter_lxml, df_iter_etree)
 
 
-@tm.network
+@pytest.mark.network
 @pytest.mark.slow
-@td.skip_if_no("lxml")
-def test_parser_consistency_url(https://github.com/datapath):
+@tm.network(
+    url=(
+        "https://data.cityofchicago.org/api/views/"
+        "8pix-ypme/rows.xml?accessType=DOWNLOAD"
+    ),
+    check_before_test=True,
+)
+def test_parser_consistency_url(https://github.com/parser):
     url = (
         "https://data.cityofchicago.org/api/views/"
         "8pix-ypme/rows.xml?accessType=DOWNLOAD"
     )
-    df_url_lxml = read_xml(url, xpath=".//row/row", parser="lxml")
-    df_url_etree = read_xml(url, xpath=".//row/row", parser="etree")
 
-    tm.assert_frame_equal(df_url_lxml, df_url_etree)
+    with tm.ensure_clean(filename="cta.xml") as path:
+        (read_xml(url, xpath=".//row/row", parser=parser).to_xml(path, index=False))
+
+        df_xpath = read_xml(path, parser=parser)
+        df_iter = read_xml(
+            path,
+            parser=parser,
+            iterparse={
+                "row": [
+                    "_id",
+                    "_uuid",
+                    "_position",
+                    "_address",
+                    "stop_id",
+                    "direction_id",
+                    "stop_name",
+                    "station_name",
+                    "station_descriptive_name",
+                    "map_id",
+                    "ada",
+                    "red",
+                    "blue",
+                    "g",
+                    "brn",
+                    "p",
+                    "pexp",
+                    "y",
+                    "pnk",
+                    "o",
+                    "location",
+                ]
+            },
+        )
+
+    tm.assert_frame_equal(df_xpath, df_iter)
 
 
 def test_file_like(datapath, parser, mode):
@@ -350,6 +423,40 @@ def test_file_buffered_reader_no_xml_declaration(datapath, parser, mode):
     tm.assert_frame_equal(df_str, df_expected)
 
 
+def test_string_charset(parser):
+    txt = "<中文標籤><row><c1>1</c1><c2>2</c2></row></中文標籤>"
+
+    df_str = read_xml(txt, parser=parser)
+
+    df_expected = DataFrame({"c1": 1, "c2": 2}, index=[0])
+
+    tm.assert_frame_equal(df_str, df_expected)
+
+
+def test_file_charset(datapath, parser):
+    xml_file = datapath("io", "data", "xml", "doc_ch_utf.xml")
+
+    df_file = read_xml(datapath(xml_file), parser=parser)
+
+    df_expected = DataFrame(
+        {
+            "問": [
+                "問  若箇是邪而言破邪 何者是正而道(Sorry, this is Big5 only)申正",
+                "問 既破有得申無得 亦應但破性執申假名以不",
+                "問 既破性申假 亦應但破有申無 若有無兩洗 亦應性假雙破耶",
+            ],
+            "答": [
+                "答  邪既無量 正亦多途  大略為言不出二種 謂有得與無得 有得是邪須破 無得是正須申\n\t\t故",
+                None,
+                "答  不例  有無皆是性 所以須雙破 既分性假異 故有破不破",
+            ],
+            "a": [None, "答 性執是有得 假名是無得  今破有得申無得 即是破性執申假名也", None],
+        }
+    )
+
+    tm.assert_frame_equal(df_file, df_expected)
+
+
 def test_file_handle_close(datapath, parser):
     xml_file = datapath("io", "data", "xml", "books.xml")
 
@@ -364,7 +471,14 @@ def test_file_handle_close(datapath, parser):
 def test_empty_string_lxml(val):
     from lxml.etree import XMLSyntaxError
 
-    with pytest.raises(XMLSyntaxError, match="Document is empty"):
+    msg = "|".join(
+        [
+            "Document is empty",
+            # Seen on Mac with lxml 4.91
+            r"None \(line 0\)",
+        ]
+    )
+    with pytest.raises(XMLSyntaxError, match=msg):
         read_xml(val, parser="lxml")
 
 
@@ -401,7 +515,11 @@ def test_wrong_file_path_etree():
         read_xml(filename, parser="etree")
 
 
-@tm.network
+@pytest.mark.network
+@tm.network(
+    url="https://www.w3schools.com/xml/books.xml",
+    check_before_test=True,
+)
 @td.skip_if_no("lxml")
 def test_url():
     url = "https://www.w3schools.com/xml/books.xml"
@@ -421,7 +539,8 @@ def test_url():
     tm.assert_frame_equal(df_url, df_expected)
 
 
-@tm.network
+@pytest.mark.network
+@tm.network(url="https://www.w3schools.com/xml/python.xml", check_before_test=True)
 def test_wrong_url(https://github.com/parser):
     with pytest.raises(HTTPError, match=("HTTP Error 404: Not Found")):
         url = "https://www.w3schools.com/xml/python.xml"
@@ -466,6 +585,12 @@ def test_default_namespace(parser):
         parser=parser,
     )
 
+    df_iter = read_xml_iterparse(
+        xml_default_nmsp,
+        parser=parser,
+        iterparse={"row": ["shape", "degrees", "sides"]},
+    )
+
     df_expected = DataFrame(
         {
             "shape": ["square", "circle", "triangle"],
@@ -475,6 +600,7 @@ def test_default_namespace(parser):
     )
 
     tm.assert_frame_equal(df_nmsp, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 def test_prefix_namespace(parser):
@@ -484,6 +610,9 @@ def test_prefix_namespace(parser):
         namespaces={"doc": "http://example.com/"},
         parser=parser,
     )
+    df_iter = read_xml_iterparse(
+        xml_prefix_nmsp, parser=parser, iterparse={"row": ["shape", "degrees", "sides"]}
+    )
 
     df_expected = DataFrame(
         {
@@ -494,6 +623,7 @@ def test_prefix_namespace(parser):
     )
 
     tm.assert_frame_equal(df_nmsp, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 @td.skip_if_no("lxml")
@@ -578,6 +708,11 @@ def test_none_namespace_prefix(key):
 def test_file_elems_and_attrs(datapath, parser):
     filename = datapath("io", "data", "xml", "books.xml")
     df_file = read_xml(filename, parser=parser)
+    df_iter = read_xml(
+        filename,
+        parser=parser,
+        iterparse={"book": ["category", "title", "author", "year", "price"]},
+    )
     df_expected = DataFrame(
         {
             "category": ["cooking", "children", "web"],
@@ -589,19 +724,27 @@ def test_file_elems_and_attrs(datapath, parser):
     )
 
     tm.assert_frame_equal(df_file, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 def test_file_only_attrs(datapath, parser):
     filename = datapath("io", "data", "xml", "books.xml")
     df_file = read_xml(filename, attrs_only=True, parser=parser)
+    df_iter = read_xml(filename, parser=parser, iterparse={"book": ["category"]})
     df_expected = DataFrame({"category": ["cooking", "children", "web"]})
 
     tm.assert_frame_equal(df_file, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 def test_file_only_elems(datapath, parser):
     filename = datapath("io", "data", "xml", "books.xml")
     df_file = read_xml(filename, elems_only=True, parser=parser)
+    df_iter = read_xml(
+        filename,
+        parser=parser,
+        iterparse={"book": ["title", "author", "year", "price"]},
+    )
     df_expected = DataFrame(
         {
             "title": ["Everyday Italian", "Harry Potter", "Learning XML"],
@@ -612,6 +755,7 @@ def test_file_only_elems(datapath, parser):
     )
 
     tm.assert_frame_equal(df_file, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 def test_elem_and_attrs_only(datapath, parser):
@@ -648,7 +792,13 @@ def test_attribute_centric_xml():
     df_lxml = read_xml(xml, xpath=".//station")
     df_etree = read_xml(xml, xpath=".//station", parser="etree")
 
+    df_iter_lx = read_xml_iterparse(xml, iterparse={"station": ["Name", "coords"]})
+    df_iter_et = read_xml_iterparse(
+        xml, parser="etree", iterparse={"station": ["Name", "coords"]}
+    )
+
     tm.assert_frame_equal(df_lxml, df_etree)
+    tm.assert_frame_equal(df_iter_lx, df_iter_et)
 
 
 # NAMES
@@ -659,6 +809,12 @@ def test_names_option_output(datapath, parser):
     df_file = read_xml(
         filename, names=["Col1", "Col2", "Col3", "Col4", "Col5"], parser=parser
     )
+    df_iter = read_xml(
+        filename,
+        parser=parser,
+        names=["Col1", "Col2", "Col3", "Col4", "Col5"],
+        iterparse={"book": ["category", "title", "author", "year", "price"]},
+    )
 
     df_expected = DataFrame(
         {
@@ -671,6 +827,82 @@ def test_names_option_output(datapath, parser):
     )
 
     tm.assert_frame_equal(df_file, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_repeat_names(parser):
+    xml = """\
+<shapes>
+  <shape type="2D">
+    <name>circle</name>
+    <type>curved</type>
+  </shape>
+  <shape type="3D">
+    <name>sphere</name>
+    <type>curved</type>
+  </shape>
+</shapes>"""
+    df_xpath = read_xml(
+        xml, xpath=".//shape", parser=parser, names=["type_dim", "shape", "type_edge"]
+    )
+
+    df_iter = read_xml_iterparse(
+        xml,
+        parser=parser,
+        iterparse={"shape": ["type", "name", "type"]},
+        names=["type_dim", "shape", "type_edge"],
+    )
+
+    df_expected = DataFrame(
+        {
+            "type_dim": ["2D", "3D"],
+            "shape": ["circle", "sphere"],
+            "type_edge": ["curved", "curved"],
+        }
+    )
+
+    tm.assert_frame_equal(df_xpath, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_repeat_values_new_names(parser):
+    xml = """\
+<shapes>
+  <shape>
+    <name>rectangle</name>
+    <family>rectangle</family>
+  </shape>
+  <shape>
+    <name>square</name>
+    <family>rectangle</family>
+  </shape>
+  <shape>
+    <name>ellipse</name>
+    <family>ellipse</family>
+  </shape>
+  <shape>
+    <name>circle</name>
+    <family>ellipse</family>
+  </shape>
+</shapes>"""
+    df_xpath = read_xml(xml, xpath=".//shape", parser=parser, names=["name", "group"])
+
+    df_iter = read_xml_iterparse(
+        xml,
+        parser=parser,
+        iterparse={"shape": ["name", "family"]},
+        names=["name", "group"],
+    )
+
+    df_expected = DataFrame(
+        {
+            "name": ["rectangle", "square", "ellipse", "circle"],
+            "group": ["rectangle", "rectangle", "ellipse", "ellipse"],
+        }
+    )
+
+    tm.assert_frame_equal(df_xpath, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
 
 
 def test_names_option_wrong_length(datapath, parser):
@@ -723,10 +955,25 @@ def test_ascii_encoding(datapath, parser):
 @td.skip_if_no("lxml")
 def test_parser_consistency_with_encoding(datapath):
     filename = datapath("io", "data", "xml", "baby_names.xml")
-    df_lxml = read_xml(filename, parser="lxml", encoding="ISO-8859-1")
-    df_etree = read_xml(filename, parser="etree", encoding="iso-8859-1")
+    df_xpath_lxml = read_xml(filename, parser="lxml", encoding="ISO-8859-1")
+    df_xpath_etree = read_xml(filename, parser="etree", encoding="iso-8859-1")
 
-    tm.assert_frame_equal(df_lxml, df_etree)
+    df_iter_lxml = read_xml(
+        filename,
+        parser="lxml",
+        encoding="ISO-8859-1",
+        iterparse={"row": ["rank", "malename", "femalename"]},
+    )
+    df_iter_etree = read_xml(
+        filename,
+        parser="etree",
+        encoding="ISO-8859-1",
+        iterparse={"row": ["rank", "malename", "femalename"]},
+    )
+
+    tm.assert_frame_equal(df_xpath_lxml, df_xpath_etree)
+    tm.assert_frame_equal(df_xpath_etree, df_iter_etree)
+    tm.assert_frame_equal(df_iter_lxml, df_iter_etree)
 
 
 @td.skip_if_no("lxml")
@@ -792,7 +1039,22 @@ def test_stylesheet_file(datapath):
         stylesheet=xsl,
     )
 
+    df_iter = read_xml(
+        kml,
+        iterparse={
+            "Placemark": [
+                "id",
+                "name",
+                "styleUrl",
+                "extrude",
+                "altitudeMode",
+                "coordinates",
+            ]
+        },
+    )
+
     tm.assert_frame_equal(df_kml, df_style)
+    tm.assert_frame_equal(df_kml, df_iter)
 
 
 def test_read_xml_passing_as_positional_deprecated(datapath, parser):
@@ -865,6 +1127,35 @@ def test_stylesheet_buffered_reader(datapath, mode):
     tm.assert_frame_equal(df_kml, df_style)
 
 
+@td.skip_if_no("lxml")
+def test_style_charset():
+    xml = "<中文標籤><row><c1>1</c1><c2>2</c2></row></中文標籤>"
+
+    xsl = """\
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:output omit-xml-declaration="yes" indent="yes"/>
+ <xsl:strip-space elements="*"/>
+
+ <xsl:template match="node()|@*">
+     <xsl:copy>
+       <xsl:apply-templates select="node()|@*"/>
+     </xsl:copy>
+ </xsl:template>
+
+ <xsl:template match="中文標籤">
+     <根>
+       <xsl:apply-templates />
+     </根>
+ </xsl:template>
+
+</xsl:stylesheet>"""
+
+    df_orig = read_xml(xml)
+    df_style = read_xml(xml, stylesheet=xsl)
+
+    tm.assert_frame_equal(df_orig, df_style)
+
+
 @td.skip_if_no("lxml")
 def test_not_stylesheet(datapath):
     from lxml.etree import XSLTParseError
@@ -993,7 +1284,7 @@ def test_stylesheet_file_close(datapath, mode):
 
 
 @td.skip_if_no("lxml")
-def test_stylesheet_with_etree(datapath):
+def test_stylesheet_with_etree():
     kml = os.path.join("data", "xml", "cta_rail_lines.kml")
     xsl = os.path.join("data", "xml", "flatten_doc.xsl")
 
@@ -1016,8 +1307,255 @@ def test_empty_stylesheet(val):
         read_xml(kml, stylesheet=val)
 
 
-@tm.network
+# ITERPARSE
+
+
+def test_string_error(parser):
+    with pytest.raises(
+        ParserError, match=("iterparse is designed for large XML files")
+    ):
+        read_xml(
+            xml_default_nmsp,
+            parser=parser,
+            iterparse={"row": ["shape", "degrees", "sides", "date"]},
+        )
+
+
+def test_file_like_error(datapath, parser, mode):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(
+        ParserError, match=("iterparse is designed for large XML files")
+    ):
+        with open(filename) as f:
+            read_xml(
+                f,
+                parser=parser,
+                iterparse={"book": ["category", "title", "year", "author", "price"]},
+            )
+
+
+@pytest.mark.network
+@tm.network(url="https://www.w3schools.com/xml/books.xml", check_before_test=True)
+def test_url_path_error(parser):
+    url = "https://www.w3schools.com/xml/books.xml"
+    with pytest.raises(
+        ParserError, match=("iterparse is designed for large XML files")
+    ):
+        read_xml(
+            url,
+            parser=parser,
+            iterparse={"row": ["shape", "degrees", "sides", "date"]},
+        )
+
+
+def test_compression_error(parser, compression_only):
+    with tm.ensure_clean(filename="geom_xml.zip") as path:
+        geom_df.to_xml(path, parser=parser, compression=compression_only)
+
+        with pytest.raises(
+            ParserError, match=("iterparse is designed for large XML files")
+        ):
+            read_xml(
+                path,
+                parser=parser,
+                iterparse={"row": ["shape", "degrees", "sides", "date"]},
+                compression=compression_only,
+            )
+
+
+def test_wrong_dict_type(datapath, parser):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(TypeError, match="list is not a valid type for iterparse"):
+        read_xml(
+            filename,
+            parser=parser,
+            iterparse=["category", "title", "year", "author", "price"],
+        )
+
+
+def test_wrong_dict_value(datapath, parser):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(
+        TypeError, match="<class 'str'> is not a valid type for value in iterparse"
+    ):
+        read_xml(filename, parser=parser, iterparse={"book": "category"})
+
+
+def test_bad_xml(parser):
+    bad_xml = """\
+<?xml version='1.0' encoding='utf-8'?>
+  <row>
+    <shape>square</shape>
+    <degrees>00360</degrees>
+    <sides>4.0</sides>
+    <date>2020-01-01</date>
+   </row>
+  <row>
+    <shape>circle</shape>
+    <degrees>00360</degrees>
+    <sides/>
+    <date>2021-01-01</date>
+  </row>
+  <row>
+    <shape>triangle</shape>
+    <degrees>00180</degrees>
+    <sides>3.0</sides>
+    <date>2022-01-01</date>
+  </row>
+"""
+    with tm.ensure_clean(filename="bad.xml") as path:
+        with open(path, "w") as f:
+            f.write(bad_xml)
+
+        with pytest.raises(
+            SyntaxError,
+            match=(
+                "Extra content at the end of the document|"
+                "junk after document element"
+            ),
+        ):
+            read_xml(
+                path,
+                parser=parser,
+                parse_dates=["date"],
+                iterparse={"row": ["shape", "degrees", "sides", "date"]},
+            )
+
+
+def test_comment(parser):
+    xml = """\
+<!-- comment before root -->
+<shapes>
+  <!-- comment within root -->
+  <shape>
+    <name>circle</name>
+    <type>2D</type>
+  </shape>
+  <shape>
+    <name>sphere</name>
+    <type>3D</type>
+    <!-- comment within child -->
+  </shape>
+  <!-- comment within root -->
+</shapes>
+<!-- comment after root -->"""
+
+    df_xpath = read_xml(xml, xpath=".//shape", parser=parser)
+
+    df_iter = read_xml_iterparse(
+        xml, parser=parser, iterparse={"shape": ["name", "type"]}
+    )
+
+    df_expected = DataFrame(
+        {
+            "name": ["circle", "sphere"],
+            "type": ["2D", "3D"],
+        }
+    )
+
+    tm.assert_frame_equal(df_xpath, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_dtd(parser):
+    xml = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE non-profits [
+    <!ELEMENT shapes (shape*) >
+    <!ELEMENT shape ( name, type )>
+    <!ELEMENT name (#PCDATA)>
+]>
+<shapes>
+  <shape>
+    <name>circle</name>
+    <type>2D</type>
+  </shape>
+  <shape>
+    <name>sphere</name>
+    <type>3D</type>
+  </shape>
+</shapes>"""
+
+    df_xpath = read_xml(xml, xpath=".//shape", parser=parser)
+
+    df_iter = read_xml_iterparse(
+        xml, parser=parser, iterparse={"shape": ["name", "type"]}
+    )
+
+    df_expected = DataFrame(
+        {
+            "name": ["circle", "sphere"],
+            "type": ["2D", "3D"],
+        }
+    )
+
+    tm.assert_frame_equal(df_xpath, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_processing_instruction(parser):
+    xml = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="https://github.com/style.xsl"?>
+<?display table-view?>
+<?sort alpha-ascending?>
+<?textinfo whitespace is allowed ?>
+<?elementnames <shape>, <name>, <type> ?>
+<shapes>
+  <shape>
+    <name>circle</name>
+    <type>2D</type>
+  </shape>
+  <shape>
+    <name>sphere</name>
+    <type>3D</type>
+  </shape>
+</shapes>"""
+
+    df_xpath = read_xml(xml, xpath=".//shape", parser=parser)
+
+    df_iter = read_xml_iterparse(
+        xml, parser=parser, iterparse={"shape": ["name", "type"]}
+    )
+
+    df_expected = DataFrame(
+        {
+            "name": ["circle", "sphere"],
+            "type": ["2D", "3D"],
+        }
+    )
+
+    tm.assert_frame_equal(df_xpath, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_no_result(datapath, parser):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(
+        ParserError, match="No result from selected items in iterparse."
+    ):
+        read_xml(
+            filename,
+            parser=parser,
+            iterparse={"node": ["attr1", "elem1", "elem2", "elem3"]},
+        )
+
+
+def test_empty_data(datapath, parser):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(EmptyDataError, match="No columns to parse from file"):
+        read_xml(
+            filename,
+            parser=parser,
+            iterparse={"book": ["attr1", "elem1", "elem2", "elem3"]},
+        )
+
+
+@pytest.mark.network
 @td.skip_if_no("lxml")
+@tm.network(
+    url="https://www.w3schools.com/xml/cdcatalog_with_xsl.xml", check_before_test=True
+)
 def test_online_stylesheet():
     xml = "https://www.w3schools.com/xml/cdcatalog_with_xsl.xml"
     xsl = "https://www.w3schools.com/xml/cdcatalog.xsl"
@@ -1055,12 +1593,23 @@ def test_online_stylesheet():
 
 
 def test_compression_read(parser, compression_only):
-    with tm.ensure_clean() as path:
-        geom_df.to_xml(path, index=False, parser=parser, compression=compression_only)
+    with tm.ensure_clean() as comp_path:
+        geom_df.to_xml(
+            comp_path, index=False, parser=parser, compression=compression_only
+        )
 
-        xml_df = read_xml(path, parser=parser, compression=compression_only)
+        df_xpath = read_xml(comp_path, parser=parser, compression=compression_only)
 
-    tm.assert_frame_equal(xml_df, geom_df)
+        df_iter = read_xml_iterparse_comp(
+            comp_path,
+            compression_only,
+            parser=parser,
+            iterparse={"row": ["shape", "degrees", "sides"]},
+            compression=compression_only,
+        )
+
+    tm.assert_frame_equal(df_xpath, geom_df)
+    tm.assert_frame_equal(df_iter, geom_df)
 
 
 def test_wrong_compression(parser, compression, compression_only):
@@ -1074,6 +1623,7 @@ def test_wrong_compression(parser, compression, compression_only):
         "bz2": (OSError, "Invalid data stream"),
         "gzip": (OSError, "Not a gzipped file"),
         "zip": (BadZipFile, "File is not a zip file"),
+        "tar": (ReadError, "file could not be opened successfully"),
     }
     zstd = import_optional_dependency("zstandard", errors="ignore")
     if zstd is not None:
@@ -1090,7 +1640,7 @@ def test_wrong_compression(parser, compression, compression_only):
             read_xml(path, parser=parser, compression=attempted_compression)
 
 
-def test_unsuported_compression(datapath, parser):
+def test_unsuported_compression(parser):
     with pytest.raises(ValueError, match="Unrecognized compression type"):
         with tm.ensure_clean() as path:
             read_xml(path, parser=parser, compression="7z")
@@ -1099,9 +1649,14 @@ def test_unsuported_compression(datapath, parser):
 # STORAGE OPTIONS
 
 
-@tm.network
+@pytest.mark.network
 @td.skip_if_no("s3fs")
 @td.skip_if_no("lxml")
+@pytest.mark.skipif(
+    is_ci_environment(),
+    reason="2022.1.17: Hanging on the CI min versions build.",
+)
+@tm.network
 def test_s3_parser_consistency():
     # Python Software Foundation (2019 IRS-990 RETURN)
     s3 = "s3://irs-form-990/201923199349319487_public.xml"
diff --git a/pandas/tests/io/xml/test_xml_dtypes.py b/pandas/tests/io/xml/test_xml_dtypes.py
new file mode 100644
index 0000000000000..5629830767c3c
--- /dev/null
+++ b/pandas/tests/io/xml/test_xml_dtypes.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import pytest
+
+from pandas.errors import ParserWarning
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Series,
+    to_datetime,
+)
+import pandas._testing as tm
+
+from pandas.io.xml import read_xml
+
+
+@pytest.fixture(params=[pytest.param("lxml", marks=td.skip_if_no("lxml")), "etree"])
+def parser(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=[None, {"book": ["category", "title", "author", "year", "price"]}]
+)
+def iterparse(request):
+    return request.param
+
+
+def read_xml_iterparse(data, **kwargs):
+    with tm.ensure_clean() as path:
+        with open(path, "w") as f:
+            f.write(data)
+        return read_xml(path, **kwargs)
+
+
+xml_types = """\
+<?xml version='1.0' encoding='utf-8'?>
+<data>
+  <row>
+    <shape>square</shape>
+    <degrees>00360</degrees>
+    <sides>4.0</sides>
+   </row>
+  <row>
+    <shape>circle</shape>
+    <degrees>00360</degrees>
+    <sides/>
+  </row>
+  <row>
+    <shape>triangle</shape>
+    <degrees>00180</degrees>
+    <sides>3.0</sides>
+  </row>
+</data>"""
+
+xml_dates = """<?xml version='1.0' encoding='utf-8'?>
+<data>
+  <row>
+    <shape>square</shape>
+    <degrees>00360</degrees>
+    <sides>4.0</sides>
+    <date>2020-01-01</date>
+   </row>
+  <row>
+    <shape>circle</shape>
+    <degrees>00360</degrees>
+    <sides/>
+    <date>2021-01-01</date>
+  </row>
+  <row>
+    <shape>triangle</shape>
+    <degrees>00180</degrees>
+    <sides>3.0</sides>
+    <date>2022-01-01</date>
+  </row>
+</data>"""
+
+
+# DTYPE
+
+
+def test_dtype_single_str(parser):
+    df_result = read_xml(xml_types, dtype={"degrees": "str"}, parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_types,
+        parser=parser,
+        dtype={"degrees": "str"},
+        iterparse={"row": ["shape", "degrees", "sides"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": ["00360", "00360", "00180"],
+            "sides": [4.0, float("nan"), 3.0],
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_dtypes_all_str(parser):
+    df_result = read_xml(xml_dates, dtype="string", parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        dtype="string",
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": ["00360", "00360", "00180"],
+            "sides": ["4.0", None, "3.0"],
+            "date": ["2020-01-01", "2021-01-01", "2022-01-01"],
+        },
+        dtype="string",
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_dtypes_with_names(parser):
+    df_result = read_xml(
+        xml_dates,
+        names=["Col1", "Col2", "Col3", "Col4"],
+        dtype={"Col2": "string", "Col3": "Int64", "Col4": "datetime64"},
+        parser=parser,
+    )
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        names=["Col1", "Col2", "Col3", "Col4"],
+        dtype={"Col2": "string", "Col3": "Int64", "Col4": "datetime64"},
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "Col1": ["square", "circle", "triangle"],
+            "Col2": Series(["00360", "00360", "00180"]).astype("string"),
+            "Col3": Series([4.0, float("nan"), 3.0]).astype("Int64"),
+            "Col4": to_datetime(["2020-01-01", "2021-01-01", "2022-01-01"]),
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_dtype_nullable_int(parser):
+    df_result = read_xml(xml_types, dtype={"sides": "Int64"}, parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_types,
+        parser=parser,
+        dtype={"sides": "Int64"},
+        iterparse={"row": ["shape", "degrees", "sides"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": Series([4.0, float("nan"), 3.0]).astype("Int64"),
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_dtype_float(parser):
+    df_result = read_xml(xml_types, dtype={"degrees": "float"}, parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_types,
+        parser=parser,
+        dtype={"degrees": "float"},
+        iterparse={"row": ["shape", "degrees", "sides"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": Series([360, 360, 180]).astype("float"),
+            "sides": [4.0, float("nan"), 3.0],
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_wrong_dtype(datapath, parser, iterparse):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(
+        ValueError, match=('Unable to parse string "Everyday Italian" at position 0')
+    ):
+        read_xml(filename, dtype={"title": "Int64"}, parser=parser, iterparse=iterparse)
+
+
+def test_both_dtype_converters(parser):
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": ["00360", "00360", "00180"],
+            "sides": [4.0, float("nan"), 3.0],
+        }
+    )
+
+    with tm.assert_produces_warning(ParserWarning, match="Both a converter and dtype"):
+        df_result = read_xml(
+            xml_types,
+            dtype={"degrees": "str"},
+            converters={"degrees": str},
+            parser=parser,
+        )
+        df_iter = read_xml_iterparse(
+            xml_types,
+            dtype={"degrees": "str"},
+            converters={"degrees": str},
+            parser=parser,
+            iterparse={"row": ["shape", "degrees", "sides"]},
+        )
+
+        tm.assert_frame_equal(df_result, df_expected)
+        tm.assert_frame_equal(df_iter, df_expected)
+
+
+# CONVERTERS
+
+
+def test_converters_str(parser):
+    df_result = read_xml(xml_types, converters={"degrees": str}, parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_types,
+        parser=parser,
+        converters={"degrees": str},
+        iterparse={"row": ["shape", "degrees", "sides"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": ["00360", "00360", "00180"],
+            "sides": [4.0, float("nan"), 3.0],
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_converters_date(parser):
+    convert_to_datetime = lambda x: to_datetime(x)
+    df_result = read_xml(
+        xml_dates, converters={"date": convert_to_datetime}, parser=parser
+    )
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        converters={"date": convert_to_datetime},
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+            "date": to_datetime(["2020-01-01", "2021-01-01", "2022-01-01"]),
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_wrong_converters_type(datapath, parser, iterparse):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(TypeError, match=("Type converters must be a dict or subclass")):
+        read_xml(filename, converters={"year", str}, parser=parser, iterparse=iterparse)
+
+
+def test_callable_func_converters(datapath, parser, iterparse):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(TypeError, match=("'float' object is not callable")):
+        read_xml(
+            filename, converters={"year": float()}, parser=parser, iterparse=iterparse
+        )
+
+
+def test_callable_str_converters(datapath, parser, iterparse):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(TypeError, match=("'str' object is not callable")):
+        read_xml(
+            filename, converters={"year": "float"}, parser=parser, iterparse=iterparse
+        )
+
+
+# PARSE DATES
+
+
+def test_parse_dates_column_name(parser):
+    df_result = read_xml(xml_dates, parse_dates=["date"], parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        parse_dates=["date"],
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+            "date": to_datetime(["2020-01-01", "2021-01-01", "2022-01-01"]),
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_parse_dates_column_index(parser):
+    df_result = read_xml(xml_dates, parse_dates=[3], parser=parser)
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        parse_dates=[3],
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+            "date": to_datetime(["2020-01-01", "2021-01-01", "2022-01-01"]),
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_parse_dates_true(parser):
+    df_result = read_xml(xml_dates, parse_dates=True, parser=parser)
+
+    df_iter = read_xml_iterparse(
+        xml_dates,
+        parser=parser,
+        parse_dates=True,
+        iterparse={"row": ["shape", "degrees", "sides", "date"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+            "date": ["2020-01-01", "2021-01-01", "2022-01-01"],
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_parse_dates_dictionary(parser):
+    xml = """<?xml version='1.0' encoding='utf-8'?>
+<data>
+  <row>
+    <shape>square</shape>
+    <degrees>360</degrees>
+    <sides>4.0</sides>
+    <year>2020</year>
+    <month>12</month>
+    <day>31</day>
+   </row>
+  <row>
+    <shape>circle</shape>
+    <degrees>360</degrees>
+    <sides/>
+    <year>2021</year>
+    <month>12</month>
+    <day>31</day>
+  </row>
+  <row>
+    <shape>triangle</shape>
+    <degrees>180</degrees>
+    <sides>3.0</sides>
+    <year>2022</year>
+    <month>12</month>
+    <day>31</day>
+  </row>
+</data>"""
+
+    df_result = read_xml(
+        xml, parse_dates={"date_end": ["year", "month", "day"]}, parser=parser
+    )
+    df_iter = read_xml_iterparse(
+        xml,
+        parser=parser,
+        parse_dates={"date_end": ["year", "month", "day"]},
+        iterparse={"row": ["shape", "degrees", "sides", "year", "month", "day"]},
+    )
+
+    df_expected = DataFrame(
+        {
+            "date_end": to_datetime(["2020-12-31", "2021-12-31", "2022-12-31"]),
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+        }
+    )
+
+    tm.assert_frame_equal(df_result, df_expected)
+    tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_day_first_parse_dates(parser):
+    xml = """\
+<?xml version='1.0' encoding='utf-8'?>
+<data>
+  <row>
+    <shape>square</shape>
+    <degrees>00360</degrees>
+    <sides>4.0</sides>
+    <date>31/12/2020</date>
+   </row>
+  <row>
+    <shape>circle</shape>
+    <degrees>00360</degrees>
+    <sides/>
+    <date>31/12/2021</date>
+  </row>
+  <row>
+    <shape>triangle</shape>
+    <degrees>00180</degrees>
+    <sides>3.0</sides>
+    <date>31/12/2022</date>
+  </row>
+</data>"""
+
+    df_expected = DataFrame(
+        {
+            "shape": ["square", "circle", "triangle"],
+            "degrees": [360, 360, 180],
+            "sides": [4.0, float("nan"), 3.0],
+            "date": to_datetime(["2020-12-31", "2021-12-31", "2022-12-31"]),
+        }
+    )
+
+    with tm.assert_produces_warning(
+        UserWarning, match="Parsing dates in DD/MM/YYYY format"
+    ):
+        df_result = read_xml(xml, parse_dates=["date"], parser=parser)
+        df_iter = read_xml_iterparse(
+            xml,
+            parse_dates=["date"],
+            parser=parser,
+            iterparse={"row": ["shape", "degrees", "sides", "date"]},
+        )
+
+        tm.assert_frame_equal(df_result, df_expected)
+        tm.assert_frame_equal(df_iter, df_expected)
+
+
+def test_wrong_parse_dates_type(datapath, parser, iterparse):
+    filename = datapath("io", "data", "xml", "books.xml")
+    with pytest.raises(
+        TypeError, match=("Only booleans, lists, and dictionaries are accepted")
+    ):
+        read_xml(filename, parse_dates={"date"}, parser=parser, iterparse=iterparse)
diff --git a/pandas/tests/libs/test_hashtable.py b/pandas/tests/libs/test_hashtable.py
index 937eccf7a0afe..0a3a10315b5fd 100644
--- a/pandas/tests/libs/test_hashtable.py
+++ b/pandas/tests/libs/test_hashtable.py
@@ -1,4 +1,5 @@
 from contextlib import contextmanager
+import struct
 import tracemalloc
 
 import numpy as np
@@ -77,16 +78,16 @@ def test_get_set_contains_len(self, table_type, dtype):
         with pytest.raises(KeyError, match=str(index + 2)):
             table.get_item(index + 2)
 
-    def test_map(self, table_type, dtype, writable):
-        # PyObjectHashTable has no map-method
-        if table_type != ht.PyObjectHashTable:
+    def test_map_keys_to_values(self, table_type, dtype, writable):
+        # only Int64HashTable has this method
+        if table_type == ht.Int64HashTable:
             N = 77
             table = table_type()
             keys = np.arange(N).astype(dtype)
             vals = np.arange(N).astype(np.int64) + N
             keys.flags.writeable = writable
             vals.flags.writeable = writable
-            table.map(keys, vals)
+            table.map_keys_to_values(keys, vals)
             for i in range(N):
                 assert table.get_item(keys[i]) == i + N
 
@@ -165,19 +166,139 @@ def test_get_state(self, table_type, dtype):
         assert "n_buckets" in state
         assert "upper_bound" in state
 
-    def test_no_reallocation(self, table_type, dtype):
-        for N in range(1, 110):
-            keys = np.arange(N).astype(dtype)
-            preallocated_table = table_type(N)
-            n_buckets_start = preallocated_table.get_state()["n_buckets"]
-            preallocated_table.map_locations(keys)
-            n_buckets_end = preallocated_table.get_state()["n_buckets"]
-            # original number of buckets was enough:
-            assert n_buckets_start == n_buckets_end
-            # check with clean table (not too much preallocated)
-            clean_table = table_type()
-            clean_table.map_locations(keys)
-            assert n_buckets_start == clean_table.get_state()["n_buckets"]
+    @pytest.mark.parametrize("N", range(1, 110))
+    def test_no_reallocation(self, table_type, dtype, N):
+        keys = np.arange(N).astype(dtype)
+        preallocated_table = table_type(N)
+        n_buckets_start = preallocated_table.get_state()["n_buckets"]
+        preallocated_table.map_locations(keys)
+        n_buckets_end = preallocated_table.get_state()["n_buckets"]
+        # original number of buckets was enough:
+        assert n_buckets_start == n_buckets_end
+        # check with clean table (not too much preallocated)
+        clean_table = table_type()
+        clean_table.map_locations(keys)
+        assert n_buckets_start == clean_table.get_state()["n_buckets"]
+
+
+class TestHashTableUnsorted:
+    # TODO: moved from test_algos; may be redundancies with other tests
+    def test_string_hashtable_set_item_signature(self):
+        # GH#30419 fix typing in StringHashTable.set_item to prevent segfault
+        tbl = ht.StringHashTable()
+
+        tbl.set_item("key", 1)
+        assert tbl.get_item("key") == 1
+
+        with pytest.raises(TypeError, match="'key' has incorrect type"):
+            # key arg typed as string, not object
+            tbl.set_item(4, 6)
+        with pytest.raises(TypeError, match="'val' has incorrect type"):
+            tbl.get_item(4)
+
+    def test_lookup_nan(self, writable):
+        # GH#21688 ensure we can deal with readonly memory views
+        xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3])
+        xs.setflags(write=writable)
+        m = ht.Float64HashTable()
+        m.map_locations(xs)
+        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
+
+    def test_add_signed_zeros(self):
+        # GH#21866 inconsistent hash-function for float64
+        # default hash-function would lead to different hash-buckets
+        # for 0.0 and -0.0 if there are more than 2^30 hash-buckets
+        # but this would mean 16GB
+        N = 4  # 12 * 10**8 would trigger the error, if you have enough memory
+        m = ht.Float64HashTable(N)
+        m.set_item(0.0, 0)
+        m.set_item(-0.0, 0)
+        assert len(m) == 1  # 0.0 and -0.0 are equivalent
+
+    def test_add_different_nans(self):
+        # GH#21866 inconsistent hash-function for float64
+        # create different nans from bit-patterns:
+        NAN1 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000000))[0]
+        NAN2 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000001))[0]
+        assert NAN1 != NAN1
+        assert NAN2 != NAN2
+        # default hash function would lead to different hash-buckets
+        # for NAN1 and NAN2 even if there are only 4 buckets:
+        m = ht.Float64HashTable()
+        m.set_item(NAN1, 0)
+        m.set_item(NAN2, 0)
+        assert len(m) == 1  # NAN1 and NAN2 are equivalent
+
+    def test_lookup_overflow(self, writable):
+        xs = np.array([1, 2, 2**63], dtype=np.uint64)
+        # GH 21688 ensure we can deal with readonly memory views
+        xs.setflags(write=writable)
+        m = ht.UInt64HashTable()
+        m.map_locations(xs)
+        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
+
+    @pytest.mark.parametrize("nvals", [0, 10])  # resizing to 0 is special case
+    @pytest.mark.parametrize(
+        "htable, uniques, dtype, safely_resizes",
+        [
+            (ht.PyObjectHashTable, ht.ObjectVector, "object", False),
+            (ht.StringHashTable, ht.ObjectVector, "object", True),
+            (ht.Float64HashTable, ht.Float64Vector, "float64", False),
+            (ht.Int64HashTable, ht.Int64Vector, "int64", False),
+            (ht.Int32HashTable, ht.Int32Vector, "int32", False),
+            (ht.UInt64HashTable, ht.UInt64Vector, "uint64", False),
+        ],
+    )
+    def test_vector_resize(
+        self, writable, htable, uniques, dtype, safely_resizes, nvals
+    ):
+        # Test for memory errors after internal vector
+        # reallocations (GH 7157)
+        # Changed from using np.random.rand to range
+        # which could cause flaky CI failures when safely_resizes=False
+        vals = np.array(range(1000), dtype=dtype)
+
+        # GH 21688 ensures we can deal with read-only memory views
+        vals.setflags(write=writable)
+
+        # initialise instances; cannot initialise in parametrization,
+        # as otherwise external views would be held on the array (which is
+        # one of the things this test is checking)
+        htable = htable()
+        uniques = uniques()
+
+        # get_labels may append to uniques
+        htable.get_labels(vals[:nvals], uniques, 0, -1)
+        # to_array() sets an external_view_exists flag on uniques.
+        tmp = uniques.to_array()
+        oldshape = tmp.shape
+
+        # subsequent get_labels() calls can no longer append to it
+        # (except for StringHashTables + ObjectVector)
+        if safely_resizes:
+            htable.get_labels(vals, uniques, 0, -1)
+        else:
+            with pytest.raises(ValueError, match="external reference.*"):
+                htable.get_labels(vals, uniques, 0, -1)
+
+        uniques.to_array()  # should not raise here
+        assert tmp.shape == oldshape
+
+    @pytest.mark.parametrize(
+        "hashtable",
+        [
+            ht.PyObjectHashTable,
+            ht.StringHashTable,
+            ht.Float64HashTable,
+            ht.Int64HashTable,
+            ht.Int32HashTable,
+            ht.UInt64HashTable,
+        ],
+    )
+    def test_hashtable_large_sizehint(self, hashtable):
+        # GH#22729 smoketest for not raising when passing a large size_hint
+        size_hint = np.iinfo(np.uint32).max + 1
+        hashtable(size_hint=size_hint)
 
 
 class TestPyObjectHashTableWithNans:
@@ -282,19 +403,19 @@ def test_tracemalloc_for_empty_StringHashTable():
         assert get_allocated_khash_memory() == 0
 
 
-def test_no_reallocation_StringHashTable():
-    for N in range(1, 110):
-        keys = np.arange(N).astype(np.compat.unicode).astype(np.object_)
-        preallocated_table = ht.StringHashTable(N)
-        n_buckets_start = preallocated_table.get_state()["n_buckets"]
-        preallocated_table.map_locations(keys)
-        n_buckets_end = preallocated_table.get_state()["n_buckets"]
-        # original number of buckets was enough:
-        assert n_buckets_start == n_buckets_end
-        # check with clean table (not too much preallocated)
-        clean_table = ht.StringHashTable()
-        clean_table.map_locations(keys)
-        assert n_buckets_start == clean_table.get_state()["n_buckets"]
+@pytest.mark.parametrize("N", range(1, 110))
+def test_no_reallocation_StringHashTable(N):
+    keys = np.arange(N).astype(np.compat.unicode).astype(np.object_)
+    preallocated_table = ht.StringHashTable(N)
+    n_buckets_start = preallocated_table.get_state()["n_buckets"]
+    preallocated_table.map_locations(keys)
+    n_buckets_end = preallocated_table.get_state()["n_buckets"]
+    # original number of buckets was enough:
+    assert n_buckets_start == n_buckets_end
+    # check with clean table (not too much preallocated)
+    clean_table = ht.StringHashTable()
+    clean_table.map_locations(keys)
+    assert n_buckets_start == clean_table.get_state()["n_buckets"]
 
 
 @pytest.mark.parametrize(
@@ -322,15 +443,6 @@ def test_get_set_contains_len(self, table_type, dtype):
         assert index in table
         assert table.get_item(index) == 41
 
-    def test_map(self, table_type, dtype):
-        N = 332
-        table = table_type()
-        keys = np.full(N, np.nan, dtype=dtype)
-        vals = (np.arange(N) + N).astype(np.int64)
-        table.map(keys, vals)
-        assert len(table) == 1
-        assert table.get_item(np.nan) == 2 * N - 1
-
     def test_map_locations(self, table_type, dtype):
         N = 10
         table = table_type()
@@ -468,6 +580,21 @@ def test_unique_label_indices_intp(writable):
     tm.assert_numpy_array_equal(result, expected)
 
 
+def test_unique_label_indices():
+
+    a = np.random.randint(1, 1 << 10, 1 << 15).astype(np.intp)
+
+    left = ht.unique_label_indices(a)
+    right = np.unique(a, return_index=True)[1]
+
+    tm.assert_numpy_array_equal(left, right, check_dtype=False)
+
+    a[np.random.choice(len(a), 10)] = -1
+    left = ht.unique_label_indices(a)
+    right = np.unique(a, return_index=True)[1][1:]
+    tm.assert_numpy_array_equal(left, right, check_dtype=False)
+
+
 @pytest.mark.parametrize(
     "dtype",
     [
diff --git a/pandas/tests/libs/test_lib.py b/pandas/tests/libs/test_lib.py
index 5b7e90fe16d8f..e9a26b26eefc4 100644
--- a/pandas/tests/libs/test_lib.py
+++ b/pandas/tests/libs/test_lib.py
@@ -54,50 +54,58 @@ def test_maybe_indices_to_slice_left_edge(self):
         assert isinstance(maybe_slice, slice)
         tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-        for end in [1, 2, 5, 20, 99]:
-            for step in [1, 2, 4]:
-                indices = np.arange(0, end, step, dtype=np.intp)
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+    @pytest.mark.parametrize("end", [1, 2, 5, 20, 99])
+    @pytest.mark.parametrize("step", [1, 2, 4])
+    def test_maybe_indices_to_slice_left_edge_not_slice_end_steps(self, end, step):
+        target = np.arange(100)
+        indices = np.arange(0, end, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-                # reverse
-                indices = indices[::-1]
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
+    @pytest.mark.parametrize(
+        "case", [[2, 1, 2, 0], [2, 2, 1, 0], [0, 1, 2, 1], [-2, 0, 2], [2, 0, -2]]
+    )
+    def test_maybe_indices_to_slice_left_edge_not_slice(self, case):
         # not slice
-        for case in [[2, 1, 2, 0], [2, 2, 1, 0], [0, 1, 2, 1], [-2, 0, 2], [2, 0, -2]]:
-            indices = np.array(case, dtype=np.intp)
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-            assert not isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(maybe_slice, indices)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-    def test_maybe_indices_to_slice_right_edge(self):
+    @pytest.mark.parametrize("start", [0, 2, 5, 20, 97, 98])
+    @pytest.mark.parametrize("step", [1, 2, 4])
+    def test_maybe_indices_to_slice_right_edge(self, start, step):
         target = np.arange(100)
 
         # slice
-        for start in [0, 2, 5, 20, 97, 98]:
-            for step in [1, 2, 4]:
-                indices = np.arange(start, 99, step, dtype=np.intp)
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        indices = np.arange(start, 99, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-                # reverse
-                indices = indices[::-1]
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
+    def test_maybe_indices_to_slice_right_edge_not_slice(self):
         # not slice
+        target = np.arange(100)
         indices = np.array([97, 98, 99, 100], dtype=np.intp)
         maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
@@ -122,65 +130,75 @@ def test_maybe_indices_to_slice_right_edge(self):
         with pytest.raises(IndexError, match=msg):
             target[maybe_slice]
 
-        for case in [[99, 97, 99, 96], [99, 99, 98, 97], [98, 98, 97, 96]]:
-            indices = np.array(case, dtype=np.intp)
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+    @pytest.mark.parametrize(
+        "case", [[99, 97, 99, 96], [99, 99, 98, 97], [98, 98, 97, 96]]
+    )
+    def test_maybe_indices_to_slice_right_edge_cases(self, case):
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-            assert not isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(maybe_slice, indices)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-    def test_maybe_indices_to_slice_both_edges(self):
+    @pytest.mark.parametrize("step", [1, 2, 4, 5, 8, 9])
+    def test_maybe_indices_to_slice_both_edges(self, step):
         target = np.arange(10)
 
         # slice
-        for step in [1, 2, 4, 5, 8, 9]:
-            indices = np.arange(0, 9, step, dtype=np.intp)
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
-            assert isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
-
-            # reverse
-            indices = indices[::-1]
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
-            assert isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        indices = np.arange(0, 9, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
+    @pytest.mark.parametrize("case", [[4, 2, 0, -2], [2, 2, 1, 0], [0, 1, 2, 1]])
+    def test_maybe_indices_to_slice_both_edges_not_slice(self, case):
         # not slice
-        for case in [[4, 2, 0, -2], [2, 2, 1, 0], [0, 1, 2, 1]]:
-            indices = np.array(case, dtype=np.intp)
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
-            assert not isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(maybe_slice, indices)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
-
-    def test_maybe_indices_to_slice_middle(self):
+        target = np.arange(10)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("start, end", [(2, 10), (5, 25), (65, 97)])
+    @pytest.mark.parametrize("step", [1, 2, 4, 20])
+    def test_maybe_indices_to_slice_middle(self, start, end, step):
         target = np.arange(100)
 
         # slice
-        for start, end in [(2, 10), (5, 25), (65, 97)]:
-            for step in [1, 2, 4, 20]:
-                indices = np.arange(start, end, step, dtype=np.intp)
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        indices = np.arange(start, end, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
-                # reverse
-                indices = indices[::-1]
-                maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-                assert isinstance(maybe_slice, slice)
-                tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
+    @pytest.mark.parametrize(
+        "case", [[14, 12, 10, 12], [12, 12, 11, 10], [10, 11, 12, 11]]
+    )
+    def test_maybe_indices_to_slice_middle_not_slice(self, case):
         # not slice
-        for case in [[14, 12, 10, 12], [12, 12, 11, 10], [10, 11, 12, 11]]:
-            indices = np.array(case, dtype=np.intp)
-            maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
 
-            assert not isinstance(maybe_slice, slice)
-            tm.assert_numpy_array_equal(maybe_slice, indices)
-            tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
 
     def test_maybe_booleans_to_slice(self):
         arr = np.array([0, 0, 1, 1, 1, 0, 1], dtype=np.uint8)
diff --git a/pandas/tests/plotting/common.py b/pandas/tests/plotting/common.py
index ae9db5e728efe..df853770b85f1 100644
--- a/pandas/tests/plotting/common.py
+++ b/pandas/tests/plotting/common.py
@@ -1,13 +1,9 @@
 """
 Module consolidating common testing functions for checking plotting.
-
-Currently all plotting tests are marked as slow via
-``pytestmark = pytest.mark.slow`` at the module level.
 """
 
 from __future__ import annotations
 
-import os
 from typing import (
     TYPE_CHECKING,
     Sequence,
@@ -22,11 +18,7 @@
 from pandas.core.dtypes.api import is_list_like
 
 import pandas as pd
-from pandas import (
-    DataFrame,
-    Series,
-    to_datetime,
-)
+from pandas import Series
 import pandas._testing as tm
 
 if TYPE_CHECKING:
@@ -39,62 +31,12 @@ class TestPlotBase:
     This is a common base class used for various plotting tests
     """
 
-    def setup_method(self, method):
-
+    def setup_method(self):
         import matplotlib as mpl
 
-        from pandas.plotting._matplotlib import compat
-
-        self.compat = compat
-
         mpl.rcdefaults()
 
-        self.start_date_to_int64 = 812419200000000000
-        self.end_date_to_int64 = 819331200000000000
-
-        self.mpl_ge_2_2_3 = compat.mpl_ge_2_2_3()
-        self.mpl_ge_3_0_0 = compat.mpl_ge_3_0_0()
-        self.mpl_ge_3_1_0 = compat.mpl_ge_3_1_0()
-        self.mpl_ge_3_2_0 = compat.mpl_ge_3_2_0()
-
-        self.bp_n_objects = 7
-        self.polycollection_factor = 2
-        self.default_figsize = (6.4, 4.8)
-        self.default_tick_position = "left"
-
-        n = 100
-        with tm.RNGContext(42):
-            gender = np.random.choice(["Male", "Female"], size=n)
-            classroom = np.random.choice(["A", "B", "C"], size=n)
-
-            self.hist_df = DataFrame(
-                {
-                    "gender": gender,
-                    "classroom": classroom,
-                    "height": np.random.normal(66, 4, size=n),
-                    "weight": np.random.normal(161, 32, size=n),
-                    "category": np.random.randint(4, size=n),
-                    "datetime": to_datetime(
-                        np.random.randint(
-                            self.start_date_to_int64,
-                            self.end_date_to_int64,
-                            size=n,
-                            dtype=np.int64,
-                        )
-                    ),
-                }
-            )
-
-        self.tdf = tm.makeTimeDataFrame()
-        self.hexbin_df = DataFrame(
-            {
-                "A": np.random.uniform(size=20),
-                "B": np.random.uniform(size=20),
-                "C": np.arange(20) + np.random.uniform(size=20),
-            }
-        )
-
-    def teardown_method(self, method):
+    def teardown_method(self):
         tm.close()
 
     @cache_readonly
@@ -166,13 +108,12 @@ def _check_data(self, xp, rs):
         xp_lines = xp.get_lines()
         rs_lines = rs.get_lines()
 
-        def check_line(xpl, rsl):
+        assert len(xp_lines) == len(rs_lines)
+        for xpl, rsl in zip(xp_lines, rs_lines):
             xpdata = xpl.get_xydata()
             rsdata = rsl.get_xydata()
             tm.assert_almost_equal(xpdata, rsdata)
 
-        assert len(xp_lines) == len(rs_lines)
-        [check_line(xpl, rsl) for xpl, rsl in zip(xp_lines, rs_lines)]
         tm.close()
 
     def _check_visible(self, collections, visible=True):
@@ -387,7 +328,7 @@ def _check_axes_shape(self, axes, axes_num=None, layout=None, figsize=None):
         from pandas.plotting._matplotlib.tools import flatten_axes
 
         if figsize is None:
-            figsize = self.default_figsize
+            figsize = (6.4, 4.8)
         visible_axes = self._flatten_visible(axes)
 
         if axes_num is not None:
@@ -525,15 +466,8 @@ def _check_grid_settings(self, obj, kinds, kws={}):
         def is_grid_on():
             xticks = self.plt.gca().xaxis.get_major_ticks()
             yticks = self.plt.gca().yaxis.get_major_ticks()
-            # for mpl 2.2.2, gridOn and gridline.get_visible disagree.
-            # for new MPL, they are the same.
-
-            if self.mpl_ge_3_1_0:
-                xoff = all(not g.gridline.get_visible() for g in xticks)
-                yoff = all(not g.gridline.get_visible() for g in yticks)
-            else:
-                xoff = all(not g.gridOn for g in xticks)
-                yoff = all(not g.gridOn for g in yticks)
+            xoff = all(not g.gridline.get_visible() for g in xticks)
+            yoff = all(not g.gridline.get_visible() for g in yticks)
 
             return not (xoff and yoff)
 
@@ -572,10 +506,18 @@ def _unpack_cycler(self, rcParams, field="color"):
         return [v[field] for v in rcParams["axes.prop_cycle"]]
 
     def get_x_axis(self, ax):
-        return ax._shared_axes["x"] if self.compat.mpl_ge_3_5_0() else ax._shared_x_axes
+        from pandas.plotting._matplotlib.compat import mpl_ge_3_5_0
+
+        if mpl_ge_3_5_0():
+            return ax._shared_axes["x"]
+        return ax._shared_x_axes
 
     def get_y_axis(self, ax):
-        return ax._shared_axes["y"] if self.compat.mpl_ge_3_5_0() else ax._shared_y_axes
+        from pandas.plotting._matplotlib.compat import mpl_ge_3_5_0
+
+        if mpl_ge_3_5_0():
+            return ax._shared_axes["y"]
+        return ax._shared_y_axes
 
 
 def _check_plot_works(f, filterwarnings="always", default_axes=False, **kwargs):
@@ -656,8 +598,3 @@ def _gen_two_subplots(f, fig, **kwargs):
     else:
         kwargs["ax"] = fig.add_subplot(212)
     yield f(**kwargs)
-
-
-def curpath():
-    pth, _ = os.path.split(os.path.abspath(__file__))
-    return pth
diff --git a/pandas/tests/plotting/conftest.py b/pandas/tests/plotting/conftest.py
new file mode 100644
index 0000000000000..b88d9344da707
--- /dev/null
+++ b/pandas/tests/plotting/conftest.py
@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def hist_df():
+    n = 100
+    with tm.RNGContext(42):
+        gender = np.random.choice(["Male", "Female"], size=n)
+        classroom = np.random.choice(["A", "B", "C"], size=n)
+
+        hist_df = DataFrame(
+            {
+                "gender": gender,
+                "classroom": classroom,
+                "height": np.random.normal(66, 4, size=n),
+                "weight": np.random.normal(161, 32, size=n),
+                "category": np.random.randint(4, size=n),
+                "datetime": to_datetime(
+                    np.random.randint(
+                        812419200000000000,
+                        819331200000000000,
+                        size=n,
+                        dtype=np.int64,
+                    )
+                ),
+            }
+        )
+    return hist_df
diff --git a/pandas/tests/plotting/frame/test_frame.py b/pandas/tests/plotting/frame/test_frame.py
index 6c07366e402d6..6221673d12375 100644
--- a/pandas/tests/plotting/frame/test_frame.py
+++ b/pandas/tests/plotting/frame/test_frame.py
@@ -33,30 +33,18 @@
 from pandas.io.formats.printing import pprint_thing
 import pandas.plotting as plotting
 
-pytestmark = pytest.mark.slow
+try:
+    from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+except ImportError:
+    mpl_ge_3_6_0 = lambda: True
 
 
 @td.skip_if_no_mpl
 class TestDataFramePlots(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-
-        self.tdf = tm.makeTimeDataFrame()
-        self.hexbin_df = DataFrame(
-            {
-                "A": np.random.uniform(size=20),
-                "B": np.random.uniform(size=20),
-                "C": np.arange(20) + np.random.uniform(size=20),
-            }
-        )
-
+    @pytest.mark.xfail(mpl_ge_3_6_0(), reason="Api changed")
+    @pytest.mark.slow
     def test_plot(self):
-        from pandas.plotting._matplotlib.compat import mpl_ge_3_1_0
-
-        df = self.tdf
+        df = tm.makeTimeDataFrame()
         _check_plot_works(df.plot, grid=False)
 
         # _check_plot_works adds an ax so use default_axes=True to avoid warning
@@ -81,10 +69,7 @@ def test_plot(self):
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
         df = DataFrame({"x": [1, 2], "y": [3, 4]})
-        if mpl_ge_3_1_0():
-            msg = "'Line2D' object has no property 'blarg'"
-        else:
-            msg = "Unknown property blarg"
+        msg = "'Line2D' object has no property 'blarg'"
         with pytest.raises(AttributeError, match=msg):
             df.plot.line(blarg=True)
 
@@ -167,12 +152,11 @@ def test_nullable_int_plot(self):
         df = DataFrame(
             {
                 "A": [1, 2, 3, 4, 5],
-                "B": [1.0, 2.0, 3.0, 4.0, 5.0],
-                "C": [7, 5, np.nan, 3, 2],
+                "B": [1, 2, 3, 4, 5],
+                "C": np.array([7, 5, np.nan, 3, 2], dtype=object),
                 "D": pd.to_datetime(dates, format="%Y").view("i8"),
                 "E": pd.to_datetime(dates, format="%Y", utc=True).view("i8"),
-            },
-            dtype=np.int64,
+            }
         )
 
         _check_plot_works(df.plot, x="A", y="B")
@@ -183,6 +167,7 @@ def test_nullable_int_plot(self):
         _check_plot_works(df[["A", "D"]].plot, x="A", y="D")
         _check_plot_works(df[["A", "E"]].plot, x="A", y="E")
 
+    @pytest.mark.slow
     def test_integer_array_plot(self):
         # GH 25587
         arr = pd.array([1, 2, 3, 4], dtype="UInt32")
@@ -220,7 +205,7 @@ def test_donot_overwrite_index_name(self):
 
     def test_plot_xy(self):
         # columns.inferred_type == 'string'
-        df = self.tdf
+        df = tm.makeTimeDataFrame()
         self._check_data(df.plot(x=0, y=1), df.set_index("A")["B"].plot())
         self._check_data(df.plot(x=0), df.set_index("A").plot())
         self._check_data(df.plot(y=0), df.B.plot())
@@ -272,7 +257,7 @@ def test_invalid_logscale(self, input_param):
 
     def test_xcompat(self):
 
-        df = self.tdf
+        df = tm.makeTimeDataFrame()
         ax = df.plot(x_compat=True)
         lines = ax.get_lines()
         assert not isinstance(lines[0].get_xdata(), PeriodIndex)
@@ -383,7 +368,8 @@ def _compare_stacked_y_cood(self, normal_lines, stacked_lines):
             sy = sl.get_data()[1]
             tm.assert_numpy_array_equal(base, sy)
 
-    def test_line_area_stacked(self):
+    @pytest.mark.parametrize("kind", ["line", "area"])
+    def test_line_area_stacked(self, kind):
         with tm.RNGContext(42):
             df = DataFrame(np.random.rand(6, 4), columns=["w", "x", "y", "z"])
             neg_df = -df
@@ -403,33 +389,32 @@ def test_line_area_stacked(self):
                 columns=["w", "x", "y", "z"],
             )
 
-            for kind in ["line", "area"]:
-                ax1 = _check_plot_works(df.plot, kind=kind, stacked=False)
-                ax2 = _check_plot_works(df.plot, kind=kind, stacked=True)
-                self._compare_stacked_y_cood(ax1.lines, ax2.lines)
-
-                ax1 = _check_plot_works(neg_df.plot, kind=kind, stacked=False)
-                ax2 = _check_plot_works(neg_df.plot, kind=kind, stacked=True)
-                self._compare_stacked_y_cood(ax1.lines, ax2.lines)
-
-                ax1 = _check_plot_works(sep_df.plot, kind=kind, stacked=False)
-                ax2 = _check_plot_works(sep_df.plot, kind=kind, stacked=True)
-                self._compare_stacked_y_cood(ax1.lines[:2], ax2.lines[:2])
-                self._compare_stacked_y_cood(ax1.lines[2:], ax2.lines[2:])
-
-                _check_plot_works(mixed_df.plot, stacked=False)
-                msg = (
-                    "When stacked is True, each column must be either all positive or "
-                    "all negative. Column 'w' contains both positive and negative "
-                    "values"
-                )
-                with pytest.raises(ValueError, match=msg):
-                    mixed_df.plot(stacked=True)
+            ax1 = _check_plot_works(df.plot, kind=kind, stacked=False)
+            ax2 = _check_plot_works(df.plot, kind=kind, stacked=True)
+            self._compare_stacked_y_cood(ax1.lines, ax2.lines)
+
+            ax1 = _check_plot_works(neg_df.plot, kind=kind, stacked=False)
+            ax2 = _check_plot_works(neg_df.plot, kind=kind, stacked=True)
+            self._compare_stacked_y_cood(ax1.lines, ax2.lines)
 
-                # Use an index with strictly positive values, preventing
-                #  matplotlib from warning about ignoring xlim
-                df2 = df.set_index(df.index + 1)
-                _check_plot_works(df2.plot, kind=kind, logx=True, stacked=True)
+            ax1 = _check_plot_works(sep_df.plot, kind=kind, stacked=False)
+            ax2 = _check_plot_works(sep_df.plot, kind=kind, stacked=True)
+            self._compare_stacked_y_cood(ax1.lines[:2], ax2.lines[:2])
+            self._compare_stacked_y_cood(ax1.lines[2:], ax2.lines[2:])
+
+            _check_plot_works(mixed_df.plot, stacked=False)
+            msg = (
+                "When stacked is True, each column must be either all positive or "
+                "all negative. Column 'w' contains both positive and negative "
+                "values"
+            )
+            with pytest.raises(ValueError, match=msg):
+                mixed_df.plot(stacked=True)
+
+            # Use an index with strictly positive values, preventing
+            #  matplotlib from warning about ignoring xlim
+            df2 = df.set_index(df.index + 1)
+            _check_plot_works(df2.plot, kind=kind, logx=True, stacked=True)
 
     def test_line_area_nan_df(self):
         values1 = [1, 2, np.nan, 3]
@@ -682,7 +667,7 @@ def test_raise_error_on_datetime_time_data(self):
         # GH 8113, datetime.time type is not supported by matplotlib in scatter
         df = DataFrame(np.random.randn(10), columns=["a"])
         df["dtime"] = date_range(start="2014-01-01", freq="h", periods=10).time
-        msg = "must be a string or a number, not 'datetime.time'"
+        msg = "must be a string or a (real )?number, not 'datetime.time'"
 
         with pytest.raises(TypeError, match=msg):
             df.plot(kind="scatter", x="dtime", y="a")
@@ -746,11 +731,11 @@ def test_plot_scatter_with_categorical_data(self, x, y):
 
         _check_plot_works(df.plot.scatter, x=x, y=y)
 
-    def test_plot_scatter_with_c(self, request):
+    def test_plot_scatter_with_c(self):
         from pandas.plotting._matplotlib.compat import mpl_ge_3_4_0
 
         df = DataFrame(
-            np.random.randn(6, 4),
+            np.random.randint(low=0, high=100, size=(6, 4)),
             index=list(string.ascii_letters[:6]),
             columns=["x", "y", "z", "four"],
         )
@@ -807,6 +792,28 @@ def test_plot_scatter_with_s(self):
         ax = df.plot.scatter(x="a", y="b", s="c")
         tm.assert_numpy_array_equal(df["c"].values, right=ax.collections[0].get_sizes())
 
+    def test_plot_scatter_with_norm(self):
+        # added while fixing GH 45809
+        import matplotlib as mpl
+
+        df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"])
+        norm = mpl.colors.LogNorm()
+        ax = df.plot.scatter(x="a", y="b", c="c", norm=norm)
+        assert ax.collections[0].norm is norm
+
+    def test_plot_scatter_without_norm(self):
+        # added while fixing GH 45809
+        import matplotlib as mpl
+
+        df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"])
+        ax = df.plot.scatter(x="a", y="b", c="c")
+        plot_norm = ax.collections[0].norm
+        color_min_max = (df.c.min(), df.c.max())
+        default_norm = mpl.colors.Normalize(*color_min_max)
+        for value in df.c:
+            assert plot_norm(value) == default_norm(value)
+
+    @pytest.mark.slow
     def test_plot_bar(self):
         df = DataFrame(
             np.random.randn(6, 4),
@@ -839,8 +846,8 @@ def test_plot_bar(self):
         ax = df.plot.barh(rot=55, fontsize=11)
         self._check_ticks_props(ax, yrot=55, ylabelsize=11, xlabelsize=11)
 
-    def test_boxplot(self):
-        df = self.hist_df
+    def test_boxplot(self, hist_df):
+        df = hist_df
         series = df["height"]
         numeric_cols = df._get_numeric_data().columns
         labels = [pprint_thing(c) for c in numeric_cols]
@@ -850,7 +857,7 @@ def test_boxplot(self):
         tm.assert_numpy_array_equal(
             ax.xaxis.get_ticklocs(), np.arange(1, len(numeric_cols) + 1)
         )
-        assert len(ax.lines) == self.bp_n_objects * len(numeric_cols)
+        assert len(ax.lines) == 7 * len(numeric_cols)
         tm.close()
 
         axes = series.plot.box(rot=40)
@@ -865,10 +872,10 @@ def test_boxplot(self):
         labels = [pprint_thing(c) for c in numeric_cols]
         self._check_text_labels(ax.get_xticklabels(), labels)
         tm.assert_numpy_array_equal(ax.xaxis.get_ticklocs(), positions)
-        assert len(ax.lines) == self.bp_n_objects * len(numeric_cols)
+        assert len(ax.lines) == 7 * len(numeric_cols)
 
-    def test_boxplot_vertical(self):
-        df = self.hist_df
+    def test_boxplot_vertical(self, hist_df):
+        df = hist_df
         numeric_cols = df._get_numeric_data().columns
         labels = [pprint_thing(c) for c in numeric_cols]
 
@@ -876,7 +883,7 @@ def test_boxplot_vertical(self):
         ax = df.plot.box(rot=50, fontsize=8, vert=False)
         self._check_ticks_props(ax, xrot=0, yrot=50, ylabelsize=8)
         self._check_text_labels(ax.get_yticklabels(), labels)
-        assert len(ax.lines) == self.bp_n_objects * len(numeric_cols)
+        assert len(ax.lines) == 7 * len(numeric_cols)
 
         axes = _check_plot_works(
             df.plot.box,
@@ -889,13 +896,13 @@ def test_boxplot_vertical(self):
         self._check_ax_scales(axes, xaxis="log")
         for ax, label in zip(axes, labels):
             self._check_text_labels(ax.get_yticklabels(), [label])
-            assert len(ax.lines) == self.bp_n_objects
+            assert len(ax.lines) == 7
 
         positions = np.array([3, 2, 8])
         ax = df.plot.box(positions=positions, vert=False)
         self._check_text_labels(ax.get_yticklabels(), labels)
         tm.assert_numpy_array_equal(ax.yaxis.get_ticklocs(), positions)
-        assert len(ax.lines) == self.bp_n_objects * len(numeric_cols)
+        assert len(ax.lines) == 7 * len(numeric_cols)
 
     def test_boxplot_return_type(self):
         df = DataFrame(
@@ -1187,7 +1194,7 @@ def test_line_label_none(self):
         assert ax.get_legend() is None
 
         ax = s.plot(legend=True)
-        assert ax.get_legend().get_texts()[0].get_text() == "None"
+        assert ax.get_legend().get_texts()[0].get_text() == ""
 
     @pytest.mark.parametrize(
         "props, expected",
@@ -1310,7 +1317,13 @@ def test_xy_args_integer(self, x, y, colnames):
         _check_plot_works(df.plot, x=x, y=y)
 
     def test_hexbin_basic(self):
-        df = self.hexbin_df
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
 
         ax = df.plot.hexbin(x="A", y="B", gridsize=10)
         # TODO: need better way to test. This just does existence.
@@ -1325,7 +1338,13 @@ def test_hexbin_basic(self):
         self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
 
     def test_hexbin_with_c(self):
-        df = self.hexbin_df
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
 
         ax = df.plot.hexbin(x="A", y="B", C="C")
         assert len(ax.collections) == 1
@@ -1342,7 +1361,13 @@ def test_hexbin_with_c(self):
         ],
     )
     def test_hexbin_cmap(self, kwargs, expected):
-        df = self.hexbin_df
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
         ax = df.plot.hexbin(x="A", y="B", **kwargs)
         assert ax.collections[0].cmap.name == expected
 
@@ -1418,6 +1443,7 @@ def test_pie_df_nan(self):
             expected_labels = base_expected[:i] + base_expected[i + 1 :]
             assert result_labels == expected_labels
 
+    @pytest.mark.slow
     def test_errorbar_plot(self):
         d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
         df = DataFrame(d)
@@ -1464,6 +1490,7 @@ def test_errorbar_plot(self):
         with tm.external_error_raised(TypeError):
             df.plot(yerr=df_err)
 
+    @pytest.mark.slow
     @pytest.mark.parametrize("kind", ["line", "bar", "barh"])
     def test_errorbar_plot_different_kinds(self, kind):
         d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
@@ -1508,16 +1535,17 @@ def test_errorbar_plot_iterator(self):
 
     def test_errorbar_with_integer_column_names(self):
         # test with integer column names
-        df = DataFrame(np.random.randn(10, 2))
-        df_err = DataFrame(np.random.randn(10, 2))
+        df = DataFrame(np.abs(np.random.randn(10, 2)))
+        df_err = DataFrame(np.abs(np.random.randn(10, 2)))
         ax = _check_plot_works(df.plot, yerr=df_err)
         self._check_has_errorbars(ax, xerr=0, yerr=2)
         ax = _check_plot_works(df.plot, y=0, yerr=1)
         self._check_has_errorbars(ax, xerr=0, yerr=1)
 
+    @pytest.mark.slow
     def test_errorbar_with_partial_columns(self):
-        df = DataFrame(np.random.randn(10, 3))
-        df_err = DataFrame(np.random.randn(10, 2), columns=[0, 2])
+        df = DataFrame(np.abs(np.random.randn(10, 3)))
+        df_err = DataFrame(np.abs(np.random.randn(10, 2)), columns=[0, 2])
         kinds = ["line", "bar"]
         for kind in kinds:
             ax = _check_plot_works(df.plot, yerr=df_err, kind=kind)
@@ -1605,9 +1633,11 @@ def test_table(self):
             assert len(ax.tables) == 1
 
     def test_errorbar_scatter(self):
-        df = DataFrame(np.random.randn(5, 2), index=range(5), columns=["x", "y"])
+        df = DataFrame(
+            np.abs(np.random.randn(5, 2)), index=range(5), columns=["x", "y"]
+        )
         df_err = DataFrame(
-            np.random.randn(5, 2) / 5, index=range(5), columns=["x", "y"]
+            np.abs(np.random.randn(5, 2)) / 5, index=range(5), columns=["x", "y"]
         )
 
         ax = _check_plot_works(df.plot.scatter, x="x", y="y")
@@ -1634,7 +1664,9 @@ def _check_errorbar_color(containers, expected, has_err="has_xerr"):
             )
 
         # GH 8081
-        df = DataFrame(np.random.randn(10, 5), columns=["a", "b", "c", "d", "e"])
+        df = DataFrame(
+            np.abs(np.random.randn(10, 5)), columns=["a", "b", "c", "d", "e"]
+        )
         ax = df.plot.scatter(x="a", y="b", xerr="d", yerr="e", c="red")
         self._check_has_errorbars(ax, xerr=1, yerr=1)
         _check_errorbar_color(ax.containers, "red", has_err="has_xerr")
@@ -1644,6 +1676,12 @@ def _check_errorbar_color(containers, expected, has_err="has_xerr"):
         self._check_has_errorbars(ax, xerr=0, yerr=1)
         _check_errorbar_color(ax.containers, "green", has_err="has_yerr")
 
+    def test_scatter_unknown_colormap(self):
+        # GH#48726
+        df = DataFrame({"a": [1, 2, 3], "b": 4})
+        with pytest.raises((ValueError, KeyError), match="'unknown' is not a"):
+            df.plot(x="a", y="b", colormap="unknown", kind="scatter")
+
     def test_sharex_and_ax(self):
         # https://github.com/pandas-dev/pandas/issues/9737 using gridspec,
         # the axis in fig.get_axis() are sorted differently than pandas
@@ -1762,12 +1800,18 @@ def test_memory_leak(self):
 
             args = {}
             if kind in ["hexbin", "scatter", "pie"]:
-                df = self.hexbin_df
+                df = DataFrame(
+                    {
+                        "A": np.random.uniform(size=20),
+                        "B": np.random.uniform(size=20),
+                        "C": np.arange(20) + np.random.uniform(size=20),
+                    }
+                )
                 args = {"x": "A", "y": "B"}
             elif kind == "area":
-                df = self.tdf.abs()
+                df = tm.makeTimeDataFrame().abs()
             else:
-                df = self.tdf
+                df = tm.makeTimeDataFrame()
 
             # Use a weakref so we can see if the object gets collected without
             # also preventing it from being collected
@@ -2039,6 +2083,90 @@ def test_plot_no_numeric_data(self):
         with pytest.raises(TypeError, match="no numeric data to plot"):
             df.plot()
 
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize(
+        "kind", ("line", "bar", "barh", "hist", "kde", "density", "area", "pie")
+    )
+    def test_group_subplot(self, kind):
+        d = {
+            "a": np.arange(10),
+            "b": np.arange(10) + 1,
+            "c": np.arange(10) + 1,
+            "d": np.arange(10),
+            "e": np.arange(10),
+        }
+        df = DataFrame(d)
+
+        axes = df.plot(subplots=[("b", "e"), ("c", "d")], kind=kind)
+        assert len(axes) == 3  # 2 groups + single column a
+
+        expected_labels = (["b", "e"], ["c", "d"], ["a"])
+        for ax, labels in zip(axes, expected_labels):
+            if kind != "pie":
+                self._check_legend_labels(ax, labels=labels)
+            if kind == "line":
+                assert len(ax.lines) == len(labels)
+
+    def test_group_subplot_series_notimplemented(self):
+        ser = Series(range(1))
+        msg = "An iterable subplots for a Series"
+        with pytest.raises(NotImplementedError, match=msg):
+            ser.plot(subplots=[("a",)])
+
+    def test_group_subplot_multiindex_notimplemented(self):
+        df = DataFrame(np.eye(2), columns=MultiIndex.from_tuples([(0, 1), (1, 2)]))
+        msg = "An iterable subplots for a DataFrame with a MultiIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            df.plot(subplots=[(0, 1)])
+
+    def test_group_subplot_nonunique_cols_notimplemented(self):
+        df = DataFrame(np.eye(2), columns=["a", "a"])
+        msg = "An iterable subplots for a DataFrame with non-unique"
+        with pytest.raises(NotImplementedError, match=msg):
+            df.plot(subplots=[("a",)])
+
+    @pytest.mark.parametrize(
+        "subplots, expected_msg",
+        [
+            (123, "subplots should be a bool or an iterable"),
+            ("a", "each entry should be a list/tuple"),  # iterable of non-iterable
+            ((1,), "each entry should be a list/tuple"),  # iterable of non-iterable
+            (("a",), "each entry should be a list/tuple"),  # iterable of strings
+        ],
+    )
+    def test_group_subplot_bad_input(self, subplots, expected_msg):
+        # Make sure error is raised when subplots is not a properly
+        # formatted iterable. Only iterables of iterables are permitted, and
+        # entries should not be strings.
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match=expected_msg):
+            df.plot(subplots=subplots)
+
+    def test_group_subplot_invalid_column_name(self):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match=r"Column label\(s\) \['bad_name'\]"):
+            df.plot(subplots=[("a", "bad_name")])
+
+    def test_group_subplot_duplicated_column(self):
+        d = {"a": np.arange(10), "b": np.arange(10), "c": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match="should be in only one subplot"):
+            df.plot(subplots=[("a", "b"), ("a", "c")])
+
+    @pytest.mark.parametrize("kind", ("box", "scatter", "hexbin"))
+    def test_group_subplot_invalid_kind(self, kind):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+        with pytest.raises(
+            ValueError, match="When subplots is an iterable, kind must be one of"
+        ):
+            df.plot(subplots=[("a", "b")], kind=kind)
+
     @pytest.mark.parametrize(
         "index_name, old_label, new_label",
         [
@@ -2088,6 +2216,30 @@ def test_xlabel_ylabel_dataframe_plane_plot(self, kind, xlabel, ylabel):
         assert ax.get_xlabel() == (xcol if xlabel is None else xlabel)
         assert ax.get_ylabel() == (ycol if ylabel is None else ylabel)
 
+    @pytest.mark.parametrize("secondary_y", (False, True))
+    def test_secondary_y(self, secondary_y):
+        ax_df = DataFrame([0]).plot(
+            secondary_y=secondary_y, ylabel="Y", ylim=(0, 100), yticks=[99]
+        )
+        for ax in ax_df.figure.axes:
+            if ax.yaxis.get_visible():
+                assert ax.get_ylabel() == "Y"
+                assert ax.get_ylim() == (0, 100)
+                assert ax.get_yticks()[0] == 99
+
+    def test_sort_columns_deprecated(self):
+        # GH 47563
+        df = DataFrame({"a": [1, 2], "b": [3, 4]})
+
+        with tm.assert_produces_warning(FutureWarning):
+            df.plot.box("a", sort_columns=True)
+
+        with tm.assert_produces_warning(FutureWarning):
+            df.plot.box(sort_columns=False)
+
+        with tm.assert_produces_warning(False):
+            df.plot.box("a")
+
 
 def _generate_4_axes_via_gridspec():
     import matplotlib as mpl
diff --git a/pandas/tests/plotting/frame/test_frame_color.py b/pandas/tests/plotting/frame/test_frame_color.py
index b46bb95829991..e6653c38df23f 100644
--- a/pandas/tests/plotting/frame/test_frame_color.py
+++ b/pandas/tests/plotting/frame/test_frame_color.py
@@ -15,26 +15,9 @@
     _check_plot_works,
 )
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestDataFrameColor(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-
-        self.tdf = tm.makeTimeDataFrame()
-        self.hexbin_df = DataFrame(
-            {
-                "A": np.random.uniform(size=20),
-                "B": np.random.uniform(size=20),
-                "C": np.arange(20) + np.random.uniform(size=20),
-            }
-        )
-
     def test_mpl2_color_cycle_str(self):
         # GH 15516
         df = DataFrame(np.random.randn(10, 3), columns=["a", "b", "c"])
@@ -220,7 +203,7 @@ def test_scatter_with_c_column_name_with_colors(self, cmap):
             columns=["length", "width"],
         )
         df["species"] = ["r", "r", "g", "g", "b"]
-        ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap)
+        ax = df.plot.scatter(x=0, y=1, cmap=cmap, c="species")
         assert ax.collections[0].colorbar is None
 
     def test_scatter_colors(self):
@@ -621,12 +604,24 @@ def test_default_color_cycle(self):
         self._check_colors(ax.get_lines(), linecolors=expected)
 
     def test_no_color_bar(self):
-        df = self.hexbin_df
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
         ax = df.plot.hexbin(x="A", y="B", colorbar=None)
         assert ax.collections[0].colorbar is None
 
     def test_mixing_cmap_and_colormap_raises(self):
-        df = self.hexbin_df
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
         msg = "Only specify one of `cmap` and `colormap`"
         with pytest.raises(TypeError, match=msg):
             df.plot.hexbin(x="A", y="B", cmap="YlGn", colormap="BuGn")
@@ -659,6 +654,6 @@ def test_colors_of_columns_with_same_name(self):
 
     def test_invalid_colormap(self):
         df = DataFrame(np.random.randn(3, 2), columns=["A", "B"])
-        msg = "'invalid_colormap' is not a valid value for name; supported values are "
-        with pytest.raises(ValueError, match=msg):
+        msg = "(is not a valid value)|(is not a known colormap)"
+        with pytest.raises((ValueError, KeyError), match=msg):
             df.plot(colormap="invalid_colormap")
diff --git a/pandas/tests/plotting/frame/test_frame_groupby.py b/pandas/tests/plotting/frame/test_frame_groupby.py
index bc35e02e6a581..9c148645966ad 100644
--- a/pandas/tests/plotting/frame/test_frame_groupby.py
+++ b/pandas/tests/plotting/frame/test_frame_groupby.py
@@ -1,34 +1,15 @@
 """ Test cases for DataFrame.plot """
 
-import numpy as np
 import pytest
 
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame
-import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestDataFramePlotsGroupby(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-
-        self.tdf = tm.makeTimeDataFrame()
-        self.hexbin_df = DataFrame(
-            {
-                "A": np.random.uniform(size=20),
-                "B": np.random.uniform(size=20),
-                "C": np.arange(20) + np.random.uniform(size=20),
-            }
-        )
-
     def _assert_ytickslabels_visibility(self, axes, expected):
         for ax, exp in zip(axes, expected):
             self._check_visible(ax.get_yticklabels(), visible=exp)
diff --git a/pandas/tests/plotting/frame/test_frame_legend.py b/pandas/tests/plotting/frame/test_frame_legend.py
index 9501047415e9e..e11aeeccfd5fb 100644
--- a/pandas/tests/plotting/frame/test_frame_legend.py
+++ b/pandas/tests/plotting/frame/test_frame_legend.py
@@ -1,14 +1,14 @@
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 from pandas import (
     DataFrame,
     date_range,
 )
 from pandas.tests.plotting.common import TestPlotBase
 
-pytestmark = pytest.mark.slow
-
 
 class TestFrameLegend(TestPlotBase):
     @pytest.mark.xfail(
@@ -45,6 +45,7 @@ def test_legend_false(self):
         expected = ["blue", "green", "red"]
         assert result == expected
 
+    @td.skip_if_no_scipy
     def test_df_legend_labels(self):
         kinds = ["line", "bar", "barh", "kde", "area", "hist"]
         df = DataFrame(np.random.rand(3, 3), columns=["a", "b", "c"])
@@ -158,13 +159,21 @@ def test_legend_name(self):
         leg_title = ax.legend_.get_title()
         self._check_text_labels(leg_title, "new")
 
-    def test_no_legend(self):
-        kinds = ["line", "bar", "barh", "kde", "area", "hist"]
+    @pytest.mark.parametrize(
+        "kind",
+        [
+            "line",
+            "bar",
+            "barh",
+            pytest.param("kde", marks=td.skip_if_no_scipy),
+            "area",
+            "hist",
+        ],
+    )
+    def test_no_legend(self, kind):
         df = DataFrame(np.random.rand(3, 3), columns=["a", "b", "c"])
-
-        for kind in kinds:
-            ax = df.plot(kind=kind, legend=False)
-            self._check_legend_labels(ax, visible=False)
+        ax = df.plot(kind=kind, legend=False)
+        self._check_legend_labels(ax, visible=False)
 
     def test_missing_markers_legend(self):
         # 14958
diff --git a/pandas/tests/plotting/frame/test_frame_subplots.py b/pandas/tests/plotting/frame/test_frame_subplots.py
index fa4a132001be5..47d91c7975a28 100644
--- a/pandas/tests/plotting/frame/test_frame_subplots.py
+++ b/pandas/tests/plotting/frame/test_frame_subplots.py
@@ -19,26 +19,10 @@
 
 from pandas.io.formats.printing import pprint_thing
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestDataFramePlotsSubplots(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-
-        self.tdf = tm.makeTimeDataFrame()
-        self.hexbin_df = DataFrame(
-            {
-                "A": np.random.uniform(size=20),
-                "B": np.random.uniform(size=20),
-                "C": np.arange(20) + np.random.uniform(size=20),
-            }
-        )
-
+    @pytest.mark.slow
     def test_subplots(self):
         df = DataFrame(np.random.rand(10, 3), index=list(string.ascii_letters[:10]))
 
@@ -53,7 +37,7 @@ def test_subplots(self):
             for ax in axes[:-2]:
                 self._check_visible(ax.xaxis)  # xaxis must be visible for grid
                 self._check_visible(ax.get_xticklabels(), visible=False)
-                if not (kind == "bar" and self.mpl_ge_3_1_0):
+                if kind != "bar":
                     # change https://github.com/pandas-dev/pandas/issues/26714
                     self._check_visible(ax.get_xticklabels(minor=True), visible=False)
                 self._check_visible(ax.xaxis.get_label(), visible=False)
@@ -252,6 +236,7 @@ def test_subplots_layout_single_column(
         )
         assert axes.shape == expected_shape
 
+    @pytest.mark.slow
     def test_subplots_warnings(self):
         # GH 9464
         with tm.assert_produces_warning(None):
@@ -405,8 +390,8 @@ def test_bar_log_subplots(self):
         tm.assert_numpy_array_equal(ax[0].yaxis.get_ticklocs(), expected)
         tm.assert_numpy_array_equal(ax[1].yaxis.get_ticklocs(), expected)
 
-    def test_boxplot_subplots_return_type(self):
-        df = self.hist_df
+    def test_boxplot_subplots_return_type(self, hist_df):
+        df = hist_df
 
         # normal style: return_type=None
         result = df.plot.box(subplots=True)
@@ -595,19 +580,21 @@ def test_bar_barwidth_position(self, kwargs):
         df = DataFrame(np.random.randn(5, 5))
         self._check_bar_alignment(df, width=0.9, position=0.2, **kwargs)
 
-    def test_bar_barwidth_position_int(self):
+    @pytest.mark.parametrize("w", [1, 1.0])
+    def test_bar_barwidth_position_int(self, w):
+        # GH 12979
+        df = DataFrame(np.random.randn(5, 5))
+        ax = df.plot.bar(stacked=True, width=w)
+        ticks = ax.xaxis.get_ticklocs()
+        tm.assert_numpy_array_equal(ticks, np.array([0, 1, 2, 3, 4]))
+        assert ax.get_xlim() == (-0.75, 4.75)
+        # check left-edge of bars
+        assert ax.patches[0].get_x() == -0.5
+        assert ax.patches[-1].get_x() == 3.5
+
+    def test_bar_barwidth_position_int_width_1(self):
         # GH 12979
         df = DataFrame(np.random.randn(5, 5))
-
-        for w in [1, 1.0]:
-            ax = df.plot.bar(stacked=True, width=w)
-            ticks = ax.xaxis.get_ticklocs()
-            tm.assert_numpy_array_equal(ticks, np.array([0, 1, 2, 3, 4]))
-            assert ax.get_xlim() == (-0.75, 4.75)
-            # check left-edge of bars
-            assert ax.patches[0].get_x() == -0.5
-            assert ax.patches[-1].get_x() == 3.5
-
         self._check_bar_alignment(df, kind="bar", stacked=True, width=1)
         self._check_bar_alignment(df, kind="barh", stacked=False, width=1)
         self._check_bar_alignment(df, kind="barh", stacked=True, width=1)
diff --git a/pandas/tests/plotting/frame/test_hist_box_by.py b/pandas/tests/plotting/frame/test_hist_box_by.py
index c92d952587967..999118144b58d 100644
--- a/pandas/tests/plotting/frame/test_hist_box_by.py
+++ b/pandas/tests/plotting/frame/test_hist_box_by.py
@@ -13,7 +13,8 @@
 )
 
 
-def _create_hist_box_with_by_df():
+@pytest.fixture
+def hist_df():
     np.random.seed(0)
     df = DataFrame(np.random.randn(30, 2), columns=["A", "B"])
     df["C"] = np.random.choice(["a", "b", "c"], 30)
@@ -23,13 +24,7 @@ def _create_hist_box_with_by_df():
 
 @td.skip_if_no_mpl
 class TestHistWithBy(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-        self.hist_df = _create_hist_box_with_by_df()
-
+    @pytest.mark.slow
     @pytest.mark.parametrize(
         "by, column, titles, legends",
         [
@@ -86,9 +81,11 @@ def setup_method(self, method):
             ),
         ],
     )
-    def test_hist_plot_by_argument(self, by, column, titles, legends):
+    def test_hist_plot_by_argument(self, by, column, titles, legends, hist_df):
         # GH 15079
-        axes = _check_plot_works(self.hist_df.plot.hist, column=column, by=by)
+        axes = _check_plot_works(
+            hist_df.plot.hist, column=column, by=by, default_axes=True
+        )
         result_titles = [ax.get_title() for ax in axes]
         result_legends = [
             [legend.get_text() for legend in ax.get_legend().texts] for ax in axes
@@ -120,12 +117,12 @@ def test_hist_plot_by_argument(self, by, column, titles, legends):
             ),
         ],
     )
-    def test_hist_plot_by_0(self, by, column, titles, legends):
+    def test_hist_plot_by_0(self, by, column, titles, legends, hist_df):
         # GH 15079
-        df = self.hist_df.copy()
+        df = hist_df.copy()
         df = df.rename(columns={"C": 0})
 
-        axes = _check_plot_works(df.plot.hist, column=column, by=by)
+        axes = _check_plot_works(df.plot.hist, default_axes=True, column=column, by=by)
         result_titles = [ax.get_title() for ax in axes]
         result_legends = [
             [legend.get_text() for legend in ax.get_legend().texts] for ax in axes
@@ -143,11 +140,13 @@ def test_hist_plot_by_0(self, by, column, titles, legends):
             ((), ["A", "B"]),
         ],
     )
-    def test_hist_plot_empty_list_string_tuple_by(self, by, column):
+    def test_hist_plot_empty_list_string_tuple_by(self, by, column, hist_df):
         # GH 15079
         msg = "No group keys passed"
         with pytest.raises(ValueError, match=msg):
-            _check_plot_works(self.hist_df.plot.hist, column=column, by=by)
+            _check_plot_works(
+                hist_df.plot.hist, default_axes=True, column=column, by=by
+            )
 
     @pytest.mark.slow
     @pytest.mark.parametrize(
@@ -166,12 +165,12 @@ def test_hist_plot_empty_list_string_tuple_by(self, by, column):
             (["C", "D"], ["A", "B"], (5, 2), 9),
         ],
     )
-    def test_hist_plot_layout_with_by(self, by, column, layout, axes_num):
+    def test_hist_plot_layout_with_by(self, by, column, layout, axes_num, hist_df):
         # GH 15079
         # _check_plot_works adds an ax so catch warning. see GH #13188
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
-                self.hist_df.plot.hist, column=column, by=by, layout=layout
+                hist_df.plot.hist, column=column, by=by, layout=layout
             )
         self._check_axes_shape(axes, axes_num=axes_num, layout=layout)
 
@@ -183,16 +182,16 @@ def test_hist_plot_layout_with_by(self, by, column, layout, axes_num):
             ("At least one dimension of layout must be positive", "C", (-1, -1)),
         ],
     )
-    def test_hist_plot_invalid_layout_with_by_raises(self, msg, by, layout):
+    def test_hist_plot_invalid_layout_with_by_raises(self, msg, by, layout, hist_df):
         # GH 15079, test if error is raised when invalid layout is given
 
         with pytest.raises(ValueError, match=msg):
-            self.hist_df.plot.hist(column=["A", "B"], by=by, layout=layout)
+            hist_df.plot.hist(column=["A", "B"], by=by, layout=layout)
 
     @pytest.mark.slow
-    def test_axis_share_x_with_by(self):
+    def test_axis_share_x_with_by(self, hist_df):
         # GH 15079
-        ax1, ax2, ax3 = self.hist_df.plot.hist(column="A", by="C", sharex=True)
+        ax1, ax2, ax3 = hist_df.plot.hist(column="A", by="C", sharex=True)
 
         # share x
         assert self.get_x_axis(ax1).joined(ax1, ax2)
@@ -207,9 +206,9 @@ def test_axis_share_x_with_by(self):
         assert not self.get_y_axis(ax3).joined(ax2, ax3)
 
     @pytest.mark.slow
-    def test_axis_share_y_with_by(self):
+    def test_axis_share_y_with_by(self, hist_df):
         # GH 15079
-        ax1, ax2, ax3 = self.hist_df.plot.hist(column="A", by="C", sharey=True)
+        ax1, ax2, ax3 = hist_df.plot.hist(column="A", by="C", sharey=True)
 
         # share y
         assert self.get_y_axis(ax1).joined(ax1, ax2)
@@ -224,21 +223,14 @@ def test_axis_share_y_with_by(self):
         assert not self.get_x_axis(ax3).joined(ax2, ax3)
 
     @pytest.mark.parametrize("figsize", [(12, 8), (20, 10)])
-    def test_figure_shape_hist_with_by(self, figsize):
+    def test_figure_shape_hist_with_by(self, figsize, hist_df):
         # GH 15079
-        axes = self.hist_df.plot.hist(column="A", by="C", figsize=figsize)
+        axes = hist_df.plot.hist(column="A", by="C", figsize=figsize)
         self._check_axes_shape(axes, axes_num=3, figsize=figsize)
 
 
 @td.skip_if_no_mpl
 class TestBoxWithBy(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-        self.box_df = _create_hist_box_with_by_df()
-
     @pytest.mark.parametrize(
         "by, column, titles, xticklabels",
         [
@@ -284,9 +276,11 @@ def setup_method(self, method):
             (["C"], None, ["A", "B"], [["a", "b", "c"]] * 2),
         ],
     )
-    def test_box_plot_by_argument(self, by, column, titles, xticklabels):
+    def test_box_plot_by_argument(self, by, column, titles, xticklabels, hist_df):
         # GH 15079
-        axes = _check_plot_works(self.box_df.plot.box, column=column, by=by)
+        axes = _check_plot_works(
+            hist_df.plot.box, default_axes=True, column=column, by=by
+        )
         result_titles = [ax.get_title() for ax in axes]
         result_xticklabels = [
             [label.get_text() for label in ax.get_xticklabels()] for ax in axes
@@ -320,12 +314,12 @@ def test_box_plot_by_argument(self, by, column, titles, xticklabels):
             (0, None, ["A", "B"], [["a", "b", "c"]] * 2),
         ],
     )
-    def test_box_plot_by_0(self, by, column, titles, xticklabels):
+    def test_box_plot_by_0(self, by, column, titles, xticklabels, hist_df):
         # GH 15079
-        df = self.box_df.copy()
+        df = hist_df.copy()
         df = df.rename(columns={"C": 0})
 
-        axes = _check_plot_works(df.plot.box, column=column, by=by)
+        axes = _check_plot_works(df.plot.box, default_axes=True, column=column, by=by)
         result_titles = [ax.get_title() for ax in axes]
         result_xticklabels = [
             [label.get_text() for label in ax.get_xticklabels()] for ax in axes
@@ -343,11 +337,11 @@ def test_box_plot_by_0(self, by, column, titles, xticklabels):
             ((), ["A", "B"]),
         ],
     )
-    def test_box_plot_with_none_empty_list_by(self, by, column):
+    def test_box_plot_with_none_empty_list_by(self, by, column, hist_df):
         # GH 15079
         msg = "No group keys passed"
         with pytest.raises(ValueError, match=msg):
-            _check_plot_works(self.box_df.plot.box, column=column, by=by)
+            _check_plot_works(hist_df.plot.box, default_axes=True, column=column, by=by)
 
     @pytest.mark.slow
     @pytest.mark.parametrize(
@@ -361,10 +355,10 @@ def test_box_plot_with_none_empty_list_by(self, by, column):
             (["C", "D"], None, (1, 2), 2),
         ],
     )
-    def test_box_plot_layout_with_by(self, by, column, layout, axes_num):
+    def test_box_plot_layout_with_by(self, by, column, layout, axes_num, hist_df):
         # GH 15079
         axes = _check_plot_works(
-            self.box_df.plot.box, column=column, by=by, layout=layout
+            hist_df.plot.box, default_axes=True, column=column, by=by, layout=layout
         )
         self._check_axes_shape(axes, axes_num=axes_num, layout=layout)
 
@@ -376,14 +370,14 @@ def test_box_plot_layout_with_by(self, by, column, layout, axes_num):
             ("At least one dimension of layout must be positive", "C", (-1, -1)),
         ],
     )
-    def test_box_plot_invalid_layout_with_by_raises(self, msg, by, layout):
+    def test_box_plot_invalid_layout_with_by_raises(self, msg, by, layout, hist_df):
         # GH 15079, test if error is raised when invalid layout is given
 
         with pytest.raises(ValueError, match=msg):
-            self.box_df.plot.box(column=["A", "B"], by=by, layout=layout)
+            hist_df.plot.box(column=["A", "B"], by=by, layout=layout)
 
     @pytest.mark.parametrize("figsize", [(12, 8), (20, 10)])
-    def test_figure_shape_hist_with_by(self, figsize):
+    def test_figure_shape_hist_with_by(self, figsize, hist_df):
         # GH 15079
-        axes = self.box_df.plot.box(column="A", by="C", figsize=figsize)
+        axes = hist_df.plot.box(column="A", by="C", figsize=figsize)
         self._check_axes_shape(axes, axes_num=1, figsize=figsize)
diff --git a/pandas/tests/plotting/test_backend.py b/pandas/tests/plotting/test_backend.py
index be053a8f46051..c087d3be293e7 100644
--- a/pandas/tests/plotting/test_backend.py
+++ b/pandas/tests/plotting/test_backend.py
@@ -1,7 +1,6 @@
 import sys
 import types
 
-import pkg_resources
 import pytest
 
 import pandas.util._test_decorators as td
@@ -12,15 +11,11 @@
 setattr(dummy_backend, "plot", lambda *args, **kwargs: "used_dummy")
 
 
-pytestmark = pytest.mark.slow
-
-
 @pytest.fixture
 def restore_backend():
     """Restore the plotting backend to matplotlib"""
-    pandas.set_option("plotting.backend", "matplotlib")
-    yield
-    pandas.set_option("plotting.backend", "matplotlib")
+    with pandas.option_context("plotting.backend", "matplotlib"):
+        yield
 
 
 def test_backend_is_not_module():
@@ -49,40 +44,28 @@ def test_backend_can_be_set_in_plot_call(monkeypatch, restore_backend):
     assert df.plot(backend="pandas_dummy_backend") == "used_dummy"
 
 
-@td.skip_if_no_mpl
-def test_register_entrypoint(restore_backend):
-
-    dist = pkg_resources.get_distribution("pandas")
-    if dist.module_path not in pandas.__file__:
-        # We are running from a non-installed pandas, and this test is invalid
-        pytest.skip("Testing a non-installed pandas")
-
-    mod = types.ModuleType("my_backend")
-    mod.plot = lambda *args, **kwargs: 1
+def test_register_entrypoint(restore_backend, tmp_path, monkeypatch):
+    monkeypatch.syspath_prepend(tmp_path)
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
 
-    backends = pkg_resources.get_entry_map("pandas")
-    my_entrypoint = pkg_resources.EntryPoint(
-        "pandas_plotting_backend", mod.__name__, dist=dist
+    dist_info = tmp_path / "my_backend-0.0.0.dist-info"
+    dist_info.mkdir()
+    # entry_point name should not match module name - otherwise pandas will
+    # fall back to backend lookup by module name
+    (dist_info / "entry_points.txt").write_bytes(
+        b"[pandas_plotting_backends]\nmy_ep_backend = pandas_dummy_backend\n"
     )
-    backends["pandas_plotting_backends"]["my_backend"] = my_entrypoint
-    # TODO: the docs recommend importlib.util.module_from_spec. But this works for now.
-    sys.modules["my_backend"] = mod
-
-    result = pandas.plotting._core._get_plot_backend("my_backend")
-    assert result is mod
 
-    # TODO(GH#27517): https://github.com/pandas-dev/pandas/issues/27517
-    # Remove the td.skip_if_no_mpl
-    with pandas.option_context("plotting.backend", "my_backend"):
-        result = pandas.plotting._core._get_plot_backend()
+    assert pandas.plotting._core._get_plot_backend("my_ep_backend") is dummy_backend
 
-    assert result is mod
+    with pandas.option_context("plotting.backend", "my_ep_backend"):
+        assert pandas.plotting._core._get_plot_backend() is dummy_backend
 
 
-def test_setting_backend_without_plot_raises():
+def test_setting_backend_without_plot_raises(monkeypatch):
     # GH-28163
     module = types.ModuleType("pandas_plot_backend")
-    sys.modules["pandas_plot_backend"] = module
+    monkeypatch.setitem(sys.modules, "pandas_plot_backend", module)
 
     assert pandas.options.plotting.backend == "matplotlib"
     with pytest.raises(
diff --git a/pandas/tests/plotting/test_boxplot_method.py b/pandas/tests/plotting/test_boxplot_method.py
index 5c543f96cb55f..9112d5cb3368f 100644
--- a/pandas/tests/plotting/test_boxplot_method.py
+++ b/pandas/tests/plotting/test_boxplot_method.py
@@ -21,13 +21,34 @@
     _check_plot_works,
 )
 
+from pandas.io.formats.printing import pprint_thing
 import pandas.plotting as plotting
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestDataFramePlots(TestPlotBase):
+    def test_stacked_boxplot_set_axis(self):
+        # GH2980
+        import matplotlib.pyplot as plt
+
+        n = 80
+        df = DataFrame(
+            {
+                "Clinical": np.random.choice([0, 1, 2, 3], n),
+                "Confirmed": np.random.choice([0, 1, 2, 3], n),
+                "Discarded": np.random.choice([0, 1, 2, 3], n),
+            },
+            index=np.arange(0, n),
+        )
+        ax = df.plot(kind="bar", stacked=True)
+        assert [int(x.get_text()) for x in ax.get_xticklabels()] == df.index.to_list()
+        ax.set_xticks(np.arange(0, 80, 10))
+        plt.draw()  # Update changes
+        assert [int(x.get_text()) for x in ax.get_xticklabels()] == list(
+            np.arange(0, 80, 10)
+        )
+
+    @pytest.mark.slow
     def test_boxplot_legacy1(self):
         df = DataFrame(
             np.random.randn(6, 4),
@@ -40,23 +61,23 @@ def test_boxplot_legacy1(self):
         _check_plot_works(df.boxplot, return_type="dict")
         _check_plot_works(df.boxplot, column=["one", "two"], return_type="dict")
         # _check_plot_works adds an ax so catch warning. see GH #13188
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.boxplot, column=["one", "two"], by="indic")
         _check_plot_works(df.boxplot, column="one", by=["indic", "indic2"])
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.boxplot, by="indic")
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.boxplot, by=["indic", "indic2"])
         _check_plot_works(plotting._core.boxplot, data=df["one"], return_type="dict")
         _check_plot_works(df.boxplot, notch=1, return_type="dict")
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.boxplot, by="indic", notch=1)
 
     def test_boxplot_legacy2(self):
         df = DataFrame(np.random.rand(10, 2), columns=["Col1", "Col2"])
         df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
         df["Y"] = Series(["A"] * 10)
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.boxplot, by="X")
 
         # When ax is supplied and required number of axes is 1,
@@ -86,9 +107,9 @@ def test_boxplot_legacy2(self):
         lines = list(itertools.chain.from_iterable(d.values()))
         assert len(ax.get_lines()) == len(lines)
 
-    def test_boxplot_return_type_none(self):
+    def test_boxplot_return_type_none(self, hist_df):
         # GH 12216; return_type=None & by=None -> axes
-        result = self.hist_df.boxplot()
+        result = hist_df.boxplot()
         assert isinstance(result, self.plt.Axes)
 
     def test_boxplot_return_type_legacy(self):
@@ -118,13 +139,13 @@ def test_boxplot_return_type_legacy(self):
             result = df.boxplot(return_type="both")
         self._check_box_return_type(result, "both")
 
-    def test_boxplot_axis_limits(self):
+    def test_boxplot_axis_limits(self, hist_df):
         def _check_ax_limits(col, ax):
             y_min, y_max = ax.get_ylim()
             assert y_min <= col.min()
             assert y_max >= col.max()
 
-        df = self.hist_df.copy()
+        df = hist_df.copy()
         df["age"] = np.random.randint(1, 20, df.shape[0])
         # One full row
         height_ax, weight_ax = df.boxplot(["height", "weight"], by="category")
@@ -254,22 +275,73 @@ def test_specified_props_kwd(self, props, expected):
 
         assert result[expected][0].get_color() == "C1"
 
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_plot_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.randn(100),
+                "b": np.random.randn(100),
+                "group": np.random.choice(["group1", "group2"], 100),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.plot(kind="box", vert=vert, xlabel=xlabel, ylabel=ylabel)
+        assert ax.get_xlabel() == xlabel
+        assert ax.get_ylabel() == ylabel
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_boxplot_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.randn(100),
+                "b": np.random.randn(100),
+                "group": np.random.choice(["group1", "group2"], 100),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.boxplot(vert=vert, xlabel=xlabel, ylabel=ylabel)
+        assert ax.get_xlabel() == xlabel
+        assert ax.get_ylabel() == ylabel
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_boxplot_group_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.randn(100),
+                "b": np.random.randn(100),
+                "group": np.random.choice(["group1", "group2"], 100),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.boxplot(by="group", vert=vert, xlabel=xlabel, ylabel=ylabel)
+        for subplot in ax:
+            assert subplot.get_xlabel() == xlabel
+            assert subplot.get_ylabel() == ylabel
+        self.plt.close()
+
+        ax = df.boxplot(by="group", vert=vert)
+        for subplot in ax:
+            target_label = subplot.get_xlabel() if vert else subplot.get_ylabel()
+            assert target_label == pprint_thing(["group"])
+        self.plt.close()
+
 
 @td.skip_if_no_mpl
 class TestDataFrameGroupByPlots(TestPlotBase):
-    def test_boxplot_legacy1(self):
-        grouped = self.hist_df.groupby(by="gender")
-        with tm.assert_produces_warning(UserWarning):
+    def test_boxplot_legacy1(self, hist_df):
+        grouped = hist_df.groupby(by="gender")
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(grouped.boxplot, return_type="axes")
         self._check_axes_shape(list(axes.values), axes_num=2, layout=(1, 2))
         axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
         self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
 
+    @pytest.mark.slow
     def test_boxplot_legacy2(self):
         tuples = zip(string.ascii_letters[:10], range(10))
         df = DataFrame(np.random.rand(10, 3), index=MultiIndex.from_tuples(tuples))
         grouped = df.groupby(level=1)
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(grouped.boxplot, return_type="axes")
         self._check_axes_shape(list(axes.values), axes_num=10, layout=(4, 3))
 
@@ -280,7 +352,7 @@ def test_boxplot_legacy3(self):
         tuples = zip(string.ascii_letters[:10], range(10))
         df = DataFrame(np.random.rand(10, 3), index=MultiIndex.from_tuples(tuples))
         grouped = df.unstack(level=1).groupby(level=0, axis=1)
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(grouped.boxplot, return_type="axes")
         self._check_axes_shape(list(axes.values), axes_num=3, layout=(2, 2))
         axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
@@ -309,8 +381,9 @@ def test_grouped_plot_fignums(self):
         res = df.groupby("gender").hist()
         tm.close()
 
-    def test_grouped_box_return_type(self):
-        df = self.hist_df
+    @pytest.mark.slow
+    def test_grouped_box_return_type(self, hist_df):
+        df = hist_df
 
         # old style: return_type=None
         result = df.boxplot(by="gender")
@@ -343,8 +416,9 @@ def test_grouped_box_return_type(self):
             returned = df2.boxplot(by="category", return_type=t)
             self._check_box_return_type(returned, t, expected_keys=columns2)
 
-    def test_grouped_box_layout(self):
-        df = self.hist_df
+    @pytest.mark.slow
+    def test_grouped_box_layout(self, hist_df):
+        df = hist_df
 
         msg = "Layout of 1x1 must be larger than required size 2"
         with pytest.raises(ValueError, match=msg):
@@ -363,20 +437,20 @@ def test_grouped_box_layout(self):
             df.boxplot(column=["weight", "height"], by=df.gender, layout=(-1, -1))
 
         # _check_plot_works adds an ax so catch warning. see GH #13188
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             box = _check_plot_works(
                 df.groupby("gender").boxplot, column="height", return_type="dict"
             )
         self._check_axes_shape(self.plt.gcf().axes, axes_num=2, layout=(1, 2))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             box = _check_plot_works(
                 df.groupby("category").boxplot, column="height", return_type="dict"
             )
         self._check_axes_shape(self.plt.gcf().axes, axes_num=4, layout=(2, 2))
 
         # GH 6769
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             box = _check_plot_works(
                 df.groupby("classroom").boxplot, column="height", return_type="dict"
             )
@@ -399,7 +473,7 @@ def test_grouped_box_layout(self):
         )
         self._check_axes_shape(self.plt.gcf().axes, axes_num=3, layout=(2, 2))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             box = _check_plot_works(
                 df.groupby("category").boxplot,
                 column="height",
@@ -407,7 +481,7 @@ def test_grouped_box_layout(self):
                 return_type="dict",
             )
         self._check_axes_shape(self.plt.gcf().axes, axes_num=4, layout=(3, 2))
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             box = _check_plot_works(
                 df.groupby("category").boxplot,
                 column="height",
@@ -436,9 +510,10 @@ def test_grouped_box_layout(self):
         )
         self._check_axes_shape(self.plt.gcf().axes, axes_num=3, layout=(1, 3))
 
-    def test_grouped_box_multiple_axes(self):
+    @pytest.mark.slow
+    def test_grouped_box_multiple_axes(self, hist_df):
         # GH 6970, GH 7069
-        df = self.hist_df
+        df = hist_df
 
         # check warning to ignore sharex / sharey
         # this check should be done in the first function which
@@ -542,9 +617,9 @@ def test_groupby_boxplot_subplots_false(self, col, expected_xticklabel):
         result_xticklabel = [x.get_text() for x in axes.get_xticklabels()]
         assert expected_xticklabel == result_xticklabel
 
-    def test_groupby_boxplot_object(self):
+    def test_groupby_boxplot_object(self, hist_df):
         # GH 43480
-        df = self.hist_df.astype("object")
+        df = hist_df.astype("object")
         grouped = df.groupby("gender")
         msg = "boxplot method requires numerical columns, nothing to plot"
         with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/plotting/test_common.py b/pandas/tests/plotting/test_common.py
index 6eebf0c01ae52..d4624cfc74872 100644
--- a/pandas/tests/plotting/test_common.py
+++ b/pandas/tests/plotting/test_common.py
@@ -9,8 +9,6 @@
     _gen_two_subplots,
 )
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestCommon(TestPlotBase):
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index fe8620ef76c4b..3ec8f4bd71c2b 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -15,8 +15,10 @@
 from pandas import (
     Index,
     Period,
+    PeriodIndex,
     Series,
     Timestamp,
+    arrays,
     date_range,
 )
 import pandas._testing as tm
@@ -43,9 +45,6 @@
 dates = pytest.importorskip("matplotlib.dates")
 
 
-pytestmark = pytest.mark.slow
-
-
 def test_registry_mpl_resets():
     # Check that Matplotlib converters are properly reset (see issue #27481)
     code = (
@@ -157,40 +156,40 @@ def test_registry_resets(self):
 
 
 class TestDateTimeConverter:
-    def setup_method(self, method):
-        self.dtc = converter.DatetimeConverter()
-        self.tc = converter.TimeFormatter(None)
+    @pytest.fixture
+    def dtc(self):
+        return converter.DatetimeConverter()
 
-    def test_convert_accepts_unicode(self):
-        r1 = self.dtc.convert("12:22", None, None)
-        r2 = self.dtc.convert("12:22", None, None)
+    def test_convert_accepts_unicode(self, dtc):
+        r1 = dtc.convert("12:22", None, None)
+        r2 = dtc.convert("12:22", None, None)
         assert r1 == r2, "DatetimeConverter.convert should accept unicode"
 
-    def test_conversion(self):
-        rs = self.dtc.convert(["2012-1-1"], None, None)[0]
+    def test_conversion(self, dtc):
+        rs = dtc.convert(["2012-1-1"], None, None)[0]
         xp = dates.date2num(datetime(2012, 1, 1))
         assert rs == xp
 
-        rs = self.dtc.convert("2012-1-1", None, None)
+        rs = dtc.convert("2012-1-1", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(date(2012, 1, 1), None, None)
+        rs = dtc.convert(date(2012, 1, 1), None, None)
         assert rs == xp
 
-        rs = self.dtc.convert("2012-1-1", None, None)
+        rs = dtc.convert("2012-1-1", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(Timestamp("2012-1-1"), None, None)
+        rs = dtc.convert(Timestamp("2012-1-1"), None, None)
         assert rs == xp
 
         # also testing datetime64 dtype (GH8614)
-        rs = self.dtc.convert("2012-01-01", None, None)
+        rs = dtc.convert("2012-01-01", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert("2012-01-01 00:00:00+0000", None, None)
+        rs = dtc.convert("2012-01-01 00:00:00+0000", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(
+        rs = dtc.convert(
             np.array(["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"]),
             None,
             None,
@@ -200,48 +199,48 @@ def test_conversion(self):
         # we have a tz-aware date (constructed to that when we turn to utc it
         # is the same as our sample)
         ts = Timestamp("2012-01-01").tz_localize("UTC").tz_convert("US/Eastern")
-        rs = self.dtc.convert(ts, None, None)
+        rs = dtc.convert(ts, None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(ts.to_pydatetime(), None, None)
+        rs = dtc.convert(ts.to_pydatetime(), None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(Index([ts - Day(1), ts]), None, None)
+        rs = dtc.convert(Index([ts - Day(1), ts]), None, None)
         assert rs[1] == xp
 
-        rs = self.dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
+        rs = dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
         assert rs[1] == xp
 
-    def test_conversion_float(self):
-        rtol = 0.5 * 10 ** -9
+    def test_conversion_float(self, dtc):
+        rtol = 0.5 * 10**-9
 
-        rs = self.dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
+        rs = dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
         xp = converter.dates.date2num(Timestamp("2012-1-1 01:02:03", tz="UTC"))
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-        rs = self.dtc.convert(
+        rs = dtc.convert(
             Timestamp("2012-1-1 09:02:03", tz="Asia/Hong_Kong"), None, None
         )
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-        rs = self.dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
+        rs = dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-    def test_conversion_outofbounds_datetime(self):
+    def test_conversion_outofbounds_datetime(self, dtc):
         # 2579
         values = [date(1677, 1, 1), date(1677, 1, 2)]
-        rs = self.dtc.convert(values, None, None)
+        rs = dtc.convert(values, None, None)
         xp = converter.dates.date2num(values)
         tm.assert_numpy_array_equal(rs, xp)
-        rs = self.dtc.convert(values[0], None, None)
+        rs = dtc.convert(values[0], None, None)
         xp = converter.dates.date2num(values[0])
         assert rs == xp
 
         values = [datetime(1677, 1, 1, 12), datetime(1677, 1, 2, 12)]
-        rs = self.dtc.convert(values, None, None)
+        rs = dtc.convert(values, None, None)
         xp = converter.dates.date2num(values)
         tm.assert_numpy_array_equal(rs, xp)
-        rs = self.dtc.convert(values[0], None, None)
+        rs = dtc.convert(values[0], None, None)
         xp = converter.dates.date2num(values[0])
         assert rs == xp
 
@@ -257,42 +256,38 @@ def test_conversion_outofbounds_datetime(self):
     )
     def test_time_formatter(self, time, format_expected):
         # issue 18478
-        result = self.tc(time)
+        result = converter.TimeFormatter(None)(time)
         assert result == format_expected
 
-    def test_dateindex_conversion(self):
-        rtol = 10 ** -9
-
-        for freq in ("B", "L", "S"):
-            dateindex = tm.makeDateIndex(k=10, freq=freq)
-            rs = self.dtc.convert(dateindex, None, None)
-            xp = converter.dates.date2num(dateindex._mpl_repr())
-            tm.assert_almost_equal(rs, xp, rtol=rtol)
-
-    def test_resolution(self):
-        def _assert_less(ts1, ts2):
-            val1 = self.dtc.convert(ts1, None, None)
-            val2 = self.dtc.convert(ts2, None, None)
-            if not val1 < val2:
-                raise AssertionError(f"{val1} is not less than {val2}.")
+    @pytest.mark.parametrize("freq", ("B", "L", "S"))
+    def test_dateindex_conversion(self, freq, dtc):
+        rtol = 10**-9
+        dateindex = tm.makeDateIndex(k=10, freq=freq)
+        rs = dtc.convert(dateindex, None, None)
+        xp = converter.dates.date2num(dateindex._mpl_repr())
+        tm.assert_almost_equal(rs, xp, rtol=rtol)
 
+    @pytest.mark.parametrize("offset", [Second(), Milli(), Micro(50)])
+    def test_resolution(self, offset, dtc):
         # Matplotlib's time representation using floats cannot distinguish
         # intervals smaller than ~10 microsecond in the common range of years.
-        ts = Timestamp("2012-1-1")
-        _assert_less(ts, ts + Second())
-        _assert_less(ts, ts + Milli())
-        _assert_less(ts, ts + Micro(50))
-
-    def test_convert_nested(self):
+        ts1 = Timestamp("2012-1-1")
+        ts2 = ts1 + offset
+        val1 = dtc.convert(ts1, None, None)
+        val2 = dtc.convert(ts2, None, None)
+        if not val1 < val2:
+            raise AssertionError(f"{val1} is not less than {val2}.")
+
+    def test_convert_nested(self, dtc):
         inner = [Timestamp("2017-01-01"), Timestamp("2017-01-02")]
         data = [inner, inner]
-        result = self.dtc.convert(data, None, None)
-        expected = [self.dtc.convert(x, None, None) for x in data]
+        result = dtc.convert(data, None, None)
+        expected = [dtc.convert(x, None, None) for x in data]
         assert (np.array(result) == expected).all()
 
 
 class TestPeriodConverter:
-    def setup_method(self, method):
+    def setup_method(self):
         self.pc = converter.PeriodConverter()
 
         class Axis:
@@ -334,7 +329,7 @@ def test_conversion(self):
 
         rs = self.pc.convert(
             np.array(
-                ["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"],
+                ["2012-01-01 00:00:00", "2012-01-02 00:00:00"],
                 dtype="datetime64[ns]",
             ),
             None,
@@ -382,3 +377,32 @@ def get_view_interval(self):
         tdc = converter.TimeSeries_TimedeltaFormatter()
         monkeypatch.setattr(tdc, "axis", mock_axis())
         tdc(0.0, 0)
+
+
+@pytest.mark.parametrize("year_span", [11.25, 30, 80, 150, 400, 800, 1500, 2500, 3500])
+# The range is limited to 11.25 at the bottom by if statements in
+# the _quarterly_finder() function
+def test_quarterly_finder(year_span):
+    vmin = -1000
+    vmax = vmin + year_span * 4
+    span = vmax - vmin + 1
+    if span < 45:  # the quarterly finder is only invoked if the span is >= 45
+        return
+    nyears = span / 4
+    (min_anndef, maj_anndef) = converter._get_default_annual_spacing(nyears)
+    result = converter._quarterly_finder(vmin, vmax, "Q")
+    quarters = PeriodIndex(
+        arrays.PeriodArray(np.array([x[0] for x in result]), freq="Q")
+    )
+    majors = np.array([x[1] for x in result])
+    minors = np.array([x[2] for x in result])
+    major_quarters = quarters[majors]
+    minor_quarters = quarters[minors]
+    check_major_years = major_quarters.year % maj_anndef == 0
+    check_minor_years = minor_quarters.year % min_anndef == 0
+    check_major_quarters = major_quarters.quarter == 1
+    check_minor_quarters = minor_quarters.quarter == 1
+    assert np.all(check_major_years)
+    assert np.all(check_minor_years)
+    assert np.all(check_major_quarters)
+    assert np.all(check_minor_quarters)
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index 44113d1e217fd..f75e5cd3491a4 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -21,6 +21,7 @@
     Index,
     NaT,
     Series,
+    concat,
     isna,
     to_datetime,
 )
@@ -38,47 +39,28 @@
 from pandas.core.indexes.timedeltas import timedelta_range
 from pandas.tests.plotting.common import TestPlotBase
 
-from pandas.tseries.offsets import WeekOfMonth
+try:
+    from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+except ImportError:
+    mpl_ge_3_6_0 = lambda: True
 
-pytestmark = pytest.mark.slow
+from pandas.tseries.offsets import WeekOfMonth
 
 
 @td.skip_if_no_mpl
 class TestTSPlot(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-
-        self.freq = ["S", "T", "H", "D", "W", "M", "Q", "A"]
-        idx = [period_range("12/31/1999", freq=x, periods=100) for x in self.freq]
-        self.period_ser = [Series(np.random.randn(len(x)), x) for x in idx]
-        self.period_df = [
-            DataFrame(np.random.randn(len(x), 3), index=x, columns=["A", "B", "C"])
-            for x in idx
-        ]
-
-        freq = ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
-        idx = [date_range("12/31/1999", freq=x, periods=100) for x in freq]
-        self.datetime_ser = [Series(np.random.randn(len(x)), x) for x in idx]
-        self.datetime_df = [
-            DataFrame(np.random.randn(len(x), 3), index=x, columns=["A", "B", "C"])
-            for x in idx
-        ]
-
-    def teardown_method(self, method):
-        tm.close()
-
+    @pytest.mark.filterwarnings("ignore::UserWarning")
     def test_ts_plot_with_tz(self, tz_aware_fixture):
         # GH2877, GH17173, GH31205, GH31580
         tz = tz_aware_fixture
         index = date_range("1/1/2011", periods=2, freq="H", tz=tz)
         ts = Series([188.5, 328.25], index=index)
-        with tm.assert_produces_warning(None):
-            _check_plot_works(ts.plot)
-            ax = ts.plot()
-            xdata = list(ax.get_lines())[0].get_xdata()
-            # Check first and last points' labels are correct
-            assert (xdata[0].hour, xdata[0].minute) == (0, 0)
-            assert (xdata[-1].hour, xdata[-1].minute) == (1, 0)
+        _check_plot_works(ts.plot)
+        ax = ts.plot()
+        xdata = list(ax.get_lines())[0].get_xdata()
+        # Check first and last points' labels are correct
+        assert (xdata[0].hour, xdata[0].minute) == (0, 0)
+        assert (xdata[-1].hour, xdata[-1].minute) == (1, 0)
 
     def test_fontsize_set_correctly(self):
         # For issue #8765
@@ -127,17 +109,24 @@ def test_nonnumeric_exclude(self):
         with pytest.raises(TypeError, match=msg):
             df["A"].plot()
 
-    def test_tsplot(self):
-
+    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    def test_tsplot_period(self, freq):
+        idx = period_range("12/31/1999", freq=freq, periods=100)
+        ser = Series(np.random.randn(len(idx)), idx)
         _, ax = self.plt.subplots()
-        ts = tm.makeTimeSeries()
+        _check_plot_works(ser.plot, ax=ax)
 
-        for s in self.period_ser:
-            _check_plot_works(s.plot, ax=ax)
-
-        for s in self.datetime_ser:
-            _check_plot_works(s.plot, ax=ax)
+    @pytest.mark.parametrize(
+        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+    )
+    def test_tsplot_datetime(self, freq):
+        idx = date_range("12/31/1999", freq=freq, periods=100)
+        ser = Series(np.random.randn(len(idx)), idx)
+        _, ax = self.plt.subplots()
+        _check_plot_works(ser.plot, ax=ax)
 
+    def test_tsplot(self):
+        ts = tm.makeTimeSeries()
         _, ax = self.plt.subplots()
         ts.plot(style="k", ax=ax)
         color = (0.0, 0.0, 0.0, 1)
@@ -158,13 +147,12 @@ def test_both_style_and_color(self):
         with pytest.raises(ValueError, match=msg):
             s.plot(style="b-", color="#000099")
 
-    def test_high_freq(self):
-        freaks = ["ms", "us"]
-        for freq in freaks:
-            _, ax = self.plt.subplots()
-            rng = date_range("1/1/2012", periods=100, freq=freq)
-            ser = Series(np.random.randn(len(rng)), rng)
-            _check_plot_works(ser.plot, ax=ax)
+    @pytest.mark.parametrize("freq", ["ms", "us"])
+    def test_high_freq(self, freq):
+        _, ax = self.plt.subplots()
+        rng = date_range("1/1/2012", periods=100, freq=freq)
+        ser = Series(np.random.randn(len(rng)), rng)
+        _check_plot_works(ser.plot, ax=ax)
 
     def test_get_datevalue(self):
         from pandas.plotting._matplotlib.converter import get_datevalue
@@ -193,9 +181,11 @@ def check_format_of_first_point(ax, expected_string):
         check_format_of_first_point(ax, "t = 2014-01-01  y = 1.000000")
         tm.close()
 
-    def test_line_plot_period_series(self):
-        for s in self.period_ser:
-            _check_plot_works(s.plot, s.index.freq)
+    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    def test_line_plot_period_series(self, freq):
+        idx = period_range("12/31/1999", freq=freq, periods=100)
+        ser = Series(np.random.randn(len(idx)), idx)
+        _check_plot_works(ser.plot, ser.index.freq)
 
     @pytest.mark.parametrize(
         "frqncy", ["1S", "3S", "5T", "7H", "4D", "8W", "11M", "3A"]
@@ -207,13 +197,19 @@ def test_line_plot_period_mlt_series(self, frqncy):
         s = Series(np.random.randn(len(idx)), idx)
         _check_plot_works(s.plot, s.index.freq.rule_code)
 
-    def test_line_plot_datetime_series(self):
-        for s in self.datetime_ser:
-            _check_plot_works(s.plot, s.index.freq.rule_code)
+    @pytest.mark.parametrize(
+        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+    )
+    def test_line_plot_datetime_series(self, freq):
+        idx = date_range("12/31/1999", freq=freq, periods=100)
+        ser = Series(np.random.randn(len(idx)), idx)
+        _check_plot_works(ser.plot, ser.index.freq.rule_code)
 
-    def test_line_plot_period_frame(self):
-        for df in self.period_df:
-            _check_plot_works(df.plot, df.index.freq)
+    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    def test_line_plot_period_frame(self, freq):
+        idx = date_range("12/31/1999", freq=freq, periods=100)
+        df = DataFrame(np.random.randn(len(idx), 3), index=idx, columns=["A", "B", "C"])
+        _check_plot_works(df.plot, df.index.freq)
 
     @pytest.mark.parametrize(
         "frqncy", ["1S", "3S", "5T", "7H", "4D", "8W", "11M", "3A"]
@@ -227,24 +223,32 @@ def test_line_plot_period_mlt_frame(self, frqncy):
         freq = df.index.asfreq(df.index.freq.rule_code).freq
         _check_plot_works(df.plot, freq)
 
-    def test_line_plot_datetime_frame(self):
-        for df in self.datetime_df:
-            freq = df.index.to_period(df.index.freq.rule_code).freq
-            _check_plot_works(df.plot, freq)
+    @pytest.mark.parametrize(
+        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+    )
+    def test_line_plot_datetime_frame(self, freq):
+        idx = date_range("12/31/1999", freq=freq, periods=100)
+        df = DataFrame(np.random.randn(len(idx), 3), index=idx, columns=["A", "B", "C"])
+        freq = df.index.to_period(df.index.freq.rule_code).freq
+        _check_plot_works(df.plot, freq)
 
-    def test_line_plot_inferred_freq(self):
-        for ser in self.datetime_ser:
-            ser = Series(ser.values, Index(np.asarray(ser.index)))
-            _check_plot_works(ser.plot, ser.index.inferred_freq)
+    @pytest.mark.parametrize(
+        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+    )
+    def test_line_plot_inferred_freq(self, freq):
+        idx = date_range("12/31/1999", freq=freq, periods=100)
+        ser = Series(np.random.randn(len(idx)), idx)
+        ser = Series(ser.values, Index(np.asarray(ser.index)))
+        _check_plot_works(ser.plot, ser.index.inferred_freq)
 
-            ser = ser[[0, 3, 5, 6]]
-            _check_plot_works(ser.plot)
+        ser = ser[[0, 3, 5, 6]]
+        _check_plot_works(ser.plot)
 
     def test_fake_inferred_business(self):
         _, ax = self.plt.subplots()
         rng = date_range("2001-1-1", "2001-1-10")
         ts = Series(range(len(rng)), index=rng)
-        ts = ts[:3].append(ts[5:])
+        ts = concat([ts[:3], ts[5:]])
         ts.plot(ax=ax)
         assert not hasattr(ax, "freq")
 
@@ -261,6 +265,7 @@ def test_plot_multiple_inferred_freq(self):
         ser = Series(np.random.randn(len(dr)), index=dr)
         _check_plot_works(ser.plot)
 
+    @pytest.mark.xfail(mpl_ge_3_6_0(), reason="Api changed")
     def test_uhf(self):
         import pandas.plotting._matplotlib.converter as conv
 
@@ -496,6 +501,7 @@ def test_finder_annual(self):
 
         assert rs == xp
 
+    @pytest.mark.slow
     def test_finder_minutely(self):
         nminutes = 50 * 24 * 60
         rng = date_range("1/1/1999", freq="Min", periods=nminutes)
@@ -522,7 +528,7 @@ def test_finder_hourly(self):
 
     def test_gaps(self):
         ts = tm.makeTimeSeries()
-        ts[5:25] = np.nan
+        ts.iloc[5:25] = np.nan
         _, ax = self.plt.subplots()
         ts.plot(ax=ax)
         lines = ax.get_lines()
@@ -530,8 +536,7 @@ def test_gaps(self):
         line = lines[0]
         data = line.get_xydata()
 
-        if self.mpl_ge_3_0_0 or not self.mpl_ge_2_2_3:
-            data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
+        data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
 
         assert isinstance(data, np.ma.core.MaskedArray)
         mask = data.mask
@@ -541,7 +546,7 @@ def test_gaps(self):
         # irregular
         ts = tm.makeTimeSeries()
         ts = ts[[0, 1, 2, 5, 7, 9, 12, 15, 20]]
-        ts[2:5] = np.nan
+        ts.iloc[2:5] = np.nan
         _, ax = self.plt.subplots()
         ax = ts.plot(ax=ax)
         lines = ax.get_lines()
@@ -549,8 +554,7 @@ def test_gaps(self):
         line = lines[0]
         data = line.get_xydata()
 
-        if self.mpl_ge_3_0_0 or not self.mpl_ge_2_2_3:
-            data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
+        data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
 
         assert isinstance(data, np.ma.core.MaskedArray)
         mask = data.mask
@@ -560,15 +564,14 @@ def test_gaps(self):
         # non-ts
         idx = [0, 1, 2, 5, 7, 9, 12, 15, 20]
         ser = Series(np.random.randn(len(idx)), idx)
-        ser[2:5] = np.nan
+        ser.iloc[2:5] = np.nan
         _, ax = self.plt.subplots()
         ser.plot(ax=ax)
         lines = ax.get_lines()
         assert len(lines) == 1
         line = lines[0]
         data = line.get_xydata()
-        if self.mpl_ge_3_0_0 or not self.mpl_ge_2_2_3:
-            data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
+        data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
 
         assert isinstance(data, np.ma.core.MaskedArray)
         mask = data.mask
@@ -576,7 +579,7 @@ def test_gaps(self):
 
     def test_gap_upsample(self):
         low = tm.makeTimeSeries()
-        low[5:25] = np.nan
+        low.iloc[5:25] = np.nan
         _, ax = self.plt.subplots()
         low.plot(ax=ax)
 
@@ -589,8 +592,7 @@ def test_gap_upsample(self):
 
         line = lines[0]
         data = line.get_xydata()
-        if self.mpl_ge_3_0_0 or not self.mpl_ge_2_2_3:
-            data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
+        data = np.ma.MaskedArray(data, mask=isna(data), fill_value=np.nan)
 
         assert isinstance(data, np.ma.core.MaskedArray)
         mask = data.mask
@@ -613,7 +615,7 @@ def test_secondary_y(self):
 
         _, ax2 = self.plt.subplots()
         ser2.plot(ax=ax2)
-        assert ax2.get_yaxis().get_ticks_position() == self.default_tick_position
+        assert ax2.get_yaxis().get_ticks_position() == "left"
         self.plt.close(ax2.get_figure())
 
         ax = ser2.plot()
@@ -642,7 +644,7 @@ def test_secondary_y_ts(self):
 
         _, ax2 = self.plt.subplots()
         ser2.plot(ax=ax2)
-        assert ax2.get_yaxis().get_ticks_position() == self.default_tick_position
+        assert ax2.get_yaxis().get_ticks_position() == "left"
         self.plt.close(ax2.get_figure())
 
         ax = ser2.plot()
@@ -671,14 +673,14 @@ def test_secondary_frame(self):
         df = DataFrame(np.random.randn(5, 3), columns=["a", "b", "c"])
         axes = df.plot(secondary_y=["a", "c"], subplots=True)
         assert axes[0].get_yaxis().get_ticks_position() == "right"
-        assert axes[1].get_yaxis().get_ticks_position() == self.default_tick_position
+        assert axes[1].get_yaxis().get_ticks_position() == "left"
         assert axes[2].get_yaxis().get_ticks_position() == "right"
 
     def test_secondary_bar_frame(self):
         df = DataFrame(np.random.randn(5, 3), columns=["a", "b", "c"])
         axes = df.plot(kind="bar", secondary_y=["a", "c"], subplots=True)
         assert axes[0].get_yaxis().get_ticks_position() == "right"
-        assert axes[1].get_yaxis().get_ticks_position() == self.default_tick_position
+        assert axes[1].get_yaxis().get_ticks_position() == "left"
         assert axes[2].get_yaxis().get_ticks_position() == "right"
 
     def test_mixed_freq_regular_first(self):
@@ -1213,6 +1215,7 @@ def test_secondary_legend(self):
         # TODO: color cycle problems
         assert len(colors) == 4
 
+    @pytest.mark.xfail(mpl_ge_3_6_0(), reason="Api changed")
     def test_format_date_axis(self):
         rng = date_range("1/1/2012", periods=12, freq="M")
         df = DataFrame(np.random.randn(len(rng), 3), rng)
@@ -1452,12 +1455,7 @@ def test_matplotlib_scatter_datetime64(self):
         ax.scatter(x="time", y="y", data=df)
         self.plt.draw()
         label = ax.get_xticklabels()[0]
-        if self.mpl_ge_3_2_0:
-            expected = "2018-01-01"
-        elif self.mpl_ge_3_0_0:
-            expected = "2017-12-08"
-        else:
-            expected = "2017-12-12"
+        expected = "2018-01-01"
         assert label.get_text() == expected
 
     def test_check_xticks_rot(self):
diff --git a/pandas/tests/plotting/test_groupby.py b/pandas/tests/plotting/test_groupby.py
index 997f5abe12078..de81ad20f7370 100644
--- a/pandas/tests/plotting/test_groupby.py
+++ b/pandas/tests/plotting/test_groupby.py
@@ -14,8 +14,6 @@
 import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_no_mpl
 class TestDataFrameGroupByPlots(TestPlotBase):
diff --git a/pandas/tests/plotting/test_hist_method.py b/pandas/tests/plotting/test_hist_method.py
index 403f4a2c06df1..dc586d15ba115 100644
--- a/pandas/tests/plotting/test_hist_method.py
+++ b/pandas/tests/plotting/test_hist_method.py
@@ -18,54 +18,53 @@
     _check_plot_works,
 )
 
-pytestmark = pytest.mark.slow
+try:
+    from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+except ImportError:
+    mpl_ge_3_6_0 = lambda: True
 
 
-@td.skip_if_no_mpl
-class TestSeriesPlots(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
+@pytest.fixture
+def ts():
+    return tm.makeTimeSeries(name="ts")
 
-        self.ts = tm.makeTimeSeries()
-        self.ts.name = "ts"
 
-    def test_hist_legacy(self):
-        _check_plot_works(self.ts.hist)
-        _check_plot_works(self.ts.hist, grid=False)
-        _check_plot_works(self.ts.hist, figsize=(8, 10))
+@td.skip_if_no_mpl
+class TestSeriesPlots(TestPlotBase):
+    def test_hist_legacy(self, ts):
+        _check_plot_works(ts.hist)
+        _check_plot_works(ts.hist, grid=False)
+        _check_plot_works(ts.hist, figsize=(8, 10))
         # _check_plot_works adds an ax so catch warning. see GH #13188
-        with tm.assert_produces_warning(UserWarning):
-            _check_plot_works(self.ts.hist, by=self.ts.index.month)
-        with tm.assert_produces_warning(UserWarning):
-            _check_plot_works(self.ts.hist, by=self.ts.index.month, bins=5)
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(ts.hist, by=ts.index.month)
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(ts.hist, by=ts.index.month, bins=5)
 
         fig, ax = self.plt.subplots(1, 1)
-        _check_plot_works(self.ts.hist, ax=ax, default_axes=True)
-        _check_plot_works(self.ts.hist, ax=ax, figure=fig, default_axes=True)
-        _check_plot_works(self.ts.hist, figure=fig, default_axes=True)
+        _check_plot_works(ts.hist, ax=ax, default_axes=True)
+        _check_plot_works(ts.hist, ax=ax, figure=fig, default_axes=True)
+        _check_plot_works(ts.hist, figure=fig, default_axes=True)
         tm.close()
 
         fig, (ax1, ax2) = self.plt.subplots(1, 2)
-        _check_plot_works(self.ts.hist, figure=fig, ax=ax1, default_axes=True)
-        _check_plot_works(self.ts.hist, figure=fig, ax=ax2, default_axes=True)
+        _check_plot_works(ts.hist, figure=fig, ax=ax1, default_axes=True)
+        _check_plot_works(ts.hist, figure=fig, ax=ax2, default_axes=True)
 
         msg = (
             "Cannot pass 'figure' when using the 'by' argument, since a new 'Figure' "
             "instance will be created"
         )
         with pytest.raises(ValueError, match=msg):
-            self.ts.hist(by=self.ts.index, figure=fig)
+            ts.hist(by=ts.index, figure=fig)
 
     def test_hist_bins_legacy(self):
         df = DataFrame(np.random.randn(10, 2))
         ax = df.hist(bins=2)[0][0]
         assert len(ax.patches) == 2
 
-    def test_hist_layout(self):
-        df = self.hist_df
+    def test_hist_layout(self, hist_df):
+        df = hist_df
         msg = "The 'layout' keyword is not supported when 'by' is None"
         with pytest.raises(ValueError, match=msg):
             df.height.hist(layout=(1, 1))
@@ -73,37 +72,38 @@ def test_hist_layout(self):
         with pytest.raises(ValueError, match=msg):
             df.height.hist(layout=[1, 1])
 
-    def test_hist_layout_with_by(self):
-        df = self.hist_df
+    @pytest.mark.slow
+    def test_hist_layout_with_by(self, hist_df):
+        df = hist_df
 
         # _check_plot_works adds an `ax` kwarg to the method call
         # so we get a warning about an axis being cleared, even
         # though we don't explicing pass one, see GH #13188
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.gender, layout=(2, 1))
         self._check_axes_shape(axes, axes_num=2, layout=(2, 1))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.gender, layout=(3, -1))
         self._check_axes_shape(axes, axes_num=2, layout=(3, 1))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.category, layout=(4, 1))
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.category, layout=(2, -1))
         self._check_axes_shape(axes, axes_num=4, layout=(2, 2))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.category, layout=(3, -1))
         self._check_axes_shape(axes, axes_num=4, layout=(3, 2))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.category, layout=(-1, 4))
         self._check_axes_shape(axes, axes_num=4, layout=(1, 4))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.height.hist, by=df.classroom, layout=(2, 2))
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
 
@@ -126,12 +126,12 @@ def test_hist_no_overlap(self):
         axes = fig.axes
         assert len(axes) == 2
 
-    def test_hist_by_no_extra_plots(self):
-        df = self.hist_df
+    def test_hist_by_no_extra_plots(self, hist_df):
+        df = hist_df
         axes = df.height.hist(by=df.gender)  # noqa
         assert len(self.plt.get_fignums()) == 1
 
-    def test_plot_fails_when_ax_differs_from_figure(self):
+    def test_plot_fails_when_ax_differs_from_figure(self, ts):
         from pylab import figure
 
         fig1 = figure()
@@ -139,7 +139,7 @@ def test_plot_fails_when_ax_differs_from_figure(self):
         ax1 = fig1.add_subplot(111)
         msg = "passed axis not bound to passed figure"
         with pytest.raises(AssertionError, match=msg):
-            self.ts.hist(ax=ax1, figure=fig2)
+            ts.hist(ax=ax1, figure=fig2)
 
     @pytest.mark.parametrize(
         "histtype, expected",
@@ -180,27 +180,28 @@ def test_hist_with_legend_raises(self, by):
         with pytest.raises(ValueError, match="Cannot use both legend and label"):
             s.hist(legend=True, by=by, label="c")
 
-    def test_hist_kwargs(self):
+    def test_hist_kwargs(self, ts):
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.hist(bins=5, ax=ax)
+        ax = ts.plot.hist(bins=5, ax=ax)
         assert len(ax.patches) == 5
         self._check_text_labels(ax.yaxis.get_label(), "Frequency")
         tm.close()
 
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.hist(orientation="horizontal", ax=ax)
+        ax = ts.plot.hist(orientation="horizontal", ax=ax)
         self._check_text_labels(ax.xaxis.get_label(), "Frequency")
         tm.close()
 
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.hist(align="left", stacked=True, ax=ax)
+        ax = ts.plot.hist(align="left", stacked=True, ax=ax)
         tm.close()
 
+    @pytest.mark.xfail(mpl_ge_3_6_0(), reason="Api changed")
     @td.skip_if_no_scipy
-    def test_hist_kde(self):
+    def test_hist_kde(self, ts):
 
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.hist(logy=True, ax=ax)
+        ax = ts.plot.hist(logy=True, ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         xlabels = ax.get_xticklabels()
         # ticks are values, thus ticklabels are blank
@@ -208,10 +209,10 @@ def test_hist_kde(self):
         ylabels = ax.get_yticklabels()
         self._check_text_labels(ylabels, [""] * len(ylabels))
 
-        _check_plot_works(self.ts.plot.kde)
-        _check_plot_works(self.ts.plot.density)
+        _check_plot_works(ts.plot.kde)
+        _check_plot_works(ts.plot.density)
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.kde(logy=True, ax=ax)
+        ax = ts.plot.kde(logy=True, ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         xlabels = ax.get_xticklabels()
         self._check_text_labels(xlabels, [""] * len(xlabels))
@@ -219,15 +220,15 @@ def test_hist_kde(self):
         self._check_text_labels(ylabels, [""] * len(ylabels))
 
     @td.skip_if_no_scipy
-    def test_hist_kde_color(self):
+    def test_hist_kde_color(self, ts):
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.hist(logy=True, bins=10, color="b", ax=ax)
+        ax = ts.plot.hist(logy=True, bins=10, color="b", ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         assert len(ax.patches) == 10
         self._check_colors(ax.patches, facecolors=["b"] * 10)
 
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.kde(logy=True, color="r", ax=ax)
+        ax = ts.plot.kde(logy=True, color="r", ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         lines = ax.get_lines()
         assert len(lines) == 1
@@ -236,23 +237,24 @@ def test_hist_kde_color(self):
 
 @td.skip_if_no_mpl
 class TestDataFramePlots(TestPlotBase):
-    def test_hist_df_legacy(self):
+    @pytest.mark.slow
+    def test_hist_df_legacy(self, hist_df):
         from matplotlib.patches import Rectangle
 
-        with tm.assert_produces_warning(UserWarning):
-            _check_plot_works(self.hist_df.hist)
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(hist_df.hist)
 
         # make sure layout is handled
         df = DataFrame(np.random.randn(100, 2))
         df[2] = to_datetime(
             np.random.randint(
-                self.start_date_to_int64,
-                self.end_date_to_int64,
+                812419200000000000,
+                819331200000000000,
                 size=100,
                 dtype=np.int64,
             )
         )
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.hist, grid=False)
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
         assert not axes[1, 1].get_visible()
@@ -265,26 +267,26 @@ def test_hist_df_legacy(self):
         df = DataFrame(np.random.randn(100, 5))
         df[5] = to_datetime(
             np.random.randint(
-                self.start_date_to_int64,
-                self.end_date_to_int64,
+                812419200000000000,
+                819331200000000000,
                 size=100,
                 dtype=np.int64,
             )
         )
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.hist, layout=(4, 2))
         self._check_axes_shape(axes, axes_num=6, layout=(4, 2))
 
         # make sure sharex, sharey is handled
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.hist, sharex=True, sharey=True)
 
         # handle figsize arg
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.hist, figsize=(8, 10))
 
         # check bins argument
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             _check_plot_works(df.hist, bins=5)
 
         # make sure xlabelsize and xrot are handled
@@ -350,8 +352,8 @@ def test_hist_layout(self):
         df = DataFrame(np.random.randn(100, 2))
         df[2] = to_datetime(
             np.random.randint(
-                self.start_date_to_int64,
-                self.end_date_to_int64,
+                812419200000000000,
+                819331200000000000,
                 size=100,
                 dtype=np.int64,
             )
@@ -392,8 +394,8 @@ def test_tight_layout(self):
         df = DataFrame(np.random.randn(100, 2))
         df[2] = to_datetime(
             np.random.randint(
-                self.start_date_to_int64,
-                self.end_date_to_int64,
+                812419200000000000,
+                819331200000000000,
                 size=100,
                 dtype=np.int64,
             )
@@ -574,8 +576,8 @@ def test_grouped_hist_legacy(self):
         df = DataFrame(np.random.randn(500, 1), columns=["A"])
         df["B"] = to_datetime(
             np.random.randint(
-                self.start_date_to_int64,
-                self.end_date_to_int64,
+                812419200000000000,
+                819331200000000000,
                 size=500,
                 dtype=np.int64,
             )
@@ -648,8 +650,9 @@ def test_grouped_hist_legacy2(self):
         assert len(self.plt.get_fignums()) == 2
         tm.close()
 
-    def test_grouped_hist_layout(self):
-        df = self.hist_df
+    @pytest.mark.slow
+    def test_grouped_hist_layout(self, hist_df):
+        df = hist_df
         msg = "Layout of 1x1 must be larger than required size 2"
         with pytest.raises(ValueError, match=msg):
             df.hist(column="weight", by=df.gender, layout=(1, 1))
@@ -662,13 +665,13 @@ def test_grouped_hist_layout(self):
         with pytest.raises(ValueError, match=msg):
             df.hist(column="height", by=df.category, layout=(-1, -1))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
                 df.hist, column="height", by=df.gender, layout=(2, 1)
             )
         self._check_axes_shape(axes, axes_num=2, layout=(2, 1))
 
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
                 df.hist, column="height", by=df.gender, layout=(2, -1)
             )
@@ -685,14 +688,14 @@ def test_grouped_hist_layout(self):
         tm.close()
 
         # GH 6769
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
                 df.hist, column="height", by="classroom", layout=(2, 2)
             )
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
 
         # without column
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(df.hist, by="classroom")
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
 
@@ -702,9 +705,9 @@ def test_grouped_hist_layout(self):
         axes = df.hist(column=["height", "weight", "category"])
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
 
-    def test_grouped_hist_multiple_axes(self):
+    def test_grouped_hist_multiple_axes(self, hist_df):
         # GH 6970, GH 7069
-        df = self.hist_df
+        df = hist_df
 
         fig, axes = self.plt.subplots(2, 3)
         returned = df.hist(column=["height", "weight", "category"], ax=axes[0])
@@ -722,8 +725,8 @@ def test_grouped_hist_multiple_axes(self):
         with pytest.raises(ValueError, match=msg):
             axes = df.hist(column="height", ax=axes)
 
-    def test_axis_share_x(self):
-        df = self.hist_df
+    def test_axis_share_x(self, hist_df):
+        df = hist_df
         # GH4089
         ax1, ax2 = df.hist(column="height", by=df.gender, sharex=True)
 
@@ -735,8 +738,8 @@ def test_axis_share_x(self):
         assert not self.get_y_axis(ax1).joined(ax1, ax2)
         assert not self.get_y_axis(ax2).joined(ax1, ax2)
 
-    def test_axis_share_y(self):
-        df = self.hist_df
+    def test_axis_share_y(self, hist_df):
+        df = hist_df
         ax1, ax2 = df.hist(column="height", by=df.gender, sharey=True)
 
         # share y
@@ -747,8 +750,8 @@ def test_axis_share_y(self):
         assert not self.get_x_axis(ax1).joined(ax1, ax2)
         assert not self.get_x_axis(ax2).joined(ax1, ax2)
 
-    def test_axis_share_xy(self):
-        df = self.hist_df
+    def test_axis_share_xy(self, hist_df):
+        df = hist_df
         ax1, ax2 = df.hist(column="height", by=df.gender, sharex=True, sharey=True)
 
         # share both x and y
diff --git a/pandas/tests/plotting/test_misc.py b/pandas/tests/plotting/test_misc.py
index adda95f4c5aa0..93da7f71f51f9 100644
--- a/pandas/tests/plotting/test_misc.py
+++ b/pandas/tests/plotting/test_misc.py
@@ -7,7 +7,10 @@
 
 from pandas import (
     DataFrame,
+    Index,
     Series,
+    Timestamp,
+    interval_range,
 )
 import pandas._testing as tm
 from pandas.tests.plotting.common import (
@@ -17,8 +20,6 @@
 
 import pandas.plotting as plotting
 
-pytestmark = pytest.mark.slow
-
 
 @td.skip_if_mpl
 def test_import_error_message():
@@ -65,36 +66,30 @@ def test_get_accessor_args():
 
 @td.skip_if_no_mpl
 class TestSeriesPlots(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
-
-        mpl.rcdefaults()
-
-        self.ts = tm.makeTimeSeries()
-        self.ts.name = "ts"
-
     def test_autocorrelation_plot(self):
         from pandas.plotting import autocorrelation_plot
 
+        ser = tm.makeTimeSeries(name="ts")
         # Ensure no UserWarning when making plot
         with tm.assert_produces_warning(None):
-            _check_plot_works(autocorrelation_plot, series=self.ts)
-            _check_plot_works(autocorrelation_plot, series=self.ts.values)
+            _check_plot_works(autocorrelation_plot, series=ser)
+            _check_plot_works(autocorrelation_plot, series=ser.values)
 
-            ax = autocorrelation_plot(self.ts, label="Test")
+            ax = autocorrelation_plot(ser, label="Test")
         self._check_legend_labels(ax, labels=["Test"])
 
-    def test_lag_plot(self):
+    @pytest.mark.parametrize("kwargs", [{}, {"lag": 5}])
+    def test_lag_plot(self, kwargs):
         from pandas.plotting import lag_plot
 
-        _check_plot_works(lag_plot, series=self.ts)
-        _check_plot_works(lag_plot, series=self.ts, lag=5)
+        ser = tm.makeTimeSeries(name="ts")
+        _check_plot_works(lag_plot, series=ser, **kwargs)
 
     def test_bootstrap_plot(self):
         from pandas.plotting import bootstrap_plot
 
-        _check_plot_works(bootstrap_plot, series=self.ts, size=10)
+        ser = tm.makeTimeSeries(name="ts")
+        _check_plot_works(bootstrap_plot, series=ser, size=10)
 
 
 @td.skip_if_no_mpl
@@ -102,8 +97,6 @@ class TestDataFramePlots(TestPlotBase):
     @td.skip_if_no_scipy
     @pytest.mark.parametrize("pass_axis", [False, True])
     def test_scatter_matrix_axis(self, pass_axis):
-        from pandas.plotting._matplotlib.compat import mpl_ge_3_0_0
-
         scatter_matrix = plotting.scatter_matrix
 
         ax = None
@@ -114,9 +107,7 @@ def test_scatter_matrix_axis(self, pass_axis):
             df = DataFrame(np.random.randn(100, 3))
 
         # we are plotting multiples on a sub-plot
-        with tm.assert_produces_warning(
-            UserWarning, raise_on_extra_warnings=mpl_ge_3_0_0()
-        ):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
                 scatter_matrix,
                 filterwarnings="always",
@@ -134,7 +125,7 @@ def test_scatter_matrix_axis(self, pass_axis):
         df[0] = (df[0] - 2) / 3
 
         # we are plotting multiples on a sub-plot
-        with tm.assert_produces_warning(UserWarning):
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
             axes = _check_plot_works(
                 scatter_matrix,
                 filterwarnings="always",
@@ -147,6 +138,7 @@ def test_scatter_matrix_axis(self, pass_axis):
         self._check_text_labels(axes0_labels, expected)
         self._check_ticks_props(axes, xlabelsize=8, xrot=90, ylabelsize=8, yrot=0)
 
+    @pytest.mark.slow
     def test_andrews_curves(self, iris):
         from matplotlib import cm
 
@@ -223,6 +215,7 @@ def test_andrews_curves(self, iris):
         handles, labels = ax.get_legend_handles_labels()
         self._check_colors(handles, linecolors=colors)
 
+    @pytest.mark.slow
     def test_parallel_coordinates(self, iris):
         from matplotlib import cm
 
@@ -450,6 +443,40 @@ def test_dictionary_color(self):
         colors = [rect.get_color() for rect in ax.get_lines()[0:2]]
         assert all(color == expected[index] for index, color in enumerate(colors))
 
+    def test_bar_plot(self):
+        # GH38947
+        # Test bar plot with string and int index
+        from matplotlib.text import Text
+
+        expected = [Text(0, 0, "0"), Text(1, 0, "Total")]
+
+        df = DataFrame(
+            {
+                "a": [1, 2],
+            },
+            index=Index([0, "Total"]),
+        )
+        plot_bar = df.plot.bar()
+        assert all(
+            (a.get_text() == b.get_text())
+            for a, b in zip(plot_bar.get_xticklabels(), expected)
+        )
+
+    def test_barh_plot_labels_mixed_integer_string(self):
+        # GH39126
+        # Test barh plot with string and integer at the same column
+        from matplotlib.text import Text
+
+        df = DataFrame([{"word": 1, "value": 0}, {"word": "knowledg", "value": 2}])
+        plot_barh = df.plot.barh(x="word", legend=None)
+        expected_yticklabels = [Text(0, 0, "1"), Text(0, 1, "knowledg")]
+        assert all(
+            actual.get_text() == expected.get_text()
+            for actual, expected in zip(
+                plot_barh.get_yticklabels(), expected_yticklabels
+            )
+        )
+
     def test_has_externally_shared_axis_x_axis(self):
         # GH33819
         # Test _has_externally_shared_axis() works for x-axis
@@ -559,3 +586,31 @@ def test_externally_shared_axes(self):
         assert not plots[0][0].xaxis.get_label().get_visible()
         assert plots[0][1].xaxis.get_label().get_visible()
         assert not plots[0][2].xaxis.get_label().get_visible()
+
+    def test_plot_bar_axis_units_timestamp_conversion(self):
+        # GH 38736
+        # Ensure string x-axis from the second plot will not be converted to datetime
+        # due to axis data from first plot
+        df = DataFrame(
+            [1.0],
+            index=[Timestamp("2022-02-22 22:22:22")],
+        )
+        _check_plot_works(df.plot)
+        s = Series({"A": 1.0})
+        _check_plot_works(s.plot.bar)
+
+    def test_bar_plt_xaxis_intervalrange(self):
+        # GH 38969
+        # Ensure IntervalIndex x-axis produces a bar plot as expected
+        from matplotlib.text import Text
+
+        expected = [Text(0, 0, "([0, 1],)"), Text(1, 0, "([1, 2],)")]
+        s = Series(
+            [1, 2],
+            index=[interval_range(0, 2, closed="both")],
+        )
+        _check_plot_works(s.plot.bar)
+        assert all(
+            (a.get_text() == b.get_text())
+            for a, b in zip(s.plot.bar().get_xticklabels(), expected)
+        )
diff --git a/pandas/tests/plotting/test_series.py b/pandas/tests/plotting/test_series.py
index 44fc6042ebaab..46b2b827d56b3 100644
--- a/pandas/tests/plotting/test_series.py
+++ b/pandas/tests/plotting/test_series.py
@@ -1,6 +1,4 @@
 """ Test cases for Series.plot """
-
-
 from datetime import datetime
 from itertools import chain
 
@@ -23,65 +21,86 @@
 
 import pandas.plotting as plotting
 
-pytestmark = pytest.mark.slow
+try:
+    from pandas.plotting._matplotlib.compat import mpl_ge_3_6_0
+except ImportError:
+    mpl_ge_3_6_0 = lambda: True
 
 
-@td.skip_if_no_mpl
-class TestSeriesPlots(TestPlotBase):
-    def setup_method(self, method):
-        TestPlotBase.setup_method(self, method)
-        import matplotlib as mpl
+@pytest.fixture
+def ts():
+    return tm.makeTimeSeries(name="ts")
 
-        mpl.rcdefaults()
 
-        self.ts = tm.makeTimeSeries()
-        self.ts.name = "ts"
+@pytest.fixture
+def series():
+    return tm.makeStringSeries(name="series")
 
-        self.series = tm.makeStringSeries()
-        self.series.name = "series"
 
-        self.iseries = tm.makePeriodSeries()
-        self.iseries.name = "iseries"
+@pytest.fixture
+def iseries():
+    return tm.makePeriodSeries(name="iseries")
 
-    def test_plot(self):
-        _check_plot_works(self.ts.plot, label="foo")
-        _check_plot_works(self.ts.plot, use_index=False)
-        axes = _check_plot_works(self.ts.plot, rot=0)
+
+@td.skip_if_no_mpl
+class TestSeriesPlots(TestPlotBase):
+    @pytest.mark.slow
+    def test_plot(self, ts):
+        _check_plot_works(ts.plot, label="foo")
+        _check_plot_works(ts.plot, use_index=False)
+        axes = _check_plot_works(ts.plot, rot=0)
         self._check_ticks_props(axes, xrot=0)
 
-        ax = _check_plot_works(self.ts.plot, style=".", logy=True)
+        ax = _check_plot_works(ts.plot, style=".", logy=True)
         self._check_ax_scales(ax, yaxis="log")
 
-        ax = _check_plot_works(self.ts.plot, style=".", logx=True)
+        ax = _check_plot_works(ts.plot, style=".", logx=True)
         self._check_ax_scales(ax, xaxis="log")
 
-        ax = _check_plot_works(self.ts.plot, style=".", loglog=True)
+        ax = _check_plot_works(ts.plot, style=".", loglog=True)
         self._check_ax_scales(ax, xaxis="log", yaxis="log")
 
-        _check_plot_works(self.ts[:10].plot.bar)
-        _check_plot_works(self.ts.plot.area, stacked=False)
-        _check_plot_works(self.iseries.plot)
+        _check_plot_works(ts[:10].plot.bar)
+        _check_plot_works(ts.plot.area, stacked=False)
+
+    def test_plot_iseries(self, iseries):
+        _check_plot_works(iseries.plot)
+
+    @pytest.mark.parametrize(
+        "kind",
+        [
+            "line",
+            "bar",
+            "barh",
+            pytest.param("kde", marks=td.skip_if_no_scipy),
+            "hist",
+            "box",
+        ],
+    )
+    def test_plot_series_kinds(self, series, kind):
+        _check_plot_works(series[:5].plot, kind=kind)
 
-        for kind in ["line", "bar", "barh", "kde", "hist", "box"]:
-            _check_plot_works(self.series[:5].plot, kind=kind)
+    def test_plot_series_barh(self, series):
+        _check_plot_works(series[:10].plot.barh)
 
-        _check_plot_works(self.series[:10].plot.barh)
+    def test_plot_series_bar_ax(self):
         ax = _check_plot_works(Series(np.random.randn(10)).plot.bar, color="black")
         self._check_colors([ax.patches[0]], facecolors=["black"])
 
+    def test_plot_6951(self, ts):
         # GH 6951
-        ax = _check_plot_works(self.ts.plot, subplots=True)
+        ax = _check_plot_works(ts.plot, subplots=True)
         self._check_axes_shape(ax, axes_num=1, layout=(1, 1))
 
-        ax = _check_plot_works(self.ts.plot, subplots=True, layout=(-1, 1))
+        ax = _check_plot_works(ts.plot, subplots=True, layout=(-1, 1))
         self._check_axes_shape(ax, axes_num=1, layout=(1, 1))
-        ax = _check_plot_works(self.ts.plot, subplots=True, layout=(1, -1))
+        ax = _check_plot_works(ts.plot, subplots=True, layout=(1, -1))
         self._check_axes_shape(ax, axes_num=1, layout=(1, 1))
 
-    def test_plot_figsize_and_title(self):
+    def test_plot_figsize_and_title(self, series):
         # figsize and title
         _, ax = self.plt.subplots()
-        ax = self.series.plot(title="Test", figsize=(16, 8), ax=ax)
+        ax = series.plot(title="Test", figsize=(16, 8), ax=ax)
         self._check_text_labels(ax.title, "Test")
         self._check_axes_shape(ax, axes_num=1, layout=(1, 1), figsize=(16, 8))
 
@@ -93,24 +112,24 @@ def test_dont_modify_rcParams(self):
         Series([1, 2, 3]).plot(ax=ax)
         assert colors == self.plt.rcParams[key]
 
-    def test_ts_line_lim(self):
+    def test_ts_line_lim(self, ts):
         fig, ax = self.plt.subplots()
-        ax = self.ts.plot(ax=ax)
+        ax = ts.plot(ax=ax)
         xmin, xmax = ax.get_xlim()
         lines = ax.get_lines()
         assert xmin <= lines[0].get_data(orig=False)[0][0]
         assert xmax >= lines[0].get_data(orig=False)[0][-1]
         tm.close()
 
-        ax = self.ts.plot(secondary_y=True, ax=ax)
+        ax = ts.plot(secondary_y=True, ax=ax)
         xmin, xmax = ax.get_xlim()
         lines = ax.get_lines()
         assert xmin <= lines[0].get_data(orig=False)[0][0]
         assert xmax >= lines[0].get_data(orig=False)[0][-1]
 
-    def test_ts_area_lim(self):
+    def test_ts_area_lim(self, ts):
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.area(stacked=False, ax=ax)
+        ax = ts.plot.area(stacked=False, ax=ax)
         xmin, xmax = ax.get_xlim()
         line = ax.get_lines()[0].get_data(orig=False)[0]
         assert xmin <= line[0]
@@ -120,7 +139,7 @@ def test_ts_area_lim(self):
 
         # GH 7471
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.area(stacked=False, x_compat=True, ax=ax)
+        ax = ts.plot.area(stacked=False, x_compat=True, ax=ax)
         xmin, xmax = ax.get_xlim()
         line = ax.get_lines()[0].get_data(orig=False)[0]
         assert xmin <= line[0]
@@ -128,7 +147,7 @@ def test_ts_area_lim(self):
         self._check_ticks_props(ax, xrot=30)
         tm.close()
 
-        tz_ts = self.ts.copy()
+        tz_ts = ts.copy()
         tz_ts.index = tz_ts.tz_localize("GMT").tz_convert("CET")
         _, ax = self.plt.subplots()
         ax = tz_ts.plot.area(stacked=False, x_compat=True, ax=ax)
@@ -147,12 +166,12 @@ def test_ts_area_lim(self):
         assert xmax >= line[-1]
         self._check_ticks_props(ax, xrot=0)
 
-    def test_area_sharey_dont_overwrite(self):
+    def test_area_sharey_dont_overwrite(self, ts):
         # GH37942
         fig, (ax1, ax2) = self.plt.subplots(1, 2, sharey=True)
 
-        abs(self.ts).plot(ax=ax1, kind="area")
-        abs(self.ts).plot(ax=ax2, kind="area")
+        abs(ts).plot(ax=ax1, kind="area")
+        abs(ts).plot(ax=ax2, kind="area")
 
         assert self.get_y_axis(ax1).joined(ax1, ax2)
         assert self.get_y_axis(ax2).joined(ax1, ax2)
@@ -165,7 +184,7 @@ def test_label(self):
         self.plt.close()
         _, ax = self.plt.subplots()
         ax = s.plot(legend=True, ax=ax)
-        self._check_legend_labels(ax, labels=["None"])
+        self._check_legend_labels(ax, labels=[""])
         self.plt.close()
         # get name from index
         s.name = "NAME"
@@ -194,28 +213,24 @@ def test_boolean(self):
         with pytest.raises(TypeError, match=msg):
             _check_plot_works(s.plot)
 
-    def test_line_area_nan_series(self):
+    @pytest.mark.parametrize("index", [None, tm.makeDateIndex(k=4)])
+    def test_line_area_nan_series(self, index):
         values = [1, 2, np.nan, 3]
-        s = Series(values)
-        ts = Series(values, index=tm.makeDateIndex(k=4))
-
-        for d in [s, ts]:
-            ax = _check_plot_works(d.plot)
-            masked = ax.lines[0].get_ydata()
-            # remove nan for comparison purpose
-            exp = np.array([1, 2, 3], dtype=np.float64)
-            tm.assert_numpy_array_equal(np.delete(masked.data, 2), exp)
-            tm.assert_numpy_array_equal(
-                masked.mask, np.array([False, False, True, False])
-            )
-
-            expected = np.array([1, 2, 0, 3], dtype=np.float64)
-            ax = _check_plot_works(d.plot, stacked=True)
-            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
-            ax = _check_plot_works(d.plot.area)
-            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
-            ax = _check_plot_works(d.plot.area, stacked=False)
-            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
+        d = Series(values, index=index)
+        ax = _check_plot_works(d.plot)
+        masked = ax.lines[0].get_ydata()
+        # remove nan for comparison purpose
+        exp = np.array([1, 2, 3], dtype=np.float64)
+        tm.assert_numpy_array_equal(np.delete(masked.data, 2), exp)
+        tm.assert_numpy_array_equal(masked.mask, np.array([False, False, True, False]))
+
+        expected = np.array([1, 2, 0, 3], dtype=np.float64)
+        ax = _check_plot_works(d.plot, stacked=True)
+        tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
+        ax = _check_plot_works(d.plot.area)
+        tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
+        ax = _check_plot_works(d.plot.area, stacked=False)
+        tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
 
     def test_line_use_index_false(self):
         s = Series([1, 2, 3], index=["a", "b", "c"])
@@ -462,15 +477,15 @@ def test_plot_fails_with_dupe_color_and_style(self):
             x.plot(style="k--", color="k", ax=ax)
 
     @td.skip_if_no_scipy
-    def test_kde_kwargs(self):
+    def test_kde_kwargs(self, ts):
         sample_points = np.linspace(-100, 100, 20)
-        _check_plot_works(self.ts.plot.kde, bw_method="scott", ind=20)
-        _check_plot_works(self.ts.plot.kde, bw_method=None, ind=20)
-        _check_plot_works(self.ts.plot.kde, bw_method=None, ind=np.int_(20))
-        _check_plot_works(self.ts.plot.kde, bw_method=0.5, ind=sample_points)
-        _check_plot_works(self.ts.plot.density, bw_method=0.5, ind=sample_points)
+        _check_plot_works(ts.plot.kde, bw_method="scott", ind=20)
+        _check_plot_works(ts.plot.kde, bw_method=None, ind=20)
+        _check_plot_works(ts.plot.kde, bw_method=None, ind=np.int_(20))
+        _check_plot_works(ts.plot.kde, bw_method=0.5, ind=sample_points)
+        _check_plot_works(ts.plot.density, bw_method=0.5, ind=sample_points)
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.kde(logy=True, bw_method=0.5, ind=sample_points, ax=ax)
+        ax = ts.plot.kde(logy=True, bw_method=0.5, ind=sample_points, ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         self._check_text_labels(ax.yaxis.get_label(), "Density")
 
@@ -483,50 +498,51 @@ def test_kde_missing_vals(self):
         # gh-14821: check if the values have any missing values
         assert any(~np.isnan(axes.lines[0].get_xdata()))
 
-    def test_boxplot_series(self):
+    @pytest.mark.xfail(mpl_ge_3_6_0(), reason="Api changed")
+    def test_boxplot_series(self, ts):
         _, ax = self.plt.subplots()
-        ax = self.ts.plot.box(logy=True, ax=ax)
+        ax = ts.plot.box(logy=True, ax=ax)
         self._check_ax_scales(ax, yaxis="log")
         xlabels = ax.get_xticklabels()
-        self._check_text_labels(xlabels, [self.ts.name])
+        self._check_text_labels(xlabels, [ts.name])
         ylabels = ax.get_yticklabels()
         self._check_text_labels(ylabels, [""] * len(ylabels))
 
-    def test_kind_both_ways(self):
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize(
+        "kind",
+        plotting.PlotAccessor._common_kinds + plotting.PlotAccessor._series_kinds,
+    )
+    def test_kind_both_ways(self, kind):
         s = Series(range(3))
-        kinds = (
-            plotting.PlotAccessor._common_kinds + plotting.PlotAccessor._series_kinds
-        )
-        for kind in kinds:
-            _, ax = self.plt.subplots()
-            s.plot(kind=kind, ax=ax)
-            self.plt.close()
-            _, ax = self.plt.subplots()
-            getattr(s.plot, kind)()
-            self.plt.close()
+        _, ax = self.plt.subplots()
+        s.plot(kind=kind, ax=ax)
+        self.plt.close()
+        _, ax = self.plt.subplots()
+        getattr(s.plot, kind)()
+        self.plt.close()
 
-    def test_invalid_plot_data(self):
+    @pytest.mark.parametrize("kind", plotting.PlotAccessor._common_kinds)
+    def test_invalid_plot_data(self, kind):
         s = Series(list("abcd"))
         _, ax = self.plt.subplots()
-        for kind in plotting.PlotAccessor._common_kinds:
-
-            msg = "no numeric data to plot"
-            with pytest.raises(TypeError, match=msg):
-                s.plot(kind=kind, ax=ax)
+        msg = "no numeric data to plot"
+        with pytest.raises(TypeError, match=msg):
+            s.plot(kind=kind, ax=ax)
 
-    def test_valid_object_plot(self):
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize("kind", plotting.PlotAccessor._common_kinds)
+    def test_valid_object_plot(self, kind):
         s = Series(range(10), dtype=object)
-        for kind in plotting.PlotAccessor._common_kinds:
-            _check_plot_works(s.plot, kind=kind)
+        _check_plot_works(s.plot, kind=kind)
 
-    def test_partially_invalid_plot_data(self):
+    @pytest.mark.parametrize("kind", plotting.PlotAccessor._common_kinds)
+    def test_partially_invalid_plot_data(self, kind):
         s = Series(["a", "b", 1.0, 2])
         _, ax = self.plt.subplots()
-        for kind in plotting.PlotAccessor._common_kinds:
-
-            msg = "no numeric data to plot"
-            with pytest.raises(TypeError, match=msg):
-                s.plot(kind=kind, ax=ax)
+        msg = "no numeric data to plot"
+        with pytest.raises(TypeError, match=msg):
+            s.plot(kind=kind, ax=ax)
 
     def test_invalid_kind(self):
         s = Series([1, 2])
@@ -561,11 +577,14 @@ def test_errorbar_asymmetrical(self):
 
         tm.close()
 
+    @pytest.mark.slow
     def test_errorbar_plot(self):
 
         s = Series(np.arange(10), name="x")
-        s_err = np.random.randn(10)
-        d_err = DataFrame(np.random.randn(10, 2), index=s.index, columns=["x", "y"])
+        s_err = np.abs(np.random.randn(10))
+        d_err = DataFrame(
+            np.abs(np.random.randn(10, 2)), index=s.index, columns=["x", "y"]
+        )
         # test line and bar plots
         kinds = ["line", "bar"]
         for kind in kinds:
@@ -586,8 +605,8 @@ def test_errorbar_plot(self):
         # test time series plotting
         ix = date_range("1/1/2000", "1/1/2001", freq="M")
         ts = Series(np.arange(12), index=ix, name="x")
-        ts_err = Series(np.random.randn(12), index=ix)
-        td_err = DataFrame(np.random.randn(12, 2), index=ix, columns=["x", "y"])
+        ts_err = Series(np.abs(np.random.randn(12)), index=ix)
+        td_err = DataFrame(np.abs(np.random.randn(12, 2)), index=ix, columns=["x", "y"])
 
         ax = _check_plot_works(ts.plot, yerr=ts_err)
         self._check_has_errorbars(ax, xerr=0, yerr=1)
@@ -602,10 +621,13 @@ def test_errorbar_plot(self):
         with tm.external_error_raised(TypeError):
             s.plot(yerr=s_err)
 
-    def test_table(self):
-        _check_plot_works(self.series.plot, table=True)
-        _check_plot_works(self.series.plot, table=self.series)
+    @pytest.mark.slow
+    def test_table(self, series):
+        _check_plot_works(series.plot, table=True)
+        _check_plot_works(series.plot, table=series)
 
+    @pytest.mark.slow
+    @td.skip_if_no_scipy
     def test_series_grid_settings(self):
         # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
         self._check_grid_settings(
@@ -613,21 +635,21 @@ def test_series_grid_settings(self):
             plotting.PlotAccessor._series_kinds + plotting.PlotAccessor._common_kinds,
         )
 
-    def test_standard_colors(self):
+    @pytest.mark.parametrize("c", ["r", "red", "green", "#FF0000"])
+    def test_standard_colors(self, c):
         from pandas.plotting._matplotlib.style import get_standard_colors
 
-        for c in ["r", "red", "green", "#FF0000"]:
-            result = get_standard_colors(1, color=c)
-            assert result == [c]
+        result = get_standard_colors(1, color=c)
+        assert result == [c]
 
-            result = get_standard_colors(1, color=[c])
-            assert result == [c]
+        result = get_standard_colors(1, color=[c])
+        assert result == [c]
 
-            result = get_standard_colors(3, color=c)
-            assert result == [c] * 3
+        result = get_standard_colors(3, color=c)
+        assert result == [c] * 3
 
-            result = get_standard_colors(3, color=[c])
-            assert result == [c] * 3
+        result = get_standard_colors(3, color=[c])
+        assert result == [c] * 3
 
     def test_standard_colors_all(self):
         import matplotlib.colors as colors
@@ -787,16 +809,20 @@ def test_style_single_ok(self):
         "index_name, old_label, new_label",
         [(None, "", "new"), ("old", "old", "new"), (None, "", "")],
     )
-    @pytest.mark.parametrize("kind", ["line", "area", "bar"])
+    @pytest.mark.parametrize("kind", ["line", "area", "bar", "barh"])
     def test_xlabel_ylabel_series(self, kind, index_name, old_label, new_label):
         # GH 9093
         ser = Series([1, 2, 3, 4])
         ser.index.name = index_name
 
-        # default is the ylabel is not shown and xlabel is index name
+        # default is the ylabel is not shown and xlabel is index name (reverse for barh)
         ax = ser.plot(kind=kind)
-        assert ax.get_ylabel() == ""
-        assert ax.get_xlabel() == old_label
+        if kind == "barh":
+            assert ax.get_xlabel() == ""
+            assert ax.get_ylabel() == old_label
+        else:
+            assert ax.get_ylabel() == ""
+            assert ax.get_xlabel() == old_label
 
         # old xlabel will be overridden and assigned ylabel will be used as ylabel
         ax = ser.plot(kind=kind, ylabel=new_label, xlabel=new_label)
diff --git a/pandas/tests/plotting/test_style.py b/pandas/tests/plotting/test_style.py
index 3c48eeaccbf34..665bda15724fd 100644
--- a/pandas/tests/plotting/test_style.py
+++ b/pandas/tests/plotting/test_style.py
@@ -5,8 +5,6 @@
 pytest.importorskip("matplotlib")
 from pandas.plotting._matplotlib.style import get_standard_colors
 
-pytestmark = pytest.mark.slow
-
 
 class TestGetStandardColors:
     @pytest.mark.parametrize(
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 70e739d1440d6..fa53ed47dbdba 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -38,7 +38,6 @@ def get_objs():
         tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern"),
         tm.makePeriodIndex(10, name="a"),
         tm.makeStringIndex(10, name="a"),
-        tm.makeUnicodeIndex(10, name="a"),
     ]
 
     arr = np.random.randn(10)
@@ -199,6 +198,18 @@ def test_numpy_reduction_with_tz_aware_dtype(self, tz_aware_fixture, func):
         result = getattr(np, func)(expected, expected)
         tm.assert_series_equal(result, expected)
 
+    def test_nan_int_timedelta_sum(self):
+        # GH 27185
+        df = DataFrame(
+            {
+                "A": Series([1, 2, NaT], dtype="timedelta64[ns]"),
+                "B": Series([1, 2, np.nan], dtype="Int64"),
+            }
+        )
+        expected = Series({"A": Timedelta(3), "B": 3})
+        result = df.sum()
+        tm.assert_series_equal(result, expected)
+
 
 class TestIndexReductions:
     # Note: the name TestIndexReductions indicates these tests
@@ -210,8 +221,8 @@ class TestIndexReductions:
         [
             (0, 400, 3),
             (500, 0, -6),
-            (-(10 ** 6), 10 ** 6, 4),
-            (10 ** 6, -(10 ** 6), -4),
+            (-(10**6), 10**6, 4),
+            (10**6, -(10**6), -4),
             (0, 10, 20),
         ],
     )
@@ -243,11 +254,11 @@ def test_minmax_timedelta64(self):
 
         # monotonic
         idx1 = TimedeltaIndex(["1 days", "2 days", "3 days"])
-        assert idx1.is_monotonic
+        assert idx1.is_monotonic_increasing
 
         # non-monotonic
         idx2 = TimedeltaIndex(["1 days", np.nan, "3 days", "NaT"])
-        assert not idx2.is_monotonic
+        assert not idx2.is_monotonic_increasing
 
         for idx in [idx1, idx2]:
             assert idx.min() == Timedelta("1 days")
@@ -366,13 +377,13 @@ def test_minmax_tz(self, tz_naive_fixture):
         tz = tz_naive_fixture
         # monotonic
         idx1 = DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03"], tz=tz)
-        assert idx1.is_monotonic
+        assert idx1.is_monotonic_increasing
 
         # non-monotonic
         idx2 = DatetimeIndex(
             ["2011-01-01", NaT, "2011-01-03", "2011-01-02", NaT], tz=tz
         )
-        assert not idx2.is_monotonic
+        assert not idx2.is_monotonic_increasing
 
         for idx in [idx1, idx2]:
             assert idx.min() == Timestamp("2011-01-01", tz=tz)
@@ -470,14 +481,14 @@ def test_minmax_period(self):
 
         # monotonic
         idx1 = PeriodIndex([NaT, "2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
-        assert not idx1.is_monotonic
-        assert idx1[1:].is_monotonic
+        assert not idx1.is_monotonic_increasing
+        assert idx1[1:].is_monotonic_increasing
 
         # non-monotonic
         idx2 = PeriodIndex(
             ["2011-01-01", NaT, "2011-01-03", "2011-01-02", NaT], freq="D"
         )
-        assert not idx2.is_monotonic
+        assert not idx2.is_monotonic_increasing
 
         for idx in [idx1, idx2]:
             assert idx.min() == Period("2011-01-01", freq="D")
@@ -487,19 +498,13 @@ def test_minmax_period(self):
         assert idx1.argmax() == 3
         assert idx2.argmax() == 2
 
-        for op in ["min", "max"]:
-            # Return NaT
-            obj = PeriodIndex([], freq="M")
-            result = getattr(obj, op)()
-            assert result is NaT
-
-            obj = PeriodIndex([NaT], freq="M")
-            result = getattr(obj, op)()
-            assert result is NaT
-
-            obj = PeriodIndex([NaT, NaT, NaT], freq="M")
-            result = getattr(obj, op)()
-            assert result is NaT
+    @pytest.mark.parametrize("op", ["min", "max"])
+    @pytest.mark.parametrize("data", [[], [NaT], [NaT, NaT, NaT]])
+    def test_minmax_period_empty_nat(self, op, data):
+        # Return NaT
+        obj = PeriodIndex(data, freq="M")
+        result = getattr(obj, op)()
+        assert result is NaT
 
     def test_numpy_minmax_period(self):
         pr = pd.period_range(start="2016-01-15", end="2016-01-20")
@@ -740,40 +745,42 @@ def test_nansum_buglet(self):
         tm.assert_almost_equal(result, 1)
 
     @pytest.mark.parametrize("use_bottleneck", [True, False])
-    def test_sum_overflow(self, use_bottleneck):
+    @pytest.mark.parametrize("dtype", ["int32", "int64"])
+    def test_sum_overflow_int(self, use_bottleneck, dtype):
 
         with pd.option_context("use_bottleneck", use_bottleneck):
             # GH#6915
             # overflowing on the smaller int dtypes
-            for dtype in ["int32", "int64"]:
-                v = np.arange(5000000, dtype=dtype)
-                s = Series(v)
-
-                result = s.sum(skipna=False)
-                assert int(result) == v.sum(dtype="int64")
-                result = s.min(skipna=False)
-                assert int(result) == 0
-                result = s.max(skipna=False)
-                assert int(result) == v[-1]
-
-            for dtype in ["float32", "float64"]:
-                v = np.arange(5000000, dtype=dtype)
-                s = Series(v)
-
-                result = s.sum(skipna=False)
-                assert result == v.sum(dtype=dtype)
-                result = s.min(skipna=False)
-                assert np.allclose(float(result), 0.0)
-                result = s.max(skipna=False)
-                assert np.allclose(float(result), v[-1])
-
-    def test_empty_timeseries_reductions_return_nat(self):
+            v = np.arange(5000000, dtype=dtype)
+            s = Series(v)
+
+            result = s.sum(skipna=False)
+            assert int(result) == v.sum(dtype="int64")
+            result = s.min(skipna=False)
+            assert int(result) == 0
+            result = s.max(skipna=False)
+            assert int(result) == v[-1]
+
+    @pytest.mark.parametrize("use_bottleneck", [True, False])
+    @pytest.mark.parametrize("dtype", ["float32", "float64"])
+    def test_sum_overflow_float(self, use_bottleneck, dtype):
+        with pd.option_context("use_bottleneck", use_bottleneck):
+            v = np.arange(5000000, dtype=dtype)
+            s = Series(v)
+
+            result = s.sum(skipna=False)
+            assert result == v.sum(dtype=dtype)
+            result = s.min(skipna=False)
+            assert np.allclose(float(result), 0.0)
+            result = s.max(skipna=False)
+            assert np.allclose(float(result), v[-1])
+
+    @pytest.mark.parametrize("dtype", ("m8[ns]", "m8[ns]", "M8[ns]", "M8[ns, UTC]"))
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_empty_timeseries_reductions_return_nat(self, dtype, skipna):
         # covers GH#11245
-        for dtype in ("m8[ns]", "m8[ns]", "M8[ns]", "M8[ns, UTC]"):
-            assert Series([], dtype=dtype).min() is NaT
-            assert Series([], dtype=dtype).max() is NaT
-            assert Series([], dtype=dtype).min(skipna=False) is NaT
-            assert Series([], dtype=dtype).max(skipna=False) is NaT
+        assert Series([], dtype=dtype).min(skipna=skipna) is NaT
+        assert Series([], dtype=dtype).max(skipna=skipna) is NaT
 
     def test_numpy_argmin(self):
         # See GH#16830
@@ -928,13 +935,9 @@ def test_all_any_params(self):
             with tm.assert_produces_warning(FutureWarning):
                 s.all(bool_only=True, level=0)
 
-        # GH#38810 bool_only is not implemented alone.
-        msg = "Series.any does not implement bool_only"
-        with pytest.raises(NotImplementedError, match=msg):
-            s.any(bool_only=True)
-        msg = "Series.all does not implement bool_only."
-        with pytest.raises(NotImplementedError, match=msg):
-            s.all(bool_only=True)
+        # GH#47500 - test bool_only works
+        assert s.any(bool_only=True)
+        assert not s.all(bool_only=True)
 
     @pytest.mark.parametrize("bool_agg_func", ["any", "all"])
     @pytest.mark.parametrize("skipna", [True, False])
@@ -1451,16 +1454,16 @@ def test_mode_category(self, dropna, expected1, expected2, expected3):
 
     @pytest.mark.parametrize(
         "dropna, expected1, expected2",
-        [(True, [2 ** 63], [1, 2 ** 63]), (False, [2 ** 63], [1, 2 ** 63])],
+        [(True, [2**63], [1, 2**63]), (False, [2**63], [1, 2**63])],
     )
     def test_mode_intoverflow(self, dropna, expected1, expected2):
         # Test for uint64 overflow.
-        s = Series([1, 2 ** 63, 2 ** 63], dtype=np.uint64)
+        s = Series([1, 2**63, 2**63], dtype=np.uint64)
         result = s.mode(dropna)
         expected1 = Series(expected1, dtype=np.uint64)
         tm.assert_series_equal(result, expected1)
 
-        s = Series([1, 2 ** 63], dtype=np.uint64)
+        s = Series([1, 2**63], dtype=np.uint64)
         result = s.mode(dropna)
         expected2 = Series(expected2, dtype=np.uint64)
         tm.assert_series_equal(result, expected2)
diff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py
index 2f1ae5df0d5d4..be40d7ca631eb 100644
--- a/pandas/tests/reductions/test_stat_reductions.py
+++ b/pandas/tests/reductions/test_stat_reductions.py
@@ -128,7 +128,7 @@ def _check_stat_op(
 
             # GH#2888
             items = [0]
-            items.extend(range(2 ** 40, 2 ** 40 + 1000))
+            items.extend(range(2**40, 2**40 + 1000))
             s = Series(items, dtype="int64")
             tm.assert_almost_equal(float(f(s)), float(alternate(s.values)))
 
@@ -149,10 +149,9 @@ def _check_stat_op(
             with pytest.raises(ValueError, match=msg):
                 f(string_series_, axis=1)
 
-            # Unimplemented numeric_only parameter.
             if "numeric_only" in inspect.getfullargspec(f).args:
-                with pytest.raises(NotImplementedError, match=name):
-                    f(string_series_, numeric_only=True)
+                # only the index is string; dtype is float
+                f(string_series_, numeric_only=True)
 
     def test_sum(self):
         string_series = tm.makeStringSeries().rename("series")
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index 2dae9ee48a90a..04f147ee40e62 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -61,14 +61,14 @@ def test_asfreq(series_and_frame, freq, create_index):
 def test_asfreq_fill_value(series, create_index):
     # test for fill value during resampling, issue 3715
 
-    s = series
+    ser = series
 
-    result = s.resample("1H").asfreq()
-    new_index = create_index(s.index[0], s.index[-1], freq="1H")
-    expected = s.reindex(new_index)
+    result = ser.resample("1H").asfreq()
+    new_index = create_index(ser.index[0], ser.index[-1], freq="1H")
+    expected = ser.reindex(new_index)
     tm.assert_series_equal(result, expected)
 
-    frame = s.to_frame("value")
+    frame = ser.to_frame("value")
     frame.iloc[1] = None
     result = frame.resample("1H").asfreq(fill_value=4.0)
     new_index = create_index(frame.index[0], frame.index[-1], freq="1H")
@@ -98,17 +98,21 @@ def test_raises_on_non_datetimelike_index():
 
 @all_ts
 @pytest.mark.parametrize("freq", ["M", "D", "H"])
-def test_resample_empty_series(freq, empty_series_dti, resample_method):
+def test_resample_empty_series(freq, empty_series_dti, resample_method, request):
     # GH12771 & GH12868
 
-    if resample_method == "ohlc":
-        pytest.skip("need to test for ohlc from GH13083")
+    if resample_method == "ohlc" and isinstance(empty_series_dti.index, PeriodIndex):
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason=f"GH13083: {resample_method} fails for PeriodIndex"
+            )
+        )
 
-    s = empty_series_dti
-    result = getattr(s.resample(freq), resample_method)()
+    ser = empty_series_dti
+    result = getattr(ser.resample(freq), resample_method)()
 
-    expected = s.copy()
-    expected.index = _asfreq_compat(s.index, freq)
+    expected = ser.copy()
+    expected.index = _asfreq_compat(ser.index, freq)
 
     tm.assert_index_equal(result.index, expected.index)
     assert result.index.freq == expected.index.freq
@@ -123,17 +127,18 @@ def test_resample_nat_index_series(request, freq, series, resample_method):
     if freq == "M":
         request.node.add_marker(pytest.mark.xfail(reason="Don't know why this fails"))
 
-    s = series.copy()
-    s.index = PeriodIndex([NaT] * len(s), freq=freq)
-    result = getattr(s.resample(freq), resample_method)()
+    ser = series.copy()
+    ser.index = PeriodIndex([NaT] * len(ser), freq=freq)
+    rs = ser.resample(freq)
+    result = getattr(rs, resample_method)()
 
     if resample_method == "ohlc":
         expected = DataFrame(
-            [], index=s.index[:0].copy(), columns=["open", "high", "low", "close"]
+            [], index=ser.index[:0].copy(), columns=["open", "high", "low", "close"]
         )
         tm.assert_frame_equal(result, expected, check_dtype=False)
     else:
-        expected = s[:0].copy()
+        expected = ser[:0].copy()
         tm.assert_series_equal(result, expected, check_dtype=False)
     tm.assert_index_equal(result.index, expected.index)
     assert result.index.freq == expected.index.freq
@@ -159,18 +164,18 @@ def test_resample_empty_dataframe(empty_frame_dti, freq, resample_method):
     # GH13212
     df = empty_frame_dti
     # count retains dimensions too
-    result = getattr(df.resample(freq), resample_method)()
+    result = getattr(df.resample(freq, group_keys=False), resample_method)()
     if resample_method != "size":
         expected = df.copy()
     else:
         # GH14962
-        expected = Series([], dtype=object)
+        expected = Series([], dtype=np.int64)
 
     expected.index = _asfreq_compat(df.index, freq)
 
     tm.assert_index_equal(result.index, expected.index)
     assert result.index.freq == expected.index.freq
-    tm.assert_almost_equal(result, expected, check_dtype=False)
+    tm.assert_almost_equal(result, expected)
 
     # test size for GH13212 (currently stays as df)
 
@@ -215,7 +220,7 @@ def test_resample_empty_dtypes(index, dtype, resample_method):
     # them to ensure they no longer do.  (GH #10228)
     empty_series_dti = Series([], index, dtype)
     try:
-        getattr(empty_series_dti.resample("d"), resample_method)()
+        getattr(empty_series_dti.resample("d", group_keys=False), resample_method)()
     except DataError:
         # Ignore these since some combinations are invalid
         # (ex: doing mean with dtype of np.object_)
@@ -223,14 +228,14 @@ def test_resample_empty_dtypes(index, dtype, resample_method):
 
 
 @all_ts
-def test_apply_to_empty_series(empty_series_dti):
+@pytest.mark.parametrize("freq", ["M", "D", "H"])
+def test_apply_to_empty_series(empty_series_dti, freq):
     # GH 14313
-    s = empty_series_dti
-    for freq in ["M", "D", "H"]:
-        result = s.resample(freq).apply(lambda x: 1)
-        expected = s.resample(freq).apply(np.sum)
+    ser = empty_series_dti
+    result = ser.resample(freq, group_keys=False).apply(lambda x: 1)
+    expected = ser.resample(freq).apply(np.sum)
 
-        tm.assert_series_equal(result, expected, check_dtype=False)
+    tm.assert_series_equal(result, expected, check_dtype=False)
 
 
 @all_ts
@@ -248,9 +253,9 @@ def test_resampler_is_iterable(series):
 @all_ts
 def test_resample_quantile(series):
     # GH 15023
-    s = series
+    ser = series
     q = 0.75
     freq = "H"
-    result = s.resample(freq).quantile(q)
-    expected = s.resample(freq).agg(lambda x: x.quantile(q)).rename(s.name)
+    result = ser.resample(freq).quantile(q)
+    expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name)
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 8b4fc4e84baab..970d4f155ecfc 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1,12 +1,14 @@
 from datetime import datetime
 from functools import partial
 from io import StringIO
+from typing import List
 
 import numpy as np
 import pytest
 import pytz
 
 from pandas._libs import lib
+from pandas._typing import DatetimeNaTType
 from pandas.errors import UnsupportedFunctionCall
 
 import pandas as pd
@@ -59,7 +61,7 @@ def test_custom_grouper(index):
 
     # check all cython functions work
     g.ohlc()  # doesn't use _cython_agg_general
-    funcs = ["add", "mean", "prod", "min", "max", "var"]
+    funcs = ["sum", "mean", "prod", "min", "max", "var"]
     for f in funcs:
         g._cython_agg_general(f, alt=None, numeric_only=True)
 
@@ -67,7 +69,7 @@ def test_custom_grouper(index):
     g = s.groupby(b)
     # check all cython functions work
     g.ohlc()  # doesn't use _cython_agg_general
-    funcs = ["add", "mean", "prod", "min", "max", "var"]
+    funcs = ["sum", "mean", "prod", "min", "max", "var"]
     for f in funcs:
         g._cython_agg_general(f, alt=None, numeric_only=True)
 
@@ -85,6 +87,10 @@ def test_custom_grouper(index):
     result = g.agg(np.sum)
     tm.assert_series_equal(result, expect)
 
+
+def test_custom_grouper_df(index):
+    b = Grouper(freq=Minute(5), closed="right", label="right")
+    dti = index
     df = DataFrame(np.random.rand(len(dti), 10), index=dti, dtype="float64")
     r = df.groupby(b).agg(np.sum)
 
@@ -408,25 +414,28 @@ def test_resample_upsampling_picked_but_not_correct():
     tm.assert_series_equal(result2, expected)
 
 
-def test_resample_frame_basic():
+@pytest.mark.parametrize("f", ["sum", "mean", "prod", "min", "max", "var"])
+def test_resample_frame_basic_cy_funcs(f):
     df = tm.makeTimeDataFrame()
 
     b = Grouper(freq="M")
     g = df.groupby(b)
 
     # check all cython functions work
-    funcs = ["add", "mean", "prod", "min", "max", "var"]
-    for f in funcs:
-        g._cython_agg_general(f, alt=None, numeric_only=True)
+    g._cython_agg_general(f, alt=None, numeric_only=True)
 
-    result = df.resample("A").mean()
-    tm.assert_series_equal(result["A"], df["A"].resample("A").mean())
 
-    result = df.resample("M").mean()
-    tm.assert_series_equal(result["A"], df["A"].resample("M").mean())
+@pytest.mark.parametrize("freq", ["A", "M"])
+def test_resample_frame_basic_M_A(freq):
+    df = tm.makeTimeDataFrame()
+    result = df.resample(freq).mean()
+    tm.assert_series_equal(result["A"], df["A"].resample(freq).mean())
+
 
-    df.resample("M", kind="period").mean()
-    df.resample("W-WED", kind="period").mean()
+@pytest.mark.parametrize("freq", ["W-WED", "M"])
+def test_resample_frame_basic_kind(freq):
+    df = tm.makeTimeDataFrame()
+    df.resample(freq, kind="period").mean()
 
 
 def test_resample_upsample():
@@ -541,6 +550,8 @@ def test_resample_ohlc_result():
     b = s.loc[:"4-14-2000"].resample("30T").ohlc()
     assert isinstance(b, DataFrame)
 
+
+def test_resample_ohlc_result_odd_period():
     # GH12348
     # raising on odd period
     rng = date_range("2013-12-30", "2014-01-07")
@@ -631,27 +642,20 @@ def test_resample_reresample():
     assert result.index.freq == offsets.Hour(8)
 
 
-def test_resample_timestamp_to_period(simple_date_range_series):
+@pytest.mark.parametrize(
+    "freq, expected_kwargs",
+    [
+        ["A-DEC", {"start": "1990", "end": "2000", "freq": "a-dec"}],
+        ["A-JUN", {"start": "1990", "end": "2000", "freq": "a-jun"}],
+        ["M", {"start": "1990-01", "end": "2000-01", "freq": "M"}],
+    ],
+)
+def test_resample_timestamp_to_period(simple_date_range_series, freq, expected_kwargs):
     ts = simple_date_range_series("1/1/1990", "1/1/2000")
 
-    result = ts.resample("A-DEC", kind="period").mean()
-    expected = ts.resample("A-DEC").mean()
-    expected.index = period_range("1990", "2000", freq="a-dec")
-    tm.assert_series_equal(result, expected)
-
-    result = ts.resample("A-JUN", kind="period").mean()
-    expected = ts.resample("A-JUN").mean()
-    expected.index = period_range("1990", "2000", freq="a-jun")
-    tm.assert_series_equal(result, expected)
-
-    result = ts.resample("M", kind="period").mean()
-    expected = ts.resample("M").mean()
-    expected.index = period_range("1990-01", "2000-01", freq="M")
-    tm.assert_series_equal(result, expected)
-
-    result = ts.resample("M", kind="period").mean()
-    expected = ts.resample("M").mean()
-    expected.index = period_range("1990-01", "2000-01", freq="M")
+    result = ts.resample(freq, kind="period").mean()
+    expected = ts.resample(freq).mean()
+    expected.index = period_range(**expected_kwargs)
     tm.assert_series_equal(result, expected)
 
 
@@ -709,7 +713,8 @@ def test_resample_axis1():
     tm.assert_frame_equal(result, expected)
 
 
-def test_resample_anchored_ticks():
+@pytest.mark.parametrize("freq", ["t", "5t", "15t", "30t", "4h", "12h"])
+def test_resample_anchored_ticks(freq):
     # If a fixed delta (5 minute, 4 hour) evenly divides a day, we should
     # "anchor" the origin at midnight so we get regular intervals rather
     # than starting from the first timestamp which might start in the
@@ -718,25 +723,21 @@ def test_resample_anchored_ticks():
     rng = date_range("1/1/2000 04:00:00", periods=86400, freq="s")
     ts = Series(np.random.randn(len(rng)), index=rng)
     ts[:2] = np.nan  # so results are the same
-
-    freqs = ["t", "5t", "15t", "30t", "4h", "12h"]
-    for freq in freqs:
-        result = ts[2:].resample(freq, closed="left", label="left").mean()
-        expected = ts.resample(freq, closed="left", label="left").mean()
-        tm.assert_series_equal(result, expected)
+    result = ts[2:].resample(freq, closed="left", label="left").mean()
+    expected = ts.resample(freq, closed="left", label="left").mean()
+    tm.assert_series_equal(result, expected)
 
 
-def test_resample_single_group():
+@pytest.mark.parametrize("end", [1, 2])
+def test_resample_single_group(end):
     mysum = lambda x: x.sum()
 
-    rng = date_range("2000-1-1", "2000-2-10", freq="D")
+    rng = date_range("2000-1-1", f"2000-{end}-10", freq="D")
     ts = Series(np.random.randn(len(rng)), index=rng)
     tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
 
-    rng = date_range("2000-1-1", "2000-1-10", freq="D")
-    ts = Series(np.random.randn(len(rng)), index=rng)
-    tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
 
+def test_resample_single_group_std():
     # GH 3849
     s = Series(
         [30.1, 31.6],
@@ -758,28 +759,25 @@ def test_resample_offset():
     tm.assert_index_equal(resampled.index, exp_rng)
 
 
-def test_resample_origin():
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"origin": "1999-12-31 23:57:00"},
+        {"origin": Timestamp("1970-01-01 00:02:00")},
+        {"origin": "epoch", "offset": "2m"},
+        # origin of '1999-31-12 12:02:00' should be equivalent for this case
+        {"origin": "1999-12-31 12:02:00"},
+        {"offset": "-3m"},
+    ],
+)
+def test_resample_origin(kwargs):
     # GH 31809
     rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s")
     ts = Series(np.random.randn(len(rng)), index=rng)
 
     exp_rng = date_range("1999-12-31 23:57:00", "2000-01-01 01:57", freq="5min")
 
-    resampled = ts.resample("5min", origin="1999-12-31 23:57:00").mean()
-    tm.assert_index_equal(resampled.index, exp_rng)
-
-    offset_timestamp = Timestamp(0) + Timedelta("2min")
-    resampled = ts.resample("5min", origin=offset_timestamp).mean()
-    tm.assert_index_equal(resampled.index, exp_rng)
-
-    resampled = ts.resample("5min", origin="epoch", offset="2m").mean()
-    tm.assert_index_equal(resampled.index, exp_rng)
-
-    # origin of '1999-31-12 12:02:00' should be equivalent for this case
-    resampled = ts.resample("5min", origin="1999-12-31 12:02:00").mean()
-    tm.assert_index_equal(resampled.index, exp_rng)
-
-    resampled = ts.resample("5min", offset="-3m").mean()
+    resampled = ts.resample("5min", **kwargs).mean()
     tm.assert_index_equal(resampled.index, exp_rng)
 
 
@@ -1117,16 +1115,14 @@ def test_resample_anchored_intraday(simple_date_range_series):
     assert len(resampled) == 1
 
 
-def test_resample_anchored_monthstart(simple_date_range_series):
+@pytest.mark.parametrize("freq", ["MS", "BMS", "QS-MAR", "AS-DEC", "AS-JUN"])
+def test_resample_anchored_monthstart(simple_date_range_series, freq):
     ts = simple_date_range_series("1/1/2000", "12/31/2002")
+    ts.resample(freq).mean()
 
-    freqs = ["MS", "BMS", "QS-MAR", "AS-DEC", "AS-JUN"]
 
-    for freq in freqs:
-        ts.resample(freq).mean()
-
-
-def test_resample_anchored_multiday():
+@pytest.mark.parametrize("label, sec", [[None, 2.0], ["right", "4.2"]])
+def test_resample_anchored_multiday(label, sec):
     # When resampling a range spanning multiple days, ensure that the
     # start date gets used to determine the offset.  Fixes issue where
     # a one day period is not a multiple of the frequency.
@@ -1140,15 +1136,11 @@ def test_resample_anchored_multiday():
     s = Series(np.random.randn(5), index=index)
 
     # Ensure left closing works
-    result = s.resample("2200L").mean()
-    assert result.index[-1] == Timestamp("2014-10-15 23:00:02.000")
-
-    # Ensure right closing works
-    result = s.resample("2200L", label="right").mean()
-    assert result.index[-1] == Timestamp("2014-10-15 23:00:04.200")
+    result = s.resample("2200L", label=label).mean()
+    assert result.index[-1] == Timestamp(f"2014-10-15 23:00:{sec}00")
 
 
-def test_corner_cases(simple_period_range_series, simple_date_range_series):
+def test_corner_cases():
     # miscellaneous test coverage
 
     rng = date_range("1/1/2000", periods=12, freq="t")
@@ -1158,11 +1150,16 @@ def test_corner_cases(simple_period_range_series, simple_date_range_series):
     ex_index = date_range("1999-12-31 23:55", periods=4, freq="5t")
     tm.assert_index_equal(result.index, ex_index)
 
+
+def test_corner_cases_period(simple_period_range_series):
+    # miscellaneous test coverage
     len0pts = simple_period_range_series("2007-01", "2010-05", freq="M")[:0]
     # it works
     result = len0pts.resample("A-DEC").mean()
     assert len(result) == 0
 
+
+def test_corner_cases_date(simple_date_range_series):
     # resample to periods
     ts = simple_date_range_series("2000-04-28", "2000-04-30 11:00", freq="h")
     result = ts.resample("M", kind="period").mean()
@@ -1198,25 +1195,34 @@ def test_resample_not_monotonic():
     tm.assert_series_equal(result, exp)
 
 
-def test_resample_median_bug_1688():
-
-    for dtype in ["int64", "int32", "float64", "float32"]:
-        df = DataFrame(
-            [1, 2],
-            index=[datetime(2012, 1, 1, 0, 0, 0), datetime(2012, 1, 1, 0, 5, 0)],
-            dtype=dtype,
-        )
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        "int64",
+        "int32",
+        "float64",
+        pytest.param(
+            "float32",
+            marks=pytest.mark.xfail(
+                reason="Empty groups cause x.mean() to return float64"
+            ),
+        ),
+    ],
+)
+def test_resample_median_bug_1688(dtype):
+    df = DataFrame(
+        [1, 2],
+        index=[datetime(2012, 1, 1, 0, 0, 0), datetime(2012, 1, 1, 0, 5, 0)],
+        dtype=dtype,
+    )
 
-        result = df.resample("T").apply(lambda x: x.mean())
-        exp = df.asfreq("T")
-        if dtype == "float32":
-            # TODO: Empty groups cause x.mean() to return float64
-            exp = exp.astype("float64")
-        tm.assert_frame_equal(result, exp)
+    result = df.resample("T").apply(lambda x: x.mean())
+    exp = df.asfreq("T")
+    tm.assert_frame_equal(result, exp)
 
-        result = df.resample("T").median()
-        exp = df.asfreq("T")
-        tm.assert_frame_equal(result, exp)
+    result = df.resample("T").median()
+    exp = df.asfreq("T")
+    tm.assert_frame_equal(result, exp)
 
 
 def test_how_lambda_functions(simple_date_range_series):
@@ -1282,51 +1288,52 @@ def test_resample_consistency():
     tm.assert_series_equal(s10_2, rl)
 
 
-def test_resample_timegrouper():
-    # GH 7227
-    dates1 = [
-        datetime(2014, 10, 1),
-        datetime(2014, 9, 3),
-        datetime(2014, 11, 5),
-        datetime(2014, 9, 5),
-        datetime(2014, 10, 8),
-        datetime(2014, 7, 15),
-    ]
+dates1: List[DatetimeNaTType] = [
+    datetime(2014, 10, 1),
+    datetime(2014, 9, 3),
+    datetime(2014, 11, 5),
+    datetime(2014, 9, 5),
+    datetime(2014, 10, 8),
+    datetime(2014, 7, 15),
+]
 
-    dates2 = dates1[:2] + [pd.NaT] + dates1[2:4] + [pd.NaT] + dates1[4:]
-    dates3 = [pd.NaT] + dates1 + [pd.NaT]
+dates2: List[DatetimeNaTType] = (
+    dates1[:2] + [pd.NaT] + dates1[2:4] + [pd.NaT] + dates1[4:]
+)
+dates3 = [pd.NaT] + dates1 + [pd.NaT]  # type: ignore[operator]
 
-    for dates in [dates1, dates2, dates3]:
-        df = DataFrame({"A": dates, "B": np.arange(len(dates))})
-        result = df.set_index("A").resample("M").count()
-        exp_idx = DatetimeIndex(
-            ["2014-07-31", "2014-08-31", "2014-09-30", "2014-10-31", "2014-11-30"],
-            freq="M",
-            name="A",
-        )
-        expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx)
-        if df["A"].isna().any():
-            expected.index = expected.index._with_freq(None)
-        tm.assert_frame_equal(result, expected)
 
-        result = df.groupby(Grouper(freq="M", key="A")).count()
-        tm.assert_frame_equal(result, expected)
+@pytest.mark.parametrize("dates", [dates1, dates2, dates3])
+def test_resample_timegrouper(dates):
+    # GH 7227
+    df = DataFrame({"A": dates, "B": np.arange(len(dates))})
+    result = df.set_index("A").resample("M").count()
+    exp_idx = DatetimeIndex(
+        ["2014-07-31", "2014-08-31", "2014-09-30", "2014-10-31", "2014-11-30"],
+        freq="M",
+        name="A",
+    )
+    expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx)
+    if df["A"].isna().any():
+        expected.index = expected.index._with_freq(None)
+    tm.assert_frame_equal(result, expected)
 
-        df = DataFrame(
-            {"A": dates, "B": np.arange(len(dates)), "C": np.arange(len(dates))}
-        )
-        result = df.set_index("A").resample("M").count()
-        expected = DataFrame(
-            {"B": [1, 0, 2, 2, 1], "C": [1, 0, 2, 2, 1]},
-            index=exp_idx,
-            columns=["B", "C"],
-        )
-        if df["A"].isna().any():
-            expected.index = expected.index._with_freq(None)
-        tm.assert_frame_equal(result, expected)
+    result = df.groupby(Grouper(freq="M", key="A")).count()
+    tm.assert_frame_equal(result, expected)
+
+    df = DataFrame({"A": dates, "B": np.arange(len(dates)), "C": np.arange(len(dates))})
+    result = df.set_index("A").resample("M").count()
+    expected = DataFrame(
+        {"B": [1, 0, 2, 2, 1], "C": [1, 0, 2, 2, 1]},
+        index=exp_idx,
+        columns=["B", "C"],
+    )
+    if df["A"].isna().any():
+        expected.index = expected.index._with_freq(None)
+    tm.assert_frame_equal(result, expected)
 
-        result = df.groupby(Grouper(freq="M", key="A")).count()
-        tm.assert_frame_equal(result, expected)
+    result = df.groupby(Grouper(freq="M", key="A")).count()
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_nunique():
@@ -1370,20 +1377,26 @@ def test_resample_nunique_preserves_column_level_names():
     tm.assert_index_equal(df.columns, result.columns)
 
 
-def test_resample_nunique_with_date_gap():
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda x: x.nunique(),
+        lambda x: x.agg(Series.nunique),
+        lambda x: x.agg("nunique"),
+    ],
+    ids=["nunique", "series_nunique", "nunique_str"],
+)
+def test_resample_nunique_with_date_gap(func):
     # GH 13453
+    # Since all elements are unique, these should all be the same
     index = date_range("1-1-2000", "2-15-2000", freq="h")
     index2 = date_range("4-15-2000", "5-15-2000", freq="h")
     index3 = index.append(index2)
     s = Series(range(len(index3)), index=index3, dtype="int64")
     r = s.resample("M")
-
-    # Since all elements are unique, these should all be the same
-    results = [r.count(), r.nunique(), r.agg(Series.nunique), r.agg("nunique")]
-
-    tm.assert_series_equal(results[0], results[1])
-    tm.assert_series_equal(results[0], results[2])
-    tm.assert_series_equal(results[0], results[3])
+    result = r.count()
+    expected = func(r)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("n", [10000, 100000])
@@ -1595,6 +1608,9 @@ def test_downsample_across_dst_weekly():
     )
     tm.assert_frame_equal(result, expected)
 
+
+def test_downsample_across_dst_weekly_2():
+    # GH 9119, GH 21459
     idx = date_range("2013-04-01", "2013-05-01", tz="Europe/London", freq="H")
     s = Series(index=idx, dtype=np.float64)
     result = s.resample("W").mean()
@@ -1840,15 +1856,11 @@ def test_resample_unsigned_int(any_unsigned_int_numpy_dtype):
     )
     df = df.loc[(df.index < "2000-01-02") | (df.index > "2000-01-03"), :]
 
-    if any_unsigned_int_numpy_dtype == "uint64":
-        with pytest.raises(RuntimeError, match="empty group with uint64_t"):
-            result = df.resample("D").max()
-    else:
-        result = df.resample("D").max()
+    result = df.resample("D").max()
 
-        expected = DataFrame(
-            [1, np.nan, 0],
-            columns=["x"],
-            index=date_range(start="2000-01-01", end="2000-01-03 23", freq="D"),
-        )
-        tm.assert_frame_equal(result, expected)
+    expected = DataFrame(
+        [1, np.nan, 0],
+        columns=["x"],
+        index=date_range(start="2000-01-01", end="2000-01-03 23", freq="D"),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 70d37f83c7f0c..4da1f4c589c56 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -376,35 +376,35 @@ def test_resample_to_timestamps(self, simple_period_range_series):
         expected = ts.to_timestamp(how="start").resample("A-DEC").mean()
         tm.assert_series_equal(result, expected)
 
-    def test_resample_to_quarterly(self, simple_period_range_series):
-        for month in MONTHS:
-            ts = simple_period_range_series("1990", "1992", freq=f"A-{month}")
-            quar_ts = ts.resample(f"Q-{month}").ffill()
-
-            stamps = ts.to_timestamp("D", how="start")
-            qdates = period_range(
-                ts.index[0].asfreq("D", "start"),
-                ts.index[-1].asfreq("D", "end"),
-                freq=f"Q-{month}",
-            )
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_resample_to_quarterly(self, simple_period_range_series, month):
+        ts = simple_period_range_series("1990", "1992", freq=f"A-{month}")
+        quar_ts = ts.resample(f"Q-{month}").ffill()
+
+        stamps = ts.to_timestamp("D", how="start")
+        qdates = period_range(
+            ts.index[0].asfreq("D", "start"),
+            ts.index[-1].asfreq("D", "end"),
+            freq=f"Q-{month}",
+        )
 
-            expected = stamps.reindex(qdates.to_timestamp("D", "s"), method="ffill")
-            expected.index = qdates
+        expected = stamps.reindex(qdates.to_timestamp("D", "s"), method="ffill")
+        expected.index = qdates
 
-            tm.assert_series_equal(quar_ts, expected)
+        tm.assert_series_equal(quar_ts, expected)
 
+    @pytest.mark.parametrize("how", ["start", "end"])
+    def test_resample_to_quarterly_start_end(self, simple_period_range_series, how):
         # conforms, but different month
         ts = simple_period_range_series("1990", "1992", freq="A-JUN")
+        result = ts.resample("Q-MAR", convention=how).ffill()
+        expected = ts.asfreq("Q-MAR", how=how)
+        expected = expected.reindex(result.index, method="ffill")
 
-        for how in ["start", "end"]:
-            result = ts.resample("Q-MAR", convention=how).ffill()
-            expected = ts.asfreq("Q-MAR", how=how)
-            expected = expected.reindex(result.index, method="ffill")
-
-            # .to_timestamp('D')
-            # expected = expected.resample('Q-MAR').ffill()
+        # .to_timestamp('D')
+        # expected = expected.resample('Q-MAR').ffill()
 
-            tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_fill_missing(self):
         rng = PeriodIndex([2000, 2005, 2007, 2009], freq="A")
@@ -611,44 +611,44 @@ def test_resample_bms_2752(self):
         assert res1.index[0] == Timestamp("20000103")
         assert res1.index[0] == res2.index[0]
 
-    # def test_monthly_convention_span(self):
-    #     rng = period_range('2000-01', periods=3, freq='M')
-    #     ts = Series(np.arange(3), index=rng)
-
-    #     # hacky way to get same thing
-    #     exp_index = period_range('2000-01-01', '2000-03-31', freq='D')
-    #     expected = ts.asfreq('D', how='end').reindex(exp_index)
-    #     expected = expected.fillna(method='bfill')
-
-    #     result = ts.resample('D', convention='span').mean()
+    @pytest.mark.xfail(reason="Commented out for more than 3 years. Should this work?")
+    def test_monthly_convention_span(self):
+        rng = period_range("2000-01", periods=3, freq="M")
+        ts = Series(np.arange(3), index=rng)
 
-    #     tm.assert_series_equal(result, expected)
+        # hacky way to get same thing
+        exp_index = period_range("2000-01-01", "2000-03-31", freq="D")
+        expected = ts.asfreq("D", how="end").reindex(exp_index)
+        expected = expected.fillna(method="bfill")
 
-    def test_default_right_closed_label(self):
-        end_freq = ["D", "Q", "M", "D"]
-        end_types = ["M", "A", "Q", "W"]
+        result = ts.resample("D").mean()
 
-        for from_freq, to_freq in zip(end_freq, end_types):
-            idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
-            df = DataFrame(np.random.randn(len(idx), 2), idx)
+        tm.assert_series_equal(result, expected)
 
-            resampled = df.resample(to_freq).mean()
-            tm.assert_frame_equal(
-                resampled, df.resample(to_freq, closed="right", label="right").mean()
-            )
+    @pytest.mark.parametrize(
+        "from_freq, to_freq", [("D", "M"), ("Q", "A"), ("M", "Q"), ("D", "W")]
+    )
+    def test_default_right_closed_label(self, from_freq, to_freq):
+        idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
+        df = DataFrame(np.random.randn(len(idx), 2), idx)
 
-    def test_default_left_closed_label(self):
-        others = ["MS", "AS", "QS", "D", "H"]
-        others_freq = ["D", "Q", "M", "H", "T"]
+        resampled = df.resample(to_freq).mean()
+        tm.assert_frame_equal(
+            resampled, df.resample(to_freq, closed="right", label="right").mean()
+        )
 
-        for from_freq, to_freq in zip(others_freq, others):
-            idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
-            df = DataFrame(np.random.randn(len(idx), 2), idx)
+    @pytest.mark.parametrize(
+        "from_freq, to_freq",
+        [("D", "MS"), ("Q", "AS"), ("M", "QS"), ("H", "D"), ("T", "H")],
+    )
+    def test_default_left_closed_label(self, from_freq, to_freq):
+        idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
+        df = DataFrame(np.random.randn(len(idx), 2), idx)
 
-            resampled = df.resample(to_freq).mean()
-            tm.assert_frame_equal(
-                resampled, df.resample(to_freq, closed="left", label="left").mean()
-            )
+        resampled = df.resample(to_freq).mean()
+        tm.assert_frame_equal(
+            resampled, df.resample(to_freq, closed="left", label="left").mean()
+        )
 
     def test_all_values_single_bin(self):
         # 2070
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index bb49450b8414e..f68a5ed434a36 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs import lib
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -88,9 +90,35 @@ def test_groupby_resample_on_api():
         }
     )
 
-    expected = df.set_index("dates").groupby("key").resample("D").mean()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = df.set_index("dates").groupby("key").resample("D").mean()
+        result = df.groupby("key").resample("D", on="dates").mean()
+    tm.assert_frame_equal(result, expected)
+
 
-    result = df.groupby("key").resample("D", on="dates").mean()
+def test_resample_group_keys():
+    df = DataFrame({"A": 1, "B": 2}, index=date_range("2000", periods=10))
+    g = df.resample("5D")
+    expected = df.copy()
+    with tm.assert_produces_warning(FutureWarning, match="Not prepending group keys"):
+        result = g.apply(lambda x: x)
+    tm.assert_frame_equal(result, expected)
+
+    # no warning
+    g = df.resample("5D", group_keys=False)
+    with tm.assert_produces_warning(None):
+        result = g.apply(lambda x: x)
+    tm.assert_frame_equal(result, expected)
+
+    # no warning, group keys
+    expected.index = pd.MultiIndex.from_arrays(
+        [pd.to_datetime(["2000-01-01", "2000-01-06"]).repeat(5), expected.index]
+    )
+
+    g = df.resample("5D", group_keys=True)
+    with tm.assert_produces_warning(None):
+        result = g.apply(lambda x: x)
     tm.assert_frame_equal(result, expected)
 
 
@@ -142,21 +170,21 @@ def test_attribute_access(test_frame):
     tm.assert_series_equal(r.A.sum(), r["A"].sum())
 
 
-def test_api_compat_before_use():
+@pytest.mark.parametrize("attr", ["groups", "ngroups", "indices"])
+def test_api_compat_before_use(attr):
 
     # make sure that we are setting the binner
     # on these attributes
-    for attr in ["groups", "ngroups", "indices"]:
-        rng = date_range("1/1/2012", periods=100, freq="S")
-        ts = Series(np.arange(len(rng)), index=rng)
-        rs = ts.resample("30s")
+    rng = date_range("1/1/2012", periods=100, freq="S")
+    ts = Series(np.arange(len(rng)), index=rng)
+    rs = ts.resample("30s")
 
-        # before use
-        getattr(rs, attr)
+    # before use
+    getattr(rs, attr)
 
-        # after grouper is initialized is ok
-        rs.mean()
-        getattr(rs, attr)
+    # after grouper is initialized is ok
+    rs.mean()
+    getattr(rs, attr)
 
 
 def tests_skip_nuisance(test_frame):
@@ -169,7 +197,9 @@ def tests_skip_nuisance(test_frame):
     tm.assert_frame_equal(result, expected)
 
     expected = r[["A", "B", "C"]].sum()
-    result = r.sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = r.sum()
     tm.assert_frame_equal(result, expected)
 
 
@@ -242,14 +272,30 @@ def test_combined_up_downsampling_of_irregular():
     tm.assert_series_equal(result, expected)
 
 
-def test_transform():
-
+def test_transform_series():
     r = test_series.resample("20min")
     expected = test_series.groupby(pd.Grouper(freq="20min")).transform("mean")
     result = r.transform("mean")
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.parametrize("on", [None, "date"])
+def test_transform_frame(on):
+    # GH#47079
+    index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
+    index.name = "date"
+    df = DataFrame(np.random.rand(10, 2), columns=list("AB"), index=index)
+    expected = df.groupby(pd.Grouper(freq="20min")).transform("mean")
+    if on == "date":
+        # Move date to being a column; result will then have a RangeIndex
+        expected = expected.reset_index(drop=True)
+        df = df.reset_index()
+
+    r = df.resample("20min", on=on)
+    result = r.transform("mean")
+    tm.assert_frame_equal(result, expected)
+
+
 def test_fillna():
 
     # need to upsample here
@@ -273,15 +319,25 @@ def test_fillna():
         r.fillna(0)
 
 
-def test_apply_without_aggregation():
-
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda x: x.resample("20min", group_keys=False),
+        lambda x: x.groupby(pd.Grouper(freq="20min"), group_keys=False),
+    ],
+    ids=["resample", "groupby"],
+)
+def test_apply_without_aggregation(func):
     # both resample and groupby should work w/o aggregation
-    r = test_series.resample("20min")
-    g = test_series.groupby(pd.Grouper(freq="20min"))
+    t = func(test_series)
+    result = t.apply(lambda x: x)
+    tm.assert_series_equal(result, test_series)
 
-    for t in [g, r]:
-        result = t.apply(lambda x: x)
-        tm.assert_series_equal(result, test_series)
+
+def test_apply_without_aggregation2():
+    grouped = test_series.to_frame(name="foo").resample("20min", group_keys=False)
+    result = grouped["foo"].apply(lambda x: x)
+    tm.assert_series_equal(result, test_series.rename("foo"))
 
 
 def test_agg_consistency():
@@ -350,7 +406,8 @@ def test_agg():
     expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1)
     expected.columns = pd.MultiIndex.from_product([["A", "B"], ["mean", "std"]])
     for t in cases:
-        warn = FutureWarning if t in cases[1:3] else None
+        # In case 2, "date" is an index and a column, so agg still tries to agg
+        warn = FutureWarning if t == cases[2] else None
         with tm.assert_produces_warning(
             warn,
             match=r"\['date'\] did not aggregate successfully",
@@ -387,7 +444,7 @@ def test_agg():
 
     msg = "nested renamer is not supported"
     for t in cases:
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t.aggregate({"A": {"mean": "mean", "sum": "sum"}})
 
     expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
@@ -395,7 +452,7 @@ def test_agg():
         [("A", "mean"), ("A", "sum"), ("B", "mean2"), ("B", "sum2")]
     )
     for t in cases:
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t.aggregate(
                 {
                     "A": {"mean": "mean", "sum": "sum"},
@@ -499,10 +556,10 @@ def test_agg_misc():
 
     # series like aggs
     for t in cases:
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t["A"].agg({"A": ["sum", "std"]})
 
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t["A"].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
 
     # errors
@@ -513,6 +570,20 @@ def test_agg_misc():
             t[["A"]].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
 
 
+@pytest.mark.parametrize(
+    "func", [["min"], ["mean", "max"], {"A": "sum"}, {"A": "prod", "B": "median"}]
+)
+def test_multi_agg_axis_1_raises(func):
+    # GH#46904
+    np.random.seed(1234)
+    index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
+    index.name = "date"
+    df = DataFrame(np.random.rand(10, 2), columns=list("AB"), index=index).T
+    res = df.resample("M", axis=1)
+    with pytest.raises(NotImplementedError, match="axis other than 0 is not supported"):
+        res.agg(func)
+
+
 def test_agg_nested_dicts():
 
     np.random.seed(1234)
@@ -534,17 +605,17 @@ def test_agg_nested_dicts():
 
     msg = "nested renamer is not supported"
     for t in cases:
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t.aggregate({"r1": {"A": ["mean", "sum"]}, "r2": {"B": ["mean", "sum"]}})
 
     for t in cases:
 
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t[["A", "B"]].agg(
                 {"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}}
             )
 
-        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        with pytest.raises(pd.errors.SpecificationError, match=msg):
             t.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
 
 
@@ -606,10 +677,14 @@ def test_selection_api_validation():
 
     exp = df_exp.resample("2D").sum()
     exp.index.name = "date"
-    tm.assert_frame_equal(exp, df.resample("2D", on="date").sum())
+    result = df.resample("2D", on="date").sum()
+    tm.assert_frame_equal(exp, result)
 
     exp.index.name = "d"
-    tm.assert_frame_equal(exp, df.resample("2D", level="d").sum())
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.resample("2D", level="d").sum()
+    tm.assert_frame_equal(exp, result)
 
 
 @pytest.mark.parametrize(
@@ -736,3 +811,151 @@ def test_end_and_end_day_origin(
     )
 
     tm.assert_series_equal(res, expected)
+
+
+@pytest.mark.parametrize(
+    # expected_data is a string when op raises a ValueError
+    "method, numeric_only, expected_data",
+    [
+        ("sum", True, {"num": [25]}),
+        ("sum", False, {"cat": ["cat_1cat_2"], "num": [25]}),
+        ("sum", lib.no_default, {"num": [25]}),
+        ("prod", True, {"num": [100]}),
+        ("prod", False, {"num": [100]}),
+        ("prod", lib.no_default, {"num": [100]}),
+        ("min", True, {"num": [5]}),
+        ("min", False, {"cat": ["cat_1"], "num": [5]}),
+        ("min", lib.no_default, {"cat": ["cat_1"], "num": [5]}),
+        ("max", True, {"num": [20]}),
+        ("max", False, {"cat": ["cat_2"], "num": [20]}),
+        ("max", lib.no_default, {"cat": ["cat_2"], "num": [20]}),
+        ("first", True, {"num": [5]}),
+        ("first", False, {"cat": ["cat_1"], "num": [5]}),
+        ("first", lib.no_default, {"cat": ["cat_1"], "num": [5]}),
+        ("last", True, {"num": [20]}),
+        ("last", False, {"cat": ["cat_2"], "num": [20]}),
+        ("last", lib.no_default, {"cat": ["cat_2"], "num": [20]}),
+        ("mean", True, {"num": [12.5]}),
+        ("mean", False, {"num": [12.5]}),
+        ("mean", lib.no_default, {"num": [12.5]}),
+        ("median", True, {"num": [12.5]}),
+        ("median", False, {"num": [12.5]}),
+        ("median", lib.no_default, {"num": [12.5]}),
+        ("std", True, {"num": [10.606601717798213]}),
+        ("std", False, "could not convert string to float"),
+        ("std", lib.no_default, {"num": [10.606601717798213]}),
+        ("var", True, {"num": [112.5]}),
+        ("var", False, "could not convert string to float"),
+        ("var", lib.no_default, {"num": [112.5]}),
+        ("sem", True, {"num": [7.5]}),
+        ("sem", False, "could not convert string to float"),
+        ("sem", lib.no_default, {"num": [7.5]}),
+    ],
+)
+def test_frame_downsample_method(method, numeric_only, expected_data):
+    # GH#46442 test if `numeric_only` behave as expected for DataFrameGroupBy
+
+    index = date_range("2018-01-01", periods=2, freq="D")
+    expected_index = date_range("2018-12-31", periods=1, freq="Y")
+    df = DataFrame({"cat": ["cat_1", "cat_2"], "num": [5, 20]}, index=index)
+    resampled = df.resample("Y")
+    if numeric_only is lib.no_default:
+        kwargs = {}
+    else:
+        kwargs = {"numeric_only": numeric_only}
+
+    func = getattr(resampled, method)
+    if numeric_only is lib.no_default and method not in (
+        "min",
+        "max",
+        "first",
+        "last",
+        "prod",
+    ):
+        warn = FutureWarning
+        msg = (
+            f"default value of numeric_only in DataFrameGroupBy.{method} is deprecated"
+        )
+    elif method in ("prod", "mean", "median") and numeric_only is not True:
+        warn = FutureWarning
+        msg = f"Dropping invalid columns in DataFrameGroupBy.{method} is deprecated"
+    else:
+        warn = None
+        msg = ""
+    with tm.assert_produces_warning(warn, match=msg):
+        if isinstance(expected_data, str):
+            klass = TypeError if method == "var" else ValueError
+            with pytest.raises(klass, match=expected_data):
+                _ = func(**kwargs)
+        else:
+            result = func(**kwargs)
+            expected = DataFrame(expected_data, index=expected_index)
+            tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method, numeric_only, expected_data",
+    [
+        ("sum", True, ()),
+        ("sum", False, ["cat_1cat_2"]),
+        ("sum", lib.no_default, ["cat_1cat_2"]),
+        ("prod", True, ()),
+        ("prod", False, ()),
+        ("prod", lib.no_default, ()),
+        ("min", True, ()),
+        ("min", False, ["cat_1"]),
+        ("min", lib.no_default, ["cat_1"]),
+        ("max", True, ()),
+        ("max", False, ["cat_2"]),
+        ("max", lib.no_default, ["cat_2"]),
+        ("first", True, ()),
+        ("first", False, ["cat_1"]),
+        ("first", lib.no_default, ["cat_1"]),
+        ("last", True, ()),
+        ("last", False, ["cat_2"]),
+        ("last", lib.no_default, ["cat_2"]),
+    ],
+)
+def test_series_downsample_method(method, numeric_only, expected_data):
+    # GH#46442 test if `numeric_only` behave as expected for SeriesGroupBy
+
+    index = date_range("2018-01-01", periods=2, freq="D")
+    expected_index = date_range("2018-12-31", periods=1, freq="Y")
+    df = Series(["cat_1", "cat_2"], index=index)
+    resampled = df.resample("Y")
+
+    func = getattr(resampled, method)
+    if numeric_only and numeric_only is not lib.no_default:
+        with tm.assert_produces_warning(
+            FutureWarning, match="This will raise a TypeError"
+        ):
+            with pytest.raises(NotImplementedError, match="not implement numeric_only"):
+                func(numeric_only=numeric_only)
+    elif method == "prod":
+        with pytest.raises(TypeError, match="can't multiply sequence by non-int"):
+            func(numeric_only=numeric_only)
+    else:
+        result = func(numeric_only=numeric_only)
+        expected = Series(expected_data, index=expected_index)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("method", ["agg", "apply", "transform"])
+def test_numeric_only_warning_numpy(method):
+    # GH#50538
+    resampled = _test_frame.assign(D="x").resample("H")
+    if method == "transform":
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            getattr(resampled, method)(np.mean)
+        # Ensure users can pass numeric_only
+        result = getattr(resampled, method)(np.mean, numeric_only=True)
+        expected = resampled.transform("mean", numeric_only=True)
+        tm.assert_frame_equal(result, expected)
+    else:
+        msg = "The operation <function mean.*failed"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            getattr(resampled, method)(np.mean)
+        # Ensure users can't pass numeric_only
+        with pytest.raises(TypeError, match="got an unexpected keyword argument"):
+            getattr(resampled, method)(np.mean, numeric_only=True)
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index dab340486cd8c..8aff217cca5c1 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -202,44 +202,51 @@ def test_nearest():
     tm.assert_series_equal(result, expected)
 
 
-def test_methods():
+@pytest.mark.parametrize(
+    "f",
+    [
+        "first",
+        "last",
+        "median",
+        "sem",
+        "sum",
+        "mean",
+        "min",
+        "max",
+        "size",
+        "count",
+        "nearest",
+        "bfill",
+        "ffill",
+        "asfreq",
+        "ohlc",
+    ],
+)
+def test_methods(f):
     g = test_frame.groupby("A")
     r = g.resample("2s")
 
-    for f in ["first", "last", "median", "sem", "sum", "mean", "min", "max"]:
-        result = getattr(r, f)()
-        expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        tm.assert_frame_equal(result, expected)
-
-    for f in ["size"]:
-        result = getattr(r, f)()
-        expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        tm.assert_series_equal(result, expected)
+    result = getattr(r, f)()
+    expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
+    tm.assert_equal(result, expected)
 
-    for f in ["count"]:
-        result = getattr(r, f)()
-        expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        tm.assert_frame_equal(result, expected)
 
+def test_methods_nunique():
     # series only
-    for f in ["nunique"]:
-        result = getattr(r.B, f)()
-        expected = g.B.apply(lambda x: getattr(x.resample("2s"), f)())
-        tm.assert_series_equal(result, expected)
-
-    for f in ["nearest", "bfill", "ffill", "asfreq"]:
-        result = getattr(r, f)()
-        expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        tm.assert_frame_equal(result, expected)
-
-    result = r.ohlc()
-    expected = g.apply(lambda x: x.resample("2s").ohlc())
-    tm.assert_frame_equal(result, expected)
+    g = test_frame.groupby("A")
+    r = g.resample("2s")
+    result = r.B.nunique()
+    expected = g.B.apply(lambda x: x.resample("2s").nunique())
+    tm.assert_series_equal(result, expected)
 
-    for f in ["std", "var"]:
-        result = getattr(r, f)(ddof=1)
-        expected = g.apply(lambda x: getattr(x.resample("2s"), f)(ddof=1))
-        tm.assert_frame_equal(result, expected)
+
+@pytest.mark.parametrize("f", ["std", "var"])
+def test_methods_std_var(f):
+    g = test_frame.groupby("A")
+    r = g.resample("2s")
+    result = getattr(r, f)(ddof=1)
+    expected = g.apply(lambda x: getattr(x.resample("2s"), f)(ddof=1))
+    tm.assert_frame_equal(result, expected)
 
 
 def test_apply():
@@ -401,7 +408,9 @@ def test_resample_groupby_agg():
     df["date"] = pd.to_datetime(df["date"])
 
     resampled = df.groupby("cat").resample("Y", on="date")
-    expected = resampled.sum()
+    msg = "The default value of numeric_only"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = resampled.sum()
     result = resampled.agg({"num": "sum"})
 
     tm.assert_frame_equal(result, expected)
@@ -455,10 +464,36 @@ def test_resample_groupby_agg_object_dtype_all_nan(consolidate):
     expected = DataFrame(
         {
             "key": ["A"] * 3 + ["B"] * 3,
-            "date": pd.to_datetime(["2020-01-01", "2020-01-06", "2020-01-13"] * 2),
             "col1": [0, 5, 12] * 2,
             "col_object": ["val"] * 3 + [np.nan] * 3,
         },
         index=idx,
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_resample_with_list_of_keys():
+    # GH 47362
+    df = DataFrame(
+        data={
+            "date": date_range(start="2016-01-01", periods=8),
+            "group": [0, 0, 0, 0, 1, 1, 1, 1],
+            "val": [1, 7, 5, 2, 3, 10, 5, 1],
+        }
+    )
+    result = df.groupby("group").resample("2D", on="date")[["val"]].mean()
+    expected = DataFrame(
+        data={
+            "val": [4.0, 3.5, 6.5, 3.0],
+        },
+        index=Index(
+            data=[
+                (0, Timestamp("2016-01-01")),
+                (0, Timestamp("2016-01-03")),
+                (1, Timestamp("2016-01-05")),
+                (1, Timestamp("2016-01-07")),
+            ],
+            name=("group", "date"),
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 2e512d74076d3..4498f11d77313 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -81,7 +81,7 @@ def f(df):
     "name, func",
     [
         ("Int64Index", tm.makeIntIndex),
-        ("Index", tm.makeUnicodeIndex),
+        ("Index", tm.makeStringIndex),
         ("Float64Index", tm.makeFloatIndex),
         ("MultiIndex", lambda m: tm.makeCustomIndex(m, 2)),
     ],
@@ -145,16 +145,31 @@ def test_aggregate_normal(resample_method):
     expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
     tm.assert_equal(expected, dt_result)
 
-    # if TimeGrouper is used included, 'nth' doesn't work yet
 
-    """
-    for func in ['nth']:
-        expected = getattr(normal_grouped, func)(3)
-        expected.index = date_range(start='2013-01-01',
-                                    freq='D', periods=5, name='key')
-        dt_result = getattr(dt_grouped, func)(3)
-        tm.assert_frame_equal(expected, dt_result)
-    """
+@pytest.mark.xfail(reason="if TimeGrouper is used included, 'nth' doesn't work yet")
+def test_aggregate_nth():
+    """Check TimeGrouper's aggregation is identical as normal groupby."""
+
+    data = np.random.randn(20, 4)
+    normal_df = DataFrame(data, columns=["A", "B", "C", "D"])
+    normal_df["key"] = [1, 2, 3, 4, 5] * 4
+
+    dt_df = DataFrame(data, columns=["A", "B", "C", "D"])
+    dt_df["key"] = [
+        datetime(2013, 1, 1),
+        datetime(2013, 1, 2),
+        datetime(2013, 1, 3),
+        datetime(2013, 1, 4),
+        datetime(2013, 1, 5),
+    ] * 4
+
+    normal_grouped = normal_df.groupby("key")
+    dt_grouped = dt_df.groupby(Grouper(key="key", freq="D"))
+
+    expected = normal_grouped.nth(3)
+    expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
+    dt_result = dt_grouped.nth(3)
+    tm.assert_frame_equal(expected, dt_result)
 
 
 @pytest.mark.parametrize(
@@ -251,7 +266,7 @@ def test_repr():
     # GH18203
     result = repr(Grouper(key="A", freq="H"))
     expected = (
-        "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, "
+        "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
         "closed='left', label='left', how='mean', "
         "convention='e', origin='start_day')"
     )
@@ -259,7 +274,7 @@ def test_repr():
 
     result = repr(Grouper(key="A", freq="H", origin="2000-01-01"))
     expected = (
-        "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, "
+        "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
         "closed='left', label='left', how='mean', "
         "convention='e', origin=Timestamp('2000-01-01 00:00:00'))"
     )
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index d55dbfca9ebdf..ad1c361373189 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -191,3 +191,17 @@ def test_resample_quantile_timedelta():
         index=pd.date_range("20200101", periods=2, tz="UTC", freq="2D"),
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_resample_closed_right():
+    # GH#45414
+    idx = pd.Index([pd.Timedelta(seconds=120 + i * 30) for i in range(10)])
+    ser = Series(range(10), index=idx)
+    result = ser.resample("T", closed="right", label="right").sum()
+    expected = Series(
+        [0, 3, 7, 11, 15, 9],
+        index=pd.TimedeltaIndex(
+            [pd.Timedelta(seconds=120 + i * 60) for i in range(6)], freq="T"
+        ),
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py
index f36bee9dd8dec..527ec43437469 100644
--- a/pandas/tests/reshape/concat/test_append_common.py
+++ b/pandas/tests/reshape/concat/test_append_common.py
@@ -61,10 +61,7 @@ def _check_expected_dtype(self, obj, label):
         considering not-supported dtypes
         """
         if isinstance(obj, Index):
-            if label == "bool":
-                assert obj.dtype == "object"
-            else:
-                assert obj.dtype == label
+            assert obj.dtype == label
         elif isinstance(obj, Series):
             if label.startswith("period"):
                 assert obj.dtype == "Period[M]"
@@ -73,11 +70,18 @@ def _check_expected_dtype(self, obj, label):
         else:
             raise ValueError
 
-    def test_dtypes(self, item):
+    @pytest.mark.parametrize("box", [Index, Series])
+    def test_dtypes(self, item, box):
         # to confirm test case covers intended dtypes
         typ, vals = item
-        self._check_expected_dtype(Index(vals), typ)
-        self._check_expected_dtype(Series(vals), typ)
+        obj = box(vals)
+        if isinstance(obj, Index):
+            assert obj.dtype == typ
+        elif isinstance(obj, Series):
+            if typ.startswith("period"):
+                assert obj.dtype == "Period[M]"
+            else:
+                assert obj.dtype == typ
 
     def test_concatlike_same_dtypes(self, item):
         # GH 13660
@@ -185,7 +189,7 @@ def test_concatlike_same_dtypes(self, item):
         with pytest.raises(TypeError, match=msg):
             pd.concat([Series(vals1), Series(vals2), vals3])
 
-    def test_concatlike_dtypes_coercion(self, item, item2):
+    def test_concatlike_dtypes_coercion(self, item, item2, request):
         # GH 13660
         typ1, vals1 = item
         typ2, vals2 = item2
@@ -210,9 +214,13 @@ def test_concatlike_dtypes_coercion(self, item, item2):
             # series coerces to numeric based on numpy rule
             # index doesn't because bool is object dtype
             exp_series_dtype = typ2
+            mark = pytest.mark.xfail(reason="GH#39187 casting to object")
+            request.node.add_marker(mark)
             warn = FutureWarning
         elif typ2 == "bool" and typ1 in ("int64", "float64"):
             exp_series_dtype = typ1
+            mark = pytest.mark.xfail(reason="GH#39187 casting to object")
+            request.node.add_marker(mark)
             warn = FutureWarning
         elif (
             typ1 == "datetime64[ns, US/Eastern]"
@@ -229,7 +237,9 @@ def test_concatlike_dtypes_coercion(self, item, item2):
         # ----- Index ----- #
 
         # index.append
-        res = Index(vals1).append(Index(vals2))
+        with tm.assert_produces_warning(warn, match="concatenating bool-dtype"):
+            # GH#39817
+            res = Index(vals1).append(Index(vals2))
         exp = Index(exp_data, dtype=exp_index_dtype)
         tm.assert_index_equal(res, exp)
 
@@ -508,7 +518,7 @@ def test_concat_categorical(self):
         s1 = Series([10, 11, np.nan], dtype="category")
         s2 = Series([np.nan, 1, 3, 2], dtype="category")
 
-        exp = Series([10, 11, np.nan, np.nan, 1, 3, 2], dtype="object")
+        exp = Series([10, 11, np.nan, np.nan, 1, 3, 2], dtype=np.float64)
         tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
         tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
 
@@ -529,12 +539,12 @@ def test_concat_categorical_coercion(self):
         s1 = Series([1, 2, np.nan], dtype="category")
         s2 = Series([2, 1, 2])
 
-        exp = Series([1, 2, np.nan, 2, 1, 2], dtype="object")
+        exp = Series([1, 2, np.nan, 2, 1, 2], dtype=np.float64)
         tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
         tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
 
         # result shouldn't be affected by 1st elem dtype
-        exp = Series([2, 1, 2, 1, 2, np.nan], dtype="object")
+        exp = Series([2, 1, 2, 1, 2, np.nan], dtype=np.float64)
         tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
         tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
 
@@ -554,11 +564,11 @@ def test_concat_categorical_coercion(self):
         s1 = Series([10, 11, np.nan], dtype="category")
         s2 = Series([1, 3, 2])
 
-        exp = Series([10, 11, np.nan, 1, 3, 2], dtype="object")
+        exp = Series([10, 11, np.nan, 1, 3, 2], dtype=np.float64)
         tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
         tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
 
-        exp = Series([1, 3, 2, 10, 11, np.nan], dtype="object")
+        exp = Series([1, 3, 2, 10, 11, np.nan], dtype=np.float64)
         tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
         tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
 
diff --git a/pandas/tests/reshape/concat/test_categorical.py b/pandas/tests/reshape/concat/test_categorical.py
index 5bafd2e8e8503..f00d3b369a94d 100644
--- a/pandas/tests/reshape/concat/test_categorical.py
+++ b/pandas/tests/reshape/concat/test_categorical.py
@@ -238,3 +238,19 @@ def test_categorical_missing_from_one_frame(self):
             index=[0, 1, 2, 0, 1, 2],
         )
         tm.assert_frame_equal(result, expected)
+
+    def test_concat_categorical_same_categories_different_order(self):
+        # https://github.com/pandas-dev/pandas/issues/24845
+
+        c1 = pd.CategoricalIndex(["a", "a"], categories=["a", "b"], ordered=False)
+        c2 = pd.CategoricalIndex(["b", "b"], categories=["b", "a"], ordered=False)
+        c3 = pd.CategoricalIndex(
+            ["a", "a", "b", "b"], categories=["a", "b"], ordered=False
+        )
+
+        df1 = DataFrame({"A": [1, 2]}, index=c1)
+        df2 = DataFrame({"A": [3, 4]}, index=c2)
+
+        result = pd.concat((df1, df2))
+        expected = DataFrame({"A": [1, 2, 3, 4]}, index=c3)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index a7b3c77e6ea0a..4ba231523af14 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -11,7 +11,11 @@
 import numpy as np
 import pytest
 
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+    InvalidIndexError,
+    PerformanceWarning,
+)
+import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
@@ -466,12 +470,12 @@ def __iter__(self):
         tm.assert_frame_equal(concat(CustomIterator2(), ignore_index=True), expected)
 
     def test_concat_order(self):
-        # GH 17344
+        # GH 17344, GH#47331
         dfs = [DataFrame(index=range(3), columns=["a", 1, None])]
-        dfs += [DataFrame(index=range(3), columns=[None, 1, "a"]) for i in range(100)]
+        dfs += [DataFrame(index=range(3), columns=[None, 1, "a"]) for _ in range(100)]
 
         result = concat(dfs, sort=True).columns
-        expected = dfs[0].columns
+        expected = Index([1, "a", None])
         tm.assert_index_equal(result, expected)
 
     def test_concat_different_extension_dtypes_upcasts(self):
@@ -490,6 +494,15 @@ def test_concat_ordered_dict(self):
         result = concat({"First": Series(range(3)), "Another": Series(range(4))})
         tm.assert_series_equal(result, expected)
 
+    def test_concat_duplicate_indices_raise(self):
+        # GH 45888: test raise for concat DataFrames with duplicate indices
+        # https://github.com/pandas-dev/pandas/issues/36263
+        df1 = DataFrame(np.random.randn(5), index=[0, 1, 2, 3, 3], columns=["a"])
+        df2 = DataFrame(np.random.randn(5), index=[0, 1, 2, 2, 4], columns=["b"])
+        msg = "Reindexing only valid with uniquely valued Index objects"
+        with pytest.raises(InvalidIndexError, match=msg):
+            concat([df1, df2], axis=1)
+
 
 @pytest.mark.parametrize("pdt", [Series, DataFrame])
 @pytest.mark.parametrize("dt", np.sctypes["float"])
@@ -541,11 +554,10 @@ def test_concat_sparse():
 
 def test_concat_dense_sparse():
     # GH 30668
-    a = Series(pd.arrays.SparseArray([1, None]), dtype=float)
+    dtype = pd.SparseDtype(np.float64, None)
+    a = Series(pd.arrays.SparseArray([1, None]), dtype=dtype)
     b = Series([1], dtype=float)
-    expected = Series(data=[1, None, 1], index=[0, 1, 0]).astype(
-        pd.SparseDtype(np.float64, None)
-    )
+    expected = Series(data=[1, None, 1], index=[0, 1, 0]).astype(dtype)
     result = concat([a, b], axis=0)
     tm.assert_series_equal(result, expected)
 
@@ -744,3 +756,50 @@ def test_concat_retain_attrs(data):
     df2.attrs = {1: 1}
     df = concat([df1, df2])
     assert df.attrs[1] == 1
+
+
+@td.skip_array_manager_invalid_test
+@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
+@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
+def test_concat_ignore_emtpy_object_float(empty_dtype, df_dtype):
+    # https://github.com/pandas-dev/pandas/issues/45637
+    df = DataFrame({"foo": [1, 2], "bar": [1, 2]}, dtype=df_dtype)
+    empty = DataFrame(columns=["foo", "bar"], dtype=empty_dtype)
+    result = concat([empty, df])
+    expected = df
+    if df_dtype == "int64":
+        # TODO what exact behaviour do we want for integer eventually?
+        if empty_dtype == "float64":
+            expected = df.astype("float64")
+        else:
+            expected = df.astype("object")
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_array_manager_invalid_test
+@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
+@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
+def test_concat_ignore_all_na_object_float(empty_dtype, df_dtype):
+    df = DataFrame({"foo": [1, 2], "bar": [1, 2]}, dtype=df_dtype)
+    empty = DataFrame({"foo": [np.nan], "bar": [np.nan]}, dtype=empty_dtype)
+    result = concat([empty, df], ignore_index=True)
+
+    if df_dtype == "int64":
+        # TODO what exact behaviour do we want for integer eventually?
+        if empty_dtype == "object":
+            df_dtype = "object"
+        else:
+            df_dtype = "float64"
+    expected = DataFrame({"foo": [None, 1, 2], "bar": [None, 1, 2]}, dtype=df_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_array_manager_invalid_test
+def test_concat_ignore_empty_from_reindex():
+    # https://github.com/pandas-dev/pandas/pull/43507#issuecomment-920375856
+    df1 = DataFrame({"a": [1], "b": [pd.Timestamp("2012-01-01")]})
+    df2 = DataFrame({"a": [2]})
+
+    result = concat([df1, df2.reindex(columns=df1.columns)], ignore_index=True)
+    expected = df1 = DataFrame({"a": [1, 2], "b": [pd.Timestamp("2012-01-01"), pd.NaT]})
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/concat/test_dataframe.py b/pandas/tests/reshape/concat/test_dataframe.py
index 01763926c6d89..1018fc2806fee 100644
--- a/pandas/tests/reshape/concat/test_dataframe.py
+++ b/pandas/tests/reshape/concat/test_dataframe.py
@@ -205,3 +205,26 @@ def test_concat_copies(self, axis, order, ignore_index):
         for arr in res._iter_column_arrays():
             for arr2 in df._iter_column_arrays():
                 assert not np.shares_memory(arr, arr2)
+
+    def test_outer_sort_columns(self):
+        # GH#47127
+        df1 = DataFrame({"A": [0], "B": [1], 0: 1})
+        df2 = DataFrame({"A": [100]})
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame({0: [1.0, np.nan], "A": [0, 100], "B": [1.0, np.nan]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_inner_sort_columns(self):
+        # GH#47127
+        df1 = DataFrame({"A": [0], "B": [1], 0: 1})
+        df2 = DataFrame({"A": [100], 0: 2})
+        result = concat([df1, df2], ignore_index=True, join="inner", sort=True)
+        expected = DataFrame({0: [1, 2], "A": [0, 100]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_columns_one_df(self):
+        # GH#47127
+        df1 = DataFrame({"A": [100], 0: 2})
+        result = concat([df1], ignore_index=True, join="inner", sort=True)
+        expected = DataFrame({0: [2], "A": [100]})
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/concat/test_empty.py b/pandas/tests/reshape/concat/test_empty.py
index 82d2a8a2b1fd2..d78337131bb97 100644
--- a/pandas/tests/reshape/concat/test_empty.py
+++ b/pandas/tests/reshape/concat/test_empty.py
@@ -129,10 +129,16 @@ def test_concat_empty_series_dtypes_match_roundtrips(self, dtype):
         result = concat([Series(dtype=dtype), Series(dtype=dtype)])
         assert result.dtype == dtype
 
-    def test_concat_empty_series_dtypes_roundtrips(self):
+    @pytest.mark.parametrize("dtype", ["float64", "int8", "uint8", "m8[ns]", "M8[ns]"])
+    @pytest.mark.parametrize(
+        "dtype2",
+        ["float64", "int8", "uint8", "m8[ns]", "M8[ns]"],
+    )
+    def test_concat_empty_series_dtypes_roundtrips(self, dtype, dtype2):
 
         # round-tripping with self & like self
-        dtypes = map(np.dtype, ["float64", "int8", "uint8", "bool", "m8[ns]", "M8[ns]"])
+        if dtype == dtype2:
+            return
 
         def int_result_type(dtype, dtype2):
             typs = {dtype.kind, dtype2.kind}
@@ -163,14 +169,11 @@ def get_result_type(dtype, dtype2):
                 return result
             return "O"
 
-        for dtype in dtypes:
-            for dtype2 in dtypes:
-                if dtype == dtype2:
-                    continue
-
-                expected = get_result_type(dtype, dtype2)
-                result = concat([Series(dtype=dtype), Series(dtype=dtype2)]).dtype
-                assert result.kind == expected
+        dtype = np.dtype(dtype)
+        dtype2 = np.dtype(dtype2)
+        expected = get_result_type(dtype, dtype2)
+        result = concat([Series(dtype=dtype), Series(dtype=dtype2)]).dtype
+        assert result.kind == expected
 
     def test_concat_empty_series_dtypes_triple(self):
 
diff --git a/pandas/tests/reshape/concat/test_index.py b/pandas/tests/reshape/concat/test_index.py
index 1692446627914..9993700fd0737 100644
--- a/pandas/tests/reshape/concat/test_index.py
+++ b/pandas/tests/reshape/concat/test_index.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import PerformanceWarning
+
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -306,3 +308,149 @@ def test_concat_with_various_multiindex_dtypes(
             result_df = concat((df1, df2), axis=1)
 
         tm.assert_frame_equal(expected_df, result_df)
+
+    def test_concat_multiindex_(self):
+        # GitHub #44786
+        df = DataFrame({"col": ["a", "b", "c"]}, index=["1", "2", "2"])
+        df = concat([df], keys=["X"])
+
+        iterables = [["X"], ["1", "2", "2"]]
+        result_index = df.index
+        expected_index = MultiIndex.from_product(iterables)
+
+        tm.assert_index_equal(result_index, expected_index)
+
+        result_df = df
+        expected_df = DataFrame(
+            {"col": ["a", "b", "c"]}, index=MultiIndex.from_product(iterables)
+        )
+        tm.assert_frame_equal(result_df, expected_df)
+
+    def test_concat_with_key_not_unique(self):
+        # GitHub #46519
+        df1 = DataFrame({"name": [1]})
+        df2 = DataFrame({"name": [2]})
+        df3 = DataFrame({"name": [3]})
+        df_a = concat([df1, df2, df3], keys=["x", "y", "x"])
+        # the warning is caused by indexing unsorted multi-index
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_a = df_a.loc[("x", 0), :]
+
+        df_b = DataFrame(
+            {"name": [1, 2, 3]}, index=Index([("x", 0), ("y", 0), ("x", 0)])
+        )
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_b = df_b.loc[("x", 0)]
+
+        tm.assert_frame_equal(out_a, out_b)
+
+        df1 = DataFrame({"name": ["a", "a", "b"]})
+        df2 = DataFrame({"name": ["a", "b"]})
+        df3 = DataFrame({"name": ["c", "d"]})
+        df_a = concat([df1, df2, df3], keys=["x", "y", "x"])
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_a = df_a.loc[("x", 0), :]
+
+        df_b = DataFrame(
+            {
+                "a": ["x", "x", "x", "y", "y", "x", "x"],
+                "b": [0, 1, 2, 0, 1, 0, 1],
+                "name": list("aababcd"),
+            }
+        ).set_index(["a", "b"])
+        df_b.index.names = [None, None]
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_b = df_b.loc[("x", 0), :]
+
+        tm.assert_frame_equal(out_a, out_b)
+
+    def test_concat_with_duplicated_levels(self):
+        # keyword levels should be unique
+        df1 = DataFrame({"A": [1]}, index=["x"])
+        df2 = DataFrame({"A": [1]}, index=["y"])
+        msg = r"Level values not unique: \['x', 'y', 'y'\]"
+        with pytest.raises(ValueError, match=msg):
+            concat([df1, df2], keys=["x", "y"], levels=[["x", "y", "y"]])
+
+    @pytest.mark.parametrize("levels", [[["x", "y"]], [["x", "y", "y"]]])
+    def test_concat_with_levels_with_none_keys(self, levels):
+        df1 = DataFrame({"A": [1]}, index=["x"])
+        df2 = DataFrame({"A": [1]}, index=["y"])
+        msg = "levels supported only when keys is not None"
+        with pytest.raises(ValueError, match=msg):
+            concat([df1, df2], levels=levels)
+
+    def test_concat_range_index_result(self):
+        # GH#47501
+        df1 = DataFrame({"a": [1, 2]})
+        df2 = DataFrame({"b": [1, 2]})
+
+        result = concat([df1, df2], sort=True, axis=1)
+        expected = DataFrame({"a": [1, 2], "b": [1, 2]})
+        tm.assert_frame_equal(result, expected)
+        expected_index = pd.RangeIndex(0, 2)
+        tm.assert_index_equal(result.index, expected_index, exact=True)
+
+    def test_concat_index_keep_dtype(self):
+        # GH#47329
+        df1 = DataFrame([[0, 1, 1]], columns=Index([1, 2, 3], dtype="object"))
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype="object"))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]], columns=Index([1, 2, 3], dtype="object")
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_index_keep_dtype_ea_numeric(self, any_numeric_ea_dtype):
+        # GH#47329
+        df1 = DataFrame(
+            [[0, 1, 1]], columns=Index([1, 2, 3], dtype=any_numeric_ea_dtype)
+        )
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype=any_numeric_ea_dtype))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]],
+            columns=Index([1, 2, 3], dtype=any_numeric_ea_dtype),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["Int8", "Int16", "Int32"])
+    def test_concat_index_find_common(self, dtype):
+        # GH#47329
+        df1 = DataFrame([[0, 1, 1]], columns=Index([1, 2, 3], dtype=dtype))
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype="Int32"))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]], columns=Index([1, 2, 3], dtype="Int32")
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_axis_1_sort_false_rangeindex(self):
+        # GH 46675
+        s1 = Series(["a", "b", "c"])
+        s2 = Series(["a", "b"])
+        s3 = Series(["a", "b", "c", "d"])
+        s4 = Series([], dtype=object)
+        result = concat(
+            [s1, s2, s3, s4], sort=False, join="outer", ignore_index=False, axis=1
+        )
+        expected = DataFrame(
+            [
+                ["a"] * 3 + [np.nan],
+                ["b"] * 3 + [np.nan],
+                ["c", np.nan] * 2,
+                [np.nan] * 2 + ["d"] + [np.nan],
+            ],
+            dtype=object,
+        )
+        tm.assert_frame_equal(
+            result, expected, check_index_type=True, check_column_type=True
+        )
diff --git a/pandas/tests/reshape/concat/test_sort.py b/pandas/tests/reshape/concat/test_sort.py
index a789dc0f8dc83..e83880625f3d6 100644
--- a/pandas/tests/reshape/concat/test_sort.py
+++ b/pandas/tests/reshape/concat/test_sort.py
@@ -93,6 +93,22 @@ def test_concat_frame_with_sort_false(self):
 
         tm.assert_frame_equal(result, expected)
 
+        # GH 37937
+        df1 = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=[1, 2, 3])
+        df2 = DataFrame({"c": [7, 8, 9], "d": [10, 11, 12]}, index=[3, 1, 6])
+        result = pd.concat([df2, df1], axis=1, sort=False)
+        expected = DataFrame(
+            [
+                [7.0, 10.0, 3.0, 6.0],
+                [8.0, 11.0, 1.0, 4.0],
+                [9.0, 12.0, np.nan, np.nan],
+                [np.nan, np.nan, 2.0, 5.0],
+            ],
+            index=[3, 1, 6, 2],
+            columns=["c", "d", "a", "b"],
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_concat_sort_none_warning(self):
         # GH#41518
         df = DataFrame({1: [1, 2], "a": [3, 4]})
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index a091d072c0911..6e87c221426c1 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -19,11 +19,9 @@
     get_test_data,
 )
 
-a_ = np.array
-
 
 class TestJoin:
-    def setup_method(self, method):
+    def setup_method(self):
         # aggregate multiple columns
         self.df = DataFrame(
             {
@@ -401,7 +399,7 @@ def test_join_inner_multiindex(self, lexsorted_two_level_string_multiindex):
         expected = expected.drop(["first", "second"], axis=1)
         expected.index = joined.index
 
-        assert joined.index.is_monotonic
+        assert joined.index.is_monotonic_increasing
         tm.assert_frame_equal(joined, expected)
 
         # _assert_same_contents(expected, expected2.loc[:, expected.columns])
@@ -555,7 +553,9 @@ def test_mixed_type_join_with_suffix(self):
         df.insert(5, "dt", "foo")
 
         grouped = df.groupby("id")
-        mn = grouped.mean()
+        msg = "The default value of numeric_only"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            mn = grouped.mean()
         cn = grouped.count()
 
         # it works!
@@ -712,6 +712,21 @@ def test_join_datetime_string(self):
         )
         tm.assert_frame_equal(result, expected)
 
+    def test_join_with_categorical_index(self):
+        # GH47812
+        ix = ["a", "b"]
+        id1 = pd.CategoricalIndex(ix, categories=ix)
+        id2 = pd.CategoricalIndex(reversed(ix), categories=reversed(ix))
+
+        df1 = DataFrame({"c1": ix}, index=id1)
+        df2 = DataFrame({"c2": reversed(ix)}, index=id2)
+        result = df1.join(df2)
+        expected = DataFrame(
+            {"c1": ["a", "b"], "c2": ["a", "b"]},
+            index=pd.CategoricalIndex(["a", "b"], categories=["a", "b"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
 
 def _check_join(left, right, result, join_col, how="left", lsuffix="_x", rsuffix="_y"):
 
@@ -722,7 +737,9 @@ def _check_join(left, right, result, join_col, how="left", lsuffix="_x", rsuffix
     left_grouped = left.groupby(join_col)
     right_grouped = right.groupby(join_col)
 
-    for group_key, group in result.groupby(join_col):
+    for group_key, group in result.groupby(
+        join_col if len(join_col) > 1 else join_col[0]
+    ):
         l_joined = _restrict_to_columns(group, left.columns, lsuffix)
         r_joined = _restrict_to_columns(group, right.columns, rsuffix)
 
@@ -881,3 +898,44 @@ def test_join_multiindex_not_alphabetical_categorical(categories, values):
         }
     ).set_index(["first", "second"])
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "left_empty, how, exp",
+    [
+        (False, "left", "left"),
+        (False, "right", "empty"),
+        (False, "inner", "empty"),
+        (False, "outer", "left"),
+        (False, "cross", "empty"),
+        (True, "left", "empty"),
+        (True, "right", "right"),
+        (True, "inner", "empty"),
+        (True, "outer", "right"),
+        (True, "cross", "empty"),
+    ],
+)
+def test_join_empty(left_empty, how, exp):
+
+    left = DataFrame({"A": [2, 1], "B": [3, 4]}, dtype="int64").set_index("A")
+    right = DataFrame({"A": [1], "C": [5]}, dtype="int64").set_index("A")
+
+    if left_empty:
+        left = left.head(0)
+    else:
+        right = right.head(0)
+
+    result = left.join(right, how=how)
+
+    if exp == "left":
+        expected = DataFrame({"A": [2, 1], "B": [3, 4], "C": [np.nan, np.nan]})
+        expected = expected.set_index("A")
+    elif exp == "right":
+        expected = DataFrame({"B": [np.nan], "A": [1], "C": [5]})
+        expected = expected.set_index("A")
+    elif exp == "empty":
+        expected = DataFrame(index=Index([]), columns=["B", "C"], dtype="int64")
+        if how != "cross":
+            expected = expected.rename_axis("A")
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 1249194d3a36d..f172528041fb3 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -118,7 +118,7 @@ def dfs_for_indicator():
 
 
 class TestMerge:
-    def setup_method(self, method):
+    def setup_method(self):
         # aggregate multiple columns
         self.df = DataFrame(
             {
@@ -682,7 +682,7 @@ def _constructor(self):
 
         assert isinstance(result, NotADataFrame)
 
-    def test_join_append_timedeltas(self):
+    def test_join_append_timedeltas(self, using_array_manager):
         # timedelta64 issues with join/merge
         # GH 5695
 
@@ -696,9 +696,11 @@ def test_join_append_timedeltas(self):
             {
                 "d": [datetime(2013, 11, 5, 5, 56), datetime(2013, 11, 5, 5, 56)],
                 "t": [timedelta(0, 22500), timedelta(0, 22500)],
-            },
-            dtype=object,
+            }
         )
+        if using_array_manager:
+            # TODO(ArrayManager) decide on exact casting rules in concat
+            expected = expected.astype(object)
         tm.assert_frame_equal(result, expected)
 
     def test_join_append_timedeltas2(self):
@@ -1717,6 +1719,46 @@ def test_merge_ea_with_string(self, join_type, string_dtype):
         )
         tm.assert_series_equal(merged.dtypes, expected)
 
+    @pytest.mark.parametrize(
+        "left_empty, how, exp",
+        [
+            (False, "left", "left"),
+            (False, "right", "empty"),
+            (False, "inner", "empty"),
+            (False, "outer", "left"),
+            (False, "cross", "empty_cross"),
+            (True, "left", "empty"),
+            (True, "right", "right"),
+            (True, "inner", "empty"),
+            (True, "outer", "right"),
+            (True, "cross", "empty_cross"),
+        ],
+    )
+    def test_merge_empty(self, left_empty, how, exp):
+
+        left = DataFrame({"A": [2, 1], "B": [3, 4]})
+        right = DataFrame({"A": [1], "C": [5]}, dtype="int64")
+
+        if left_empty:
+            left = left.head(0)
+        else:
+            right = right.head(0)
+
+        result = left.merge(right, how=how)
+
+        if exp == "left":
+            expected = DataFrame({"A": [2, 1], "B": [3, 4], "C": [np.nan, np.nan]})
+        elif exp == "right":
+            expected = DataFrame({"B": [np.nan], "A": [1], "C": [5]})
+        elif exp == "empty":
+            expected = DataFrame(columns=["A", "B", "C"], dtype="int64")
+            if left_empty:
+                expected = expected[["B", "A", "C"]]
+        elif exp == "empty_cross":
+            expected = DataFrame(columns=["A_x", "B", "A_y", "C"], dtype="int64")
+
+        tm.assert_frame_equal(result, expected)
+
 
 @pytest.fixture
 def left():
@@ -2153,6 +2195,26 @@ def test_merge_series(on, left_on, right_on, left_index, right_index, nm):
             )
 
 
+def test_merge_series_multilevel():
+    # GH#47946
+    a = DataFrame(
+        {"A": [1, 2, 3, 4]},
+        index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]),
+    )
+    b = Series(
+        [1, 2, 3, 4],
+        index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]),
+        name=("B", "C"),
+    )
+    expected = DataFrame(
+        {"A": [2, 4], ("B", "C"): [1, 3]},
+        index=MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]),
+    )
+    with tm.assert_produces_warning(FutureWarning):
+        result = merge(a, b, on=["outer", "inner"])
+    tm.assert_frame_equal(result, expected)
+
+
 @pytest.mark.parametrize(
     "col1, col2, kwargs, expected_cols",
     [
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index f9310db3123f6..ebf67b0518c65 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -27,17 +27,29 @@ def read_data(self, datapath, name, dedupe=False):
         x.time = to_datetime(x.time)
         return x
 
-    @pytest.fixture(autouse=True)
-    def setup_method(self, datapath):
+    @pytest.fixture
+    def trades(self, datapath):
+        return self.read_data(datapath, "trades.csv")
 
-        self.trades = self.read_data(datapath, "trades.csv")
-        self.quotes = self.read_data(datapath, "quotes.csv", dedupe=True)
-        self.asof = self.read_data(datapath, "asof.csv")
-        self.tolerance = self.read_data(datapath, "tolerance.csv")
-        self.allow_exact_matches = self.read_data(datapath, "allow_exact_matches.csv")
-        self.allow_exact_matches_and_tolerance = self.read_data(
-            datapath, "allow_exact_matches_and_tolerance.csv"
-        )
+    @pytest.fixture
+    def quotes(self, datapath):
+        return self.read_data(datapath, "quotes.csv", dedupe=True)
+
+    @pytest.fixture
+    def asof(self, datapath):
+        return self.read_data(datapath, "asof.csv")
+
+    @pytest.fixture
+    def tolerance(self, datapath):
+        return self.read_data(datapath, "tolerance.csv")
+
+    @pytest.fixture
+    def allow_exact_matches(self, datapath):
+        return self.read_data(datapath, "allow_exact_matches.csv")
+
+    @pytest.fixture
+    def allow_exact_matches_and_tolerance(self, datapath):
+        return self.read_data(datapath, "allow_exact_matches_and_tolerance.csv")
 
     def test_examples1(self):
         """doc-string examples"""
@@ -163,33 +175,28 @@ def test_examples4(self):
         result = merge_asof(left, right, on="a", direction="nearest")
         tm.assert_frame_equal(result, expected)
 
-    def test_basic(self):
+    def test_basic(self, trades, asof, quotes):
 
-        expected = self.asof
-        trades = self.trades
-        quotes = self.quotes
+        expected = asof
 
         result = merge_asof(trades, quotes, on="time", by="ticker")
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_categorical(self):
+    def test_basic_categorical(self, trades, asof, quotes):
 
-        expected = self.asof
-        trades = self.trades.copy()
+        expected = asof
         trades.ticker = trades.ticker.astype("category")
-        quotes = self.quotes.copy()
         quotes.ticker = quotes.ticker.astype("category")
         expected.ticker = expected.ticker.astype("category")
 
         result = merge_asof(trades, quotes, on="time", by="ticker")
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_left_index(self):
+    def test_basic_left_index(self, trades, asof, quotes):
 
         # GH14253
-        expected = self.asof
-        trades = self.trades.set_index("time")
-        quotes = self.quotes
+        expected = asof
+        trades = trades.set_index("time")
 
         result = merge_asof(
             trades, quotes, left_index=True, right_on="time", by="ticker"
@@ -200,77 +207,77 @@ def test_basic_left_index(self):
         expected = expected[result.columns]
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_right_index(self):
+    def test_basic_right_index(self, trades, asof, quotes):
 
-        expected = self.asof
-        trades = self.trades
-        quotes = self.quotes.set_index("time")
+        expected = asof
+        trades = trades
+        quotes = quotes.set_index("time")
 
         result = merge_asof(
             trades, quotes, left_on="time", right_index=True, by="ticker"
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_left_index_right_index(self):
+    def test_basic_left_index_right_index(self, trades, asof, quotes):
 
-        expected = self.asof.set_index("time")
-        trades = self.trades.set_index("time")
-        quotes = self.quotes.set_index("time")
+        expected = asof.set_index("time")
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
 
         result = merge_asof(
             trades, quotes, left_index=True, right_index=True, by="ticker"
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_multi_index(self):
+    def test_multi_index_left(self, trades, quotes):
 
         # MultiIndex is prohibited
-        trades = self.trades.set_index(["time", "price"])
-        quotes = self.quotes.set_index("time")
+        trades = trades.set_index(["time", "price"])
+        quotes = quotes.set_index("time")
         with pytest.raises(MergeError, match="left can only have one index"):
             merge_asof(trades, quotes, left_index=True, right_index=True)
 
-        trades = self.trades.set_index("time")
-        quotes = self.quotes.set_index(["time", "bid"])
+    def test_multi_index_right(self, trades, quotes):
+
+        # MultiIndex is prohibited
+        trades = trades.set_index("time")
+        quotes = quotes.set_index(["time", "bid"])
         with pytest.raises(MergeError, match="right can only have one index"):
             merge_asof(trades, quotes, left_index=True, right_index=True)
 
-    def test_on_and_index(self):
+    def test_on_and_index_left_on(self, trades, quotes):
 
         # "on" parameter and index together is prohibited
-        trades = self.trades.set_index("time")
-        quotes = self.quotes.set_index("time")
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
         msg = 'Can only pass argument "left_on" OR "left_index" not both.'
         with pytest.raises(MergeError, match=msg):
             merge_asof(
                 trades, quotes, left_on="price", left_index=True, right_index=True
             )
 
-        trades = self.trades.set_index("time")
-        quotes = self.quotes.set_index("time")
+    def test_on_and_index_right_on(self, trades, quotes):
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
         msg = 'Can only pass argument "right_on" OR "right_index" not both.'
         with pytest.raises(MergeError, match=msg):
             merge_asof(
                 trades, quotes, right_on="bid", left_index=True, right_index=True
             )
 
-    def test_basic_left_by_right_by(self):
+    def test_basic_left_by_right_by(self, trades, asof, quotes):
 
         # GH14253
-        expected = self.asof
-        trades = self.trades
-        quotes = self.quotes
+        expected = asof
 
         result = merge_asof(
             trades, quotes, on="time", left_by="ticker", right_by="ticker"
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_missing_right_by(self):
+    def test_missing_right_by(self, trades, asof, quotes):
 
-        expected = self.asof
-        trades = self.trades
-        quotes = self.quotes
+        expected = asof
 
         q = quotes[quotes.ticker != "MSFT"]
         result = merge_asof(trades, q, on="time", by="ticker")
@@ -466,7 +473,7 @@ def test_basic2(self, datapath):
         result = merge_asof(trades, quotes, on="time", by="ticker")
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_no_by(self):
+    def test_basic_no_by(self, trades, asof, quotes):
         f = (
             lambda x: x[x.ticker == "MSFT"]
             .drop("ticker", axis=1)
@@ -474,17 +481,14 @@ def test_basic_no_by(self):
         )
 
         # just use a single ticker
-        expected = f(self.asof)
-        trades = f(self.trades)
-        quotes = f(self.quotes)
+        expected = f(asof)
+        trades = f(trades)
+        quotes = f(quotes)
 
         result = merge_asof(trades, quotes, on="time")
         tm.assert_frame_equal(result, expected)
 
-    def test_valid_join_keys(self):
-
-        trades = self.trades
-        quotes = self.quotes
+    def test_valid_join_keys(self, trades, quotes):
 
         msg = r"incompatible merge keys \[1\] .* must be the same type"
 
@@ -497,14 +501,14 @@ def test_valid_join_keys(self):
         with pytest.raises(MergeError, match="can only asof on a key for left"):
             merge_asof(trades, quotes, by="ticker")
 
-    def test_with_duplicates(self, datapath):
+    def test_with_duplicates(self, datapath, trades, quotes):
 
         q = (
-            pd.concat([self.quotes, self.quotes])
+            pd.concat([quotes, quotes])
             .sort_values(["time", "ticker"])
             .reset_index(drop=True)
         )
-        result = merge_asof(self.trades, q, on="time", by="ticker")
+        result = merge_asof(trades, q, on="time", by="ticker")
         expected = self.read_data(datapath, "asof.csv")
         tm.assert_frame_equal(result, expected)
 
@@ -518,10 +522,7 @@ def test_with_duplicates_no_on(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_valid_allow_exact_matches(self):
-
-        trades = self.trades
-        quotes = self.quotes
+    def test_valid_allow_exact_matches(self, trades, quotes):
 
         msg = "allow_exact_matches must be boolean, passed foo"
 
@@ -530,10 +531,7 @@ def test_valid_allow_exact_matches(self):
                 trades, quotes, on="time", by="ticker", allow_exact_matches="foo"
             )
 
-    def test_valid_tolerance(self):
-
-        trades = self.trades
-        quotes = self.quotes
+    def test_valid_tolerance(self, trades, quotes):
 
         # dti
         merge_asof(trades, quotes, on="time", by="ticker", tolerance=Timedelta("1s"))
@@ -580,42 +578,40 @@ def test_valid_tolerance(self):
                 tolerance=-1,
             )
 
-    def test_non_sorted(self):
+    def test_non_sorted(self, trades, quotes):
 
-        trades = self.trades.sort_values("time", ascending=False)
-        quotes = self.quotes.sort_values("time", ascending=False)
+        trades = trades.sort_values("time", ascending=False)
+        quotes = quotes.sort_values("time", ascending=False)
 
         # we require that we are already sorted on time & quotes
-        assert not trades.time.is_monotonic
-        assert not quotes.time.is_monotonic
+        assert not trades.time.is_monotonic_increasing
+        assert not quotes.time.is_monotonic_increasing
         with pytest.raises(ValueError, match="left keys must be sorted"):
             merge_asof(trades, quotes, on="time", by="ticker")
 
-        trades = self.trades.sort_values("time")
-        assert trades.time.is_monotonic
-        assert not quotes.time.is_monotonic
+        trades = trades.sort_values("time")
+        assert trades.time.is_monotonic_increasing
+        assert not quotes.time.is_monotonic_increasing
         with pytest.raises(ValueError, match="right keys must be sorted"):
             merge_asof(trades, quotes, on="time", by="ticker")
 
-        quotes = self.quotes.sort_values("time")
-        assert trades.time.is_monotonic
-        assert quotes.time.is_monotonic
+        quotes = quotes.sort_values("time")
+        assert trades.time.is_monotonic_increasing
+        assert quotes.time.is_monotonic_increasing
 
         # ok, though has dupes
-        merge_asof(trades, self.quotes, on="time", by="ticker")
+        merge_asof(trades, quotes, on="time", by="ticker")
 
     @pytest.mark.parametrize(
-        "tolerance",
+        "tolerance_ts",
         [Timedelta("1day"), datetime.timedelta(days=1)],
         ids=["Timedelta", "datetime.timedelta"],
     )
-    def test_tolerance(self, tolerance):
-
-        trades = self.trades
-        quotes = self.quotes
-
-        result = merge_asof(trades, quotes, on="time", by="ticker", tolerance=tolerance)
-        expected = self.tolerance
+    def test_tolerance(self, tolerance_ts, trades, quotes, tolerance):
+        result = merge_asof(
+            trades, quotes, on="time", by="ticker", tolerance=tolerance_ts
+        )
+        expected = tolerance
         tm.assert_frame_equal(result, expected)
 
     def test_tolerance_forward(self):
@@ -702,11 +698,11 @@ def test_tolerance_float(self):
         result = merge_asof(left, right, on="a", direction="nearest", tolerance=0.5)
         tm.assert_frame_equal(result, expected)
 
-    def test_index_tolerance(self):
+    def test_index_tolerance(self, trades, quotes, tolerance):
         # GH 15135
-        expected = self.tolerance.set_index("time")
-        trades = self.trades.set_index("time")
-        quotes = self.quotes.set_index("time")
+        expected = tolerance.set_index("time")
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
 
         result = merge_asof(
             trades,
@@ -718,12 +714,12 @@ def test_index_tolerance(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_allow_exact_matches(self):
+    def test_allow_exact_matches(self, trades, quotes, allow_exact_matches):
 
         result = merge_asof(
-            self.trades, self.quotes, on="time", by="ticker", allow_exact_matches=False
+            trades, quotes, on="time", by="ticker", allow_exact_matches=False
         )
-        expected = self.allow_exact_matches
+        expected = allow_exact_matches
         tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_forward(self):
@@ -756,17 +752,19 @@ def test_allow_exact_matches_nearest(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_allow_exact_matches_and_tolerance(self):
+    def test_allow_exact_matches_and_tolerance(
+        self, trades, quotes, allow_exact_matches_and_tolerance
+    ):
 
         result = merge_asof(
-            self.trades,
-            self.quotes,
+            trades,
+            quotes,
             on="time",
             by="ticker",
             tolerance=Timedelta("100ms"),
             allow_exact_matches=False,
         )
-        expected = self.allow_exact_matches_and_tolerance
+        expected = allow_exact_matches_and_tolerance
         tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance2(self):
@@ -1224,6 +1222,50 @@ def test_merge_on_nans(self, func, side):
             else:
                 merge_asof(df, df_null, on="a")
 
+    def test_by_nullable(self, any_numeric_ea_dtype):
+        # Note: this test passes if instead of using pd.array we use
+        #  np.array([np.nan, 1]).  Other than that, I (@jbrockmendel)
+        #  have NO IDEA what the expected behavior is.
+        # TODO(GH#32306): may be relevant to the expected behavior here.
+
+        arr = pd.array([pd.NA, 0, 1], dtype=any_numeric_ea_dtype)
+        if arr.dtype.kind in ["i", "u"]:
+            max_val = np.iinfo(arr.dtype.numpy_dtype).max
+        else:
+            max_val = np.finfo(arr.dtype.numpy_dtype).max
+        # set value s.t. (at least for integer dtypes) arr._values_for_argsort
+        #  is not an injection
+        arr[2] = max_val
+
+        left = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["HELLO", "To", "You"],
+                "on_col": [2, 4, 6],
+                "value": ["a", "c", "e"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["WORLD", "Wide", "Web"],
+                "on_col": [1, 2, 6],
+                "value": ["b", "d", "f"],
+            }
+        )
+
+        result = merge_asof(left, right, by=["by_col1", "by_col2"], on="on_col")
+        expected = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["HELLO", "To", "You"],
+                "on_col": [2, 4, 6],
+                "value_x": ["a", "c", "e"],
+            }
+        )
+        expected["value_y"] = np.array([np.nan, np.nan, np.nan], dtype=object)
+        tm.assert_frame_equal(result, expected)
+
     def test_merge_by_col_tz_aware(self):
         # GH 21184
         left = pd.DataFrame(
@@ -1309,6 +1351,7 @@ def test_timedelta_tolerance_nearest(self):
 
         tm.assert_frame_equal(result, expected)
 
+    # TODO: any_int_dtype; causes failures in _get_join_indexers
     def test_int_type_tolerance(self, any_int_numpy_dtype):
         # GH #28870
 
diff --git a/pandas/tests/reshape/merge/test_merge_ordered.py b/pandas/tests/reshape/merge/test_merge_ordered.py
index 0268801c66e1d..1d0d4e3eb554b 100644
--- a/pandas/tests/reshape/merge/test_merge_ordered.py
+++ b/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -9,14 +9,19 @@
 import pandas._testing as tm
 
 
-class TestMergeOrdered:
-    def setup_method(self, method):
-        self.left = DataFrame({"key": ["a", "c", "e"], "lvalue": [1, 2.0, 3]})
+@pytest.fixture
+def left():
+    return DataFrame({"key": ["a", "c", "e"], "lvalue": [1, 2.0, 3]})
+
+
+@pytest.fixture
+def right():
+    return DataFrame({"key": ["b", "c", "d", "f"], "rvalue": [1, 2, 3.0, 4]})
 
-        self.right = DataFrame({"key": ["b", "c", "d", "f"], "rvalue": [1, 2, 3.0, 4]})
 
-    def test_basic(self):
-        result = merge_ordered(self.left, self.right, on="key")
+class TestMergeOrdered:
+    def test_basic(self, left, right):
+        result = merge_ordered(left, right, on="key")
         expected = DataFrame(
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
@@ -27,8 +32,8 @@ def test_basic(self):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_ffill(self):
-        result = merge_ordered(self.left, self.right, on="key", fill_method="ffill")
+    def test_ffill(self, left, right):
+        result = merge_ordered(left, right, on="key", fill_method="ffill")
         expected = DataFrame(
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
@@ -38,13 +43,13 @@ def test_ffill(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_multigroup(self):
-        left = pd.concat([self.left, self.left], ignore_index=True)
+    def test_multigroup(self, left, right):
+        left = pd.concat([left, left], ignore_index=True)
 
         left["group"] = ["a"] * 3 + ["b"] * 3
 
         result = merge_ordered(
-            left, self.right, on="key", left_by="group", fill_method="ffill"
+            left, right, on="key", left_by="group", fill_method="ffill"
         )
         expected = DataFrame(
             {
@@ -58,42 +63,44 @@ def test_multigroup(self):
         tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
         result2 = merge_ordered(
-            self.right, left, on="key", right_by="group", fill_method="ffill"
+            right, left, on="key", right_by="group", fill_method="ffill"
         )
         tm.assert_frame_equal(result, result2.loc[:, result.columns])
 
-        result = merge_ordered(left, self.right, on="key", left_by="group")
+        result = merge_ordered(left, right, on="key", left_by="group")
         assert result["group"].notna().all()
 
-    def test_merge_type(self):
+    def test_merge_type(self, left, right):
         class NotADataFrame(DataFrame):
             @property
             def _constructor(self):
                 return NotADataFrame
 
-        nad = NotADataFrame(self.left)
-        result = nad.merge(self.right, on="key")
+        nad = NotADataFrame(left)
+        result = nad.merge(right, on="key")
 
         assert isinstance(result, NotADataFrame)
 
-    def test_empty_sequence_concat(self):
+    @pytest.mark.parametrize(
+        "df_seq, pattern",
+        [
+            ((), "[Nn]o objects"),
+            ([], "[Nn]o objects"),
+            ({}, "[Nn]o objects"),
+            ([None], "objects.*None"),
+            ([None, None], "objects.*None"),
+        ],
+    )
+    def test_empty_sequence_concat(self, df_seq, pattern):
         # GH 9157
-        empty_pat = "[Nn]o objects"
-        none_pat = "objects.*None"
-        test_cases = [
-            ((), empty_pat),
-            ([], empty_pat),
-            ({}, empty_pat),
-            ([None], none_pat),
-            ([None, None], none_pat),
-        ]
-        for df_seq, pattern in test_cases:
-            with pytest.raises(ValueError, match=pattern):
-                pd.concat(df_seq)
-
-        pd.concat([DataFrame()])
-        pd.concat([None, DataFrame()])
-        pd.concat([DataFrame(), None])
+        with pytest.raises(ValueError, match=pattern):
+            pd.concat(df_seq)
+
+    @pytest.mark.parametrize(
+        "arg", [[DataFrame()], [None, DataFrame()], [DataFrame(), None]]
+    )
+    def test_empty_sequence_concat_ok(self, arg):
+        pd.concat(arg)
 
     def test_doc_example(self):
         left = DataFrame(
diff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py
index b5945f7542077..0dbe45eeb1e82 100644
--- a/pandas/tests/reshape/merge/test_multi.py
+++ b/pandas/tests/reshape/merge/test_multi.py
@@ -93,7 +93,7 @@ def test_merge_on_multikey(self, left, right, join_type):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("sort", [False, True])
-    def test_left_join_multi_index(self, left, right, sort):
+    def test_left_join_multi_index(self, sort):
         icols = ["1st", "2nd", "3rd"]
 
         def bind_cols(df):
diff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py
index cc6eec671ac3a..76448d5942a5a 100644
--- a/pandas/tests/reshape/test_crosstab.py
+++ b/pandas/tests/reshape/test_crosstab.py
@@ -15,66 +15,65 @@
 import pandas._testing as tm
 
 
-class TestCrosstab:
-    def setup_method(self, method):
-        df = DataFrame(
-            {
-                "A": [
-                    "foo",
-                    "foo",
-                    "foo",
-                    "foo",
-                    "bar",
-                    "bar",
-                    "bar",
-                    "bar",
-                    "foo",
-                    "foo",
-                    "foo",
-                ],
-                "B": [
-                    "one",
-                    "one",
-                    "one",
-                    "two",
-                    "one",
-                    "one",
-                    "one",
-                    "two",
-                    "two",
-                    "two",
-                    "one",
-                ],
-                "C": [
-                    "dull",
-                    "dull",
-                    "shiny",
-                    "dull",
-                    "dull",
-                    "shiny",
-                    "shiny",
-                    "dull",
-                    "shiny",
-                    "shiny",
-                    "shiny",
-                ],
-                "D": np.random.randn(11),
-                "E": np.random.randn(11),
-                "F": np.random.randn(11),
-            }
-        )
+@pytest.fixture
+def df():
+    df = DataFrame(
+        {
+            "A": [
+                "foo",
+                "foo",
+                "foo",
+                "foo",
+                "bar",
+                "bar",
+                "bar",
+                "bar",
+                "foo",
+                "foo",
+                "foo",
+            ],
+            "B": [
+                "one",
+                "one",
+                "one",
+                "two",
+                "one",
+                "one",
+                "one",
+                "two",
+                "two",
+                "two",
+                "one",
+            ],
+            "C": [
+                "dull",
+                "dull",
+                "shiny",
+                "dull",
+                "dull",
+                "shiny",
+                "shiny",
+                "dull",
+                "shiny",
+                "shiny",
+                "shiny",
+            ],
+            "D": np.random.randn(11),
+            "E": np.random.randn(11),
+            "F": np.random.randn(11),
+        }
+    )
 
-        self.df = pd.concat([df, df], ignore_index=True)
+    return pd.concat([df, df], ignore_index=True)
 
-    def test_crosstab_single(self):
-        df = self.df
+
+class TestCrosstab:
+    def test_crosstab_single(self, df):
         result = crosstab(df["A"], df["C"])
         expected = df.groupby(["A", "C"]).size().unstack()
         tm.assert_frame_equal(result, expected.fillna(0).astype(np.int64))
 
-    def test_crosstab_multiple(self):
-        df = self.df
-
+    def test_crosstab_multiple(self, df):
         result = crosstab(df["A"], [df["B"], df["C"]])
         expected = df.groupby(["A", "B", "C"]).size()
         expected = expected.unstack("B").unstack("C").fillna(0).astype(np.int64)
diff --git a/pandas/tests/reshape/test_cut.py b/pandas/tests/reshape/test_cut.py
index 1425686f027e4..3b9ab6a83a575 100644
--- a/pandas/tests/reshape/test_cut.py
+++ b/pandas/tests/reshape/test_cut.py
@@ -14,6 +14,7 @@
     Timestamp,
     cut,
     date_range,
+    interval_range,
     isna,
     qcut,
     timedelta_range,
@@ -734,3 +735,12 @@ def test_cut_with_timestamp_tuple_labels():
 
     expected = Categorical.from_codes([0, 1, 2], labels, ordered=True)
     tm.assert_categorical_equal(result, expected)
+
+
+def test_cut_bins_datetime_intervalindex():
+    # https://github.com/pandas-dev/pandas/issues/46218
+    bins = interval_range(Timestamp("2022-02-25"), Timestamp("2022-02-27"), freq="1D")
+    # passing Series instead of list is important to trigger bug
+    result = cut(Series([Timestamp("2022-02-26")]), bins=bins)
+    expected = Categorical.from_codes([0], bins, ordered=True)
+    tm.assert_categorical_equal(result.array, expected)
diff --git a/pandas/tests/reshape/test_from_dummies.py b/pandas/tests/reshape/test_from_dummies.py
new file mode 100644
index 0000000000000..ab80473725288
--- /dev/null
+++ b/pandas/tests/reshape/test_from_dummies.py
@@ -0,0 +1,398 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    from_dummies,
+    get_dummies,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def dummies_basic():
+    return DataFrame(
+        {
+            "col1_a": [1, 0, 1],
+            "col1_b": [0, 1, 0],
+            "col2_a": [0, 1, 0],
+            "col2_b": [1, 0, 0],
+            "col2_c": [0, 0, 1],
+        },
+    )
+
+
+@pytest.fixture
+def dummies_with_unassigned():
+    return DataFrame(
+        {
+            "col1_a": [1, 0, 0],
+            "col1_b": [0, 1, 0],
+            "col2_a": [0, 1, 0],
+            "col2_b": [0, 0, 0],
+            "col2_c": [0, 0, 1],
+        },
+    )
+
+
+def test_error_wrong_data_type():
+    dummies = [0, 1, 0]
+    with pytest.raises(
+        TypeError,
+        match=r"Expected 'data' to be a 'DataFrame'; Received 'data' of type: list",
+    ):
+        from_dummies(dummies)
+
+
+def test_error_no_prefix_contains_unassigned():
+    dummies = DataFrame({"a": [1, 0, 0], "b": [0, 1, 0]})
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"Dummy DataFrame contains unassigned value\(s\); "
+            r"First instance in row: 2"
+        ),
+    ):
+        from_dummies(dummies)
+
+
+def test_error_no_prefix_wrong_default_category_type():
+    dummies = DataFrame({"a": [1, 0, 1], "b": [0, 1, 1]})
+    with pytest.raises(
+        TypeError,
+        match=(
+            r"Expected 'default_category' to be of type 'None', 'Hashable', or 'dict'; "
+            r"Received 'default_category' of type: list"
+        ),
+    ):
+        from_dummies(dummies, default_category=["c", "d"])
+
+
+def test_error_no_prefix_multi_assignment():
+    dummies = DataFrame({"a": [1, 0, 1], "b": [0, 1, 1]})
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"Dummy DataFrame contains multi-assignment\(s\); "
+            r"First instance in row: 2"
+        ),
+    ):
+        from_dummies(dummies)
+
+
+def test_error_no_prefix_contains_nan():
+    dummies = DataFrame({"a": [1, 0, 0], "b": [0, 1, np.nan]})
+    with pytest.raises(
+        ValueError, match=r"Dummy DataFrame contains NA value in column: 'b'"
+    ):
+        from_dummies(dummies)
+
+
+def test_error_contains_non_dummies():
+    dummies = DataFrame(
+        {"a": [1, 6, 3, 1], "b": [0, 1, 0, 2], "c": ["c1", "c2", "c3", "c4"]}
+    )
+    with pytest.raises(
+        TypeError,
+        match=r"Passed DataFrame contains non-dummy data",
+    ):
+        from_dummies(dummies)
+
+
+def test_error_with_prefix_multiple_seperators():
+    dummies = DataFrame(
+        {
+            "col1_a": [1, 0, 1],
+            "col1_b": [0, 1, 0],
+            "col2-a": [0, 1, 0],
+            "col2-b": [1, 0, 1],
+        },
+    )
+    with pytest.raises(
+        ValueError,
+        match=(r"Separator not specified for column: col2-a"),
+    ):
+        from_dummies(dummies, sep="_")
+
+
+def test_error_with_prefix_sep_wrong_type(dummies_basic):
+
+    with pytest.raises(
+        TypeError,
+        match=(
+            r"Expected 'sep' to be of type 'str' or 'None'; "
+            r"Received 'sep' of type: list"
+        ),
+    ):
+        from_dummies(dummies_basic, sep=["_"])
+
+
+def test_error_with_prefix_contains_unassigned(dummies_with_unassigned):
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"Dummy DataFrame contains unassigned value\(s\); "
+            r"First instance in row: 2"
+        ),
+    ):
+        from_dummies(dummies_with_unassigned, sep="_")
+
+
+def test_error_with_prefix_default_category_wrong_type(dummies_with_unassigned):
+    with pytest.raises(
+        TypeError,
+        match=(
+            r"Expected 'default_category' to be of type 'None', 'Hashable', or 'dict'; "
+            r"Received 'default_category' of type: list"
+        ),
+    ):
+        from_dummies(dummies_with_unassigned, sep="_", default_category=["x", "y"])
+
+
+def test_error_with_prefix_default_category_dict_not_complete(
+    dummies_with_unassigned,
+):
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"Length of 'default_category' \(1\) did not match "
+            r"the length of the columns being encoded \(2\)"
+        ),
+    ):
+        from_dummies(dummies_with_unassigned, sep="_", default_category={"col1": "x"})
+
+
+def test_error_with_prefix_contains_nan(dummies_basic):
+    dummies_basic.loc[2, "col2_c"] = np.nan
+    with pytest.raises(
+        ValueError, match=r"Dummy DataFrame contains NA value in column: 'col2_c'"
+    ):
+        from_dummies(dummies_basic, sep="_")
+
+
+def test_error_with_prefix_contains_non_dummies(dummies_basic):
+    dummies_basic.loc[2, "col2_c"] = "str"
+    with pytest.raises(TypeError, match=r"Passed DataFrame contains non-dummy data"):
+        from_dummies(dummies_basic, sep="_")
+
+
+def test_error_with_prefix_double_assignment():
+    dummies = DataFrame(
+        {
+            "col1_a": [1, 0, 1],
+            "col1_b": [1, 1, 0],
+            "col2_a": [0, 1, 0],
+            "col2_b": [1, 0, 0],
+            "col2_c": [0, 0, 1],
+        },
+    )
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"Dummy DataFrame contains multi-assignment\(s\); "
+            r"First instance in row: 0"
+        ),
+    ):
+        from_dummies(dummies, sep="_")
+
+
+def test_roundtrip_series_to_dataframe():
+    categories = Series(["a", "b", "c", "a"])
+    dummies = get_dummies(categories)
+    result = from_dummies(dummies)
+    expected = DataFrame({"": ["a", "b", "c", "a"]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_roundtrip_single_column_dataframe():
+    categories = DataFrame({"": ["a", "b", "c", "a"]})
+    dummies = get_dummies(categories)
+    result = from_dummies(dummies, sep="_")
+    expected = categories
+    tm.assert_frame_equal(result, expected)
+
+
+def test_roundtrip_with_prefixes():
+    categories = DataFrame({"col1": ["a", "b", "a"], "col2": ["b", "a", "c"]})
+    dummies = get_dummies(categories)
+    result = from_dummies(dummies, sep="_")
+    expected = categories
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_string_cats_basic():
+    dummies = DataFrame({"a": [1, 0, 0, 1], "b": [0, 1, 0, 0], "c": [0, 0, 1, 0]})
+    expected = DataFrame({"": ["a", "b", "c", "a"]})
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_string_cats_basic_bool_values():
+    dummies = DataFrame(
+        {
+            "a": [True, False, False, True],
+            "b": [False, True, False, False],
+            "c": [False, False, True, False],
+        }
+    )
+    expected = DataFrame({"": ["a", "b", "c", "a"]})
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_string_cats_basic_mixed_bool_values():
+    dummies = DataFrame(
+        {"a": [1, 0, 0, 1], "b": [False, True, False, False], "c": [0, 0, 1, 0]}
+    )
+    expected = DataFrame({"": ["a", "b", "c", "a"]})
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_int_cats_basic():
+    dummies = DataFrame(
+        {1: [1, 0, 0, 0], 25: [0, 1, 0, 0], 2: [0, 0, 1, 0], 5: [0, 0, 0, 1]}
+    )
+    expected = DataFrame({"": [1, 25, 2, 5]}, dtype="object")
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_float_cats_basic():
+    dummies = DataFrame(
+        {1.0: [1, 0, 0, 0], 25.0: [0, 1, 0, 0], 2.5: [0, 0, 1, 0], 5.84: [0, 0, 0, 1]}
+    )
+    expected = DataFrame({"": [1.0, 25.0, 2.5, 5.84]}, dtype="object")
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_mixed_cats_basic():
+    dummies = DataFrame(
+        {
+            1.23: [1, 0, 0, 0, 0],
+            "c": [0, 1, 0, 0, 0],
+            2: [0, 0, 1, 0, 0],
+            False: [0, 0, 0, 1, 0],
+            None: [0, 0, 0, 0, 1],
+        }
+    )
+    expected = DataFrame({"": [1.23, "c", 2, False, None]}, dtype="object")
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_no_prefix_string_cats_contains_get_dummies_NaN_column():
+    dummies = DataFrame({"a": [1, 0, 0], "b": [0, 1, 0], "NaN": [0, 0, 1]})
+    expected = DataFrame({"": ["a", "b", "NaN"]})
+    result = from_dummies(dummies)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "default_category, expected",
+    [
+        pytest.param(
+            "c",
+            DataFrame({"": ["a", "b", "c"]}),
+            id="default_category is a str",
+        ),
+        pytest.param(
+            1,
+            DataFrame({"": ["a", "b", 1]}),
+            id="default_category is a int",
+        ),
+        pytest.param(
+            1.25,
+            DataFrame({"": ["a", "b", 1.25]}),
+            id="default_category is a float",
+        ),
+        pytest.param(
+            0,
+            DataFrame({"": ["a", "b", 0]}),
+            id="default_category is a 0",
+        ),
+        pytest.param(
+            False,
+            DataFrame({"": ["a", "b", False]}),
+            id="default_category is a bool",
+        ),
+        pytest.param(
+            (1, 2),
+            DataFrame({"": ["a", "b", (1, 2)]}),
+            id="default_category is a tuple",
+        ),
+    ],
+)
+def test_no_prefix_string_cats_default_category(default_category, expected):
+    dummies = DataFrame({"a": [1, 0, 0], "b": [0, 1, 0]})
+    result = from_dummies(dummies, default_category=default_category)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_with_prefix_basic(dummies_basic):
+    expected = DataFrame({"col1": ["a", "b", "a"], "col2": ["b", "a", "c"]})
+    result = from_dummies(dummies_basic, sep="_")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_with_prefix_contains_get_dummies_NaN_column():
+    dummies = DataFrame(
+        {
+            "col1_a": [1, 0, 0],
+            "col1_b": [0, 1, 0],
+            "col1_NaN": [0, 0, 1],
+            "col2_a": [0, 1, 0],
+            "col2_b": [0, 0, 0],
+            "col2_c": [0, 0, 1],
+            "col2_NaN": [1, 0, 0],
+        },
+    )
+    expected = DataFrame({"col1": ["a", "b", "NaN"], "col2": ["NaN", "a", "c"]})
+    result = from_dummies(dummies, sep="_")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "default_category, expected",
+    [
+        pytest.param(
+            "x",
+            DataFrame({"col1": ["a", "b", "x"], "col2": ["x", "a", "c"]}),
+            id="default_category is a str",
+        ),
+        pytest.param(
+            0,
+            DataFrame({"col1": ["a", "b", 0], "col2": [0, "a", "c"]}),
+            id="default_category is a 0",
+        ),
+        pytest.param(
+            False,
+            DataFrame({"col1": ["a", "b", False], "col2": [False, "a", "c"]}),
+            id="default_category is a False",
+        ),
+        pytest.param(
+            {"col2": 1, "col1": 2.5},
+            DataFrame({"col1": ["a", "b", 2.5], "col2": [1, "a", "c"]}),
+            id="default_category is a dict with int and float values",
+        ),
+        pytest.param(
+            {"col2": None, "col1": False},
+            DataFrame({"col1": ["a", "b", False], "col2": [None, "a", "c"]}),
+            id="default_category is a dict with bool and None values",
+        ),
+        pytest.param(
+            {"col2": (1, 2), "col1": [1.25, False]},
+            DataFrame({"col1": ["a", "b", [1.25, False]], "col2": [(1, 2), "a", "c"]}),
+            id="default_category is a dict with list and tuple values",
+        ),
+    ],
+)
+def test_with_prefix_default_category(
+    dummies_with_unassigned, default_category, expected
+):
+    result = from_dummies(
+        dummies_with_unassigned, sep="_", default_category=default_category
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_get_dummies.py b/pandas/tests/reshape/test_get_dummies.py
index 653ea88ed62ac..6c9a60caaa2be 100644
--- a/pandas/tests/reshape/test_get_dummies.py
+++ b/pandas/tests/reshape/test_get_dummies.py
@@ -196,6 +196,22 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_dataframe_dummies_string_dtype(self, df):
+        # GH44965
+        df = df[["A", "B"]]
+        df = df.astype({"A": "object", "B": "string"})
+        result = get_dummies(df)
+        expected = DataFrame(
+            {
+                "A_a": [1, 0, 1],
+                "A_b": [0, 1, 0],
+                "B_b": [1, 1, 0],
+                "B_c": [0, 0, 1],
+            },
+            dtype=np.uint8,
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_dataframe_dummies_mix_default(self, df, sparse, dtype):
         result = get_dummies(df, sparse=sparse, dtype=dtype)
         if sparse:
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index 8a83cdcbdefb0..2013b3484ebff 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -11,98 +11,111 @@
 import pandas._testing as tm
 
 
-class TestMelt:
-    def setup_method(self, method):
-        self.df = tm.makeTimeDataFrame()[:10]
-        self.df["id1"] = (self.df["A"] > 0).astype(np.int64)
-        self.df["id2"] = (self.df["B"] > 0).astype(np.int64)
-
-        self.var_name = "var"
-        self.value_name = "val"
-
-        self.df1 = DataFrame(
-            [
-                [1.067683, -1.110463, 0.20867],
-                [-1.321405, 0.368915, -1.055342],
-                [-0.807333, 0.08298, -0.873361],
-            ]
-        )
-        self.df1.columns = [list("ABC"), list("abc")]
-        self.df1.columns.names = ["CAP", "low"]
+@pytest.fixture
+def df():
+    res = tm.makeTimeDataFrame()[:10]
+    res["id1"] = (res["A"] > 0).astype(np.int64)
+    res["id2"] = (res["B"] > 0).astype(np.int64)
+    return res
+
+
+@pytest.fixture
+def df1():
+    res = DataFrame(
+        [
+            [1.067683, -1.110463, 0.20867],
+            [-1.321405, 0.368915, -1.055342],
+            [-0.807333, 0.08298, -0.873361],
+        ]
+    )
+    res.columns = [list("ABC"), list("abc")]
+    res.columns.names = ["CAP", "low"]
+    return res
+
 
-    def test_top_level_method(self):
-        result = melt(self.df)
+@pytest.fixture
+def var_name():
+    return "var"
+
+
+@pytest.fixture
+def value_name():
+    return "val"
+
+
+class TestMelt:
+    def test_top_level_method(self, df):
+        result = melt(df)
         assert result.columns.tolist() == ["variable", "value"]
 
-    def test_method_signatures(self):
-        tm.assert_frame_equal(self.df.melt(), melt(self.df))
+    def test_method_signatures(self, df, df1, var_name, value_name):
+        tm.assert_frame_equal(df.melt(), melt(df))
 
         tm.assert_frame_equal(
-            self.df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"]),
-            melt(self.df, id_vars=["id1", "id2"], value_vars=["A", "B"]),
+            df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"]),
+            melt(df, id_vars=["id1", "id2"], value_vars=["A", "B"]),
         )
 
         tm.assert_frame_equal(
-            self.df.melt(var_name=self.var_name, value_name=self.value_name),
-            melt(self.df, var_name=self.var_name, value_name=self.value_name),
+            df.melt(var_name=var_name, value_name=value_name),
+            melt(df, var_name=var_name, value_name=value_name),
         )
 
-        tm.assert_frame_equal(self.df1.melt(col_level=0), melt(self.df1, col_level=0))
+        tm.assert_frame_equal(df1.melt(col_level=0), melt(df1, col_level=0))
 
-    def test_default_col_names(self):
-        result = self.df.melt()
+    def test_default_col_names(self, df):
+        result = df.melt()
         assert result.columns.tolist() == ["variable", "value"]
 
-        result1 = self.df.melt(id_vars=["id1"])
+        result1 = df.melt(id_vars=["id1"])
         assert result1.columns.tolist() == ["id1", "variable", "value"]
 
-        result2 = self.df.melt(id_vars=["id1", "id2"])
+        result2 = df.melt(id_vars=["id1", "id2"])
         assert result2.columns.tolist() == ["id1", "id2", "variable", "value"]
 
-    def test_value_vars(self):
-        result3 = self.df.melt(id_vars=["id1", "id2"], value_vars="A")
+    def test_value_vars(self, df):
+        result3 = df.melt(id_vars=["id1", "id2"], value_vars="A")
         assert len(result3) == 10
 
-        result4 = self.df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"])
+        result4 = df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"])
         expected4 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
             columns=["id1", "id2", "variable", "value"],
         )
         tm.assert_frame_equal(result4, expected4)
 
-    def test_value_vars_types(self):
+    @pytest.mark.parametrize("type_", (tuple, list, np.array))
+    def test_value_vars_types(self, type_, df):
         # GH 15348
         expected = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
             columns=["id1", "id2", "variable", "value"],
         )
+        result = df.melt(id_vars=["id1", "id2"], value_vars=type_(("A", "B")))
+        tm.assert_frame_equal(result, expected)
 
-        for type_ in (tuple, list, np.array):
-            result = self.df.melt(id_vars=["id1", "id2"], value_vars=type_(("A", "B")))
-            tm.assert_frame_equal(result, expected)
-
-    def test_vars_work_with_multiindex(self):
+    def test_vars_work_with_multiindex(self, df1):
         expected = DataFrame(
             {
-                ("A", "a"): self.df1[("A", "a")],
-                "CAP": ["B"] * len(self.df1),
-                "low": ["b"] * len(self.df1),
-                "value": self.df1[("B", "b")],
+                ("A", "a"): df1[("A", "a")],
+                "CAP": ["B"] * len(df1),
+                "low": ["b"] * len(df1),
+                "value": df1[("B", "b")],
             },
             columns=[("A", "a"), "CAP", "low", "value"],
         )
 
-        result = self.df1.melt(id_vars=[("A", "a")], value_vars=[("B", "b")])
+        result = df1.melt(id_vars=[("A", "a")], value_vars=[("B", "b")])
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -135,140 +148,133 @@ def test_vars_work_with_multiindex(self):
         ],
     )
     def test_single_vars_work_with_multiindex(
-        self, id_vars, value_vars, col_level, expected
+        self, id_vars, value_vars, col_level, expected, df1
     ):
-        result = self.df1.melt(id_vars, value_vars, col_level=col_level)
+        result = df1.melt(id_vars, value_vars, col_level=col_level)
         tm.assert_frame_equal(result, expected)
 
-    def test_tuple_vars_fail_with_multiindex(self):
+    @pytest.mark.parametrize(
+        "id_vars, value_vars",
+        [
+            [("A", "a"), [("B", "b")]],
+            [[("A", "a")], ("B", "b")],
+            [("A", "a"), ("B", "b")],
+        ],
+    )
+    def test_tuple_vars_fail_with_multiindex(self, id_vars, value_vars, df1):
         # melt should fail with an informative error message if
         # the columns have a MultiIndex and a tuple is passed
         # for id_vars or value_vars.
-        tuple_a = ("A", "a")
-        list_a = [tuple_a]
-        tuple_b = ("B", "b")
-        list_b = [tuple_b]
-
         msg = r"(id|value)_vars must be a list of tuples when columns are a MultiIndex"
-        for id_vars, value_vars in (
-            (tuple_a, list_b),
-            (list_a, tuple_b),
-            (tuple_a, tuple_b),
-        ):
-            with pytest.raises(ValueError, match=msg):
-                self.df1.melt(id_vars=id_vars, value_vars=value_vars)
+        with pytest.raises(ValueError, match=msg):
+            df1.melt(id_vars=id_vars, value_vars=value_vars)
 
-    def test_custom_var_name(self):
-        result5 = self.df.melt(var_name=self.var_name)
+    def test_custom_var_name(self, df, var_name):
+        result5 = df.melt(var_name=var_name)
         assert result5.columns.tolist() == ["var", "value"]
 
-        result6 = self.df.melt(id_vars=["id1"], var_name=self.var_name)
+        result6 = df.melt(id_vars=["id1"], var_name=var_name)
         assert result6.columns.tolist() == ["id1", "var", "value"]
 
-        result7 = self.df.melt(id_vars=["id1", "id2"], var_name=self.var_name)
+        result7 = df.melt(id_vars=["id1", "id2"], var_name=var_name)
         assert result7.columns.tolist() == ["id1", "id2", "var", "value"]
 
-        result8 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars="A", var_name=self.var_name
-        )
+        result8 = df.melt(id_vars=["id1", "id2"], value_vars="A", var_name=var_name)
         assert result8.columns.tolist() == ["id1", "id2", "var", "value"]
 
-        result9 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars=["A", "B"], var_name=self.var_name
+        result9 = df.melt(
+            id_vars=["id1", "id2"], value_vars=["A", "B"], var_name=var_name
         )
         expected9 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
-                self.var_name: ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
+                var_name: ["A"] * 10 + ["B"] * 10,
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", self.var_name, "value"],
+            columns=["id1", "id2", var_name, "value"],
         )
         tm.assert_frame_equal(result9, expected9)
 
-    def test_custom_value_name(self):
-        result10 = self.df.melt(value_name=self.value_name)
+    def test_custom_value_name(self, df, value_name):
+        result10 = df.melt(value_name=value_name)
         assert result10.columns.tolist() == ["variable", "val"]
 
-        result11 = self.df.melt(id_vars=["id1"], value_name=self.value_name)
+        result11 = df.melt(id_vars=["id1"], value_name=value_name)
         assert result11.columns.tolist() == ["id1", "variable", "val"]
 
-        result12 = self.df.melt(id_vars=["id1", "id2"], value_name=self.value_name)
+        result12 = df.melt(id_vars=["id1", "id2"], value_name=value_name)
         assert result12.columns.tolist() == ["id1", "id2", "variable", "val"]
 
-        result13 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars="A", value_name=self.value_name
+        result13 = df.melt(
+            id_vars=["id1", "id2"], value_vars="A", value_name=value_name
         )
         assert result13.columns.tolist() == ["id1", "id2", "variable", "val"]
 
-        result14 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars=["A", "B"], value_name=self.value_name
+        result14 = df.melt(
+            id_vars=["id1", "id2"], value_vars=["A", "B"], value_name=value_name
         )
         expected14 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                self.value_name: (self.df["A"].tolist() + self.df["B"].tolist()),
+                value_name: (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", "variable", self.value_name],
+            columns=["id1", "id2", "variable", value_name],
         )
         tm.assert_frame_equal(result14, expected14)
 
-    def test_custom_var_and_value_name(self):
+    def test_custom_var_and_value_name(self, df, value_name, var_name):
 
-        result15 = self.df.melt(var_name=self.var_name, value_name=self.value_name)
+        result15 = df.melt(var_name=var_name, value_name=value_name)
         assert result15.columns.tolist() == ["var", "val"]
 
-        result16 = self.df.melt(
-            id_vars=["id1"], var_name=self.var_name, value_name=self.value_name
-        )
+        result16 = df.melt(id_vars=["id1"], var_name=var_name, value_name=value_name)
         assert result16.columns.tolist() == ["id1", "var", "val"]
 
-        result17 = self.df.melt(
-            id_vars=["id1", "id2"], var_name=self.var_name, value_name=self.value_name
+        result17 = df.melt(
+            id_vars=["id1", "id2"], var_name=var_name, value_name=value_name
         )
         assert result17.columns.tolist() == ["id1", "id2", "var", "val"]
 
-        result18 = self.df.melt(
+        result18 = df.melt(
             id_vars=["id1", "id2"],
             value_vars="A",
-            var_name=self.var_name,
-            value_name=self.value_name,
+            var_name=var_name,
+            value_name=value_name,
         )
         assert result18.columns.tolist() == ["id1", "id2", "var", "val"]
 
-        result19 = self.df.melt(
+        result19 = df.melt(
             id_vars=["id1", "id2"],
             value_vars=["A", "B"],
-            var_name=self.var_name,
-            value_name=self.value_name,
+            var_name=var_name,
+            value_name=value_name,
         )
         expected19 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
-                self.var_name: ["A"] * 10 + ["B"] * 10,
-                self.value_name: (self.df["A"].tolist() + self.df["B"].tolist()),
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
+                var_name: ["A"] * 10 + ["B"] * 10,
+                value_name: (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", self.var_name, self.value_name],
+            columns=["id1", "id2", var_name, value_name],
         )
         tm.assert_frame_equal(result19, expected19)
 
-        df20 = self.df.copy()
+        df20 = df.copy()
         df20.columns.name = "foo"
         result20 = df20.melt()
         assert result20.columns.tolist() == ["foo", "value"]
 
-    def test_col_level(self):
-        res1 = self.df1.melt(col_level=0)
-        res2 = self.df1.melt(col_level="CAP")
-        assert res1.columns.tolist() == ["CAP", "value"]
-        assert res2.columns.tolist() == ["CAP", "value"]
+    @pytest.mark.parametrize("col_level", [0, "CAP"])
+    def test_col_level(self, col_level, df1):
+        res = df1.melt(col_level=col_level)
+        assert res.columns.tolist() == ["CAP", "value"]
 
-    def test_multiindex(self):
-        res = self.df1.melt()
+    def test_multiindex(self, df1):
+        res = df1.melt()
         assert res.columns.tolist() == ["CAP", "low", "value"]
 
     @pytest.mark.parametrize(
@@ -633,7 +639,7 @@ def test_pairs(self):
         tm.assert_frame_equal(result, exp)
 
         with tm.assert_produces_warning(FutureWarning):
-            result = lreshape(df, spec, dropna=False, label="foo")
+            lreshape(df, spec, dropna=False, label="foo")
 
         spec = {
             "visitdt": [f"visitdt{i:d}" for i in range(1, 3)],
@@ -1080,3 +1086,27 @@ def test_warn_of_column_name_value(self):
         with tm.assert_produces_warning(FutureWarning):
             result = df.melt(id_vars="value")
             tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["O", "string"])
+    def test_missing_stubname(self, dtype):
+        # GH46044
+        df = DataFrame({"id": ["1", "2"], "a-1": [100, 200], "a-2": [300, 400]})
+        df = df.astype({"id": dtype})
+        result = wide_to_long(
+            df,
+            stubnames=["a", "b"],
+            i="id",
+            j="num",
+            sep="-",
+        )
+        index = pd.Index(
+            [("1", 1), ("2", 1), ("1", 2), ("2", 2)],
+            name=("id", "num"),
+        )
+        expected = DataFrame(
+            {"a": [100, 200, 300, 400], "b": [np.nan] * 4},
+            index=index,
+        )
+        new_level = expected.index.levels[0].astype(dtype)
+        expected.index = expected.index.set_levels(new_level, level=0)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index a023adfb509a0..416ff104b4cae 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -39,7 +39,7 @@ def interval_values(request, closed):
 
 
 class TestPivotTable:
-    def setup_method(self, method):
+    def setup_method(self):
         self.data = DataFrame(
             {
                 "A": [
@@ -146,8 +146,11 @@ def test_pivot_table_nocols(self):
         df = DataFrame(
             {"rows": ["a", "b", "c"], "cols": ["x", "y", "z"], "values": [1, 2, 3]}
         )
-        rs = df.pivot_table(columns="cols", aggfunc=np.sum)
-        xp = df.pivot_table(index="cols", aggfunc=np.sum).T
+        # GH#50538
+        msg = "The operation <function sum.*failed"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = df.pivot_table(columns="cols", aggfunc=np.sum)
+            xp = df.pivot_table(index="cols", aggfunc=np.sum).T
         tm.assert_frame_equal(rs, xp)
 
         rs = df.pivot_table(columns="cols", aggfunc={"values": "mean"})
@@ -260,6 +263,7 @@ def test_pivot_with_non_observable_dropna(self, dropna):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_pivot_with_non_observable_dropna_multi_cat(self, dropna):
         # gh-21378
         df = DataFrame(
             {
@@ -477,9 +481,11 @@ def test_pivot_index_with_nan(self, method):
             }
         )
         if method:
-            result = df.pivot("a", "b", "c")
+            with tm.assert_produces_warning(FutureWarning):
+                result = df.pivot("a", columns="b", values="c")
         else:
-            result = pd.pivot(df, "a", "b", "c")
+            with tm.assert_produces_warning(FutureWarning):
+                result = pd.pivot(df, "a", columns="b", values="c")
         expected = DataFrame(
             [
                 [nan, nan, 17, nan],
@@ -491,8 +497,10 @@ def test_pivot_index_with_nan(self, method):
             columns=Index(["C1", "C2", "C3", "C4"], name="b"),
         )
         tm.assert_frame_equal(result, expected)
-        tm.assert_frame_equal(df.pivot("b", "a", "c"), expected.T)
+        tm.assert_frame_equal(df.pivot(index="b", columns="a", values="c"), expected.T)
 
+    @pytest.mark.parametrize("method", [True, False])
+    def test_pivot_index_with_nan_dates(self, method):
         # GH9491
         df = DataFrame(
             {
@@ -501,22 +509,22 @@ def test_pivot_index_with_nan(self, method):
             }
         )
         df["b"] = df["a"] - pd.Timestamp("2014-02-02")
-        df.loc[1, "a"] = df.loc[3, "a"] = nan
-        df.loc[1, "b"] = df.loc[4, "b"] = nan
+        df.loc[1, "a"] = df.loc[3, "a"] = np.nan
+        df.loc[1, "b"] = df.loc[4, "b"] = np.nan
 
         if method:
-            pv = df.pivot("a", "b", "c")
+            pv = df.pivot(index="a", columns="b", values="c")
         else:
-            pv = pd.pivot(df, "a", "b", "c")
+            pv = pd.pivot(df, index="a", columns="b", values="c")
         assert pv.notna().values.sum() == len(df)
 
         for _, row in df.iterrows():
             assert pv.loc[row["a"], row["b"]] == row["c"]
 
         if method:
-            result = df.pivot("b", "a", "c")
+            result = df.pivot(index="b", columns="a", values="c")
         else:
-            result = pd.pivot(df, "b", "a", "c")
+            result = pd.pivot(df, index="b", columns="a", values="c")
         tm.assert_frame_equal(result, pv.T)
 
     @pytest.mark.filterwarnings("ignore:Timestamp.freq is deprecated:FutureWarning")
@@ -851,33 +859,31 @@ def test_pivot_with_tuple_of_values(self, method):
             else:
                 pd.pivot(df, index="zoo", columns="foo", values=("bar", "baz"))
 
-    def test_margins(self):
-        def _check_output(
-            result, values_col, index=["A", "B"], columns=["C"], margins_col="All"
-        ):
-            col_margins = result.loc[result.index[:-1], margins_col]
-            expected_col_margins = self.data.groupby(index)[values_col].mean()
-            tm.assert_series_equal(col_margins, expected_col_margins, check_names=False)
-            assert col_margins.name == margins_col
-
-            result = result.sort_index()
-            index_margins = result.loc[(margins_col, "")].iloc[:-1]
-
-            expected_ix_margins = self.data.groupby(columns)[values_col].mean()
-            tm.assert_series_equal(
-                index_margins, expected_ix_margins, check_names=False
-            )
-            assert index_margins.name == (margins_col, "")
+    def _check_output(
+        self, result, values_col, index=["A", "B"], columns=["C"], margins_col="All"
+    ):
+        col_margins = result.loc[result.index[:-1], margins_col]
+        expected_col_margins = self.data.groupby(index)[values_col].mean()
+        tm.assert_series_equal(col_margins, expected_col_margins, check_names=False)
+        assert col_margins.name == margins_col
 
-            grand_total_margins = result.loc[(margins_col, ""), margins_col]
-            expected_total_margins = self.data[values_col].mean()
-            assert grand_total_margins == expected_total_margins
+        result = result.sort_index()
+        index_margins = result.loc[(margins_col, "")].iloc[:-1]
 
+        expected_ix_margins = self.data.groupby(columns)[values_col].mean()
+        tm.assert_series_equal(index_margins, expected_ix_margins, check_names=False)
+        assert index_margins.name == (margins_col, "")
+
+        grand_total_margins = result.loc[(margins_col, ""), margins_col]
+        expected_total_margins = self.data[values_col].mean()
+        assert grand_total_margins == expected_total_margins
+
+    def test_margins(self):
         # column specified
         result = self.data.pivot_table(
             values="D", index=["A", "B"], columns="C", margins=True, aggfunc=np.mean
         )
-        _check_output(result, "D")
+        self._check_output(result, "D")
 
         # Set a different margins_name (not 'All')
         result = self.data.pivot_table(
@@ -888,25 +894,35 @@ def _check_output(
             aggfunc=np.mean,
             margins_name="Totals",
         )
-        _check_output(result, "D", margins_col="Totals")
+        self._check_output(result, "D", margins_col="Totals")
 
         # no column specified
         table = self.data.pivot_table(
             index=["A", "B"], columns="C", margins=True, aggfunc=np.mean
         )
         for value_col in table.columns.levels[0]:
-            _check_output(table[value_col], value_col)
+            self._check_output(table[value_col], value_col)
 
+    def test_no_col(self):
         # no col
 
         # to help with a buglet
         self.data.columns = [k * 2 for k in self.data.columns]
-        table = self.data.pivot_table(index=["AA", "BB"], margins=True, aggfunc=np.mean)
+        # GH#50538
+        msg = "The operation <function mean.*failed"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            table = self.data.pivot_table(
+                index=["AA", "BB"], margins=True, aggfunc=np.mean
+            )
         for value_col in table.columns:
             totals = table.loc[("All", ""), value_col]
             assert totals == self.data[value_col].mean()
 
-        table = self.data.pivot_table(index=["AA", "BB"], margins=True, aggfunc="mean")
+        msg = "pivot_table dropped a column because it failed to aggregate"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            table = self.data.pivot_table(
+                index=["AA", "BB"], margins=True, aggfunc="mean"
+            )
         for item in ["DD", "EE", "FF"]:
             totals = table.loc[("All", ""), item]
             assert totals == self.data[item].mean()
@@ -962,7 +978,13 @@ def test_margin_with_only_columns_defined(
             }
         )
 
-        result = df.pivot_table(columns=columns, margins=True, aggfunc=aggfunc)
+        if aggfunc == "sum":
+            msg = "pivot_table dropped a column because it failed to aggregate"
+        else:
+            # GH#50538
+            msg = "The operation <function mean.*failed"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.pivot_table(columns=columns, margins=True, aggfunc=aggfunc)
         expected = DataFrame(values, index=Index(["D", "E"]), columns=expected_columns)
 
         tm.assert_frame_equal(result, expected)
@@ -1121,7 +1143,7 @@ def test_pivot_columns_lexsorted(self):
             aggfunc="mean",
         )
 
-        assert pivoted.columns.is_monotonic
+        assert pivoted.columns.is_monotonic_increasing
 
     def test_pivot_complex_aggfunc(self):
         f = {"D": ["std"], "E": ["sum"]}
@@ -1353,6 +1375,7 @@ def test_pivot_timegrouper(self, using_array_manager):
                 aggfunc=np.sum,
             )
 
+    def test_pivot_timegrouper_double(self):
         # double grouper
         df = DataFrame(
             {
@@ -1633,7 +1656,8 @@ def test_pivot_dtaccessor(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_daily(self):
+    @pytest.mark.parametrize("i", range(1, 367))
+    def test_daily(self, i):
         rng = date_range("1/1/2000", "12/31/2004", freq="D")
         ts = Series(np.random.randn(len(rng)), index=rng)
 
@@ -1644,15 +1668,15 @@ def test_daily(self):
 
         doy = np.asarray(ts.index.dayofyear)
 
-        for i in range(1, 367):
-            subset = ts[doy == i]
-            subset.index = subset.index.year
+        subset = ts[doy == i]
+        subset.index = subset.index.year
 
-            result = annual[i].dropna()
-            tm.assert_series_equal(result, subset, check_names=False)
-            assert result.name == i
+        result = annual[i].dropna()
+        tm.assert_series_equal(result, subset, check_names=False)
+        assert result.name == i
 
-    def test_monthly(self):
+    @pytest.mark.parametrize("i", range(1, 13))
+    def test_monthly(self, i):
         rng = date_range("1/1/2000", "12/31/2004", freq="M")
         ts = Series(np.random.randn(len(rng)), index=rng)
 
@@ -1660,12 +1684,11 @@ def test_monthly(self):
         annual.columns = annual.columns.droplevel(0)
 
         month = ts.index.month
-        for i in range(1, 13):
-            subset = ts[month == i]
-            subset.index = subset.index.year
-            result = annual[i].dropna()
-            tm.assert_series_equal(result, subset, check_names=False)
-            assert result.name == i
+        subset = ts[month == i]
+        subset.index = subset.index.year
+        result = annual[i].dropna()
+        tm.assert_series_equal(result, subset, check_names=False)
+        assert result.name == i
 
     def test_pivot_table_with_iterator_values(self):
         # GH 12017
@@ -1755,7 +1778,7 @@ def test_categorical_margins_category(self, observed, request):
         table = df.pivot_table("x", "y", "z", dropna=observed, margins=True)
         tm.assert_frame_equal(table, expected)
 
-    def test_margins_casted_to_float(self, observed):
+    def test_margins_casted_to_float(self):
         # GH 24893
         df = DataFrame(
             {
@@ -1987,8 +2010,11 @@ def test_pivot_string_as_func(self):
     def test_pivot_string_func_vs_func(self, f, f_numpy):
         # GH #18713
         # for consistency purposes
-        result = pivot_table(self.data, index="A", columns="B", aggfunc=f)
-        expected = pivot_table(self.data, index="A", columns="B", aggfunc=f_numpy)
+
+        msg = "pivot_table dropped a column because it failed to aggregate"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = pivot_table(self.data, index="A", columns="B", aggfunc=f)
+            expected = pivot_table(self.data, index="A", columns="B", aggfunc=f_numpy)
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.slow
@@ -1996,7 +2022,7 @@ def test_pivot_number_of_levels_larger_than_int32(self, monkeypatch):
         # GH 20601
         # GH 26314: Change ValueError to PerformanceWarning
         class MockUnstacker(reshape_lib._Unstacker):
-            def __init__(self, *args, **kwargs):
+            def __init__(self, *args, **kwargs) -> None:
                 # __init__ will raise the warning
                 super().__init__(*args, **kwargs)
                 raise Exception("Don't compute final result.")
@@ -2004,7 +2030,7 @@ def __init__(self, *args, **kwargs):
         with monkeypatch.context() as m:
             m.setattr(reshape_lib, "_Unstacker", MockUnstacker)
             df = DataFrame(
-                {"ind1": np.arange(2 ** 16), "ind2": np.arange(2 ** 16), "count": 0}
+                {"ind1": np.arange(2**16), "ind2": np.arange(2**16), "count": 0}
             )
 
             msg = "The following operation may generate"
@@ -2164,6 +2190,28 @@ def test_pivot_table_sort_false(self):
         )
         tm.assert_frame_equal(result, expected)
 
+    def test_pivot_table_sort_false_with_multiple_values(self):
+        df = DataFrame(
+            {
+                "firstname": ["John", "Michael"],
+                "lastname": ["Foo", "Bar"],
+                "height": [173, 182],
+                "age": [47, 33],
+            }
+        )
+        result = df.pivot_table(
+            index=["lastname", "firstname"], values=["height", "age"], sort=False
+        )
+        expected = DataFrame(
+            [[173, 47], [182, 33]],
+            columns=["height", "age"],
+            index=MultiIndex.from_tuples(
+                [("Foo", "John"), ("Bar", "Michael")],
+                names=["lastname", "firstname"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_pivot_table_with_margins_and_numeric_columns(self):
         # GH 26568
         df = DataFrame([["a", "x", 1], ["a", "y", 2], ["b", "y", 3], ["b", "z", 4]])
@@ -2181,6 +2229,122 @@ def test_pivot_table_with_margins_and_numeric_columns(self):
 
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize("dropna", [True, False])
+    def test_pivot_ea_dtype_dropna(self, dropna):
+        # GH#47477
+        df = DataFrame({"x": "a", "y": "b", "age": Series([20, 40], dtype="Int64")})
+        result = df.pivot_table(
+            index="x", columns="y", values="age", aggfunc="mean", dropna=dropna
+        )
+        expected = DataFrame(
+            [[30]],
+            index=Index(["a"], name="x"),
+            columns=Index(["b"], name="y"),
+            dtype="Float64",
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_pivot_table_datetime_warning(self):
+        # GH#48683
+        df = DataFrame(
+            {
+                "a": "A",
+                "b": [1, 2],
+                "date": pd.Timestamp("2019-12-31"),
+                "sales": [10.0, 11],
+            }
+        )
+        with tm.assert_produces_warning(None):
+            result = df.pivot_table(
+                index=["b", "date"], columns="a", margins=True, aggfunc="sum"
+            )
+        expected = DataFrame(
+            [[10.0, 10.0], [11.0, 11.0], [21.0, 21.0]],
+            index=MultiIndex.from_arrays(
+                [
+                    Index([1, 2, "All"], name="b"),
+                    Index(
+                        [pd.Timestamp("2019-12-31"), pd.Timestamp("2019-12-31"), ""],
+                        dtype=object,
+                        name="date",
+                    ),
+                ]
+            ),
+            columns=MultiIndex.from_tuples(
+                [("sales", "A"), ("sales", "All")], names=[None, "a"]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_pivot_table_with_mixed_nested_tuples(self, using_array_manager):
+        # GH 50342
+        df = DataFrame(
+            {
+                "A": ["foo", "foo", "foo", "foo", "foo", "bar", "bar", "bar", "bar"],
+                "B": ["one", "one", "one", "two", "two", "one", "one", "two", "two"],
+                "C": [
+                    "small",
+                    "large",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                ],
+                "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+                "E": [2, 4, 5, 5, 6, 6, 8, 9, 9],
+                ("col5",): [
+                    "foo",
+                    "foo",
+                    "foo",
+                    "foo",
+                    "foo",
+                    "bar",
+                    "bar",
+                    "bar",
+                    "bar",
+                ],
+                ("col6", 6): [
+                    "one",
+                    "one",
+                    "one",
+                    "two",
+                    "two",
+                    "one",
+                    "one",
+                    "two",
+                    "two",
+                ],
+                (7, "seven"): [
+                    "small",
+                    "large",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                ],
+            }
+        )
+        result = pivot_table(
+            df, values="D", index=["A", "B"], columns=[(7, "seven")], aggfunc=np.sum
+        )
+        expected = DataFrame(
+            [[4.0, 5.0], [7.0, 6.0], [4.0, 1.0], [np.nan, 6.0]],
+            columns=Index(["large", "small"], name=(7, "seven")),
+            index=MultiIndex.from_arrays(
+                [["bar", "bar", "foo", "foo"], ["one", "two"] * 2], names=["A", "B"]
+            ),
+        )
+        if using_array_manager:
+            # INFO(ArrayManager) column without NaNs can preserve int dtype
+            expected["small"] = expected["small"].astype("int64")
+        tm.assert_frame_equal(result, expected)
+
 
 class TestPivot:
     def test_pivot(self):
@@ -2221,11 +2385,11 @@ def test_pivot_duplicates(self):
             }
         )
         with pytest.raises(ValueError, match="duplicate entries"):
-            data.pivot("a", "b", "c")
+            data.pivot(index="a", columns="b", values="c")
 
     def test_pivot_empty(self):
         df = DataFrame(columns=["a", "b", "c"])
-        result = df.pivot("a", "b", "c")
+        result = df.pivot(index="a", columns="b", values="c")
         expected = DataFrame()
         tm.assert_frame_equal(result, expected, check_names=False)
 
diff --git a/pandas/tests/reshape/test_union_categoricals.py b/pandas/tests/reshape/test_union_categoricals.py
index f39b5de2478b0..7505d69aee134 100644
--- a/pandas/tests/reshape/test_union_categoricals.py
+++ b/pandas/tests/reshape/test_union_categoricals.py
@@ -13,9 +13,9 @@
 
 
 class TestUnionCategoricals:
-    def test_union_categorical(self):
-        # GH 13361
-        data = [
+    @pytest.mark.parametrize(
+        "a, b, combined",
+        [
             (list("abc"), list("abd"), list("abcabd")),
             ([0, 1, 2], [2, 3, 4], [0, 1, 2, 2, 3, 4]),
             ([0, 1.2, 2], [2, 3.4, 4], [0, 1.2, 2, 2, 3.4, 4]),
@@ -39,14 +39,16 @@ def test_union_categorical(self):
                 pd.period_range("2014-01-06", "2014-01-07"),
                 pd.period_range("2014-01-01", "2014-01-07"),
             ),
-        ]
-
-        for a, b, combined in data:
-            for box in [Categorical, CategoricalIndex, Series]:
-                result = union_categoricals([box(Categorical(a)), box(Categorical(b))])
-                expected = Categorical(combined)
-                tm.assert_categorical_equal(result, expected)
+        ],
+    )
+    @pytest.mark.parametrize("box", [Categorical, CategoricalIndex, Series])
+    def test_union_categorical(self, a, b, combined, box):
+        # GH 13361
+        result = union_categoricals([box(Categorical(a)), box(Categorical(b))])
+        expected = Categorical(combined)
+        tm.assert_categorical_equal(result, expected)
 
+    def test_union_categorical_ordered_appearance(self):
         # new categories ordered by appearance
         s = Categorical(["x", "y", "z"])
         s2 = Categorical(["a", "b", "c"])
@@ -56,12 +58,14 @@ def test_union_categorical(self):
         )
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categorical_ordered_true(self):
         s = Categorical([0, 1.2, 2], ordered=True)
         s2 = Categorical([0, 1.2, 2], ordered=True)
         result = union_categoricals([s, s2])
         expected = Categorical([0, 1.2, 2, 0, 1.2, 2], ordered=True)
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categorical_match_types(self):
         # must exactly match types
         s = Categorical([0, 1.2, 2])
         s2 = Categorical([2, 3, 4])
@@ -69,6 +73,7 @@ def test_union_categorical(self):
         with pytest.raises(TypeError, match=msg):
             union_categoricals([s, s2])
 
+    def test_union_categorical_empty(self):
         msg = "No Categoricals to union"
         with pytest.raises(ValueError, match=msg):
             union_categoricals([])
@@ -117,14 +122,11 @@ def test_union_categoricals_nan(self):
         exp = Categorical([np.nan, np.nan, np.nan, np.nan])
         tm.assert_categorical_equal(res, exp)
 
-    def test_union_categoricals_empty(self):
+    @pytest.mark.parametrize("val", [[], ["1"]])
+    def test_union_categoricals_empty(self, val):
         # GH 13759
-        res = union_categoricals([Categorical([]), Categorical([])])
-        exp = Categorical([])
-        tm.assert_categorical_equal(res, exp)
-
-        res = union_categoricals([Categorical([]), Categorical(["1"])])
-        exp = Categorical(["1"])
+        res = union_categoricals([Categorical([]), Categorical(val)])
+        exp = Categorical(val)
         tm.assert_categorical_equal(res, exp)
 
     def test_union_categorical_same_category(self):
@@ -135,6 +137,7 @@ def test_union_categorical_same_category(self):
         exp = Categorical([1, 2, 3, 4, 3, 2, 1, np.nan], categories=[1, 2, 3, 4])
         tm.assert_categorical_equal(res, exp)
 
+    def test_union_categorical_same_category_str(self):
         c1 = Categorical(["z", "z", "z"], categories=["x", "y", "z"])
         c2 = Categorical(["x", "x", "x"], categories=["x", "y", "z"])
         res = union_categoricals([c1, c2])
@@ -293,6 +296,7 @@ def test_union_categoricals_sort_false(self):
         )
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_fastpath(self):
         # fastpath
         c1 = Categorical(["a", "b"], categories=["b", "a", "c"])
         c2 = Categorical(["b", "c"], categories=["b", "a", "c"])
@@ -300,6 +304,7 @@ def test_union_categoricals_sort_false(self):
         expected = Categorical(["a", "b", "b", "c"], categories=["b", "a", "c"])
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_skipresort(self):
         # fastpath - skip resort
         c1 = Categorical(["a", "b"], categories=["a", "b", "c"])
         c2 = Categorical(["b", "c"], categories=["a", "b", "c"])
@@ -307,24 +312,28 @@ def test_union_categoricals_sort_false(self):
         expected = Categorical(["a", "b", "b", "c"], categories=["a", "b", "c"])
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_one_nan(self):
         c1 = Categorical(["x", np.nan])
         c2 = Categorical([np.nan, "b"])
         result = union_categoricals([c1, c2], sort_categories=False)
         expected = Categorical(["x", np.nan, np.nan, "b"], categories=["x", "b"])
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_only_nan(self):
         c1 = Categorical([np.nan])
         c2 = Categorical([np.nan])
         result = union_categoricals([c1, c2], sort_categories=False)
         expected = Categorical([np.nan, np.nan])
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_empty(self):
         c1 = Categorical([])
         c2 = Categorical([])
         result = union_categoricals([c1, c2], sort_categories=False)
         expected = Categorical([])
         tm.assert_categorical_equal(result, expected)
 
+    def test_union_categoricals_sort_false_ordered_true(self):
         c1 = Categorical(["b", "a"], categories=["b", "a", "c"], ordered=True)
         c2 = Categorical(["a", "c"], categories=["b", "a", "c"], ordered=True)
         result = union_categoricals([c1, c2], sort_categories=False)
diff --git a/pandas/tests/reshape/test_util.py b/pandas/tests/reshape/test_util.py
index 1ebe96a8b5a8d..3a9ddaebf2934 100644
--- a/pandas/tests/reshape/test_util.py
+++ b/pandas/tests/reshape/test_util.py
@@ -44,17 +44,16 @@ def test_tzaware_retained_categorical(self):
         expected = x.repeat(2)
         tm.assert_index_equal(result1, expected)
 
-    def test_empty(self):
+    @pytest.mark.parametrize("x, y", [[[], []], [[0, 1], []], [[], ["a", "b", "c"]]])
+    def test_empty(self, x, y):
         # product of empty factors
-        X = [[], [0, 1], []]
-        Y = [[], [], ["a", "b", "c"]]
-        for x, y in zip(X, Y):
-            expected1 = np.array([], dtype=np.asarray(x).dtype)
-            expected2 = np.array([], dtype=np.asarray(y).dtype)
-            result1, result2 = cartesian_product([x, y])
-            tm.assert_numpy_array_equal(result1, expected1)
-            tm.assert_numpy_array_equal(result2, expected2)
+        expected1 = np.array([], dtype=np.asarray(x).dtype)
+        expected2 = np.array([], dtype=np.asarray(y).dtype)
+        result1, result2 = cartesian_product([x, y])
+        tm.assert_numpy_array_equal(result1, expected1)
+        tm.assert_numpy_array_equal(result2, expected2)
 
+    def test_empty_input(self):
         # empty product (empty input):
         result = cartesian_product([])
         expected = []
diff --git a/pandas/tests/scalar/interval/test_arithmetic.py b/pandas/tests/scalar/interval/test_arithmetic.py
index 987f7d53afacc..863446c64de42 100644
--- a/pandas/tests/scalar/interval/test_arithmetic.py
+++ b/pandas/tests/scalar/interval/test_arithmetic.py
@@ -52,7 +52,7 @@ def test_numeric_interval_add_timedelta_raises(interval, delta):
 
 
 @pytest.mark.parametrize("klass", [timedelta, np.timedelta64, Timedelta])
-def test_timdelta_add_timestamp_interval(klass):
+def test_timedelta_add_timestamp_interval(klass):
     delta = klass(0)
     expected = Interval(Timestamp("2020-01-01"), Timestamp("2020-02-01"))
 
diff --git a/pandas/tests/scalar/interval/test_interval.py b/pandas/tests/scalar/interval/test_interval.py
index 1f76a7df1e996..192aaacbac2b5 100644
--- a/pandas/tests/scalar/interval/test_interval.py
+++ b/pandas/tests/scalar/interval/test_interval.py
@@ -36,11 +36,7 @@ def test_contains(self, interval):
         assert 1 in interval
         assert 0 not in interval
 
-        msg = "__contains__ not defined for two intervals"
-        with pytest.raises(TypeError, match=msg):
-            interval in interval
-
-        interval_both = Interval(0, 1, closed="both")
+        interval_both = Interval(0, 1, "both")
         assert 0 in interval_both
         assert 1 in interval_both
 
diff --git a/pandas/tests/scalar/interval/test_ops.py b/pandas/tests/scalar/interval/test_ops.py
index 9fe40c208d880..92db6ac772830 100644
--- a/pandas/tests/scalar/interval/test_ops.py
+++ b/pandas/tests/scalar/interval/test_ops.py
@@ -66,3 +66,54 @@ def test_overlaps_invalid_type(self, other):
         msg = f"`other` must be an Interval, got {type(other).__name__}"
         with pytest.raises(TypeError, match=msg):
             interval.overlaps(other)
+
+
+class TestContains:
+    def test_contains_interval(self, inclusive_endpoints_fixture):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(0, 1, inclusive_endpoints_fixture)
+        assert interval1 in interval1
+        assert interval2 in interval2
+        assert interval2 in interval1
+        assert interval1 not in interval2 or inclusive_endpoints_fixture == "both"
+
+    def test_contains_infinite_length(self):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(float("-inf"), float("inf"), "neither")
+        assert interval1 in interval2
+        assert interval2 not in interval1
+
+    def test_contains_zero_length(self):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(-1, -1, "both")
+        interval3 = Interval(0.5, 0.5, "both")
+        assert interval2 not in interval1
+        assert interval3 in interval1
+        assert interval2 not in interval3 and interval3 not in interval2
+        assert interval1 not in interval2 and interval1 not in interval3
+
+    @pytest.mark.parametrize(
+        "type1",
+        [
+            (0, 1),
+            (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)),
+            (Timedelta("0h"), Timedelta("1h")),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "type2",
+        [
+            (0, 1),
+            (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)),
+            (Timedelta("0h"), Timedelta("1h")),
+        ],
+    )
+    def test_contains_mixed_types(self, type1, type2):
+        interval1 = Interval(*type1)
+        interval2 = Interval(*type2)
+        if type1 == type2:
+            assert interval1 in interval2
+        else:
+            msg = "^'<=' not supported between instances of"
+            with pytest.raises(TypeError, match=msg):
+                interval1 in interval2
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 7d437f3b47274..c9e28f8249c1b 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -113,6 +113,21 @@ def test_construction(self):
         with pytest.raises(TypeError, match="pass as a string instead"):
             Period("1982", freq=("Min", 1))
 
+    def test_construction_from_timestamp_nanos(self):
+        # GH#46811 don't drop nanos from Timestamp
+        ts = Timestamp("2022-04-20 09:23:24.123456789")
+        per = Period(ts, freq="ns")
+
+        # should losslessly round-trip, not lose the 789
+        rt = per.to_timestamp()
+        assert rt == ts
+
+        # same thing but from a datetime64 object
+        dt64 = ts.asm8
+        per2 = Period(dt64, freq="ns")
+        rt2 = per2.to_timestamp()
+        assert rt2.asm8 == dt64
+
     def test_construction_bday(self):
 
         # Biz day construction, roll forward if non-weekday
@@ -286,7 +301,7 @@ def test_invalid_arguments(self):
         with pytest.raises(ValueError, match=msg):
             Period(month=1)
 
-        msg = "Given date string not likely a datetime"
+        msg = "Given date string -2000 not likely a datetime"
         with pytest.raises(ValueError, match=msg):
             Period("-2000", "A")
         msg = "day is out of range for month"
@@ -324,8 +339,10 @@ def test_constructor_infer_freq(self):
         p = Period("2007-01-01 07:10:15.123")
         assert p.freq == "L"
 
+        # We see that there are 6 digits after the decimal, so get microsecond
+        #  even though they are all zeros.
         p = Period("2007-01-01 07:10:15.123000")
-        assert p.freq == "L"
+        assert p.freq == "U"
 
         p = Period("2007-01-01 07:10:15.123400")
         assert p.freq == "U"
@@ -836,7 +853,7 @@ def _period_constructor(bound, offset):
 
     @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
     @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
-    def test_outter_bounds_start_and_end_time(self, bound, offset, period_property):
+    def test_outer_bounds_start_and_end_time(self, bound, offset, period_property):
         # GH #13346
         period = TestPeriodProperties._period_constructor(bound, offset)
         with pytest.raises(OutOfBoundsDatetime, match="Out of bounds nanosecond"):
@@ -1170,6 +1187,19 @@ def test_comparison_numpy_zerodim_arr(self, zerodim_arr, expected):
 
 
 class TestArithmetic:
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "m"])
+    def test_add_sub_td64_nat(self, unit):
+        # GH#47196
+        per = Period("2022-06-01", "D")
+        nat = np.timedelta64("NaT", unit)
+
+        assert per + nat is NaT
+        assert nat + per is NaT
+        assert per - nat is NaT
+
+        with pytest.raises(TypeError, match="unsupported operand"):
+            nat - per
+
     def test_sub_delta(self):
         left, right = Period("2011", freq="A"), Period("2007", freq="A")
         result = left - right
diff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py
index 77265e8745315..88b06ec578905 100644
--- a/pandas/tests/scalar/test_na_scalar.py
+++ b/pandas/tests/scalar/test_na_scalar.py
@@ -100,7 +100,7 @@ def test_comparison_ops():
 def test_pow_special(value, asarray):
     if asarray:
         value = np.array([value])
-    result = NA ** value
+    result = NA**value
 
     if asarray:
         result = result[0]
@@ -117,7 +117,7 @@ def test_pow_special(value, asarray):
 def test_rpow_special(value, asarray):
     if asarray:
         value = np.array([value])
-    result = value ** NA
+    result = value**NA
 
     if asarray:
         result = result[0]
@@ -133,7 +133,7 @@ def test_rpow_special(value, asarray):
 def test_rpow_minus_one(value, asarray):
     if asarray:
         value = np.array([value])
-    result = value ** NA
+    result = value**NA
 
     if asarray:
         result = result[0]
diff --git a/pandas/tests/scalar/test_nat.py b/pandas/tests/scalar/test_nat.py
index 7850a20efc878..55577af7be9d9 100644
--- a/pandas/tests/scalar/test_nat.py
+++ b/pandas/tests/scalar/test_nat.py
@@ -110,9 +110,11 @@ def test_identity(klass, value):
 
 @pytest.mark.parametrize("klass", [Timestamp, Timedelta, Period])
 @pytest.mark.parametrize("value", ["", "nat", "NAT", None, np.nan])
-def test_equality(klass, value):
+def test_equality(klass, value, request):
     if klass is Period and value == "":
-        pytest.skip("Period cannot parse empty string")
+        request.node.add_marker(
+            pytest.mark.xfail(reason="Period cannot parse empty string")
+        )
 
     assert klass(value).value == iNaT
 
@@ -188,7 +190,7 @@ def test_nat_iso_format(get_nat):
 @pytest.mark.parametrize(
     "klass,expected",
     [
-        (Timestamp, ["freqstr", "normalize", "to_julian_date", "to_period", "tz"]),
+        (Timestamp, ["freqstr", "normalize", "to_julian_date", "to_period"]),
         (
             Timedelta,
             [
@@ -318,6 +320,7 @@ def test_overlap_public_nat_methods(klass, expected):
         _get_overlap_public_nat_methods(Timestamp, True)
         + _get_overlap_public_nat_methods(Timedelta, True)
     ),
+    ids=lambda x: f"{x[0].__name__}.{x[1]}",
 )
 def test_nat_doc_strings(compare):
     # see gh-17327
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 36ad24f2e1ef2..f3b84388b0f70 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -99,10 +99,11 @@ def test_td_add_datetimelike_scalar(self, op):
         assert result is NaT
 
     def test_td_add_timestamp_overflow(self):
-        msg = "int too (large|big) to convert"
-        with pytest.raises(OverflowError, match=msg):
+        msg = "Cannot cast 259987 from D to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timestamp("1700-01-01") + Timedelta(13 * 19999, unit="D")
 
+        msg = "Cannot cast 259987 days, 0:00:00 to unit=ns without overflow"
         with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timestamp("1700-01-01") + timedelta(days=13 * 19999)
 
@@ -317,6 +318,26 @@ def test_td_add_sub_dt64_ndarray(self):
         tm.assert_numpy_array_equal(-td + other, expected)
         tm.assert_numpy_array_equal(other - td, expected)
 
+    def test_td_add_sub_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(td.asm8)
+
+        result = td + other
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other + td
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other - td
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
+        result = td - other
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
 
 class TestTimedeltaMultiplicationDivision:
     """
@@ -394,6 +415,20 @@ def test_td_mul_numeric_ndarray(self):
         result = other * td
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_td_mul_numeric_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(2)
+        assert other.ndim == 0
+        expected = Timedelta("2 days")
+
+        res = td * other
+        assert type(res) is Timedelta
+        assert res == expected
+
+        res = other * td
+        assert type(res) is Timedelta
+        assert res == expected
+
     def test_td_mul_td64_ndarray_invalid(self):
         td = Timedelta("1 day")
         other = np.array([Timedelta("2 Days").to_timedelta64()])
@@ -427,9 +462,9 @@ def test_td_div_td64_non_nano(self):
         # truediv
         td = Timedelta("1 days 2 hours 3 ns")
         result = td / np.timedelta64(1, "D")
-        assert result == td.value / (86400 * 10 ** 9)
+        assert result == td.value / (86400 * 10**9)
         result = td / np.timedelta64(1, "s")
-        assert result == td.value / 10 ** 9
+        assert result == td.value / 10**9
         result = td / np.timedelta64(1, "ns")
         assert result == td.value
 
@@ -483,6 +518,14 @@ def test_td_div_td64_ndarray(self):
         result = other / td
         tm.assert_numpy_array_equal(result, expected * 4)
 
+    def test_td_div_ndarray_0d(self):
+        td = Timedelta("1 day")
+
+        other = np.array(1)
+        res = td / other
+        assert isinstance(res, Timedelta)
+        assert res == td
+
     # ---------------------------------------------------------------
     # Timedelta.__rdiv__
 
@@ -538,6 +581,13 @@ def test_td_rdiv_ndarray(self):
         with pytest.raises(TypeError, match=msg):
             arr / td
 
+    def test_td_rdiv_ndarray_0d(self):
+        td = Timedelta(10, unit="d")
+
+        arr = np.array(td.asm8)
+
+        assert arr / td == 1
+
     # ---------------------------------------------------------------
     # Timedelta.__floordiv__
 
@@ -694,7 +744,7 @@ def test_td_rfloordiv_timedeltalike_array(self):
 
     def test_td_rfloordiv_intarray(self):
         # deprecated GH#19761, enforced GH#29797
-        ints = np.array([1349654400, 1349740800, 1349827200, 1349913600]) * 10 ** 9
+        ints = np.array([1349654400, 1349740800, 1349827200, 1349913600]) * 10**9
 
         msg = "Invalid dtype"
         with pytest.raises(TypeError, match=msg):
@@ -988,7 +1038,7 @@ def test_compare_custom_object(self):
         """
 
         class CustomClass:
-            def __init__(self, cmp_result=None):
+            def __init__(self, cmp_result=None) -> None:
                 self.cmp_result = cmp_result
 
             def generic_result(self):
diff --git a/pandas/tests/scalar/timedelta/test_constructors.py b/pandas/tests/scalar/timedelta/test_constructors.py
index 34b725eb9fe77..90e148f51dd87 100644
--- a/pandas/tests/scalar/timedelta/test_constructors.py
+++ b/pandas/tests/scalar/timedelta/test_constructors.py
@@ -13,6 +13,30 @@
 )
 
 
+def test_construct_with_weeks_unit_overflow():
+    # GH#47268 don't silently wrap around
+    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
+        Timedelta(1000000000000000000, unit="W")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
+        Timedelta(1000000000000000000.0, unit="W")
+
+
+def test_construct_from_td64_with_unit():
+    # ignore the unit, as it may cause silently overflows leading to incorrect
+    #  results, and in non-overflow cases is irrelevant GH#46827
+    obj = np.timedelta64(123456789, "h")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789 hours"):
+        Timedelta(obj, unit="ps")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789 hours"):
+        Timedelta(obj, unit="ns")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789 hours"):
+        Timedelta(obj)
+
+
 def test_construction():
     expected = np.timedelta64(10, "D").astype("m8[ns]").view("i8")
     assert Timedelta(10, unit="d").value == expected
@@ -189,17 +213,18 @@ def test_td_from_repr_roundtrip(val):
 
 
 def test_overflow_on_construction():
-    msg = "int too (large|big) to convert"
-
     # GH#3374
     value = Timedelta("1day").value * 20169940
-    with pytest.raises(OverflowError, match=msg):
+    msg = "Cannot cast 1742682816000000000000 from ns to 'ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
         Timedelta(value)
 
     # xref GH#17637
-    with pytest.raises(OverflowError, match=msg):
+    msg = "Cannot cast 139993 from D to 'ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
         Timedelta(7 * 19999, unit="D")
 
+    msg = "Cannot cast 259987 days, 0:00:00 to unit=ns without overflow"
     with pytest.raises(OutOfBoundsTimedelta, match=msg):
         Timedelta(timedelta(days=13 * 19999))
 
@@ -377,3 +402,12 @@ def test_string_without_numbers(value):
     )
     with pytest.raises(ValueError, match=msg):
         Timedelta(value)
+
+
+def test_subclass_respected():
+    # GH#49579
+    class MyCustomTimedelta(Timedelta):
+        pass
+
+    td = MyCustomTimedelta("1 minute")
+    assert isinstance(td, MyCustomTimedelta)
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 7a32c932aee77..21f32cf2d2d1e 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -13,6 +13,8 @@
     NaT,
     iNaT,
 )
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsTimedelta
 
 import pandas as pd
 from pandas import (
@@ -24,6 +26,281 @@
 import pandas._testing as tm
 
 
+class TestAsUnit:
+    def test_as_unit(self):
+        td = Timedelta(days=1)
+
+        assert td._as_unit("ns") is td
+
+        res = td._as_unit("us")
+        assert res.value == td.value // 1000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_us.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == td.value
+        assert rt._reso == td._reso
+
+        res = td._as_unit("ms")
+        assert res.value == td.value // 1_000_000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == td.value
+        assert rt._reso == td._reso
+
+        res = td._as_unit("s")
+        assert res.value == td.value // 1_000_000_000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_s.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == td.value
+        assert rt._reso == td._reso
+
+    def test_as_unit_overflows(self):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        td = Timedelta._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value)
+
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td._as_unit("ns")
+
+        res = td._as_unit("ms")
+        assert res.value == us // 1000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    def test_as_unit_rounding(self):
+        td = Timedelta(microseconds=1500)
+        res = td._as_unit("ms")
+
+        expected = Timedelta(milliseconds=1)
+        assert res == expected
+
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res.value == 1
+
+        with pytest.raises(ValueError, match="Cannot losslessly convert units"):
+            td._as_unit("ms", round_ok=False)
+
+    def test_as_unit_non_nano(self):
+        # case where we are going neither to nor from nano
+        td = Timedelta(days=1)._as_unit("ms")
+        assert td.days == 1
+        assert td.value == 86_400_000
+        assert td.components.days == 1
+        assert td._d == 1
+        assert td.total_seconds() == 86400
+
+        res = td._as_unit("us")
+        assert res.value == 86_400_000_000
+        assert res.components.days == 1
+        assert res.components.hours == 0
+        assert res._d == 1
+        assert res._h == 0
+        assert res.total_seconds() == 86400
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def unit_str(self, request):
+        return request.param
+
+    @pytest.fixture
+    def unit(self, unit_str):
+        # 7, 8, 9 correspond to second, millisecond, and microsecond, respectively
+        attr = f"NPY_FR_{unit_str}"
+        return getattr(NpyDatetimeUnit, attr).value
+
+    @pytest.fixture
+    def val(self, unit):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        if unit == NpyDatetimeUnit.NPY_FR_us.value:
+            value = us
+        elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+            value = us // 1000
+        else:
+            value = us // 1_000_000
+        return value
+
+    @pytest.fixture
+    def td(self, unit, val):
+        return Timedelta._from_value_and_reso(val, unit)
+
+    def test_from_value_and_reso(self, unit, val):
+        # Just checking that the fixture is giving us what we asked for
+        td = Timedelta._from_value_and_reso(val, unit)
+        assert td.value == val
+        assert td._reso == unit
+        assert td.days == 106752
+
+    def test_unary_non_nano(self, td, unit):
+        assert abs(td)._reso == unit
+        assert (-td)._reso == unit
+        assert (+td)._reso == unit
+
+    def test_sub_preserves_reso(self, td, unit):
+        res = td - td
+        expected = Timedelta._from_value_and_reso(0, unit)
+        assert res == expected
+        assert res._reso == unit
+
+    def test_mul_preserves_reso(self, td, unit):
+        # The td fixture should always be far from the implementation
+        #  bound, so doubling does not risk overflow.
+        res = td * 2
+        assert res.value == td.value * 2
+        assert res._reso == unit
+
+    def test_cmp_cross_reso(self, td):
+        # numpy gets this wrong because of silent overflow
+        other = Timedelta(days=106751, unit="ns")
+        assert other < td
+        assert td > other
+        assert not other == td
+        assert td != other
+
+    def test_to_pytimedelta(self, td):
+        res = td.to_pytimedelta()
+        expected = timedelta(days=106752)
+        assert type(res) is timedelta
+        assert res == expected
+
+    def test_to_timedelta64(self, td, unit):
+        for res in [td.to_timedelta64(), td.to_numpy(), td.asm8]:
+
+            assert isinstance(res, np.timedelta64)
+            assert res.view("i8") == td.value
+            if unit == NpyDatetimeUnit.NPY_FR_s.value:
+                assert res.dtype == "m8[s]"
+            elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+                assert res.dtype == "m8[ms]"
+            elif unit == NpyDatetimeUnit.NPY_FR_us.value:
+                assert res.dtype == "m8[us]"
+
+    def test_truediv_timedeltalike(self, td):
+        assert td / td == 1
+        assert (2.5 * td) / td == 2.5
+
+        other = Timedelta(td.value)
+        msg = "with mismatched resolutions are not supported"
+        with pytest.raises(ValueError, match=msg):
+            td / other
+
+        with pytest.raises(ValueError, match=msg):
+            # __rtruediv__
+            other.to_pytimedelta() / td
+
+    def test_truediv_numeric(self, td):
+        assert td / np.nan is NaT
+
+        res = td / 2
+        assert res.value == td.value / 2
+        assert res._reso == td._reso
+
+        res = td / 2.0
+        assert res.value == td.value / 2
+        assert res._reso == td._reso
+
+    def test_floordiv_timedeltalike(self, td):
+        assert td // td == 1
+        assert (2.5 * td) // td == 2
+
+        other = Timedelta(td.value)
+        msg = "with mismatched resolutions are not supported"
+        with pytest.raises(ValueError, match=msg):
+            td // other
+
+        with pytest.raises(ValueError, match=msg):
+            # __rfloordiv__
+            other.to_pytimedelta() // td
+
+    def test_floordiv_numeric(self, td):
+        assert td // np.nan is NaT
+
+        res = td // 2
+        assert res.value == td.value // 2
+        assert res._reso == td._reso
+
+        res = td // 2.0
+        assert res.value == td.value // 2
+        assert res._reso == td._reso
+
+        assert td // np.array(np.nan) is NaT
+
+        res = td // np.array(2)
+        assert res.value == td.value // 2
+        assert res._reso == td._reso
+
+        res = td // np.array(2.0)
+        assert res.value == td.value // 2
+        assert res._reso == td._reso
+
+    def test_addsub_mismatched_reso(self, td):
+        other = Timedelta(days=1)  # can losslessly convert to other resos
+
+        result = td + other
+        assert result._reso == td._reso
+        assert result.days == td.days + 1
+
+        result = other + td
+        assert result._reso == td._reso
+        assert result.days == td.days + 1
+
+        result = td - other
+        assert result._reso == td._reso
+        assert result.days == td.days - 1
+
+        result = other - td
+        assert result._reso == td._reso
+        assert result.days == 1 - td.days
+
+        other2 = Timedelta(500)  # can't cast losslessly
+
+        msg = (
+            "Timedelta addition/subtraction with mismatched resolutions is "
+            "not allowed when casting to the lower resolution would require "
+            "lossy rounding"
+        )
+        with pytest.raises(ValueError, match=msg):
+            td + other2
+        with pytest.raises(ValueError, match=msg):
+            other2 + td
+        with pytest.raises(ValueError, match=msg):
+            td - other2
+        with pytest.raises(ValueError, match=msg):
+            other2 - td
+
+    def test_min(self, td):
+        assert td.min <= td
+        assert td.min._reso == td._reso
+        assert td.min.value == NaT.value + 1
+
+    def test_max(self, td):
+        assert td.max >= td
+        assert td.max._reso == td._reso
+        assert td.max.value == np.iinfo(np.int64).max
+
+    def test_resolution(self, td):
+        expected = Timedelta._from_value_and_reso(1, td._reso)
+        result = td.resolution
+        assert result == expected
+        assert result._reso == expected._reso
+
+
+def test_timedelta_class_min_max_resolution():
+    # when accessed on the class (as opposed to an instance), we default
+    #  to nanoseconds
+    assert Timedelta.min == Timedelta(NaT.value + 1)
+    assert Timedelta.min._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.max == Timedelta(np.iinfo(np.int64).max)
+    assert Timedelta.max._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.resolution == Timedelta(1)
+    assert Timedelta.resolution._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+
 class TestTimedeltaUnaryOps:
     def test_invert(self):
         td = Timedelta(10, unit="d")
@@ -413,6 +690,7 @@ def test_round_implementation_bounds(self):
         with pytest.raises(OverflowError, match=msg):
             Timedelta.max.ceil("s")
 
+    @pytest.mark.xfail(reason="Failing on builds", strict=False)
     @given(val=st.integers(min_value=iNaT + 1, max_value=lib.i8max))
     @pytest.mark.parametrize(
         "method", [Timedelta.round, Timedelta.floor, Timedelta.ceil]
@@ -453,16 +731,21 @@ def test_round_sanity(self, val, method):
         assert np.abs((res - td).value) < nanos
         assert res.value % nanos == 0
 
-    def test_contains(self):
-        # Checking for any NaT-like objects
-        # GH 13603
-        td = to_timedelta(range(5), unit="d") + offsets.Hour(1)
-        for v in [NaT, None, float("nan"), np.nan]:
-            assert not (v in td)
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_round_non_nano(self, unit):
+        td = Timedelta("1 days 02:34:57")._as_unit(unit)
 
-        td = to_timedelta([NaT])
-        for v in [NaT, None, float("nan"), np.nan]:
-            assert v in td
+        res = td.round("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._reso == td._reso
+
+        res = td.floor("min")
+        assert res == Timedelta("1 days 02:34:00")
+        assert res._reso == td._reso
+
+        res = td.ceil("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._reso == td._reso
 
     def test_identity(self):
 
@@ -595,10 +878,12 @@ def test_implementation_limits(self):
         td = Timedelta(min_td.value - 1, "ns")
         assert td is NaT
 
-        with pytest.raises(OverflowError, match=msg):
+        msg = "Cannot cast -9223372036854775809 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(min_td.value - 2, "ns")
 
-        with pytest.raises(OverflowError, match=msg):
+        msg = "Cannot cast 9223372036854775808 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(max_td.value + 1, "ns")
 
     def test_total_seconds_precision(self):
@@ -659,3 +944,32 @@ def test_timedelta_attribute_precision():
     result += td.nanoseconds
     expected = td.value
     assert result == expected
+
+
+def test_freq_deprecated():
+    # GH#46430
+    td = Timedelta(123456546, unit="ns")
+    with tm.assert_produces_warning(FutureWarning, match="Timedelta.freq"):
+        freq = td.freq
+
+    assert freq is None
+
+    with pytest.raises(AttributeError, match="is not writable"):
+        td.freq = offsets.Day()
+
+
+def test_is_populated_deprecated():
+    # GH#46430
+    td = Timedelta(123456546, unit="ns")
+    with tm.assert_produces_warning(FutureWarning, match="Timedelta.is_populated"):
+        td.is_populated
+
+    with pytest.raises(AttributeError, match="is not writable"):
+        td.is_populated = 1
+
+
+def test_delta_deprecated():
+    # GH#46476
+    td = Timedelta(123456546, unit="ns")
+    with tm.assert_produces_warning(FutureWarning, match="Timedelta.delta is"):
+        td.delta
diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py
index 2ff1de51c33ad..65610bbe14e41 100644
--- a/pandas/tests/scalar/timestamp/test_arithmetic.py
+++ b/pandas/tests/scalar/timestamp/test_arithmetic.py
@@ -9,6 +9,7 @@
 
 from pandas._libs.tslibs import (
     OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
     Timedelta,
     Timestamp,
     offsets,
@@ -44,32 +45,31 @@ def test_overflow_offset_raises(self):
             r"\<-?\d+ \* Days\> and \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} "
             "will overflow"
         )
-        lmsg = "|".join(
-            ["Python int too large to convert to C long", "int too big to convert"]
-        )
+        lmsg2 = r"Cannot cast <-?20169940 \* Days> to unit=ns without overflow"
 
-        with pytest.raises(OverflowError, match=lmsg):
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
             stamp + offset_overflow
 
         with pytest.raises(OverflowError, match=msg):
             offset_overflow + stamp
 
-        with pytest.raises(OverflowError, match=lmsg):
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
             stamp - offset_overflow
 
         # xref https://github.com/pandas-dev/pandas/issues/14080
         # used to crash, so check for proper overflow exception
 
         stamp = Timestamp("2000/1/1")
-        offset_overflow = to_offset("D") * 100 ** 5
+        offset_overflow = to_offset("D") * 100**5
 
-        with pytest.raises(OverflowError, match=lmsg):
+        lmsg3 = r"Cannot cast <-?10000000000 \* Days> to unit=ns without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
             stamp + offset_overflow
 
         with pytest.raises(OverflowError, match=msg):
             offset_overflow + stamp
 
-        with pytest.raises(OverflowError, match=lmsg):
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
             stamp - offset_overflow
 
     def test_overflow_timestamp_raises(self):
diff --git a/pandas/tests/scalar/timestamp/test_comparisons.py b/pandas/tests/scalar/timestamp/test_comparisons.py
index 7ed0a6aedebc1..b5084e7a8925e 100644
--- a/pandas/tests/scalar/timestamp/test_comparisons.py
+++ b/pandas/tests/scalar/timestamp/test_comparisons.py
@@ -12,7 +12,7 @@
 
 
 class TestTimestampComparison:
-    def test_comparison_dt64_ndarray(self, fixed_now_ts):
+    def test_comparison_dt64_ndarray(self):
         ts = Timestamp("2021-01-01")
         ts2 = Timestamp("2019-04-05")
         arr = np.array([[ts.asm8, ts2.asm8]], dtype="M8[ns]")
diff --git a/pandas/tests/scalar/timestamp/test_constructors.py b/pandas/tests/scalar/timestamp/test_constructors.py
index b3deb1a57e5c3..7b3647dc6cbef 100644
--- a/pandas/tests/scalar/timestamp/test_constructors.py
+++ b/pandas/tests/scalar/timestamp/test_constructors.py
@@ -2,6 +2,7 @@
 from datetime import (
     datetime,
     timedelta,
+    timezone,
 )
 
 import dateutil.tz
@@ -24,6 +25,28 @@
 
 
 class TestTimestampConstructors:
+    @pytest.mark.parametrize("typ", [int, float])
+    def test_constructor_int_float_with_YM_unit(self, typ):
+        # GH#47266 avoid the conversions in cast_from_unit
+        val = typ(150)
+
+        ts = Timestamp(val, unit="Y")
+        expected = Timestamp("2120-01-01")
+        assert ts == expected
+
+        ts = Timestamp(val, unit="M")
+        expected = Timestamp("1982-07-01")
+        assert ts == expected
+
+    def test_constructor_float_not_round_with_YM_unit_deprecated(self):
+        # GH#47267 avoid the conversions in cast_from-unit
+
+        with tm.assert_produces_warning(FutureWarning, match="ambiguous"):
+            Timestamp(150.5, unit="Y")
+
+        with tm.assert_produces_warning(FutureWarning, match="ambiguous"):
+            Timestamp(150.5, unit="M")
+
     def test_constructor_datetime64_with_tz(self):
         # GH#42288, GH#24559
         dt = np.datetime64("1970-01-01 05:00:00")
@@ -242,6 +265,25 @@ def test_constructor_tz_or_tzinfo(self):
         ]
         assert all(ts == stamps[0] for ts in stamps)
 
+    def test_constructor_positional_with_tzinfo(self):
+        # GH#31929
+        ts = Timestamp(2020, 12, 31, tzinfo=timezone.utc)
+        expected = Timestamp("2020-12-31", tzinfo=timezone.utc)
+        assert ts == expected
+
+    @pytest.mark.xfail(reason="GH#45307")
+    @pytest.mark.parametrize("kwd", ["nanosecond", "microsecond", "second", "minute"])
+    def test_constructor_positional_keyword_mixed_with_tzinfo(self, kwd):
+        # TODO: if we passed microsecond with a keyword we would mess up
+        #  xref GH#45307
+        kwargs = {kwd: 4}
+        ts = Timestamp(2020, 12, 31, tzinfo=timezone.utc, **kwargs)
+
+        td_kwargs = {kwd + "s": 4}
+        td = Timedelta(**td_kwargs)
+        expected = Timestamp("2020-12-31", tz=timezone.utc) + td
+        assert ts == expected
+
     def test_constructor_positional(self):
         # see gh-10758
         msg = (
@@ -292,20 +334,17 @@ def test_constructor_keyword(self):
             Timestamp("20151112")
         )
 
-        assert (
-            repr(
-                Timestamp(
-                    year=2015,
-                    month=11,
-                    day=12,
-                    hour=1,
-                    minute=2,
-                    second=3,
-                    microsecond=999999,
-                )
+        assert repr(
+            Timestamp(
+                year=2015,
+                month=11,
+                day=12,
+                hour=1,
+                minute=2,
+                second=3,
+                microsecond=999999,
             )
-            == repr(Timestamp("2015-11-12 01:02:03.999999"))
-        )
+        ) == repr(Timestamp("2015-11-12 01:02:03.999999"))
 
     @pytest.mark.filterwarnings("ignore:Timestamp.freq is:FutureWarning")
     @pytest.mark.filterwarnings("ignore:The 'freq' argument:FutureWarning")
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index f734c331e3def..67ad152dcab30 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -18,10 +18,14 @@
     utc,
 )
 
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 from pandas._libs.tslibs.timezones import (
     dateutil_gettz as gettz,
     get_timezone,
+    maybe_get_tz,
+    tz_compare,
 )
+from pandas.errors import OutOfBoundsDatetime
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -592,6 +596,13 @@ def test_conversion(self):
         assert type(result) == type(expected)
         assert result.dtype == expected.dtype
 
+    def test_to_pydatetime_fold(self):
+        # GH#45087
+        tzstr = "dateutil/usr/share/zoneinfo/America/Chicago"
+        ts = Timestamp(year=2013, month=11, day=3, hour=1, minute=0, fold=1, tz=tzstr)
+        dt = ts.to_pydatetime()
+        assert dt.fold == 1
+
     def test_to_pydatetime_nonzero_nano(self):
         ts = Timestamp("2011-01-01 9:00:00.123456789")
 
@@ -685,3 +696,425 @@ def test_dt_subclass_add_timedelta(lh, rh):
     result = lh + rh
     expected = SubDatetime(2000, 1, 1, 1)
     assert result == expected
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def reso(self, request):
+        return request.param
+
+    @pytest.fixture
+    def dt64(self, reso):
+        # cases that are in-bounds for nanosecond, so we can compare against
+        #  the existing implementation.
+        return np.datetime64("2016-01-01", reso)
+
+    @pytest.fixture
+    def ts(self, dt64):
+        return Timestamp._from_dt64(dt64)
+
+    @pytest.fixture
+    def ts_tz(self, ts, tz_aware_fixture):
+        tz = maybe_get_tz(tz_aware_fixture)
+        return Timestamp._from_value_and_reso(ts.value, ts._reso, tz)
+
+    def test_non_nano_construction(self, dt64, ts, reso):
+        assert ts.value == dt64.view("i8")
+
+        if reso == "s":
+            assert ts._reso == NpyDatetimeUnit.NPY_FR_s.value
+        elif reso == "ms":
+            assert ts._reso == NpyDatetimeUnit.NPY_FR_ms.value
+        elif reso == "us":
+            assert ts._reso == NpyDatetimeUnit.NPY_FR_us.value
+
+    def test_non_nano_fields(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert ts.year == alt.year
+        assert ts.month == alt.month
+        assert ts.day == alt.day
+        assert ts.hour == ts.minute == ts.second == ts.microsecond == 0
+        assert ts.nanosecond == 0
+
+        assert ts.to_julian_date() == alt.to_julian_date()
+        assert ts.weekday() == alt.weekday()
+        assert ts.isoweekday() == alt.isoweekday()
+
+    def test_start_end_fields(self, ts):
+        assert ts.is_year_start
+        assert ts.is_quarter_start
+        assert ts.is_month_start
+        assert not ts.is_year_end
+        assert not ts.is_month_end
+        assert not ts.is_month_end
+
+        freq = offsets.BDay()
+        ts._set_freq(freq)
+
+        # 2016-01-01 is a Friday, so is year/quarter/month start with this freq
+        msg = "Timestamp.freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert ts.is_year_start
+            assert ts.is_quarter_start
+            assert ts.is_month_start
+            assert not ts.is_year_end
+            assert not ts.is_month_end
+            assert not ts.is_month_end
+
+    def test_day_name(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.day_name() == alt.day_name()
+
+    def test_month_name(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.month_name() == alt.month_name()
+
+    def test_tz_convert(self, ts):
+        ts = Timestamp._from_value_and_reso(ts.value, ts._reso, utc)
+
+        tz = pytz.timezone("US/Pacific")
+        result = ts.tz_convert(tz)
+
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts._reso
+        assert tz_compare(result.tz, tz)
+
+    def test_repr(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert str(ts) == str(alt)
+        assert repr(ts) == repr(alt)
+
+    def test_comparison(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert ts == dt64
+        assert dt64 == ts
+        assert ts == alt
+        assert alt == ts
+
+        assert not ts != dt64
+        assert not dt64 != ts
+        assert not ts != alt
+        assert not alt != ts
+
+        assert not ts < dt64
+        assert not dt64 < ts
+        assert not ts < alt
+        assert not alt < ts
+
+        assert not ts > dt64
+        assert not dt64 > ts
+        assert not ts > alt
+        assert not alt > ts
+
+        assert ts >= dt64
+        assert dt64 >= ts
+        assert ts >= alt
+        assert alt >= ts
+
+        assert ts <= dt64
+        assert dt64 <= ts
+        assert ts <= alt
+        assert alt <= ts
+
+    def test_cmp_cross_reso(self):
+        # numpy gets this wrong because of silent overflow
+        dt64 = np.datetime64(9223372800, "s")  # won't fit in M8[ns]
+        ts = Timestamp._from_dt64(dt64)
+
+        # subtracting 3600*24 gives a datetime64 that _can_ fit inside the
+        #  nanosecond implementation bounds.
+        other = Timestamp(dt64 - 3600 * 24)
+        assert other < ts
+        assert other.asm8 > ts.asm8  # <- numpy gets this wrong
+        assert ts > other
+        assert ts.asm8 < other.asm8  # <- numpy gets this wrong
+        assert not other == ts
+        assert ts != other
+
+    @pytest.mark.xfail(reason="Dispatches to np.datetime64 which is wrong")
+    def test_cmp_cross_reso_reversed_dt64(self):
+        dt64 = np.datetime64(106752, "D")  # won't fit in M8[ns]
+        ts = Timestamp._from_dt64(dt64)
+        other = Timestamp(dt64 - 1)
+
+        assert other.asm8 < ts
+
+    def test_pickle(self, ts, tz_aware_fixture):
+        tz = tz_aware_fixture
+        tz = maybe_get_tz(tz)
+        ts = Timestamp._from_value_and_reso(ts.value, ts._reso, tz)
+        rt = tm.round_trip_pickle(ts)
+        assert rt._reso == ts._reso
+        assert rt == ts
+
+    def test_normalize(self, dt64, ts):
+        alt = Timestamp(dt64)
+        result = ts.normalize()
+        assert result._reso == ts._reso
+        assert result == alt.normalize()
+
+    def test_asm8(self, dt64, ts):
+        rt = ts.asm8
+        assert rt == dt64
+        assert rt.dtype == dt64.dtype
+
+    def test_to_numpy(self, dt64, ts):
+        res = ts.to_numpy()
+        assert res == dt64
+        assert res.dtype == dt64.dtype
+
+    def test_to_datetime64(self, dt64, ts):
+        res = ts.to_datetime64()
+        assert res == dt64
+        assert res.dtype == dt64.dtype
+
+    def test_timestamp(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.timestamp() == alt.timestamp()
+
+    def test_to_period(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.to_period("D") == alt.to_period("D")
+
+    @pytest.mark.parametrize(
+        "td", [timedelta(days=4), Timedelta(days=4), np.timedelta64(4, "D")]
+    )
+    def test_addsub_timedeltalike_non_nano(self, dt64, ts, td):
+
+        result = ts - td
+        expected = Timestamp(dt64) - td
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts._reso
+        assert result == expected
+
+        result = ts + td
+        expected = Timestamp(dt64) + td
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts._reso
+        assert result == expected
+
+        result = td + ts
+        expected = td + Timestamp(dt64)
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts._reso
+        assert result == expected
+
+    @pytest.mark.xfail(reason="tz_localize not yet implemented for non-nano")
+    def test_addsub_offset(self, ts_tz):
+        # specifically non-Tick offset
+        off = offsets.YearBegin(1)
+        result = ts_tz + off
+
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts_tz._reso
+        # If ts_tz is ever on the last day of the year, the year would be
+        #  incremented by one
+        assert result.year == ts_tz.year
+        assert result.day == 31
+        assert result.month == 12
+        assert tz_compare(result.tz, ts_tz.tz)
+
+        result = ts_tz - off
+
+        assert isinstance(result, Timestamp)
+        assert result._reso == ts_tz._reso
+        assert result.year == ts_tz.year - 1
+        assert result.day == 31
+        assert result.month == 12
+        assert tz_compare(result.tz, ts_tz.tz)
+
+    def test_sub_datetimelike_mismatched_reso(self, ts_tz):
+        # case with non-lossy rounding
+        ts = ts_tz
+
+        # choose a unit for `other` that doesn't match ts_tz's;
+        #  this construction ensures we get cases with other._reso < ts._reso
+        #  and cases with other._reso > ts._reso
+        unit = {
+            NpyDatetimeUnit.NPY_FR_us.value: "ms",
+            NpyDatetimeUnit.NPY_FR_ms.value: "s",
+            NpyDatetimeUnit.NPY_FR_s.value: "us",
+        }[ts._reso]
+        other = ts._as_unit(unit)
+        assert other._reso != ts._reso
+
+        result = ts - other
+        assert isinstance(result, Timedelta)
+        assert result.value == 0
+        assert result._reso == min(ts._reso, other._reso)
+
+        result = other - ts
+        assert isinstance(result, Timedelta)
+        assert result.value == 0
+        assert result._reso == min(ts._reso, other._reso)
+
+        msg = "Timestamp subtraction with mismatched resolutions"
+        if ts._reso < other._reso:
+            # Case where rounding is lossy
+            other2 = other + Timedelta._from_value_and_reso(1, other._reso)
+            with pytest.raises(ValueError, match=msg):
+                ts - other2
+            with pytest.raises(ValueError, match=msg):
+                other2 - ts
+        else:
+            ts2 = ts + Timedelta._from_value_and_reso(1, ts._reso)
+            with pytest.raises(ValueError, match=msg):
+                ts2 - other
+            with pytest.raises(ValueError, match=msg):
+                other - ts2
+
+    def test_sub_timedeltalike_mismatched_reso(self, ts_tz):
+        # case with non-lossy rounding
+        ts = ts_tz
+
+        # choose a unit for `other` that doesn't match ts_tz's;
+        #  this construction ensures we get cases with other._reso < ts._reso
+        #  and cases with other._reso > ts._reso
+        unit = {
+            NpyDatetimeUnit.NPY_FR_us.value: "ms",
+            NpyDatetimeUnit.NPY_FR_ms.value: "s",
+            NpyDatetimeUnit.NPY_FR_s.value: "us",
+        }[ts._reso]
+        other = Timedelta(0)._as_unit(unit)
+        assert other._reso != ts._reso
+
+        result = ts + other
+        assert isinstance(result, Timestamp)
+        assert result == ts
+        assert result._reso == min(ts._reso, other._reso)
+
+        result = other + ts
+        assert isinstance(result, Timestamp)
+        assert result == ts
+        assert result._reso == min(ts._reso, other._reso)
+
+        msg = "Timestamp addition with mismatched resolutions"
+        if ts._reso < other._reso:
+            # Case where rounding is lossy
+            other2 = other + Timedelta._from_value_and_reso(1, other._reso)
+            with pytest.raises(ValueError, match=msg):
+                ts + other2
+            with pytest.raises(ValueError, match=msg):
+                other2 + ts
+        else:
+            ts2 = ts + Timedelta._from_value_and_reso(1, ts._reso)
+            with pytest.raises(ValueError, match=msg):
+                ts2 + other
+            with pytest.raises(ValueError, match=msg):
+                other + ts2
+
+        msg = "Addition between Timestamp and Timedelta with mismatched resolutions"
+        with pytest.raises(ValueError, match=msg):
+            # With a mismatched td64 as opposed to Timedelta
+            ts + np.timedelta64(1, "ns")
+
+    def test_min(self, ts):
+        assert ts.min <= ts
+        assert ts.min._reso == ts._reso
+        assert ts.min.value == NaT.value + 1
+
+    def test_max(self, ts):
+        assert ts.max >= ts
+        assert ts.max._reso == ts._reso
+        assert ts.max.value == np.iinfo(np.int64).max
+
+    def test_resolution(self, ts):
+        expected = Timedelta._from_value_and_reso(1, ts._reso)
+        result = ts.resolution
+        assert result == expected
+        assert result._reso == expected._reso
+
+
+def test_timestamp_class_min_max_resolution():
+    # when accessed on the class (as opposed to an instance), we default
+    #  to nanoseconds
+    assert Timestamp.min == Timestamp(NaT.value + 1)
+    assert Timestamp.min._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timestamp.max == Timestamp(np.iinfo(np.int64).max)
+    assert Timestamp.max._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timestamp.resolution == Timedelta(1)
+    assert Timestamp.resolution._reso == NpyDatetimeUnit.NPY_FR_ns.value
+
+
+class TestAsUnit:
+    def test_as_unit(self):
+        ts = Timestamp("1970-01-01")
+
+        assert ts._as_unit("ns") is ts
+
+        res = ts._as_unit("us")
+        assert res.value == ts.value // 1000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_us.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == ts.value
+        assert rt._reso == ts._reso
+
+        res = ts._as_unit("ms")
+        assert res.value == ts.value // 1_000_000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == ts.value
+        assert rt._reso == ts._reso
+
+        res = ts._as_unit("s")
+        assert res.value == ts.value // 1_000_000_000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_s.value
+
+        rt = res._as_unit("ns")
+        assert rt.value == ts.value
+        assert rt._reso == ts._reso
+
+    def test_as_unit_overflows(self):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        ts = Timestamp._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value, None)
+
+        msg = "Cannot cast 2262-04-12 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            ts._as_unit("ns")
+
+        res = ts._as_unit("ms")
+        assert res.value == us // 1000
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    def test_as_unit_rounding(self):
+        ts = Timestamp(1_500_000)  # i.e. 1500 microseconds
+        res = ts._as_unit("ms")
+
+        expected = Timestamp(1_000_000)  # i.e. 1 millisecond
+        assert res == expected
+
+        assert res._reso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res.value == 1
+
+        with pytest.raises(ValueError, match="Cannot losslessly convert units"):
+            ts._as_unit("ms", round_ok=False)
+
+    def test_as_unit_non_nano(self):
+        # case where we are going neither to nor from nano
+        ts = Timestamp("1970-01-02")._as_unit("ms")
+        assert ts.year == 1970
+        assert ts.month == 1
+        assert ts.day == 2
+        assert ts.hour == ts.minute == ts.second == ts.microsecond == ts.nanosecond == 0
+
+        res = ts._as_unit("s")
+        assert res.value == 24 * 3600
+        assert res.year == 1970
+        assert res.month == 1
+        assert res.day == 2
+        assert (
+            res.hour
+            == res.minute
+            == res.second
+            == res.microsecond
+            == res.nanosecond
+            == 0
+        )
diff --git a/pandas/tests/scalar/timestamp/test_timezones.py b/pandas/tests/scalar/timestamp/test_timezones.py
index 9ba4a2c1f77cd..874575fa9ad4c 100644
--- a/pandas/tests/scalar/timestamp/test_timezones.py
+++ b/pandas/tests/scalar/timestamp/test_timezones.py
@@ -20,6 +20,7 @@
 )
 
 from pandas._libs.tslibs import timezones
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 from pandas.errors import OutOfBoundsDatetime
 import pandas.util._test_decorators as td
 
@@ -57,10 +58,11 @@ def test_tz_localize_pushes_out_of_bounds(self):
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             Timestamp.max.tz_localize("US/Pacific")
 
-    def test_tz_localize_ambiguous_bool(self):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_tz_localize_ambiguous_bool(self, unit):
         # make sure that we are correctly accepting bool values as ambiguous
         # GH#14402
-        ts = Timestamp("2015-11-01 01:00:03")
+        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")
 
@@ -70,9 +72,11 @@ def test_tz_localize_ambiguous_bool(self):
 
         result = ts.tz_localize("US/Central", ambiguous=True)
         assert result == expected0
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
         result = ts.tz_localize("US/Central", ambiguous=False)
         assert result == expected1
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
     def test_tz_localize_ambiguous(self):
         ts = Timestamp("2014-11-02 01:00")
@@ -166,9 +170,9 @@ def test_tz_localize_ambiguous_compat(self):
         assert result_pytz.value == 1382835600000000000
 
         # fixed ambiguous behavior
-        # see gh-14621
+        # see gh-14621, GH#45087
         assert result_pytz.to_pydatetime().tzname() == "GMT"
-        assert result_dateutil.to_pydatetime().tzname() == "BST"
+        assert result_dateutil.to_pydatetime().tzname() == "GMT"
         assert str(result_pytz) == str(result_dateutil)
 
         # 1 hour difference
@@ -245,17 +249,28 @@ def test_timestamp_tz_localize(self, tz):
         ],
     )
     @pytest.mark.parametrize("tz_type", ["", "dateutil/"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
     def test_timestamp_tz_localize_nonexistent_shift(
-        self, start_ts, tz, end_ts, shift, tz_type
+        self, start_ts, tz, end_ts, shift, tz_type, unit
     ):
         # GH 8917, 24466
         tz = tz_type + tz
         if isinstance(shift, str):
             shift = "shift_" + shift
-        ts = Timestamp(start_ts)
+        ts = Timestamp(start_ts)._as_unit(unit)
         result = ts.tz_localize(tz, nonexistent=shift)
         expected = Timestamp(end_ts).tz_localize(tz)
-        assert result == expected
+
+        if unit == "us":
+            assert result == expected.replace(nanosecond=0)
+        elif unit == "ms":
+            micros = expected.microsecond - expected.microsecond % 1000
+            assert result == expected.replace(microsecond=micros, nanosecond=0)
+        elif unit == "s":
+            assert result == expected.replace(microsecond=0, nanosecond=0)
+        else:
+            assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
     @pytest.mark.parametrize("offset", [-1, 1])
     @pytest.mark.parametrize("tz_type", ["", "dateutil/"])
@@ -268,16 +283,18 @@ def test_timestamp_tz_localize_nonexistent_shift_invalid(self, offset, tz_type):
             ts.tz_localize(tz, nonexistent=timedelta(seconds=offset))
 
     @pytest.mark.parametrize("tz", ["Europe/Warsaw", "dateutil/Europe/Warsaw"])
-    def test_timestamp_tz_localize_nonexistent_NaT(self, tz):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_timestamp_tz_localize_nonexistent_NaT(self, tz, unit):
         # GH 8917
-        ts = Timestamp("2015-03-29 02:20:00")
+        ts = Timestamp("2015-03-29 02:20:00")._as_unit(unit)
         result = ts.tz_localize(tz, nonexistent="NaT")
         assert result is NaT
 
     @pytest.mark.parametrize("tz", ["Europe/Warsaw", "dateutil/Europe/Warsaw"])
-    def test_timestamp_tz_localize_nonexistent_raise(self, tz):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_timestamp_tz_localize_nonexistent_raise(self, tz, unit):
         # GH 8917
-        ts = Timestamp("2015-03-29 02:20:00")
+        ts = Timestamp("2015-03-29 02:20:00")._as_unit(unit)
         msg = "2015-03-29 02:20:00"
         with pytest.raises(pytz.NonExistentTimeError, match=msg):
             ts.tz_localize(tz, nonexistent="raise")
diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index 5f07cabd51ca1..9c376c7a13efc 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -19,6 +19,7 @@
     iNaT,
     to_offset,
 )
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 import pandas.util._test_decorators as td
 
@@ -147,31 +148,42 @@ def test_round_minute_freq(self, test_input, freq, expected, rounder):
         result = func(freq)
         assert result == expected
 
-    def test_ceil(self):
-        dt = Timestamp("20130101 09:10:11")
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_ceil(self, unit):
+        dt = Timestamp("20130101 09:10:11")._as_unit(unit)
         result = dt.ceil("D")
         expected = Timestamp("20130102")
         assert result == expected
+        assert result._reso == dt._reso
 
-    def test_floor(self):
-        dt = Timestamp("20130101 09:10:11")
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_floor(self, unit):
+        dt = Timestamp("20130101 09:10:11")._as_unit(unit)
         result = dt.floor("D")
         expected = Timestamp("20130101")
         assert result == expected
+        assert result._reso == dt._reso
 
     @pytest.mark.parametrize("method", ["ceil", "round", "floor"])
-    def test_round_dst_border_ambiguous(self, method):
+    @pytest.mark.parametrize(
+        "unit",
+        ["ns", "us", "ms", "s"],
+    )
+    def test_round_dst_border_ambiguous(self, method, unit):
         # GH 18946 round near "fall back" DST
         ts = Timestamp("2017-10-29 00:00:00", tz="UTC").tz_convert("Europe/Madrid")
+        ts = ts._as_unit(unit)
         #
         result = getattr(ts, method)("H", ambiguous=True)
         assert result == ts
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
         result = getattr(ts, method)("H", ambiguous=False)
         expected = Timestamp("2017-10-29 01:00:00", tz="UTC").tz_convert(
             "Europe/Madrid"
         )
         assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
         result = getattr(ts, method)("H", ambiguous="NaT")
         assert result is NaT
@@ -188,12 +200,17 @@ def test_round_dst_border_ambiguous(self, method):
             ["floor", "2018-03-11 03:01:00-0500", "2H"],
         ],
     )
-    def test_round_dst_border_nonexistent(self, method, ts_str, freq):
+    @pytest.mark.parametrize(
+        "unit",
+        ["ns", "us", "ms", "s"],
+    )
+    def test_round_dst_border_nonexistent(self, method, ts_str, freq, unit):
         # GH 23324 round near "spring forward" DST
-        ts = Timestamp(ts_str, tz="America/Chicago")
+        ts = Timestamp(ts_str, tz="America/Chicago")._as_unit(unit)
         result = getattr(ts, method)(freq, nonexistent="shift_forward")
         expected = Timestamp("2018-03-11 03:00:00", tz="America/Chicago")
         assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
         result = getattr(ts, method)(freq, nonexistent="NaT")
         assert result is NaT
@@ -280,6 +297,7 @@ def test_round_implementation_bounds(self):
         with pytest.raises(OverflowError, match=msg):
             Timestamp.max.ceil("s")
 
+    @pytest.mark.xfail(reason="Failing on builds", strict=False)
     @given(val=st.integers(iNaT + 1, lib.i8max))
     @pytest.mark.parametrize(
         "method", [Timestamp.round, Timestamp.floor, Timestamp.ceil]
@@ -338,6 +356,16 @@ def checker(res, ts, nanos):
     # --------------------------------------------------------------
     # Timestamp.replace
 
+    def test_replace_non_nano(self):
+        ts = Timestamp._from_value_and_reso(
+            91514880000000000, NpyDatetimeUnit.NPY_FR_us.value, None
+        )
+        assert ts.to_pydatetime() == datetime(4869, 12, 28)
+
+        result = ts.replace(year=4900)
+        assert result._reso == ts._reso
+        assert result.to_pydatetime() == datetime(4900, 12, 28)
+
     def test_replace_naive(self):
         # GH#14621, GH#7825
         ts = Timestamp("2016-01-01 09:00:00")
@@ -455,35 +483,41 @@ def test_replace_across_dst(self, tz, normalize):
         ts2b = normalize(ts2)
         assert ts2 == ts2b
 
-    def test_replace_dst_border(self):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_replace_dst_border(self, unit):
         # Gh 7825
-        t = Timestamp("2013-11-3", tz="America/Chicago")
+        t = Timestamp("2013-11-3", tz="America/Chicago")._as_unit(unit)
         result = t.replace(hour=3)
         expected = Timestamp("2013-11-3 03:00:00", tz="America/Chicago")
         assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
     @pytest.mark.parametrize("fold", [0, 1])
     @pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"])
-    def test_replace_dst_fold(self, fold, tz):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_replace_dst_fold(self, fold, tz, unit):
         # GH 25017
         d = datetime(2019, 10, 27, 2, 30)
-        ts = Timestamp(d, tz=tz)
+        ts = Timestamp(d, tz=tz)._as_unit(unit)
         result = ts.replace(hour=1, fold=fold)
         expected = Timestamp(datetime(2019, 10, 27, 1, 30)).tz_localize(
             tz, ambiguous=not fold
         )
         assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
     # --------------------------------------------------------------
     # Timestamp.normalize
 
     @pytest.mark.parametrize("arg", ["2013-11-30", "2013-11-30 12:00:00"])
-    def test_normalize(self, tz_naive_fixture, arg):
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_normalize(self, tz_naive_fixture, arg, unit):
         tz = tz_naive_fixture
-        ts = Timestamp(arg, tz=tz)
+        ts = Timestamp(arg, tz=tz)._as_unit(unit)
         result = ts.normalize()
         expected = Timestamp("2013-11-30", tz=tz)
         assert result == expected
+        assert result._reso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
     def test_normalize_pre_epoch_dates(self):
         # GH: 36294
diff --git a/pandas/tests/series/accessors/test_cat_accessor.py b/pandas/tests/series/accessors/test_cat_accessor.py
index 1a038839a67c9..750e84b8cde08 100644
--- a/pandas/tests/series/accessors/test_cat_accessor.py
+++ b/pandas/tests/series/accessors/test_cat_accessor.py
@@ -110,7 +110,8 @@ def test_categorical_delegations(self):
         ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
         exp_categories = Index(["a", "b", "c"])
         tm.assert_index_equal(ser.cat.categories, exp_categories)
-        ser.cat.categories = [1, 2, 3]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            ser.cat.categories = [1, 2, 3]
         exp_categories = Index([1, 2, 3])
         tm.assert_index_equal(ser.cat.categories, exp_categories)
 
@@ -120,7 +121,8 @@ def test_categorical_delegations(self):
         assert ser.cat.ordered
         ser = ser.cat.as_unordered()
         assert not ser.cat.ordered
-        return_value = ser.cat.as_ordered(inplace=True)
+        with tm.assert_produces_warning(FutureWarning, match="The `inplace`"):
+            return_value = ser.cat.as_ordered(inplace=True)
         assert return_value is None
         assert ser.cat.ordered
 
@@ -267,8 +269,10 @@ def test_set_categories_setitem(self):
         df = DataFrame({"Survived": [1, 0, 1], "Sex": [0, 1, 1]}, dtype="category")
 
         # change the dtype in-place
-        df["Survived"].cat.categories = ["No", "Yes"]
-        df["Sex"].cat.categories = ["female", "male"]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            df["Survived"].cat.categories = ["No", "Yes"]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            df["Sex"].cat.categories = ["female", "male"]
 
         # values should not be coerced to NaN
         assert list(df["Sex"]) == ["female", "male", "male"]
@@ -282,3 +286,12 @@ def test_set_categories_setitem(self):
         # values should not be coerced to NaN
         assert list(df["Sex"]) == ["female", "male", "male"]
         assert list(df["Survived"]) == ["Yes", "No", "Yes"]
+
+    def test_categorical_of_booleans_is_boolean(self):
+        # https://github.com/pandas-dev/pandas/issues/46313
+        df = DataFrame(
+            {"int_cat": [1, 2, 3], "bool_cat": [True, False, False]}, dtype="category"
+        )
+        value = df["bool_cat"].cat.categories.dtype
+        expected = np.dtype(np.bool_)
+        assert value is expected
diff --git a/pandas/tests/series/accessors/test_dt_accessor.py b/pandas/tests/series/accessors/test_dt_accessor.py
index 41b5e55e75213..11ad7c1dd457e 100644
--- a/pandas/tests/series/accessors/test_dt_accessor.py
+++ b/pandas/tests/series/accessors/test_dt_accessor.py
@@ -12,6 +12,7 @@
 import pytz
 
 from pandas._libs.tslibs.timezones import maybe_get_tz
+from pandas.errors import SettingWithCopyError
 
 from pandas.core.dtypes.common import (
     is_integer_dtype,
@@ -37,7 +38,6 @@
     PeriodArray,
     TimedeltaArray,
 )
-import pandas.core.common as com
 
 ok_for_period = PeriodArray._datetimelike_ops
 ok_for_period_methods = ["strftime", "to_timestamp", "asfreq"]
@@ -279,7 +279,7 @@ def test_dt_accessor_ambiguous_freq_conversions(self):
         expected = Series(exp_values, name="xxx")
         tm.assert_series_equal(ser, expected)
 
-    def test_dt_accessor_not_writeable(self):
+    def test_dt_accessor_not_writeable(self, using_copy_on_write):
         # no setting allowed
         ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
         with pytest.raises(ValueError, match="modifications"):
@@ -288,8 +288,12 @@ def test_dt_accessor_not_writeable(self):
         # trying to set a copy
         msg = "modifications to a property of a datetimelike.+not supported"
         with pd.option_context("chained_assignment", "raise"):
-            with pytest.raises(com.SettingWithCopyError, match=msg):
+            if using_copy_on_write:
+                # TODO(CoW) it would be nice to keep a warning/error for this case
                 ser.dt.hour[0] = 5
+            else:
+                with pytest.raises(SettingWithCopyError, match=msg):
+                    ser.dt.hour[0] = 5
 
     @pytest.mark.parametrize(
         "method, dates",
@@ -618,6 +622,17 @@ def test_strftime_nat(self, data):
         expected = Series(["2019-01-01", np.nan])
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "data", [DatetimeIndex([pd.NaT]), PeriodIndex([pd.NaT], dtype="period[D]")]
+    )
+    def test_strftime_all_nat(self, data):
+        # https://github.com/pandas-dev/pandas/issues/45858
+        ser = Series(data)
+        with tm.assert_produces_warning(None):
+            result = ser.dt.strftime("%Y-%m-%d")
+        expected = Series([np.nan], dtype=object)
+        tm.assert_series_equal(result, expected)
+
     def test_valid_dt_with_missing_values(self):
 
         from datetime import (
diff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py
index 0da376ccac450..acdcc03cee92c 100644
--- a/pandas/tests/series/indexing/test_getitem.py
+++ b/pandas/tests/series/indexing/test_getitem.py
@@ -201,6 +201,12 @@ def test_getitem_str_with_timedeltaindex(self):
         with pytest.raises(KeyError, match=msg):
             ser["50 days"]
 
+    def test_getitem_bool_index_positional(self):
+        # GH#48653
+        ser = Series({True: 1, False: 0})
+        result = ser[0]
+        assert result == 1
+
 
 class TestSeriesGetitemSlices:
     def test_getitem_partial_str_slice_with_datetimeindex(self):
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index 3671ddee60b6f..e3df9671e6c64 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -5,7 +5,10 @@
 import numpy as np
 import pytest
 
+from pandas.errors import IndexingError
+
 from pandas import (
+    NA,
     DataFrame,
     IndexSlice,
     MultiIndex,
@@ -165,7 +168,7 @@ def test_setitem_ambiguous_keyerror(indexer_sl):
     tm.assert_series_equal(s2, expected)
 
 
-def test_setitem(datetime_series, string_series):
+def test_setitem(datetime_series):
     datetime_series[datetime_series.index[5]] = np.NaN
     datetime_series[[1, 2, 17]] = np.NaN
     datetime_series[6] = np.NaN
@@ -206,7 +209,8 @@ def test_basic_getitem_setitem_corner(datetime_series):
         datetime_series[[5, slice(None, None)]] = 2
 
 
-def test_slice(string_series, object_series):
+def test_slice(string_series, object_series, using_copy_on_write):
+    original = string_series.copy()
     numSlice = string_series[10:20]
     numSliceEnd = string_series[-10:]
     objSlice = object_series[10:20]
@@ -224,7 +228,11 @@ def test_slice(string_series, object_series):
     sl = string_series[10:20]
     sl[:] = 0
 
-    assert (string_series[10:20] == 0).all()
+    if using_copy_on_write:
+        # Doesn't modify parent (CoW)
+        tm.assert_series_equal(string_series, original)
+    else:
+        assert (string_series[10:20] == 0).all()
 
 
 def test_timedelta_assignment():
@@ -241,21 +249,25 @@ def test_timedelta_assignment():
     tm.assert_series_equal(s, expected)
 
 
-def test_underlying_data_conversion():
+def test_underlying_data_conversion(using_copy_on_write):
     # GH 4080
     df = DataFrame({c: [1, 2, 3] for c in ["a", "b", "c"]})
     return_value = df.set_index(["a", "b", "c"], inplace=True)
     assert return_value is None
     s = Series([1], index=[(2, 2, 2)])
     df["val"] = 0
+    df_original = df.copy()
     df
     df["val"].update(s)
 
-    expected = DataFrame(
-        {"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3], "val": [0, 1, 0]}
-    )
-    return_value = expected.set_index(["a", "b", "c"], inplace=True)
-    assert return_value is None
+    if using_copy_on_write:
+        expected = df_original
+    else:
+        expected = DataFrame(
+            {"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3], "val": [0, 1, 0]}
+        )
+        return_value = expected.set_index(["a", "b", "c"], inplace=True)
+        assert return_value is None
     tm.assert_frame_equal(df, expected)
 
 
@@ -321,7 +333,48 @@ def test_frozenset_index():
     assert s[idx1] == 3
 
 
-class TestDepreactedIndexers:
+def test_loc_setitem_all_false_indexer():
+    # GH#45778
+    ser = Series([1, 2], index=["a", "b"])
+    expected = ser.copy()
+    rhs = Series([6, 7], index=["a", "b"])
+    ser.loc[ser > 100] = rhs
+    tm.assert_series_equal(ser, expected)
+
+
+def test_loc_boolean_indexer_non_matching_index():
+    # GH#46551
+    ser = Series([1])
+    result = ser.loc[Series([NA, False], dtype="boolean")]
+    expected = Series([], dtype="int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_boolean_indexer_miss_matching_index():
+    # GH#46551
+    ser = Series([1])
+    indexer = Series([NA, False], dtype="boolean", index=[1, 2])
+    with pytest.raises(IndexingError, match="Unalignable"):
+        ser.loc[indexer]
+
+
+def test_loc_setitem_nested_data_enlargement():
+    # GH#48614
+    df = DataFrame({"a": [1]})
+    ser = Series({"label": df})
+    ser.loc["new_label"] = df
+    expected = Series({"label": df, "new_label": df})
+    tm.assert_series_equal(ser, expected)
+
+
+def test_getitem_bool_int_key():
+    # GH#48653
+    ser = Series({True: 1, False: 0})
+    with pytest.raises(KeyError, match="0"):
+        ser.loc[0]
+
+
+class TestDeprecatedIndexers:
     @pytest.mark.parametrize("key", [{1}, {1: 1}])
     def test_getitem_dict_and_set_deprecated(self, key):
         # GH#42825
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index fb07b28c5a54f..500ff2e90adb1 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -6,9 +6,12 @@
 import numpy as np
 import pytest
 
+from pandas.errors import IndexingError
+
 from pandas.core.dtypes.common import is_list_like
 
 from pandas import (
+    NA,
     Categorical,
     DataFrame,
     DatetimeIndex,
@@ -17,15 +20,18 @@
     IntervalIndex,
     MultiIndex,
     NaT,
+    Period,
     Series,
     Timedelta,
     Timestamp,
+    array,
     concat,
     date_range,
+    interval_range,
     period_range,
+    timedelta_range,
 )
 import pandas._testing as tm
-from pandas.core.indexing import IndexingError
 
 from pandas.tseries.offsets import BDay
 
@@ -354,6 +360,48 @@ def test_setitem_nan_with_bool(self):
         expected = Series([np.nan, False, True], dtype=object)
         tm.assert_series_equal(result, expected)
 
+    def test_setitem_mask_smallint_upcast(self):
+        orig = Series([1, 2, 3], dtype="int8")
+        alt = np.array([999, 1000, 1001], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        ser[mask] = Series(alt)
+        expected = Series([999, 2, 1001])
+        tm.assert_series_equal(ser, expected)
+
+        ser2 = orig.copy()
+        ser2.mask(mask, alt, inplace=True)
+        tm.assert_series_equal(ser2, expected)
+
+        ser3 = orig.copy()
+        res = ser3.where(~mask, Series(alt))
+        tm.assert_series_equal(res, expected)
+
+    def test_setitem_mask_smallint_no_upcast(self):
+        # like test_setitem_mask_smallint_upcast, but while we can't hold 'alt',
+        #  we *can* hold alt[mask] without casting
+        orig = Series([1, 2, 3], dtype="uint8")
+        alt = Series([245, 1000, 246], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        ser[mask] = alt
+        expected = Series([245, 2, 246], dtype="uint8")
+        tm.assert_series_equal(ser, expected)
+
+        ser2 = orig.copy()
+        ser2.mask(mask, alt, inplace=True)
+        tm.assert_series_equal(ser2, expected)
+
+        # FIXME: don't leave commented-out
+        # FIXME: ser.where(~mask, alt) unnecessarily upcasts to int64
+        # ser3 = orig.copy()
+        # res = ser3.where(~mask, alt)
+        # tm.assert_series_equal(res, expected)
+
 
 class TestSetitemViewCopySemantics:
     def test_setitem_invalidates_datetime_index_freq(self):
@@ -481,6 +529,41 @@ def test_setitem_not_contained(self, string_series):
         expected = concat([string_series, app])
         tm.assert_series_equal(ser, expected)
 
+    def test_setitem_keep_precision(self, any_numeric_ea_dtype):
+        # GH#32346
+        ser = Series([1, 2], dtype=any_numeric_ea_dtype)
+        ser[2] = 10
+        expected = Series([1, 2, 10], dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("indexer", [1, 2])
+    @pytest.mark.parametrize(
+        "na, target_na, dtype, target_dtype",
+        [
+            (NA, NA, "Int64", "Int64"),
+            (NA, np.nan, "int64", "float64"),
+            (NaT, NaT, "int64", "object"),
+            (np.nan, NA, "Int64", "Int64"),
+            (np.nan, NA, "Float64", "Float64"),
+            (np.nan, np.nan, "int64", "float64"),
+        ],
+    )
+    def test_setitem_enlarge_with_na(self, na, target_na, dtype, target_dtype, indexer):
+        # GH#32346
+        ser = Series([1, 2], dtype=dtype)
+        ser[indexer] = na
+        expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
+        expected = Series(expected_values, dtype=target_dtype)
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_enlargement_object_none(self, nulls_fixture):
+        # GH#48665
+        ser = Series(["a", "b"])
+        ser[3] = nulls_fixture
+        expected = Series(["a", "b", nulls_fixture], index=[0, 1, 3])
+        tm.assert_series_equal(ser, expected)
+        assert ser[3] is nulls_fixture
+
 
 def test_setitem_scalar_into_readonly_backing_data():
     # GH#14359: test that you cannot mutate a read only buffer
@@ -565,6 +648,19 @@ def test_setitem_non_bool_into_bool(self, val, indexer_sli, unique):
             expected = Series([val, val], dtype=object, index=[1, 1])
         tm.assert_series_equal(ser, expected)
 
+    def test_setitem_boolean_array_into_npbool(self):
+        # GH#45462
+        ser = Series([True, False, True])
+        values = ser._values
+        arr = array([True, False, None])
+
+        ser[:2] = arr[:2]  # no NAs -> can set inplace
+        assert ser._values is values
+
+        ser[1:] = arr[1:]  # has an NA -> cast to boolean dtype
+        expected = Series(arr)
+        tm.assert_series_equal(ser, expected)
+
 
 class SetitemCastingEquivalents:
     """
@@ -576,11 +672,15 @@ class SetitemCastingEquivalents:
     """
 
     @pytest.fixture
-    def is_inplace(self):
+    def is_inplace(self, obj, expected):
         """
-        Indicate that we are not (yet) checking whether or not setting is inplace.
+        Whether we expect the setting to be in-place or not.
         """
-        return None
+        try:
+            return expected.dtype == obj.dtype
+        except TypeError:
+            # older numpys
+            return False
 
     def check_indexer(self, obj, key, expected, val, indexer, is_inplace):
         orig = obj
@@ -688,32 +788,35 @@ def test_series_where(self, obj, key, expected, val, is_inplace):
 
         self._check_inplace(is_inplace, orig, arr, obj)
 
-    def test_index_where(self, obj, key, expected, val, request):
-        if obj.dtype == bool:
-            # TODO(GH#45061): Should become unreachable
-            pytest.skip("test not applicable for this dtype")
-
+    def test_index_where(self, obj, key, expected, val):
         mask = np.zeros(obj.shape, dtype=bool)
         mask[key] = True
 
         res = Index(obj).where(~mask, val)
-        tm.assert_index_equal(res, Index(expected))
+        tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
 
     def test_index_putmask(self, obj, key, expected, val):
-        if obj.dtype == bool:
-            # TODO(GH#45061): Should become unreachable
-            pytest.skip("test not applicable for this dtype")
-
         mask = np.zeros(obj.shape, dtype=bool)
         mask[key] = True
 
         res = Index(obj).putmask(mask, val)
-        tm.assert_index_equal(res, Index(expected))
+        tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
 
 
 @pytest.mark.parametrize(
     "obj,expected,key",
     [
+        pytest.param(
+            # GH#45568 setting a valid NA value into IntervalDtype[int] should
+            #  cast to IntervalDtype[float]
+            Series(interval_range(1, 5)),
+            Series(
+                [Interval(1, 2), np.nan, Interval(3, 4), Interval(4, 5)],
+                dtype="interval[float64]",
+            ),
+            1,
+            id="interval_int_na_value",
+        ),
         pytest.param(
             # these induce dtype changes
             Series([2, 3, 4, 5, 6, 7, 8, 9, 10]),
@@ -759,11 +862,13 @@ def test_index_putmask(self, obj, key, expected, val):
     ],
 )
 class TestSetitemCastingEquivalents(SetitemCastingEquivalents):
-    @pytest.fixture(params=[np.nan, np.float64("NaN")])
+    @pytest.fixture(params=[np.nan, np.float64("NaN"), None, NA])
     def val(self, request):
         """
-        One python float NaN, one np.float64.  Only np.float64 has a `dtype`
-        attribute.
+        NA values that should generally be valid_na for *all* dtypes.
+
+        Include both python float NaN and np.float64; only np.float64 has a
+        `dtype` attribute.
         """
         return request.param
 
@@ -800,13 +905,6 @@ def expected(self, dtype):
     def key(self):
         return 0
 
-    @pytest.fixture
-    def is_inplace(self):
-        """
-        Indicate we do _not_ expect the setting to be done inplace.
-        """
-        return False
-
 
 class TestSetitemDT64IntoInt(SetitemCastingEquivalents):
     # GH#39619 dont cast dt64 to int when doing this setitem
@@ -843,10 +941,6 @@ def val(self, scalar, request):
             return scalar
         return box([scalar, scalar])
 
-    @pytest.fixture
-    def is_inplace(self):
-        return False
-
 
 class TestSetitemNAPeriodDtype(SetitemCastingEquivalents):
     # Setting compatible NA values into Series with PeriodDtype
@@ -870,10 +964,6 @@ def key(self, request):
     def val(self, request):
         return request.param
 
-    @pytest.fixture
-    def is_inplace(self):
-        return True
-
 
 class TestSetitemNADatetimeLikeDtype(SetitemCastingEquivalents):
     # some nat-like values should be cast to datetime64/timedelta64 when
@@ -986,11 +1076,6 @@ def key(self):
     def val(self):
         return None
 
-    @pytest.fixture
-    def is_inplace(self, obj):
-        # This is specific to the 4 cases currently implemented for this class.
-        return obj.dtype.kind != "i"
-
 
 class TestSetitemFloatIntervalWithIntIntervalValues(SetitemCastingEquivalents):
     # GH#44201 Cast to shared IntervalDtype rather than object
@@ -1048,17 +1133,13 @@ def expected(self, any_int_numpy_dtype):
         exp = Series([2, 3, 2, 3, 4], dtype=dtype)
         return exp
 
-    @pytest.fixture
-    def inplace(self):
-        return True
-
 
 @pytest.mark.parametrize(
     "val",
     [
         np.array([2.0, 3.0]),
         np.array([2.5, 3.5]),
-        np.array([2 ** 65, 2 ** 65 + 1], dtype=np.float64),  # all ints, but can't cast
+        np.array([2**65, 2**65 + 1], dtype=np.float64),  # all ints, but can't cast
     ],
 )
 class TestSetitemFloatNDarrayIntoIntegerSeries(SetitemCastingEquivalents):
@@ -1071,13 +1152,9 @@ def key(self):
         return slice(0, 2)
 
     @pytest.fixture
-    def inplace(self, val):
-        # NB: this condition is based on currently-harcoded "val" cases
-        return val[0] == 2
-
-    @pytest.fixture
-    def expected(self, val, inplace):
-        if inplace:
+    def expected(self, val):
+        if val[0] == 2:
+            # NB: this condition is based on currently-hardcoded "val" cases
             dtype = np.int64
         else:
             dtype = np.float64
@@ -1096,28 +1173,12 @@ def obj(self):
     def key(self):
         return 1
 
-    @pytest.fixture
-    def inplace(self):
-        return False
-
     @pytest.fixture
     def expected(self):
         return Series([1, 512, 3], dtype=np.int16)
 
-    def test_int_key(self, obj, key, expected, val, indexer_sli, is_inplace, request):
-        if not isinstance(val, np.int16):
-            mark = pytest.mark.xfail
-            request.node.add_marker(mark)
-        super().test_int_key(obj, key, expected, val, indexer_sli, is_inplace)
 
-    def test_mask_key(self, obj, key, expected, val, indexer_sli, request):
-        if not isinstance(val, np.int16):
-            mark = pytest.mark.xfail
-            request.node.add_marker(mark)
-        super().test_mask_key(obj, key, expected, val, indexer_sli)
-
-
-@pytest.mark.parametrize("val", [2 ** 33 + 1.0, 2 ** 33 + 1.1, 2 ** 62])
+@pytest.mark.parametrize("val", [2**33 + 1.0, 2**33 + 1.1, 2**62])
 class TestSmallIntegerSetitemUpcast(SetitemCastingEquivalents):
     # https://github.com/pandas-dev/pandas/issues/39584#issuecomment-941212124
     @pytest.fixture
@@ -1129,35 +1190,207 @@ def key(self):
         return 0
 
     @pytest.fixture
-    def inplace(self):
-        return False
+    def expected(self, val):
+        if val % 1 != 0:
+            dtype = "f8"
+        else:
+            dtype = "i8"
+        return Series([val, 2, 3], dtype=dtype)
+
+
+class CoercionTest(SetitemCastingEquivalents):
+    # Tests ported from tests.indexing.test_coercion
 
     @pytest.fixture
-    def expected(self, val):
-        if val == 2 ** 62:
-            return Series([val, 2, 3], dtype="i8")
-        elif val == 2 ** 33 + 1.1:
-            return Series([val, 2, 3], dtype="f8")
+    def key(self):
+        return 1
+
+    @pytest.fixture
+    def expected(self, obj, key, val, exp_dtype):
+        vals = list(obj)
+        vals[key] = val
+        return Series(vals, dtype=exp_dtype)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype", [(np.int32(1), np.int8), (np.int16(2**9), np.int16)]
+)
+class TestCoercionInt8(CoercionTest):
+    # previously test_setitem_series_int8 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4], dtype=np.int8)
+
+
+@pytest.mark.parametrize("val", [1, 1.1, 1 + 1j, True])
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestCoercionObject(CoercionTest):
+    # previously test_setitem_series_object in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(["a", "b", "c", "d"], dtype=object)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [(1, np.complex128), (1.1, np.complex128), (1 + 1j, np.complex128), (True, object)],
+)
+class TestCoercionComplex(CoercionTest):
+    # previously test_setitem_series_complex128 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [
+        (1, object),
+        ("3", object),
+        (3, object),
+        (1.1, object),
+        (1 + 1j, object),
+        (True, bool),
+    ],
+)
+class TestCoercionBool(CoercionTest):
+    # previously test_setitem_series_bool in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([True, False, True, False], dtype=bool)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [(1, np.int64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)],
+)
+class TestCoercionInt64(CoercionTest):
+    # previously test_setitem_series_int64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [(1, np.float64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)],
+)
+class TestCoercionFloat64(CoercionTest):
+    # previously test_setitem_series_float64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [
+        (1, np.float32),
+        pytest.param(
+            1.1,
+            np.float32,
+            marks=pytest.mark.xfail(
+                reason="np.float32(1.1) ends up as 1.100000023841858, so "
+                "np_can_hold_element raises and we cast to float64",
+            ),
+        ),
+        (1 + 1j, np.complex128),
+        (True, object),
+        (np.uint8(2), np.float32),
+        (np.uint32(2), np.float32),
+        # float32 cannot hold np.iinfo(np.uint32).max exactly
+        # (closest it can hold is 4294967300.0 which off by 5.0), so
+        # we cast to float64
+        (np.uint32(np.iinfo(np.uint32).max), np.float64),
+        (np.uint64(2), np.float32),
+        (np.int64(2), np.float32),
+    ],
+)
+class TestCoercionFloat32(CoercionTest):
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4], dtype=np.float32)
+
+    def test_slice_key(self, obj, key, expected, val, indexer_sli, is_inplace):
+        super().test_slice_key(obj, key, expected, val, indexer_sli, is_inplace)
+
+        if type(val) is float:
+            # the xfail would xpass bc test_slice_key short-circuits
+            raise AssertionError("xfail not relevant for this test.")
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [(Timestamp("2012-01-01"), "datetime64[ns]"), (1, object), ("x", object)],
+)
+class TestCoercionDatetime64(CoercionTest):
+    # previously test_setitem_series_datetime64 in tests.indexing.test_coercion
+
+    @pytest.fixture
+    def obj(self):
+        return Series(date_range("2011-01-01", freq="D", periods=4))
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [
+        (Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]"),
+        (Timestamp("2012-01-01", tz="US/Pacific"), object),
+        (Timestamp("2012-01-01"), object),
+        (1, object),
+    ],
+)
+class TestCoercionDatetime64TZ(CoercionTest):
+    # previously test_setitem_series_datetime64tz in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        tz = "US/Eastern"
+        return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz))
+
+    @pytest.fixture(autouse=True)
+    def assert_warns(self, request):
+        # check that we issue a FutureWarning about timezone-matching
+        if request.function.__name__ == "test_slice_key":
+            key = request.getfixturevalue("key")
+            if not isinstance(key, slice):
+                # The test is a no-op, so no warning will be issued
+                yield
+            return
+
+        exp_dtype = request.getfixturevalue("exp_dtype")
+        val = request.getfixturevalue("val")
+        if exp_dtype == object and isinstance(val, Timestamp) and val.tz is not None:
+            with tm.assert_produces_warning(FutureWarning, match="mismatched timezone"):
+                yield
         else:
-            return Series([val, 2, 3], dtype="i8")
+            yield
+
 
-    def test_series_where(self, obj, key, expected, val, is_inplace, request):
-        if isinstance(val, float) and val % 1 == 0:
-            mark = pytest.mark.xfail
-            request.node.add_marker(mark)
-        super().test_series_where(obj, key, expected, val, is_inplace)
+@pytest.mark.parametrize(
+    "val,exp_dtype",
+    [(Timedelta("12 day"), "timedelta64[ns]"), (1, object), ("x", object)],
+)
+class TestCoercionTimedelta64(CoercionTest):
+    # previously test_setitem_series_timedelta64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(timedelta_range("1 day", periods=4))
 
-    def test_int_key(self, obj, key, expected, val, indexer_sli, is_inplace, request):
-        if val % 1 == 0:
-            mark = pytest.mark.xfail
-            request.node.add_marker(mark)
-        super().test_int_key(obj, key, expected, val, indexer_sli, is_inplace)
 
-    def test_mask_key(self, obj, key, expected, val, indexer_sli, request):
-        if val % 1 == 0:
-            mark = pytest.mark.xfail
-            request.node.add_marker(mark)
-        super().test_mask_key(obj, key, expected, val, indexer_sli)
+@pytest.mark.parametrize(
+    "val", ["foo", Period("2016", freq="Y"), Interval(1, 2, closed="both")]
+)
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestPeriodIntervalCoercion(CoercionTest):
+    # GH#45768
+    @pytest.fixture(
+        params=[
+            period_range("2016-01-01", periods=3, freq="D"),
+            interval_range(1, 5),
+        ]
+    )
+    def obj(self, request):
+        return Series(request.param)
 
 
 def test_20643():
@@ -1250,28 +1483,6 @@ def test_15413():
     tm.assert_series_equal(ser, expected)
 
 
-def test_37477():
-    # fixed by GH#45121
-    orig = DataFrame({"A": [1, 2, 3], "B": [3, 4, 5]})
-    expected = DataFrame({"A": [1, 2, 3], "B": [3, 1.2, 5]})
-
-    df = orig.copy()
-    df.at[1, "B"] = 1.2
-    tm.assert_frame_equal(df, expected)
-
-    df = orig.copy()
-    df.loc[1, "B"] = 1.2
-    tm.assert_frame_equal(df, expected)
-
-    df = orig.copy()
-    df.iat[1, 1] = 1.2
-    tm.assert_frame_equal(df, expected)
-
-    df = orig.copy()
-    df.iloc[1, 1] = 1.2
-    tm.assert_frame_equal(df, expected)
-
-
 def test_32878_int_itemsize():
     # Fixed by GH#45121
     arr = np.arange(5).astype("i4")
@@ -1282,22 +1493,17 @@ def test_32878_int_itemsize():
     tm.assert_series_equal(ser, expected)
 
 
-def test_26395(indexer_al):
-    # .at case fixed by GH#45121 (best guess)
-    df = DataFrame(index=["A", "B", "C"])
-    df["D"] = 0
-
-    indexer_al(df)["C", "D"] = 2
-    expected = DataFrame({"D": [0, 0, 2]}, index=["A", "B", "C"], dtype=np.int64)
-    tm.assert_frame_equal(df, expected)
-
-    indexer_al(df)["C", "D"] = 44.5
-    expected = DataFrame({"D": [0, 0, 44.5]}, index=["A", "B", "C"], dtype=np.float64)
-    tm.assert_frame_equal(df, expected)
+def test_32878_complex_itemsize():
+    arr = np.arange(5).astype("c8")
+    ser = Series(arr)
+    val = np.finfo(np.float64).max
+    val = val.astype("c16")
 
-    indexer_al(df)["C", "D"] = "hello"
-    expected = DataFrame({"D": [0, 0, "hello"]}, index=["A", "B", "C"], dtype=object)
-    tm.assert_frame_equal(df, expected)
+    # GH#32878 used to coerce val to inf+0.000000e+00j
+    ser[0] = val
+    assert ser[0] == val
+    expected = Series([val, 1, 2, 3, 4], dtype="c16")
+    tm.assert_series_equal(ser, expected)
 
 
 def test_37692(indexer_al):
@@ -1332,26 +1538,9 @@ def test_setitem_bool_int_float_consistency(indexer_sli):
     indexer_sli(ser)[0] = np.int64(1)
 
 
-def test_6942(indexer_al):
-    # check that the .at __setitem__ after setting "Live" actually sets the data
-    start = Timestamp("2014-04-01")
-    t1 = Timestamp("2014-04-23 12:42:38.883082")
-    t2 = Timestamp("2014-04-24 01:33:30.040039")
-
-    dti = date_range(start, periods=1)
-    orig = DataFrame(index=dti, columns=["timenow", "Live"])
-
-    df = orig.copy()
-    indexer_al(df)[start, "timenow"] = t1
-
-    df["Live"] = True
-
-    df.at[start, "timenow"] = t2
-    assert df.iloc[0, 0] == t2
-
-
-@pytest.mark.xfail(reason="Doesn't catch when numpy raises.")
-def test_45070():
+def test_setitem_positional_with_casting():
+    # GH#45070 case where in __setitem__ we get a KeyError, then when
+    #  we fallback we *also* get a ValueError if we try to set inplace.
     ser = Series([1, 2, 3], index=["a", "b", "c"])
 
     ser[0] = "X"
@@ -1359,101 +1548,15 @@ def test_45070():
     tm.assert_series_equal(ser, expected)
 
 
-@pytest.mark.xfail(reason="unwanted upcast")
-def test_15231():
-    df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"])
-    df.loc[2] = Series({"a": 5, "b": 6})
-    assert (df.dtypes == np.int64).all()
-
-    df.loc[3] = Series({"a": 7})
-
-    # df["a"] doesn't have any NaNs, should not have been cast
-    exp_dtypes = Series([np.int64, np.float64], dtype=object, index=["a", "b"])
-    tm.assert_series_equal(df.dtypes, exp_dtypes)
-
-
-@pytest.mark.xfail(reason="Fails to upcast")
-def test_32878_complex_itemsize():
-    # TODO: when fixed, put adjacent to test_32878_int_itemsize
-    arr = np.arange(5).astype("c8")
-    ser = Series(arr)
-    val = np.finfo(np.float64).max
-    val = val.astype("c16")
-
-    # GH#32878 used to coerce val to inf+0.000000e+00j
-    ser[0] = val
-    assert ser[0] == val
-    expected = Series([val, 1, 2, 3, 4], dtype="c16")
+def test_setitem_positional_float_into_int_coerces():
+    # Case where we hit a KeyError and then trying to set in-place incorrectly
+    #  casts a float to an int
+    ser = Series([1, 2, 3], index=["a", "b", "c"])
+    ser[0] = 1.5
+    expected = Series([1.5, 2, 3], index=["a", "b", "c"])
     tm.assert_series_equal(ser, expected)
 
 
-@pytest.mark.xfail(reason="Unnecessarily upcasts to float64")
-def test_iloc_setitem_unnecesssary_float_upcasting():
-    # GH#12255
-    df = DataFrame(
-        {
-            0: np.array([1, 3], dtype=np.float32),
-            1: np.array([2, 4], dtype=np.float32),
-            2: ["a", "b"],
-        }
-    )
-    orig = df.copy()
-
-    values = df[0].values.reshape(2, 1)
-    df.iloc[:, 0:1] = values
-
-    tm.assert_frame_equal(df, orig)
-
-
-@pytest.mark.xfail(reason="unwanted casting to dt64")
-def test_12499():
-    # TODO: OP in GH#12499 used np.datetim64("NaT") instead of pd.NaT,
-    #  which has consequences for the expected df["two"] (though i think at
-    #  the time it might not have because of a separate bug). See if it makes
-    #  a difference which one we use here.
-    ts = Timestamp("2016-03-01 03:13:22.98986", tz="UTC")
-
-    data = [{"one": 0, "two": ts}]
-    orig = DataFrame(data)
-    df = orig.copy()
-    df.loc[1] = [np.nan, NaT]
-
-    expected = DataFrame(
-        {"one": [0, np.nan], "two": Series([ts, NaT], dtype="datetime64[ns, UTC]")}
-    )
-    tm.assert_frame_equal(df, expected)
-
-    data = [{"one": 0, "two": ts}]
-    df = orig.copy()
-    df.loc[1, :] = [np.nan, NaT]
-    tm.assert_frame_equal(df, expected)
-
-
-@pytest.mark.xfail(reason="Too many columns cast to float64")
-def test_20476():
-    mi = MultiIndex.from_product([["A", "B"], ["a", "b", "c"]])
-    df = DataFrame(-1, index=range(3), columns=mi)
-    filler = DataFrame([[1, 2, 3.0]] * 3, index=range(3), columns=["a", "b", "c"])
-    df["A"] = filler
-
-    expected = DataFrame(
-        {
-            0: [1, 1, 1],
-            1: [2, 2, 2],
-            2: [3.0, 3.0, 3.0],
-            3: [-1, -1, -1],
-            4: [-1, -1, -1],
-            5: [-1, -1, -1],
-        }
-    )
-    expected.columns = mi
-    exp_dtypes = Series(
-        [np.dtype(np.int64)] * 2 + [np.dtype(np.float64)] + [np.dtype(np.int64)] * 3,
-        index=mi,
-    )
-    tm.assert_series_equal(df.dtypes, exp_dtypes)
-
-
 def test_setitem_int_as_positional_fallback_deprecation():
     # GH#42215 deprecated falling back to positional on __setitem__ with an
     #  int not contained in the index
@@ -1544,3 +1647,18 @@ def test_setitem_bool_indexer_dont_broadcast_length1_values(size, mask, item, bo
         expected = Series(np.arange(size, dtype=float))
         expected[selection] = item
         tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_empty_mask_dont_upcast_dt64():
+    dti = date_range("2016-01-01", periods=3)
+    ser = Series(dti)
+    orig = ser.copy()
+    mask = np.zeros(3, dtype=bool)
+
+    ser[mask] = "foo"
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
+
+    ser.mask(mask, "foo", inplace=True)
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
diff --git a/pandas/tests/series/indexing/test_where.py b/pandas/tests/series/indexing/test_where.py
index 9ed04885bd9e1..eabaf23bd36f8 100644
--- a/pandas/tests/series/indexing/test_where.py
+++ b/pandas/tests/series/indexing/test_where.py
@@ -438,7 +438,7 @@ def test_where_categorical(frame_or_series):
     tm.assert_equal(exp, res)
 
 
-def test_where_datetimelike_categorical(request, tz_naive_fixture):
+def test_where_datetimelike_categorical(tz_naive_fixture):
     # GH#37682
     tz = tz_naive_fixture
 
diff --git a/pandas/tests/series/indexing/test_xs.py b/pandas/tests/series/indexing/test_xs.py
index 9a277783a1b3d..8f3414f673627 100644
--- a/pandas/tests/series/indexing/test_xs.py
+++ b/pandas/tests/series/indexing/test_xs.py
@@ -45,7 +45,7 @@ def test_series_getitem_multiindex_xs_by_label(self):
         result = ser.xs("one", level="L2")
         tm.assert_series_equal(result, expected)
 
-    def test_series_getitem_multiindex_xs(xs):
+    def test_series_getitem_multiindex_xs(self):
         # GH#6258
         dt = list(date_range("20130903", periods=3))
         idx = MultiIndex.from_product([list("AB"), dt])
diff --git a/pandas/tests/series/methods/test_align.py b/pandas/tests/series/methods/test_align.py
index 8769ab048a136..33e2b1ccecf2d 100644
--- a/pandas/tests/series/methods/test_align.py
+++ b/pandas/tests/series/methods/test_align.py
@@ -184,3 +184,41 @@ def test_align_periodindex(join_type):
 
     # TODO: assert something?
     ts.align(ts[::2], join=join_type)
+
+
+def test_align_left_fewer_levels():
+    # GH#45224
+    left = Series([2], index=pd.MultiIndex.from_tuples([(1, 3)], names=["a", "c"]))
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)
+
+
+def test_align_left_different_named_levels():
+    # GH#45224
+    left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 4, 3)], names=["a", "d", "c"])
+    )
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 3, 4, 2)], names=["a", "c", "d", "b"])
+    )
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 3, 4, 2)], names=["a", "c", "d", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)
diff --git a/pandas/tests/series/methods/test_asof.py b/pandas/tests/series/methods/test_asof.py
index 7ede868861ac0..4381aa3f34f8d 100644
--- a/pandas/tests/series/methods/test_asof.py
+++ b/pandas/tests/series/methods/test_asof.py
@@ -23,9 +23,12 @@ def test_asof_nanosecond_index_access(self):
 
         first_value = ser.asof(ser.index[0])
 
+        # GH#46903 previously incorrectly was "day"
+        assert dti.resolution == "nanosecond"
+
         # this used to not work bc parsing was done by dateutil that didn't
         #  handle nanoseconds
-        assert first_value == ser["2013-01-01 00:00:00.000000050+0000"]
+        assert first_value == ser["2013-01-01 00:00:00.000000050"]
 
         expected_ts = np.datetime64("2013-01-01 00:00:00.000000050", "ns")
         assert first_value == ser[Timestamp(expected_ts)]
@@ -172,7 +175,7 @@ def test_errors(self):
         )
 
         # non-monotonic
-        assert not s.index.is_monotonic
+        assert not s.index.is_monotonic_increasing
         with pytest.raises(ValueError, match="requires a sorted index"):
             s.asof(s.index[0])
 
diff --git a/pandas/tests/series/methods/test_astype.py b/pandas/tests/series/methods/test_astype.py
index 8197722687e78..498225307b52e 100644
--- a/pandas/tests/series/methods/test_astype.py
+++ b/pandas/tests/series/methods/test_astype.py
@@ -30,6 +30,19 @@
 
 
 class TestAstypeAPI:
+    def test_astype_unitless_dt64_deprecated(self):
+        # GH#47844
+        ser = Series(["1970-01-01", "1970-01-01", "1970-01-01"], dtype="datetime64[ns]")
+
+        msg = "Passing unit-less datetime64 dtype to .astype is deprecated and "
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.astype(np.datetime64)
+        tm.assert_series_equal(ser, res)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.astype("datetime64")
+        tm.assert_series_equal(ser, res)
+
     def test_arg_for_errors_in_astype(self):
         # see GH#14878
         ser = Series([1, 2, 3])
@@ -135,8 +148,8 @@ def test_astype_generic_timestamp_no_frequency(self, dtype, request):
             request.node.add_marker(mark)
 
         msg = (
-            fr"The '{dtype.__name__}' dtype has no unit\. "
-            fr"Please pass in '{dtype.__name__}\[ns\]' instead."
+            rf"The '{dtype.__name__}' dtype has no unit\. "
+            rf"Please pass in '{dtype.__name__}\[ns\]' instead."
         )
         with pytest.raises(ValueError, match=msg):
             ser.astype(dtype)
@@ -322,6 +335,17 @@ def test_astype_cast_object_int_fail(self, dtype):
         with pytest.raises(ValueError, match=msg):
             arr.astype(dtype)
 
+    def test_astype_float_to_uint_negatives_raise(
+        self, float_numpy_dtype, any_unsigned_int_numpy_dtype
+    ):
+        # GH#45151
+        # TODO: same for EA float/uint dtypes
+        arr = np.arange(5).astype(float_numpy_dtype) - 3  # includes negatives
+        ser = Series(arr)
+
+        with pytest.raises(ValueError, match="losslessly"):
+            ser.astype(any_unsigned_int_numpy_dtype)
+
     def test_astype_cast_object_int(self):
         arr = Series(["1", "2", "3", "4"], dtype=object)
         result = arr.astype(int)
@@ -370,7 +394,12 @@ def test_astype_nan_to_bool(self):
     )
     def test_astype_ea_to_datetimetzdtype(self, dtype):
         # GH37553
-        result = Series([4, 0, 9], dtype=dtype).astype(DatetimeTZDtype(tz="US/Pacific"))
+        ser = Series([4, 0, 9], dtype=dtype)
+        warn = FutureWarning if ser.dtype.kind == "f" else None
+        msg = "with a timezone-aware dtype and floating-dtype data"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = ser.astype(DatetimeTZDtype(tz="US/Pacific"))
+
         expected = Series(
             {
                 0: Timestamp("1969-12-31 16:00:00.000000004-08:00", tz="US/Pacific"),
@@ -430,7 +459,7 @@ def test_astype_string_to_extension_dtype_roundtrip(
         self, data, dtype, request, nullable_string_dtype
     ):
         if dtype == "boolean" or (
-            dtype in ("period[M]", "datetime64[ns]", "timedelta64[ns]") and NaT in data
+            dtype in ("datetime64[ns]", "timedelta64[ns]") and NaT in data
         ):
             mark = pytest.mark.xfail(
                 reason="TODO StringArray.astype() with missing values #GH40566"
@@ -584,3 +613,9 @@ def test_astype_from_categorical_with_keywords(self):
         exp = Series(Categorical(lst, categories=list("abcdef"), ordered=True))
         res = ser.astype(CategoricalDtype(list("abcdef"), ordered=True))
         tm.assert_series_equal(res, exp)
+
+    def test_astype_timedelta64_with_np_nan(self):
+        # GH45798
+        result = Series([Timedelta(1), np.nan], dtype="timedelta64[ns]")
+        expected = Series([Timedelta(1), NaT], dtype="timedelta64[ns]")
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_compare.py b/pandas/tests/series/methods/test_compare.py
index 8570800048898..fe2016a245ec7 100644
--- a/pandas/tests/series/methods/test_compare.py
+++ b/pandas/tests/series/methods/test_compare.py
@@ -114,3 +114,28 @@ def test_compare_unaligned_objects():
         ser1 = pd.Series([1, 2, 3])
         ser2 = pd.Series([1, 2, 3, 4])
         ser1.compare(ser2)
+
+
+def test_compare_datetime64_and_string():
+    # Issue https://github.com/pandas-dev/pandas/issues/45506
+    # Catch OverflowError when comparing datetime64 and string
+    data = [
+        {"a": "2015-07-01", "b": "08335394550"},
+        {"a": "2015-07-02", "b": "+49 (0) 0345 300033"},
+        {"a": "2015-07-03", "b": "+49(0)2598 04457"},
+        {"a": "2015-07-04", "b": "0741470003"},
+        {"a": "2015-07-05", "b": "04181 83668"},
+    ]
+    dtypes = {"a": "datetime64[ns]", "b": "string"}
+    df = pd.DataFrame(data=data).astype(dtypes)
+
+    result_eq1 = df["a"].eq(df["b"])
+    result_eq2 = df["a"] == df["b"]
+    result_neq = df["a"] != df["b"]
+
+    expected_eq = pd.Series([False] * 5)  # For .eq and ==
+    expected_neq = pd.Series([True] * 5)  # For !=
+
+    tm.assert_series_equal(result_eq1, expected_eq)
+    tm.assert_series_equal(result_eq2, expected_eq)
+    tm.assert_series_equal(result_neq, expected_neq)
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index 1e88ddf3cd943..25cbcf2a84490 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.core.dtypes.common import is_interval_dtype
-
 import pandas as pd
 import pandas._testing as tm
 
@@ -203,12 +201,8 @@ def test_convert_dtypes(
 
         # Test that it is a copy
         copy = series.copy(deep=True)
-        if is_interval_dtype(result.dtype) and result.dtype.subtype.kind in ["i", "u"]:
-            msg = "Cannot set float NaN to integer-backed IntervalArray"
-            with pytest.raises(ValueError, match=msg):
-                result[result.notna()] = np.nan
-        else:
-            result[result.notna()] = np.nan
+
+        result[result.notna()] = np.nan
 
         # Make sure original not changed
         tm.assert_series_equal(series, copy)
diff --git a/pandas/tests/series/methods/test_copy.py b/pandas/tests/series/methods/test_copy.py
index 8aa5c14812dc0..d681c0d02e0a2 100644
--- a/pandas/tests/series/methods/test_copy.py
+++ b/pandas/tests/series/methods/test_copy.py
@@ -9,20 +9,28 @@
 
 
 class TestCopy:
-    @pytest.mark.parametrize("deep", [None, False, True])
-    def test_copy(self, deep):
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy(self, deep, using_copy_on_write):
 
         ser = Series(np.arange(10), dtype="float64")
 
         # default deep is True
-        if deep is None:
+        if deep == "default":
             ser2 = ser.copy()
         else:
             ser2 = ser.copy(deep=deep)
 
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
         ser2[::2] = np.NaN
 
-        if deep is None or deep is True:
+        if deep is not False or using_copy_on_write:
             # Did not modify original Series
             assert np.isnan(ser2[0])
             assert not np.isnan(ser[0])
@@ -31,8 +39,8 @@ def test_copy(self, deep):
             assert np.isnan(ser2[0])
             assert np.isnan(ser[0])
 
-    @pytest.mark.parametrize("deep", [None, False, True])
-    def test_copy_tzaware(self, deep):
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy_tzaware(self, deep, using_copy_on_write):
         # GH#11794
         # copy of tz-aware
         expected = Series([Timestamp("2012/01/01", tz="UTC")])
@@ -40,15 +48,23 @@ def test_copy_tzaware(self, deep):
 
         ser = Series([Timestamp("2012/01/01", tz="UTC")])
 
-        if deep is None:
+        if deep == "default":
             ser2 = ser.copy()
         else:
             ser2 = ser.copy(deep=deep)
 
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
         ser2[0] = Timestamp("1999/01/01", tz="UTC")
 
         # default deep is True
-        if deep is None or deep is True:
+        if deep is not False or using_copy_on_write:
             # Did not modify original Series
             tm.assert_series_equal(ser2, expected2)
             tm.assert_series_equal(ser, expected)
diff --git a/pandas/tests/series/methods/test_describe.py b/pandas/tests/series/methods/test_describe.py
index e6c6016d2b3a1..56bd9341d2efe 100644
--- a/pandas/tests/series/methods/test_describe.py
+++ b/pandas/tests/series/methods/test_describe.py
@@ -1,4 +1,12 @@
 import numpy as np
+import pytest
+
+from pandas.compat import is_numpy_dev
+
+from pandas.core.dtypes.common import (
+    is_complex_dtype,
+    is_extension_array_dtype,
+)
 
 from pandas import (
     Period,
@@ -149,3 +157,34 @@ def test_datetime_is_numeric_includes_datetime(self):
             index=["count", "mean", "min", "25%", "50%", "75%", "max"],
         )
         tm.assert_series_equal(result, expected)
+
+    def test_numeric_result_dtype(self, any_numeric_dtype):
+        # GH#48340 - describe should always return float on non-complex numeric input
+        if is_extension_array_dtype(any_numeric_dtype):
+            dtype = "Float64"
+        else:
+            dtype = "complex128" if is_complex_dtype(any_numeric_dtype) else None
+
+        ser = Series([0, 1], dtype=any_numeric_dtype)
+        if dtype == "complex128" and is_numpy_dev:
+            with pytest.raises(
+                TypeError, match=r"^a must be an array of real numbers$"
+            ):
+                ser.describe()
+            return
+        result = ser.describe()
+        expected = Series(
+            [
+                2.0,
+                0.5,
+                ser.std(),
+                0,
+                0.25,
+                0.5,
+                0.75,
+                1.0,
+            ],
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype=dtype,
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_drop.py b/pandas/tests/series/methods/test_drop.py
index a566f8f62d72e..c960c281b2b95 100644
--- a/pandas/tests/series/methods/test_drop.py
+++ b/pandas/tests/series/methods/test_drop.py
@@ -1,6 +1,9 @@
 import pytest
 
-from pandas import Series
+from pandas import (
+    Index,
+    Series,
+)
 import pandas._testing as tm
 
 
@@ -21,8 +24,8 @@ def test_drop_unique_and_non_unique_index(
     data, index, axis, drop_labels, expected_data, expected_index
 ):
 
-    s = Series(data=data, index=index)
-    result = s.drop(drop_labels, axis=axis)
+    ser = Series(data=data, index=index)
+    result = ser.drop(drop_labels, axis=axis)
     expected = Series(data=expected_data, index=expected_index)
     tm.assert_series_equal(result, expected)
 
@@ -45,17 +48,18 @@ def test_drop_exception_raised(data, index, drop_labels, axis, error_type, error
 
 def test_drop_with_ignore_errors():
     # errors='ignore'
-    s = Series(range(3), index=list("abc"))
-    result = s.drop("bc", errors="ignore")
-    tm.assert_series_equal(result, s)
-    result = s.drop(["a", "d"], errors="ignore")
-    expected = s.iloc[1:]
+    ser = Series(range(3), index=list("abc"))
+    result = ser.drop("bc", errors="ignore")
+    tm.assert_series_equal(result, ser)
+    result = ser.drop(["a", "d"], errors="ignore")
+    expected = ser.iloc[1:]
     tm.assert_series_equal(result, expected)
 
     # GH 8522
-    s = Series([2, 3], index=[True, False])
-    assert s.index.is_object()
-    result = s.drop(True)
+    ser = Series([2, 3], index=[True, False])
+    assert not ser.index.is_object()
+    assert ser.index.dtype == bool
+    result = ser.drop(True)
     expected = Series([3], index=[False])
     tm.assert_series_equal(result, expected)
 
@@ -97,3 +101,12 @@ def test_drop_pos_args_deprecation():
         result = ser.drop(1, 0)
     expected = Series([1, 3], index=[0, 2])
     tm.assert_series_equal(result, expected)
+
+
+def test_drop_index_ea_dtype(any_numeric_ea_dtype):
+    # GH#45860
+    df = Series(100, index=Index([1, 2, 2], dtype=any_numeric_ea_dtype))
+    idx = Index([df.index[1]])
+    result = df.drop(idx)
+    expected = Series(100, index=Index([1], dtype=any_numeric_ea_dtype))
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_equals.py b/pandas/tests/series/methods/test_equals.py
index 22e27c271df88..9278d1b51e1aa 100644
--- a/pandas/tests/series/methods/test_equals.py
+++ b/pandas/tests/series/methods/test_equals.py
@@ -5,6 +5,7 @@
 import pytest
 
 from pandas._libs.missing import is_matching_na
+from pandas.compat import is_numpy_dev
 
 from pandas.core.dtypes.common import is_float
 
@@ -50,7 +51,7 @@ def test_equals_list_array(val):
 
     cm = (
         tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
-        if isinstance(val, str)
+        if isinstance(val, str) and not is_numpy_dev
         else nullcontext()
     )
     with cm:
diff --git a/pandas/tests/series/methods/test_fillna.py b/pandas/tests/series/methods/test_fillna.py
index 19f61a0a2d6fc..ac12b513aad4e 100644
--- a/pandas/tests/series/methods/test_fillna.py
+++ b/pandas/tests/series/methods/test_fillna.py
@@ -151,15 +151,14 @@ def test_fillna_consistency(self):
         )
         tm.assert_series_equal(result, expected)
 
-        msg = "The 'errors' keyword in "
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            # where (we ignore the errors=)
+        # where (we ignore the errors=)
+        with tm.assert_produces_warning(FutureWarning, match="the 'errors' keyword"):
             result = ser.where(
                 [True, False], Timestamp("20130101", tz="US/Eastern"), errors="ignore"
             )
         tm.assert_series_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match="the 'errors' keyword"):
             result = ser.where(
                 [True, False], Timestamp("20130101", tz="US/Eastern"), errors="ignore"
             )
@@ -253,8 +252,11 @@ def test_timedelta_fillna(self, frame_or_series):
 
         # interpreted as seconds, no longer supported
         msg = "value should be a 'Timedelta', 'NaT', or array of those. Got 'int'"
+        wmsg = "In a future version, this will cast to a common dtype"
         with pytest.raises(TypeError, match=msg):
-            obj.fillna(1)
+            with tm.assert_produces_warning(FutureWarning, match=wmsg):
+                # GH#45746
+                obj.fillna(1)
 
         result = obj.fillna(Timedelta(seconds=1))
         expected = Series(
@@ -280,7 +282,7 @@ def test_timedelta_fillna(self, frame_or_series):
         expected = frame_or_series(expected)
         tm.assert_equal(result, expected)
 
-        result = obj.fillna(np.timedelta64(10 ** 9))
+        result = obj.fillna(np.timedelta64(10**9))
         expected = Series(
             [
                 timedelta(seconds=1),
@@ -749,14 +751,31 @@ def test_fillna_categorical_raises(self):
 
     @pytest.mark.parametrize("dtype", [float, "float32", "float64"])
     @pytest.mark.parametrize("fill_type", tm.ALL_REAL_NUMPY_DTYPES)
-    def test_fillna_float_casting(self, dtype, fill_type):
+    @pytest.mark.parametrize("scalar", [True, False])
+    def test_fillna_float_casting(self, dtype, fill_type, scalar):
         # GH-43424
         ser = Series([np.nan, 1.2], dtype=dtype)
         fill_values = Series([2, 2], dtype=fill_type)
+        if scalar:
+            fill_values = fill_values.dtype.type(2)
+
         result = ser.fillna(fill_values)
         expected = Series([2.0, 1.2], dtype=dtype)
         tm.assert_series_equal(result, expected)
 
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        mask = ser.isna().to_numpy()
+        ser[mask] = fill_values
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        ser.mask(mask, fill_values, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        res = ser.where(~mask, fill_values)
+        tm.assert_series_equal(res, expected)
+
     def test_fillna_f32_upcast_with_dict(self):
         # GH-43424
         ser = Series([np.nan, 1.2], dtype=np.float32)
@@ -834,6 +853,24 @@ def test_fillna_pos_args_deprecation(self):
         expected = Series([1, 2, 3, 0], dtype=float)
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "input, input_fillna, expected_data, expected_categories",
+        [
+            (["A", "B", None, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+            (["A", "B", np.nan, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+        ],
+    )
+    def test_fillna_categorical_accept_same_type(
+        self, input, input_fillna, expected_data, expected_categories
+    ):
+        # GH32414
+        cat = Categorical(input)
+        ser = Series(cat).fillna(input_fillna)
+        filled = cat.fillna(ser)
+        result = cat.fillna(filled)
+        expected = Categorical(expected_data, categories=expected_categories)
+        tm.assert_categorical_equal(result, expected)
+
 
 class TestFillnaPad:
     def test_fillna_bug(self):
diff --git a/pandas/tests/series/methods/test_get_numeric_data.py b/pandas/tests/series/methods/test_get_numeric_data.py
index e386f4b5b1dec..60dd64d7e1948 100644
--- a/pandas/tests/series/methods/test_get_numeric_data.py
+++ b/pandas/tests/series/methods/test_get_numeric_data.py
@@ -7,13 +7,20 @@
 
 
 class TestGetNumericData:
-    def test_get_numeric_data_preserve_dtype(self):
+    def test_get_numeric_data_preserve_dtype(self, using_copy_on_write):
 
         # get the numeric data
         obj = Series([1, 2, 3])
         result = obj._get_numeric_data()
         tm.assert_series_equal(result, obj)
 
+        # returned object is a shallow copy
+        result.iloc[0] = 0
+        if using_copy_on_write:
+            assert obj.iloc[0] == 1
+        else:
+            assert obj.iloc[0] == 0
+
         obj = Series([1, "2", 3.0])
         result = obj._get_numeric_data()
         expected = Series([], dtype=object, index=Index([], dtype=object))
diff --git a/pandas/tests/series/methods/test_interpolate.py b/pandas/tests/series/methods/test_interpolate.py
index 8ca2d37016691..c46f427fd6f09 100644
--- a/pandas/tests/series/methods/test_interpolate.py
+++ b/pandas/tests/series/methods/test_interpolate.py
@@ -78,7 +78,7 @@ def interp_methods_ind(request):
 
 
 class TestSeriesInterpolateData:
-    def test_interpolate(self, datetime_series, string_series):
+    def test_interpolate(self, datetime_series):
         ts = Series(np.arange(len(datetime_series), dtype=float), datetime_series.index)
 
         ts_copy = ts.copy()
@@ -778,7 +778,8 @@ def test_interp_non_timedelta_index(self, interp_methods_ind, ind):
             with pytest.raises(ValueError, match=expected_error):
                 df[0].interpolate(method=method, **kwargs)
 
-    def test_interpolate_timedelta_index(self, interp_methods_ind):
+    @td.skip_if_no_scipy
+    def test_interpolate_timedelta_index(self, request, interp_methods_ind):
         """
         Tests for non numerical index types  - object, period, timedelta
         Note that all methods except time, index, nearest and values
@@ -789,17 +790,16 @@ def test_interpolate_timedelta_index(self, interp_methods_ind):
         df = pd.DataFrame([0, 1, np.nan, 3], index=ind)
 
         method, kwargs = interp_methods_ind
-        if method == "pchip":
-            pytest.importorskip("scipy")
 
-        if method in {"linear", "pchip"}:
-            result = df[0].interpolate(method=method, **kwargs)
-            expected = Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
-            tm.assert_series_equal(result, expected)
-        else:
-            pytest.skip(
-                "This interpolation method is not supported for Timedelta Index yet."
+        if method in {"cubic", "zero"}:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{method} interpolation is not supported for TimedeltaIndex"
+                )
             )
+        result = df[0].interpolate(method=method, **kwargs)
+        expected = Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "ascending, expected_values",
diff --git a/pandas/tests/series/methods/test_is_monotonic.py b/pandas/tests/series/methods/test_is_monotonic.py
index f02939374cc5b..8d7769539ad82 100644
--- a/pandas/tests/series/methods/test_is_monotonic.py
+++ b/pandas/tests/series/methods/test_is_monotonic.py
@@ -10,9 +10,9 @@ class TestIsMonotonic:
     def test_is_monotonic_numeric(self):
 
         ser = Series(np.random.randint(0, 10, size=1000))
-        assert not ser.is_monotonic
+        assert not ser.is_monotonic_increasing
         ser = Series(np.arange(1000))
-        assert ser.is_monotonic is True
+        assert ser.is_monotonic_increasing is True
         assert ser.is_monotonic_increasing is True
         ser = Series(np.arange(1000, 0, -1))
         assert ser.is_monotonic_decreasing is True
@@ -20,9 +20,9 @@ def test_is_monotonic_numeric(self):
     def test_is_monotonic_dt64(self):
 
         ser = Series(date_range("20130101", periods=10))
-        assert ser.is_monotonic is True
+        assert ser.is_monotonic_increasing is True
         assert ser.is_monotonic_increasing is True
 
         ser = Series(list(reversed(ser)))
-        assert ser.is_monotonic is False
+        assert ser.is_monotonic_increasing is False
         assert ser.is_monotonic_decreasing is True
diff --git a/pandas/tests/series/methods/test_is_unique.py b/pandas/tests/series/methods/test_is_unique.py
index c696d365662ea..960057cb3d646 100644
--- a/pandas/tests/series/methods/test_is_unique.py
+++ b/pandas/tests/series/methods/test_is_unique.py
@@ -26,7 +26,7 @@ def test_is_unique(data, expected):
 def test_is_unique_class_ne(capsys):
     # GH#20661
     class Foo:
-        def __init__(self, val):
+        def __init__(self, val) -> None:
             self._value = val
 
         def __ne__(self, other):
diff --git a/pandas/tests/series/methods/test_isin.py b/pandas/tests/series/methods/test_isin.py
index f769c08a512ef..2288dfb5c2409 100644
--- a/pandas/tests/series/methods/test_isin.py
+++ b/pandas/tests/series/methods/test_isin.py
@@ -22,7 +22,7 @@ def test_isin(self):
         # This specific issue has to have a series over 1e6 in len, but the
         # comparison array (in_list) must be large enough so that numpy doesn't
         # do a manual masking trick that will avoid this issue altogether
-        s = Series(list("abcdefghijk" * 10 ** 5))
+        s = Series(list("abcdefghijk" * 10**5))
         # If numpy doesn't do the manual comparison/mask, these
         # unorderable mixed types are what cause the exception in numpy
         in_list = [-1, "a", "b", "G", "Y", "Z", "E", "K", "E", "S", "I", "R", "R"] * 6
diff --git a/pandas/tests/series/methods/test_item.py b/pandas/tests/series/methods/test_item.py
index 2bdeb4da5f70f..8e8c33619d564 100644
--- a/pandas/tests/series/methods/test_item.py
+++ b/pandas/tests/series/methods/test_item.py
@@ -55,5 +55,5 @@ def test_item(self):
 
         # Case where ser[0] would not work
         ser = Series(dti, index=[5, 6])
-        val = ser[:1].item()
+        val = ser.iloc[:1].item()
         assert val == dti[0]
diff --git a/pandas/tests/series/methods/test_nlargest.py b/pandas/tests/series/methods/test_nlargest.py
index ee96ab08ad66c..4f07257038bc9 100644
--- a/pandas/tests/series/methods/test_nlargest.py
+++ b/pandas/tests/series/methods/test_nlargest.py
@@ -231,3 +231,15 @@ def test_nlargest_nullable(self, any_numeric_ea_dtype):
             .astype(dtype)
         )
         tm.assert_series_equal(result, expected)
+
+    def test_nsmallest_nan_when_keep_is_all(self):
+        # GH#46589
+        s = Series([1, 2, 3, 3, 3, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1.0, 2.0, 3.0, 3.0, 3.0])
+        tm.assert_series_equal(result, expected)
+
+        s = Series([1, 2, None, None, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1, 2, None, None, None])
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_quantile.py b/pandas/tests/series/methods/test_quantile.py
index 84bfe8524634b..e740f569506ff 100644
--- a/pandas/tests/series/methods/test_quantile.py
+++ b/pandas/tests/series/methods/test_quantile.py
@@ -222,4 +222,21 @@ def test_quantile_empty(self):
     def test_quantile_dtypes(self, dtype):
         result = Series([1, 2, 3], dtype=dtype).quantile(np.arange(0, 1, 0.25))
         expected = Series(np.arange(1, 3, 0.5), index=np.arange(0, 1, 0.25))
+        if dtype == "Int64":
+            expected = expected.astype("Float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_all_na(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
+        with tm.assert_produces_warning(None):
+            result = ser.quantile([0.1, 0.5])
+        expected = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype, index=[0.1, 0.5])
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_dtype_size(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA, 1], dtype=any_int_ea_dtype)
+        result = ser.quantile([0.1, 0.5])
+        expected = Series([1, 1], dtype=any_int_ea_dtype, index=[0.1, 0.5])
         tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_rank.py b/pandas/tests/series/methods/test_rank.py
index d85b84bec55ac..3af06502a3066 100644
--- a/pandas/tests/series/methods/test_rank.py
+++ b/pandas/tests/series/methods/test_rank.py
@@ -475,10 +475,9 @@ def test_rank_first_pct(dtype, ser, exp):
     tm.assert_series_equal(result, expected)
 
 
-@pytest.mark.single
-@pytest.mark.high_memory
+@pytest.mark.single_cpu
 def test_pct_max_many_rows():
     # GH 18271
-    s = Series(np.arange(2 ** 24 + 1))
+    s = Series(np.arange(2**24 + 1))
     result = s.rank(pct=True).max()
     assert result == 1
diff --git a/pandas/tests/series/methods/test_reindex.py b/pandas/tests/series/methods/test_reindex.py
index a500252a44e07..b64c7bec6ea39 100644
--- a/pandas/tests/series/methods/test_reindex.py
+++ b/pandas/tests/series/methods/test_reindex.py
@@ -2,13 +2,17 @@
 import pytest
 
 from pandas import (
+    NA,
     Categorical,
+    Float64Dtype,
     Index,
     MultiIndex,
     NaT,
     Period,
     PeriodIndex,
     Series,
+    Timedelta,
+    Timestamp,
     date_range,
     isna,
 )
@@ -296,6 +300,24 @@ def test_reindex_fill_value():
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+@pytest.mark.parametrize("fill_value", ["string", 0, Timedelta(0)])
+def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value, using_array_manager):
+    # https://github.com/pandas-dev/pandas/issues/42921
+    if using_array_manager:
+        pytest.skip("Array manager does not promote dtype, hence we fail")
+
+    if dtype == "timedelta64[ns]" and fill_value == Timedelta(0):
+        # use the scalar that is not compatible with the dtype for this test
+        fill_value = Timestamp(0)
+
+    ser = Series([NaT], dtype=dtype)
+
+    result = ser.reindex([0, 1], fill_value=fill_value)
+    expected = Series([None, fill_value], index=[0, 1], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
 def test_reindex_datetimeindexes_tz_naive_and_aware():
     # GH 8306
     idx = date_range("20131101", tz="America/Chicago", periods=7)
@@ -388,3 +410,16 @@ def test_reindex_missing_category():
     msg = r"Cannot setitem on a Categorical with a new category \(-1\)"
     with pytest.raises(TypeError, match=msg):
         ser.reindex([1, 2, 3, 4, 5], fill_value=-1)
+
+
+def test_reindexing_with_float64_NA_log():
+    # GH 47055
+    s = Series([1.0, NA], dtype=Float64Dtype())
+    s_reindex = s.reindex(range(3))
+    result = s_reindex.values._data
+    expected = np.array([1, np.NaN, np.NaN])
+    tm.assert_numpy_array_equal(result, expected)
+    with tm.assert_produces_warning(None):
+        result_log = np.log(s_reindex)
+        expected_log = Series([0, np.NaN, np.NaN], dtype=Float64Dtype())
+        tm.assert_series_equal(result_log, expected_log)
diff --git a/pandas/tests/series/methods/test_rename.py b/pandas/tests/series/methods/test_rename.py
index 90c8f775586e6..d0392929cb082 100644
--- a/pandas/tests/series/methods/test_rename.py
+++ b/pandas/tests/series/methods/test_rename.py
@@ -1,4 +1,5 @@
 from datetime import datetime
+import re
 
 import numpy as np
 import pytest
@@ -134,3 +135,23 @@ def test_rename_series_with_multiindex(self):
         series_expected = Series(np.ones(5), index=index_expected)
 
         tm.assert_series_equal(result, series_expected)
+
+    def test_rename_error_arg(self):
+        # GH 46889
+        ser = Series(["foo", "bar"])
+        match = re.escape("[2] not found in axis")
+        with pytest.raises(KeyError, match=match):
+            ser.rename({2: 9}, errors="raise")
+
+    def test_rename_copy_false(self, using_copy_on_write):
+        # GH 46889
+        ser = Series(["foo", "bar"])
+        ser_orig = ser.copy()
+        shallow_copy = ser.rename({1: 9}, copy=False)
+        ser[0] = "foobar"
+        if using_copy_on_write:
+            assert ser_orig[0] == shallow_copy[0]
+            assert ser_orig[1] == shallow_copy[9]
+        else:
+            assert ser[0] == shallow_copy[0]
+            assert ser[1] == shallow_copy[9]
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 6a8dacfda5e78..126a89503d636 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -642,7 +642,12 @@ def test_replace_nullable_numeric(self):
         assert ints.replace(1, 9).dtype == ints.dtype
         assert ints.replace({1: 9.0}).dtype == ints.dtype
         assert ints.replace(1, 9.0).dtype == ints.dtype
-        # FIXME: ints.replace({1: 9.5}) raises bc of incorrect _can_hold_element
+
+        # nullable (for now) raises instead of casting
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace({1: 9.5})
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace(1, 9.5)
 
     @pytest.mark.parametrize("regex", [False, True])
     def test_replace_regex_dtype_series(self, regex):
@@ -651,3 +656,22 @@ def test_replace_regex_dtype_series(self, regex):
         expected = pd.Series([1])
         result = series.replace(to_replace="0", value=1, regex=regex)
         tm.assert_series_equal(result, expected)
+
+    def test_replace_different_int_types(self, any_int_numpy_dtype):
+        # GH#45311
+        labs = pd.Series([1, 1, 1, 0, 0, 2, 2, 2], dtype=any_int_numpy_dtype)
+
+        maps = pd.Series([0, 2, 1], dtype=any_int_numpy_dtype)
+        map_dict = {old: new for (old, new) in zip(maps.values, maps.index)}
+
+        result = labs.replace(map_dict)
+        expected = labs.replace({0: 0, 2: 1, 1: 2})
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [2, np.nan, 2.0])
+    def test_replace_value_none_dtype_numeric(self, val):
+        # GH#48231
+        ser = pd.Series([1, val])
+        result = ser.replace(val, None)
+        expected = pd.Series([1, None], dtype=object)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_reset_index.py b/pandas/tests/series/methods/test_reset_index.py
index f38491508cc23..e7340aaf376e5 100644
--- a/pandas/tests/series/methods/test_reset_index.py
+++ b/pandas/tests/series/methods/test_reset_index.py
@@ -186,3 +186,23 @@ def test_reset_index_dtypes_on_empty_series_with_multiindex(array, dtype):
         {"level_0": np.int64, "level_1": np.float64, "level_2": dtype, 0: object}
     )
     tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "names, expected_names",
+    [
+        (["A", "A"], ["A", "A"]),
+        (["level_1", None], ["level_1", "level_1"]),
+    ],
+)
+@pytest.mark.parametrize("allow_duplicates", [False, True])
+def test_column_name_duplicates(names, expected_names, allow_duplicates):
+    # GH#44755 reset_index with duplicate column labels
+    s = Series([1], index=MultiIndex.from_arrays([[1], [1]], names=names))
+    if allow_duplicates:
+        result = s.reset_index(allow_duplicates=True)
+        expected = DataFrame([[1, 1, 1]], columns=expected_names + [0])
+        tm.assert_frame_equal(result, expected)
+    else:
+        with pytest.raises(ValueError, match="cannot insert"):
+            s.reset_index()
diff --git a/pandas/tests/series/methods/test_to_frame.py b/pandas/tests/series/methods/test_to_frame.py
index 55d49b8fbee70..5f303d09dcc33 100644
--- a/pandas/tests/series/methods/test_to_frame.py
+++ b/pandas/tests/series/methods/test_to_frame.py
@@ -10,13 +10,18 @@ class TestToFrame:
     def test_to_frame_respects_name_none(self):
         # GH#44212 if we explicitly pass name=None, then that should be respected,
         #  not changed to 0
+        # GH-45448 this is first deprecated to only change in the future
         ser = Series(range(3))
-        result = ser.to_frame(None)
+        with tm.assert_produces_warning(FutureWarning):
+            result = ser.to_frame(None)
 
-        exp_index = Index([None], dtype=object)
+        # exp_index = Index([None], dtype=object)
+        exp_index = Index([0])
         tm.assert_index_equal(result.columns, exp_index)
 
-        result = ser.rename("foo").to_frame(None)
+        with tm.assert_produces_warning(FutureWarning):
+            result = ser.rename("foo").to_frame(None)
+        exp_index = Index(["foo"], dtype=object)
         tm.assert_index_equal(result.columns, exp_index)
 
     def test_to_frame(self, datetime_series):
diff --git a/pandas/tests/series/methods/test_unique.py b/pandas/tests/series/methods/test_unique.py
index 856fe6e7c4f04..14e2473325032 100644
--- a/pandas/tests/series/methods/test_unique.py
+++ b/pandas/tests/series/methods/test_unique.py
@@ -2,12 +2,20 @@
 
 from pandas import (
     Categorical,
+    IntervalIndex,
     Series,
+    date_range,
 )
 import pandas._testing as tm
 
 
 class TestUnique:
+    def test_unique_uint64(self):
+        ser = Series([1, 2, 2**63, 2**63], dtype=np.uint64)
+        res = ser.unique()
+        exp = np.array([1, 2, 2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(res, exp)
+
     def test_unique_data_ownership(self):
         # it works! GH#1807
         Series(Series(["a", "c", "b"]).unique()).sort_values()
@@ -50,3 +58,19 @@ def test_unique_categorical(self):
         ser = Series(cat)
         result = ser.unique()
         tm.assert_categorical_equal(result, cat)
+
+    def test_tz_unique(self):
+        # GH 46128
+        dti1 = date_range("2016-01-01", periods=3)
+        ii1 = IntervalIndex.from_breaks(dti1)
+        ser1 = Series(ii1)
+        uni1 = ser1.unique()
+        tm.assert_interval_array_equal(ser1.array, uni1)
+
+        dti2 = date_range("2016-01-01", periods=3, tz="US/Eastern")
+        ii2 = IntervalIndex.from_breaks(dti2)
+        ser2 = Series(ii2)
+        uni2 = ser2.unique()
+        tm.assert_interval_array_equal(ser2.array, uni2)
+
+        assert uni1.dtype != uni2.dtype
diff --git a/pandas/tests/series/methods/test_update.py b/pandas/tests/series/methods/test_update.py
index d9d6641d54237..6403fcf76122a 100644
--- a/pandas/tests/series/methods/test_update.py
+++ b/pandas/tests/series/methods/test_update.py
@@ -14,7 +14,7 @@
 
 
 class TestUpdate:
-    def test_update(self):
+    def test_update(self, using_copy_on_write):
         s = Series([1.5, np.nan, 3.0, 4.0, np.nan])
         s2 = Series([np.nan, 3.5, np.nan, 5.0])
         s.update(s2)
@@ -25,11 +25,15 @@ def test_update(self):
         # GH 3217
         df = DataFrame([{"a": 1}, {"a": 3, "b": 2}])
         df["c"] = np.nan
+        df_orig = df.copy()
 
         df["c"].update(Series(["foo"], index=[0]))
-        expected = DataFrame(
-            [[1, np.nan, "foo"], [3, 2.0, np.nan]], columns=["a", "b", "c"]
-        )
+        if using_copy_on_write:
+            expected = df_orig
+        else:
+            expected = DataFrame(
+                [[1, np.nan, "foo"], [3, 2.0, np.nan]], columns=["a", "b", "c"]
+            )
         tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/series/methods/test_value_counts.py b/pandas/tests/series/methods/test_value_counts.py
index c914dba75dc35..a7d57eee7e5a1 100644
--- a/pandas/tests/series/methods/test_value_counts.py
+++ b/pandas/tests/series/methods/test_value_counts.py
@@ -194,7 +194,7 @@ def test_value_counts_categorical_with_nan(self):
             (
                 Series([False, True, True, pd.NA]),
                 True,
-                Series([2, 1], index=[True, False]),
+                Series([2, 1], index=pd.Index([True, False], dtype=object)),
             ),
             (
                 Series(range(3), index=[True, False, np.nan]).index,
@@ -216,13 +216,12 @@ def test_value_counts_bool_with_nan(self, ser, dropna, exp):
                 Series([3, 2, 1], index=pd.Index([3j, 1 + 1j, 1], dtype=np.complex128)),
             ),
             (
-                [1 + 1j, 1 + 1j, 1, 3j, 3j, 3j],
+                np.array([1 + 1j, 1 + 1j, 1, 3j, 3j, 3j], dtype=np.complex64),
                 Series([3, 2, 1], index=pd.Index([3j, 1 + 1j, 1], dtype=np.complex64)),
             ),
         ],
     )
     def test_value_counts_complex_numbers(self, input_array, expected):
         # GH 17927
-        # Complex Index dtype is cast to object
         result = Series(input_array).value_counts()
         tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index 146663d90f752..0aab381d6e076 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -70,7 +70,6 @@ def test_tab_completion_with_categorical(self):
     @pytest.mark.parametrize(
         "index",
         [
-            tm.makeUnicodeIndex(10),
             tm.makeStringIndex(10),
             tm.makeCategoricalIndex(10),
             Index(["foo", "bar", "baz"] * 2),
@@ -172,7 +171,9 @@ def test_attrs(self):
     def test_inspect_getmembers(self):
         # GH38782
         ser = Series(dtype=object)
-        with tm.assert_produces_warning(None):
+        # TODO(2.0): Change to None once is_monotonic deprecation
+        # is enforced
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
             inspect.getmembers(ser)
 
     def test_unknown_attribute(self):
@@ -203,3 +204,102 @@ def test_series_datetimelike_attribute_access_invalid(self):
         msg = "'Series' object has no attribute 'weekday'"
         with pytest.raises(AttributeError, match=msg):
             ser.weekday
+
+    def test_series_iteritems_deprecated(self):
+        ser = Series([1])
+        with tm.assert_produces_warning(FutureWarning):
+            next(ser.iteritems())
+
+    @pytest.mark.parametrize(
+        "kernel, has_numeric_only",
+        [
+            ("skew", True),
+            ("var", True),
+            ("all", False),
+            ("prod", True),
+            ("any", False),
+            ("idxmin", False),
+            ("quantile", False),
+            ("idxmax", False),
+            ("min", True),
+            ("sem", True),
+            ("mean", True),
+            ("nunique", False),
+            ("max", True),
+            ("sum", True),
+            ("count", False),
+            ("median", True),
+            ("std", True),
+            ("backfill", False),
+            ("rank", True),
+            ("pct_change", False),
+            ("cummax", False),
+            ("shift", False),
+            ("diff", False),
+            ("cumsum", False),
+            ("cummin", False),
+            ("cumprod", False),
+            ("fillna", False),
+            ("ffill", False),
+            ("pad", False),
+            ("bfill", False),
+            ("sample", False),
+            ("tail", False),
+            ("take", False),
+            ("head", False),
+            ("cov", False),
+            ("corr", False),
+        ],
+    )
+    @pytest.mark.parametrize("dtype", [bool, int, float, object])
+    def test_numeric_only(self, kernel, has_numeric_only, dtype):
+        # GH#47500
+        ser = Series([0, 1, 1], dtype=dtype)
+        if kernel == "corrwith":
+            args = (ser,)
+        elif kernel == "corr":
+            args = (ser,)
+        elif kernel == "cov":
+            args = (ser,)
+        elif kernel == "nth":
+            args = (0,)
+        elif kernel == "fillna":
+            args = (True,)
+        elif kernel == "fillna":
+            args = ("ffill",)
+        elif kernel == "take":
+            args = ([0],)
+        elif kernel == "quantile":
+            args = (0.5,)
+        else:
+            args = ()
+        method = getattr(ser, kernel)
+        if not has_numeric_only:
+            msg = (
+                "(got an unexpected keyword argument 'numeric_only'"
+                "|too many arguments passed in)"
+            )
+            with pytest.raises(TypeError, match=msg):
+                method(*args, numeric_only=True)
+        elif dtype is object:
+            if kernel == "rank":
+                msg = "Calling Series.rank with numeric_only=True and dtype object"
+                with tm.assert_produces_warning(FutureWarning, match=msg):
+                    method(*args, numeric_only=True)
+            else:
+                warn_msg = (
+                    f"Calling Series.{kernel} with numeric_only=True and dtype object"
+                )
+                err_msg = f"Series.{kernel} does not implement numeric_only"
+                with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                    with pytest.raises(NotImplementedError, match=err_msg):
+                        method(*args, numeric_only=True)
+        else:
+            result = method(*args, numeric_only=True)
+            expected = method(*args, numeric_only=False)
+            if isinstance(expected, Series):
+                # transformer
+                tm.assert_series_equal(result, expected)
+            else:
+                # reducer
+                assert result == expected
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 5fbb42789d746..c8044a44b48ee 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -722,9 +722,7 @@ def test_align_date_objects_with_datetimeindex(self):
 class TestNamePreservation:
     @pytest.mark.parametrize("box", [list, tuple, np.array, Index, Series, pd.array])
     @pytest.mark.parametrize("flex", [True, False])
-    def test_series_ops_name_retention(
-        self, request, flex, box, names, all_binary_operators
-    ):
+    def test_series_ops_name_retention(self, flex, box, names, all_binary_operators):
         # GH#33930 consistent name renteiton
         op = all_binary_operators
 
@@ -825,11 +823,13 @@ def test_series_inplace_ops(self, dtype1, dtype2, dtype_expected, dtype_mul):
         tm.assert_series_equal(ser1, expected)
 
 
-def test_none_comparison(series_with_simple_index):
+def test_none_comparison(request, series_with_simple_index):
     series = series_with_simple_index
 
     if len(series) < 1:
-        pytest.skip("Test doesn't make sense on empty data")
+        request.node.add_marker(
+            pytest.mark.xfail(reason="Test doesn't make sense on empty data")
+        )
 
     # bug brought up by #1079
     # changed from TypeError in 0.17.0
@@ -887,8 +887,8 @@ def test_series_varied_multiindex_alignment():
     expected = Series(
         [1000, 2001, 3002, 4003],
         index=pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("a", "x", 2), ("a", "y", 1), ("a", "y", 2)],
-            names=["ab", "xy", "num"],
+            [("x", 1, "a"), ("x", 2, "a"), ("y", 1, "a"), ("y", 2, "a")],
+            names=["xy", "num", "ab"],
         ),
     )
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 7300b8f03ade6..bc26158f40416 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -13,10 +13,8 @@
     iNaT,
     lib,
 )
-from pandas.compat.numpy import (
-    np_version_under1p19,
-    np_version_under1p20,
-)
+from pandas.compat import is_numpy_dev
+from pandas.compat.numpy import np_version_gte1p24
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import (
@@ -480,7 +478,8 @@ def test_categorical_sideeffects_free(self):
         cat = Categorical(["a", "b", "c", "a"])
         s = Series(cat, copy=True)
         assert s.cat is not cat
-        s.cat.categories = [1, 2, 3]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            s.cat.categories = [1, 2, 3]
         exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
         exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_)
         tm.assert_numpy_array_equal(s.__array__(), exp_s)
@@ -497,7 +496,8 @@ def test_categorical_sideeffects_free(self):
         cat = Categorical(["a", "b", "c", "a"])
         s = Series(cat)
         assert s.values is cat
-        s.cat.categories = [1, 2, 3]
+        with tm.assert_produces_warning(FutureWarning, match="Use rename_categories"):
+            s.cat.categories = [1, 2, 3]
         exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
         tm.assert_numpy_array_equal(s.__array__(), exp_s)
         tm.assert_numpy_array_equal(cat.__array__(), exp_s)
@@ -736,29 +736,106 @@ def test_constructor_cast(self):
     def test_constructor_signed_int_overflow_deprecation(self):
         # GH#41734 disallow silent overflow
         msg = "Values are too large to be losslessly cast"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
+        warns = (
+            (FutureWarning, DeprecationWarning)
+            if is_numpy_dev or np_version_gte1p24
+            else FutureWarning
+        )
+        with tm.assert_produces_warning(warns, match=msg, check_stacklevel=False):
             ser = Series([1, 200, 923442], dtype="int8")
 
         expected = Series([1, -56, 50], dtype="int8")
         tm.assert_series_equal(ser, expected)
 
-        with tm.assert_produces_warning(FutureWarning, match=msg):
+        with tm.assert_produces_warning(warns, match=msg, check_stacklevel=False):
             ser = Series([1, 200, 923442], dtype="uint8")
 
         expected = Series([1, 200, 50], dtype="uint8")
         tm.assert_series_equal(ser, expected)
 
+    @pytest.mark.parametrize(
+        "values",
+        [
+            np.array([1], dtype=np.uint16),
+            np.array([1], dtype=np.uint32),
+            np.array([1], dtype=np.uint64),
+            [np.uint16(1)],
+            [np.uint32(1)],
+            [np.uint64(1)],
+        ],
+    )
+    def test_constructor_numpy_uints(self, values):
+        # GH#47294
+        value = values[0]
+        result = Series(values)
+
+        assert result[0].dtype == value.dtype
+        assert result[0] == value
+
     def test_constructor_unsigned_dtype_overflow(self, any_unsigned_int_numpy_dtype):
         # see gh-15832
         msg = "Trying to coerce negative values to unsigned integers"
         with pytest.raises(OverflowError, match=msg):
             Series([-1], dtype=any_unsigned_int_numpy_dtype)
 
+    def test_constructor_floating_data_int_dtype(self, frame_or_series):
+        # GH#40110
+        arr = np.random.randn(2)
+
+        if frame_or_series is Series:
+            # Long-standing behavior has been to ignore the dtype on these;
+            #  not clear if this is what we want long-term
+            expected = frame_or_series(arr)
+
+            res = frame_or_series(arr, dtype="i8")
+            tm.assert_equal(res, expected)
+
+            res = frame_or_series(list(arr), dtype="i8")
+            tm.assert_equal(res, expected)
+
+        else:
+            msg = "passing float-dtype values and an integer dtype"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                # DataFrame will behave like Series
+                frame_or_series(arr, dtype="i8")
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                # DataFrame will behave like Series
+                frame_or_series(list(arr), dtype="i8")
+
+        # When we have NaNs, we silently ignore the integer dtype
+        arr[0] = np.nan
+        expected = frame_or_series(arr)
+        msg = "passing float-dtype values containing NaN and an integer dtype"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            obj = frame_or_series(arr, dtype="i8")
+        tm.assert_equal(obj, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            # same behavior if we pass list instead of the ndarray
+            obj = frame_or_series(list(arr), dtype="i8")
+        tm.assert_equal(obj, expected)
+
+        # float array that can be losslessly cast to integers
+        arr = np.array([1.0, 2.0], dtype="float64")
+        expected = frame_or_series(arr.astype("i8"))
+
+        obj = frame_or_series(arr, dtype="i8")
+        tm.assert_equal(obj, expected)
+
+        obj = frame_or_series(list(arr), dtype="i8")
+        tm.assert_equal(obj, expected)
+
     def test_constructor_coerce_float_fail(self, any_int_numpy_dtype):
         # see gh-15832
-        msg = "Trying to coerce float values to integers"
-        with pytest.raises(ValueError, match=msg):
-            Series([1, 2, 3.5], dtype=any_int_numpy_dtype)
+        # Updated: make sure we treat this list the same as we would treat
+        #  the equivalent ndarray
+        vals = [1, 2, 3.5]
+
+        res = Series(vals, dtype=any_int_numpy_dtype)
+        expected = Series(np.array(vals), dtype=any_int_numpy_dtype)
+        tm.assert_series_equal(res, expected)
+        alt = Series(np.array(vals))  # i.e. we ignore the dtype kwd
+        tm.assert_series_equal(alt, expected)
 
     def test_constructor_coerce_float_valid(self, float_numpy_dtype):
         s = Series([1, 2, 3.5], dtype=float_numpy_dtype)
@@ -767,10 +844,16 @@ def test_constructor_coerce_float_valid(self, float_numpy_dtype):
 
     def test_constructor_invalid_coerce_ints_with_float_nan(self, any_int_numpy_dtype):
         # GH 22585
-
-        msg = "cannot convert float NaN to integer"
-        with pytest.raises(ValueError, match=msg):
-            Series([1, 2, np.nan], dtype=any_int_numpy_dtype)
+        # Updated: make sure we treat this list the same as we would treat the
+        # equivalent ndarray
+        vals = [1, 2, np.nan]
+        msg = "In a future version, passing float-dtype values containing NaN"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = Series(vals, dtype=any_int_numpy_dtype)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = Series(np.array(vals), dtype=any_int_numpy_dtype)
+        tm.assert_series_equal(res, expected)
+        assert np.isnan(expected.iloc[-1])
 
     def test_constructor_dtype_no_cast(self):
         # see gh-1572
@@ -877,9 +960,7 @@ def test_constructor_dtype_datetime64_10(self):
         dts = Series(dates, dtype="datetime64[ns]")
 
         # valid astype
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(np.int64) deprecated
-            dts.astype("int64")
+        dts.astype("int64")
 
         # invalid casting
         msg = r"cannot astype a datetimelike from \[datetime64\[ns\]\] to \[int32\]"
@@ -889,10 +970,8 @@ def test_constructor_dtype_datetime64_10(self):
         # ints are ok
         # we test with np.int64 to get similar results on
         # windows / 32-bit platforms
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(np.int64) deprecated
-            result = Series(dts, dtype=np.int64)
-            expected = Series(dts.astype(np.int64))
+        result = Series(dts, dtype=np.int64)
+        expected = Series(dts.astype(np.int64))
         tm.assert_series_equal(result, expected)
 
     def test_constructor_dtype_datetime64_9(self):
@@ -1403,9 +1482,7 @@ def test_constructor_dtype_timedelta64(self):
         assert td.dtype == "timedelta64[ns]"
 
         # valid astype
-        with tm.assert_produces_warning(FutureWarning):
-            # astype(int64) deprecated
-            td.astype("int64")
+        td.astype("int64")
 
         # invalid casting
         msg = r"cannot astype a datetimelike from \[timedelta64\[ns\]\] to \[int32\]"
@@ -1531,10 +1608,8 @@ def test_constructor_cant_cast_datetimelike(self, index):
         # ints are ok
         # we test with np.int64 to get similar results on
         # windows / 32-bit platforms
-        with tm.assert_produces_warning(FutureWarning):
-            # asype(np.int64) deprecated, use .view(np.int64) instead
-            result = Series(index, dtype=np.int64)
-            expected = Series(index.astype(np.int64))
+        result = Series(index, dtype=np.int64)
+        expected = Series(index.astype(np.int64))
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -1593,28 +1668,28 @@ def test_constructor_range_dtype(self, dtype):
 
     def test_constructor_range_overflows(self):
         # GH#30173 range objects that overflow int64
-        rng = range(2 ** 63, 2 ** 63 + 4)
+        rng = range(2**63, 2**63 + 4)
         ser = Series(rng)
         expected = Series(list(rng))
         tm.assert_series_equal(ser, expected)
         assert list(ser) == list(rng)
         assert ser.dtype == np.uint64
 
-        rng2 = range(2 ** 63 + 4, 2 ** 63, -1)
+        rng2 = range(2**63 + 4, 2**63, -1)
         ser2 = Series(rng2)
         expected2 = Series(list(rng2))
         tm.assert_series_equal(ser2, expected2)
         assert list(ser2) == list(rng2)
         assert ser2.dtype == np.uint64
 
-        rng3 = range(-(2 ** 63), -(2 ** 63) - 4, -1)
+        rng3 = range(-(2**63), -(2**63) - 4, -1)
         ser3 = Series(rng3)
         expected3 = Series(list(rng3))
         tm.assert_series_equal(ser3, expected3)
         assert list(ser3) == list(rng3)
         assert ser3.dtype == object
 
-        rng4 = range(2 ** 73, 2 ** 73 + 4)
+        rng4 = range(2**73, 2**73 + 4)
         ser4 = Series(rng4)
         expected4 = Series(list(rng4))
         tm.assert_series_equal(ser4, expected4)
@@ -1812,12 +1887,31 @@ def test_constructor_bool_dtype_missing_values(self):
         expected = Series(True, index=[0], dtype="bool")
         tm.assert_series_equal(result, expected)
 
+    def test_constructor_dtype_timedelta_alternative_construct(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]")
+        expected = Series(pd.to_timedelta([1000000, 200000, 3000000], unit="ns"))
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dtype_timedelta_ns_s(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]")
+        expected = Series([1000000, 200000, 3000000], dtype="timedelta64[s]")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dtype_timedelta_ns_s_astype_int64(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]").astype(
+            "int64"
+        )
+        expected = Series([1000000, 200000, 3000000], dtype="timedelta64[s]").astype(
+            "int64"
+        )
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.filterwarnings(
         "ignore:elementwise comparison failed:DeprecationWarning"
     )
-    @pytest.mark.xfail(
-        np_version_under1p20, reason="np.array([td64nat, float, float]) raises"
-    )
     @pytest.mark.parametrize("func", [Series, DataFrame, Index, pd.array])
     def test_constructor_mismatched_null_nullable_dtype(
         self, func, any_numeric_ea_dtype
@@ -1900,15 +1994,6 @@ def test_constructor(rand_series_with_duplicate_datetimeindex):
         ({1: 1}, np.array([[1]], dtype=np.int64)),
     ],
 )
-@pytest.mark.skipif(np_version_under1p19, reason="fails on numpy below 1.19")
 def test_numpy_array(input_dict, expected):
     result = np.array([Series(input_dict)])
     tm.assert_numpy_array_equal(result, expected)
-
-
-@pytest.mark.skipif(
-    not np_version_under1p19, reason="check failure on numpy below 1.19"
-)
-def test_numpy_array_np_v1p19():
-    with pytest.raises(KeyError, match="0"):
-        np.array([Series({1: 1})])
diff --git a/pandas/tests/series/test_iteration.py b/pandas/tests/series/test_iteration.py
index dc9fe9e3bdd34..d5551575b3617 100644
--- a/pandas/tests/series/test_iteration.py
+++ b/pandas/tests/series/test_iteration.py
@@ -11,15 +11,15 @@ def test_iter_strings(self, string_series):
             assert val == string_series[i]
 
     def test_iteritems_datetimes(self, datetime_series):
-        for idx, val in datetime_series.iteritems():
+        for idx, val in datetime_series.items():
             assert val == datetime_series[idx]
 
     def test_iteritems_strings(self, string_series):
-        for idx, val in string_series.iteritems():
+        for idx, val in string_series.items():
             assert val == string_series[idx]
 
         # assert is lazy (generators don't define reverse, lists do)
-        assert not hasattr(string_series.iteritems(), "reverse")
+        assert not hasattr(string_series.items(), "reverse")
 
     def test_items_datetimes(self, datetime_series):
         for idx, val in datetime_series.items():
diff --git a/pandas/tests/series/test_logical_ops.py b/pandas/tests/series/test_logical_ops.py
index 9648b01492e02..38e3c5ec8a6f2 100644
--- a/pandas/tests/series/test_logical_ops.py
+++ b/pandas/tests/series/test_logical_ops.py
@@ -268,7 +268,9 @@ def test_logical_ops_with_index(self, op):
     def test_reversed_xor_with_index_returns_index(self):
         # GH#22092, GH#19792
         ser = Series([True, True, False, False])
-        idx1 = Index([True, False, True, False])
+        idx1 = Index(
+            [True, False, True, False], dtype=object
+        )  # TODO: raises if bool-dtype
         idx2 = Index([1, 0, 1, 0])
 
         msg = "operating as a set operation"
@@ -325,7 +327,7 @@ def test_reversed_logical_op_with_index_returns_series(self, op):
         [
             (ops.rand_, Index([False, True])),
             (ops.ror_, Index([False, True])),
-            (ops.rxor, Index([])),
+            (ops.rxor, Index([], dtype=bool)),
         ],
     )
     def test_reverse_ops_with_index(self, op, expected):
diff --git a/pandas/tests/series/test_reductions.py b/pandas/tests/series/test_reductions.py
index 8fb51af70f3a0..a552d9d84329f 100644
--- a/pandas/tests/series/test_reductions.py
+++ b/pandas/tests/series/test_reductions.py
@@ -9,6 +9,14 @@
 import pandas._testing as tm
 
 
+@pytest.mark.parametrize("operation, expected", [("min", "a"), ("max", "b")])
+def test_reductions_series_strings(operation, expected):
+    # GH#31746
+    ser = Series(["a", "b"], dtype="string")
+    res_operation_serie = getattr(ser, operation)()
+    assert res_operation_serie == expected
+
+
 @pytest.mark.parametrize("as_period", [True, False])
 def test_mode_extension_dtype(as_period):
     # GH#41927 preserve dt64tz dtype
@@ -94,7 +102,7 @@ def test_validate_any_all_out_keepdims_raises(kwargs, func):
     msg = (
         f"the '{param}' parameter is not "
         "supported in the pandas "
-        fr"implementation of {name}\(\)"
+        rf"implementation of {name}\(\)"
     )
     with pytest.raises(ValueError, match=msg):
         func(ser, **kwargs)
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index e243f609145f3..a12bc1df37269 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -258,6 +258,13 @@ def test_float_repr(self):
         expected = "0    1.0\ndtype: object"
         assert repr(ser) == expected
 
+    def test_different_null_objects(self):
+        # GH#45263
+        ser = Series([1, 2, 3, 4], [True, None, np.nan, pd.NaT])
+        result = repr(ser)
+        expected = "True    1\nNone    2\nNaN     3\nNaT     4\ndtype: int64"
+        assert result == expected
+
 
 class TestCategoricalRepr:
     def test_categorical_repr_unicode(self):
diff --git a/pandas/tests/series/test_ufunc.py b/pandas/tests/series/test_ufunc.py
index ed07a31c24768..8e1384db024b0 100644
--- a/pandas/tests/series/test_ufunc.py
+++ b/pandas/tests/series/test_ufunc.py
@@ -10,11 +10,9 @@
 import pandas._testing as tm
 from pandas.arrays import SparseArray
 
-UNARY_UFUNCS = [np.positive, np.floor, np.exp]
 BINARY_UFUNCS = [np.add, np.logaddexp]  # dunder op
 SPARSE = [True, False]
 SPARSE_IDS = ["sparse", "dense"]
-SHUFFLE = [True, False]
 
 
 @pytest.fixture
@@ -29,7 +27,7 @@ def arrays_for_binary_ufunc():
     return a1, a2
 
 
-@pytest.mark.parametrize("ufunc", UNARY_UFUNCS)
+@pytest.mark.parametrize("ufunc", [np.positive, np.floor, np.exp])
 @pytest.mark.parametrize("sparse", SPARSE, ids=SPARSE_IDS)
 def test_unary_ufunc(ufunc, sparse):
     # Test that ufunc(pd.Series) == pd.Series(ufunc)
@@ -174,11 +172,9 @@ def test_binary_ufunc_scalar(ufunc, sparse, flip, arrays_for_binary_ufunc):
 
 @pytest.mark.parametrize("ufunc", [np.divmod])  # TODO: np.modf, np.frexp
 @pytest.mark.parametrize("sparse", SPARSE, ids=SPARSE_IDS)
-@pytest.mark.parametrize("shuffle", SHUFFLE)
+@pytest.mark.parametrize("shuffle", [True, False])
 @pytest.mark.filterwarnings("ignore:divide by zero:RuntimeWarning")
-def test_multiple_output_binary_ufuncs(
-    ufunc, sparse, shuffle, arrays_for_binary_ufunc, request
-):
+def test_multiple_output_binary_ufuncs(ufunc, sparse, shuffle, arrays_for_binary_ufunc):
     # Test that
     #  the same conditions from binary_ufunc_scalar apply to
     #  ufuncs with multiple outputs.
@@ -242,7 +238,7 @@ def test_binary_ufunc_drops_series_name(ufunc, sparse, arrays_for_binary_ufunc):
 
 def test_object_series_ok():
     class Dummy:
-        def __init__(self, value):
+        def __init__(self, value) -> None:
             self.value = value
 
         def __add__(self, other):
@@ -288,7 +284,7 @@ def test_multiply(self, values_for_np_reduce, box_with_array, request):
             obj = box(values)
 
         if isinstance(values, pd.core.arrays.SparseArray) and box is not pd.Index:
-            mark = pytest.mark.xfail(reason="SparseArray has no 'mul'")
+            mark = pytest.mark.xfail(reason="SparseArray has no 'prod'")
             request.node.add_marker(mark)
 
         if values.dtype.kind in "iuf":
@@ -417,7 +413,7 @@ def test_binary_ufunc_other_types(type_):
 
 def test_object_dtype_ok():
     class Thing:
-        def __init__(self, value):
+        def __init__(self, value) -> None:
             self.value = value
 
         def __add__(self, other):
@@ -438,8 +434,22 @@ def __repr__(self) -> str:
 
 def test_outer():
     # https://github.com/pandas-dev/pandas/issues/27186
-    s = pd.Series([1, 2, 3])
-    o = np.array([1, 2, 3])
+    ser = pd.Series([1, 2, 3])
+    obj = np.array([1, 2, 3])
 
     with pytest.raises(NotImplementedError, match=tm.EMPTY_STRING_PATTERN):
-        np.subtract.outer(s, o)
+        np.subtract.outer(ser, obj)
+
+
+def test_np_matmul():
+    # GH26650
+    df1 = pd.DataFrame(data=[[-1, 1, 10]])
+    df2 = pd.DataFrame(data=[-1, 1, 10])
+    expected_result = pd.DataFrame(data=[102])
+
+    with tm.assert_produces_warning(FutureWarning, match="on non-aligned"):
+        result = np.matmul(df1, df2)
+    tm.assert_frame_equal(
+        expected_result,
+        result,
+    )
diff --git a/pandas/tests/strings/test_api.py b/pandas/tests/strings/test_api.py
index 974ecc152f17b..d76ed65be9e1b 100644
--- a/pandas/tests/strings/test_api.py
+++ b/pandas/tests/strings/test_api.py
@@ -132,7 +132,7 @@ def test_api_for_categorical(any_string_method, any_string_dtype, request):
         any_string_dtype == "string" and get_option("string_storage") == "pyarrow"
     ):
         # unsupported operand type(s) for +: 'ArrowStringArray' and 'str'
-        mark = pytest.mark.xfail(raises=TypeError, reason="Not Implemented")
+        mark = pytest.mark.xfail(raises=NotImplementedError, reason="Not Implemented")
         request.node.add_marker(mark)
 
     s = Series(list("aabb"), dtype=any_string_dtype)
diff --git a/pandas/tests/strings/test_cat.py b/pandas/tests/strings/test_cat.py
index 8abbc59343e78..4decdff8063a8 100644
--- a/pandas/tests/strings/test_cat.py
+++ b/pandas/tests/strings/test_cat.py
@@ -376,3 +376,22 @@ def test_cat_different_classes(klass):
     result = s.str.cat(klass(["x", "y", "z"]))
     expected = Series(["ax", "by", "cz"])
     tm.assert_series_equal(result, expected)
+
+
+def test_cat_on_series_dot_str():
+    # GH 28277
+    # Test future warning of `Series.str.__iter__`
+    ps = Series(["AbC", "de", "FGHI", "j", "kLLLm"])
+    with tm.assert_produces_warning(FutureWarning):
+        ps.str.cat(others=ps.str)
+    # TODO(2.0): The following code can be uncommented
+    # when `Series.str.__iter__` is removed.
+
+    # message = re.escape(
+    #     "others must be Series, Index, DataFrame, np.ndarray "
+    #     "or list-like (either containing only strings or "
+    #     "containing only objects of type Series/Index/"
+    #     "np.ndarray[1-dim])"
+    # )
+    # with pytest.raises(TypeError, match=message):
+    #     ps.str.cat(others=ps.str)
diff --git a/pandas/tests/strings/test_extract.py b/pandas/tests/strings/test_extract.py
index 0f4ffccd8ad7f..04c355c6c78c5 100644
--- a/pandas/tests/strings/test_extract.py
+++ b/pandas/tests/strings/test_extract.py
@@ -174,13 +174,13 @@ def test_extract_expand_capture_groups(any_string_dtype):
     tm.assert_frame_equal(result, expected)
 
 
-def test_extract_expand_capture_groups_index(index, any_string_dtype):
+def test_extract_expand_capture_groups_index(request, index, any_string_dtype):
     # https://github.com/pandas-dev/pandas/issues/6348
     # not passing index to the extractor
     data = ["A1", "B2", "C"]
 
     if len(index) < len(data):
-        pytest.skip("Index too short")
+        request.node.add_marker(pytest.mark.xfail(reason="Index too short."))
 
     index = index[: len(data)]
     s = Series(data, index=index, dtype=any_string_dtype)
diff --git a/pandas/tests/strings/test_find_replace.py b/pandas/tests/strings/test_find_replace.py
index 067bcf5969587..62f9478bf25ff 100644
--- a/pandas/tests/strings/test_find_replace.py
+++ b/pandas/tests/strings/test_find_replace.py
@@ -4,6 +4,9 @@
 import numpy as np
 import pytest
 
+from pandas.compat import pa_version_under4p0
+from pandas.errors import PerformanceWarning
+
 import pandas as pd
 from pandas import (
     Series,
@@ -22,7 +25,11 @@ def test_contains(any_string_dtype):
     values = Series(values, dtype=any_string_dtype)
     pat = "mmm[_]+"
 
-    result = values.str.contains(pat)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.contains(pat)
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series(
         np.array([False, np.nan, True, True, False], dtype=np.object_),
@@ -41,7 +48,11 @@ def test_contains(any_string_dtype):
         np.array(["foo", "xyz", "fooommm__foo", "mmm_"], dtype=object),
         dtype=any_string_dtype,
     )
-    result = values.str.contains(pat)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.contains(pat)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series(np.array([False, False, True, True]), dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -51,7 +62,10 @@ def test_contains(any_string_dtype):
         np.array(["Foo", "xYz", "fOOomMm__fOo", "MMM_"], dtype=object),
         dtype=any_string_dtype,
     )
-    result = values.str.contains("FOO|mmm", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = values.str.contains("FOO|mmm", case=False)
     expected = Series(np.array([True, False, True, True]), dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -67,14 +81,22 @@ def test_contains(any_string_dtype):
     )
     pat = "mmm[_]+"
 
-    result = values.str.contains(pat)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.contains(pat)
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series(
         np.array([False, np.nan, True, True], dtype=np.object_), dtype=expected_dtype
     )
     tm.assert_series_equal(result, expected)
 
-    result = values.str.contains(pat, na=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.contains(pat, na=False)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series(np.array([False, False, True, True]), dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -83,7 +105,11 @@ def test_contains(any_string_dtype):
         np.array(["foo", "xyz", "fooommm__foo", "mmm_"], dtype=np.object_),
         dtype=any_string_dtype,
     )
-    result = values.str.contains(pat)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.contains(pat)
     expected = Series(np.array([False, False, True, True]), dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -147,7 +173,11 @@ def test_contains_na_kwarg_for_nullable_string_dtype(
     # https://github.com/pandas-dev/pandas/pull/41025#issuecomment-824062416
 
     values = Series(["a", "b", "c", "a", np.nan], dtype=nullable_string_dtype)
-    result = values.str.contains("a", na=na, regex=regex)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        nullable_string_dtype == "string[pyarrow]" and pa_version_under4p0 and regex,
+    ):
+        result = values.str.contains("a", na=na, regex=regex)
     expected = Series([True, False, False, True, expected], dtype="boolean")
     tm.assert_series_equal(result, expected)
 
@@ -159,7 +189,11 @@ def test_contains_moar(any_string_dtype):
         dtype=any_string_dtype,
     )
 
-    result = s.str.contains("a")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("a")
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series(
         [False, False, False, True, True, False, np.nan, False, False, True],
@@ -167,28 +201,42 @@ def test_contains_moar(any_string_dtype):
     )
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("a", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = s.str.contains("a", case=False)
     expected = Series(
         [True, False, False, True, True, False, np.nan, True, False, True],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("Aa")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("Aa")
     expected = Series(
         [False, False, False, True, False, False, np.nan, False, False, False],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("ba")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("ba")
     expected = Series(
         [False, False, False, True, False, False, np.nan, False, False, False],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("ba", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = s.str.contains("ba", case=False)
     expected = Series(
         [False, False, False, True, True, False, np.nan, True, False, False],
         dtype=expected_dtype,
@@ -200,23 +248,39 @@ def test_contains_nan(any_string_dtype):
     # PR #14171
     s = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype)
 
-    result = s.str.contains("foo", na=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("foo", na=False)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series([False, False, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("foo", na=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("foo", na=True)
     expected = Series([True, True, True], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("foo", na="foo")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("foo", na="foo")
     if any_string_dtype == "object":
         expected = Series(["foo", "foo", "foo"], dtype=np.object_)
     else:
         expected = Series([True, True, True], dtype="boolean")
     tm.assert_series_equal(result, expected)
 
-    result = s.str.contains("foo")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.contains("foo")
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series([np.nan, np.nan, np.nan], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -227,21 +291,22 @@ def test_contains_nan(any_string_dtype):
 # --------------------------------------------------------------------------------------
 
 
+@pytest.mark.parametrize("pat", ["foo", ("foo", "baz")])
 @pytest.mark.parametrize("dtype", [None, "category"])
 @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
 @pytest.mark.parametrize("na", [True, False])
-def test_startswith(dtype, null_value, na):
+def test_startswith(pat, dtype, null_value, na):
     # add category dtype parametrizations for GH-36241
     values = Series(
         ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
         dtype=dtype,
     )
 
-    result = values.str.startswith("foo")
+    result = values.str.startswith(pat)
     exp = Series([False, np.nan, True, False, False, np.nan, True])
     tm.assert_series_equal(result, exp)
 
-    result = values.str.startswith("foo", na=na)
+    result = values.str.startswith(pat, na=na)
     exp = Series([False, na, True, False, False, na, True])
     tm.assert_series_equal(result, exp)
 
@@ -261,13 +326,21 @@ def test_startswith_nullable_string_dtype(nullable_string_dtype, na):
         ["om", None, "foo_nom", "nom", "bar_foo", None, "foo", "regex", "rege."],
         dtype=nullable_string_dtype,
     )
-    result = values.str.startswith("foo", na=na)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        nullable_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.startswith("foo", na=na)
     exp = Series(
         [False, na, True, False, False, na, True, False, False], dtype="boolean"
     )
     tm.assert_series_equal(result, exp)
 
-    result = values.str.startswith("rege.", na=na)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        nullable_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.startswith("rege.", na=na)
     exp = Series(
         [False, na, False, False, False, na, False, False, True], dtype="boolean"
     )
@@ -279,21 +352,22 @@ def test_startswith_nullable_string_dtype(nullable_string_dtype, na):
 # --------------------------------------------------------------------------------------
 
 
+@pytest.mark.parametrize("pat", ["foo", ("foo", "baz")])
 @pytest.mark.parametrize("dtype", [None, "category"])
 @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
 @pytest.mark.parametrize("na", [True, False])
-def test_endswith(dtype, null_value, na):
+def test_endswith(pat, dtype, null_value, na):
     # add category dtype parametrizations for GH-36241
     values = Series(
         ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
         dtype=dtype,
     )
 
-    result = values.str.endswith("foo")
+    result = values.str.endswith(pat)
     exp = Series([False, np.nan, False, False, True, np.nan, True])
     tm.assert_series_equal(result, exp)
 
-    result = values.str.endswith("foo", na=na)
+    result = values.str.endswith(pat, na=na)
     exp = Series([False, na, False, False, True, na, True])
     tm.assert_series_equal(result, exp)
 
@@ -313,13 +387,21 @@ def test_endswith_nullable_string_dtype(nullable_string_dtype, na):
         ["om", None, "foo_nom", "nom", "bar_foo", None, "foo", "regex", "rege."],
         dtype=nullable_string_dtype,
     )
-    result = values.str.endswith("foo", na=na)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        nullable_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.endswith("foo", na=na)
     exp = Series(
         [False, na, False, False, True, na, True, False, False], dtype="boolean"
     )
     tm.assert_series_equal(result, exp)
 
-    result = values.str.endswith("rege.", na=na)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        nullable_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.endswith("rege.", na=na)
     exp = Series(
         [False, na, False, False, False, na, False, False, True], dtype="boolean"
     )
@@ -334,7 +416,11 @@ def test_endswith_nullable_string_dtype(nullable_string_dtype, na):
 def test_replace(any_string_dtype):
     ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype)
 
-    result = ser.str.replace("BAD[_]*", "", regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("BAD[_]*", "", regex=True)
     expected = Series(["foobar", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -343,11 +429,19 @@ def test_replace_max_replacements(any_string_dtype):
     ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype)
 
     expected = Series(["foobarBAD", np.nan], dtype=any_string_dtype)
-    result = ser.str.replace("BAD[_]*", "", n=1, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("BAD[_]*", "", n=1, regex=True)
     tm.assert_series_equal(result, expected)
 
     expected = Series(["foo__barBAD", np.nan], dtype=any_string_dtype)
-    result = ser.str.replace("BAD", "", n=1, regex=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("BAD", "", n=1, regex=False)
     tm.assert_series_equal(result, expected)
 
 
@@ -363,7 +457,10 @@ def test_replace_mixed_object():
 def test_replace_unicode(any_string_dtype):
     ser = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype)
     expected = Series([b"abcd, \xc3\xa0".decode("utf-8")], dtype=any_string_dtype)
-    result = ser.str.replace(r"(?<=\w),(?=\w)", ", ", flags=re.UNICODE, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(r"(?<=\w),(?=\w)", ", ", flags=re.UNICODE, regex=True)
     tm.assert_series_equal(result, expected)
 
 
@@ -383,7 +480,10 @@ def test_replace_callable(any_string_dtype):
 
     # test with callable
     repl = lambda m: m.group(0).swapcase()
-    result = ser.str.replace("[a-z][A-Z]{2}", repl, n=2, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace("[a-z][A-Z]{2}", repl, n=2, regex=True)
     expected = Series(["foObaD__baRbaD", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -401,7 +501,10 @@ def test_replace_callable_raises(any_string_dtype, repl):
         r"(?(3)required )positional arguments?"
     )
     with pytest.raises(TypeError, match=msg):
-        values.str.replace("a", repl)
+        with tm.maybe_produces_warning(
+            PerformanceWarning, any_string_dtype == "string[pyarrow]"
+        ):
+            values.str.replace("a", repl)
 
 
 def test_replace_callable_named_groups(any_string_dtype):
@@ -409,7 +512,10 @@ def test_replace_callable_named_groups(any_string_dtype):
     ser = Series(["Foo Bar Baz", np.nan], dtype=any_string_dtype)
     pat = r"(?P<first>\w+) (?P<middle>\w+) (?P<last>\w+)"
     repl = lambda m: m.group("middle").swapcase()
-    result = ser.str.replace(pat, repl, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(pat, repl, regex=True)
     expected = Series(["bAR", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -420,11 +526,17 @@ def test_replace_compiled_regex(any_string_dtype):
 
     # test with compiled regex
     pat = re.compile(r"BAD_*")
-    result = ser.str.replace(pat, "", regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(pat, "", regex=True)
     expected = Series(["foobar", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.replace(pat, "", n=1, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(pat, "", n=1, regex=True)
     expected = Series(["foobarBAD", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -443,7 +555,10 @@ def test_replace_compiled_regex_unicode(any_string_dtype):
     ser = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype)
     expected = Series([b"abcd, \xc3\xa0".decode("utf-8")], dtype=any_string_dtype)
     pat = re.compile(r"(?<=\w),(?=\w)", flags=re.UNICODE)
-    result = ser.str.replace(pat, ", ")
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(pat, ", ")
     tm.assert_series_equal(result, expected)
 
 
@@ -470,7 +585,10 @@ def test_replace_compiled_regex_callable(any_string_dtype):
     ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype)
     repl = lambda m: m.group(0).swapcase()
     pat = re.compile("[a-z][A-Z]{2}")
-    result = ser.str.replace(pat, repl, n=2)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace(pat, repl, n=2)
     expected = Series(["foObaD__baRbaD", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -482,7 +600,11 @@ def test_replace_literal(regex, expected, any_string_dtype):
     # GH16808 literal replace (regex=False vs regex=True)
     ser = Series(["f.o", "foo", np.nan], dtype=any_string_dtype)
     expected = Series(expected, dtype=any_string_dtype)
-    result = ser.str.replace("f.", "ba", regex=regex)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("f.", "ba", regex=regex)
     tm.assert_series_equal(result, expected)
 
 
@@ -511,14 +633,21 @@ def test_replace_moar(any_string_dtype):
         dtype=any_string_dtype,
     )
 
-    result = ser.str.replace("A", "YYY")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("A", "YYY")
     expected = Series(
         ["YYY", "B", "C", "YYYaba", "Baca", "", np.nan, "CYYYBYYY", "dog", "cat"],
         dtype=any_string_dtype,
     )
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.replace("A", "YYY", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace("A", "YYY", case=False)
     expected = Series(
         [
             "YYY",
@@ -536,7 +665,10 @@ def test_replace_moar(any_string_dtype):
     )
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.replace("^.a|dog", "XX-XX ", case=False, regex=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace("^.a|dog", "XX-XX ", case=False, regex=True)
     expected = Series(
         [
             "A",
@@ -559,11 +691,17 @@ def test_replace_not_case_sensitive_not_regex(any_string_dtype):
     # https://github.com/pandas-dev/pandas/issues/41602
     ser = Series(["A.", "a.", "Ab", "ab", np.nan], dtype=any_string_dtype)
 
-    result = ser.str.replace("a", "c", case=False, regex=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace("a", "c", case=False, regex=False)
     expected = Series(["c.", "c.", "cb", "cb", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.replace("a.", "c.", case=False, regex=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.replace("a.", "c.", case=False, regex=False)
     expected = Series(["c.", "c.", "Ab", "ab", np.nan], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -575,7 +713,12 @@ def test_replace_regex_default_warning(any_string_dtype):
         "The default value of regex will change from True to False in a "
         "future version\\.$"
     )
-    with tm.assert_produces_warning(FutureWarning, match=msg):
+
+    with tm.assert_produces_warning(
+        FutureWarning,
+        match=msg,
+        raise_on_extra_warnings=any_string_dtype != "string[pyarrow]",
+    ):
         result = s.str.replace("^.$", "a")
     expected = Series(["a", "a", "ac", np.nan, ""], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
@@ -596,10 +739,17 @@ def test_replace_regex_single_character(regex, any_string_dtype):
             "version. In addition, single character regular expressions will *not* "
             "be treated as literal strings when regex=True."
         )
-        with tm.assert_produces_warning(FutureWarning, match=msg):
+        pyarrow_warn = any_string_dtype == "string[pyarrow]" and pa_version_under4p0
+        with tm.assert_produces_warning(
+            FutureWarning, match=msg, raise_on_extra_warnings=not pyarrow_warn
+        ):
             result = s.str.replace(".", "a", regex=regex)
     else:
-        result = s.str.replace(".", "a", regex=regex)
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+        ):
+            result = s.str.replace(".", "a", regex=regex)
 
     expected = Series(["aab", "a", "b", np.nan, ""], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
@@ -615,29 +765,49 @@ def test_match(any_string_dtype):
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
 
     values = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype)
-    result = values.str.match(".*(BAD[_]+).*(BAD)")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.match(".*(BAD[_]+).*(BAD)")
     expected = Series([True, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     values = Series(
         ["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
-    result = values.str.match(".*BAD[_]+.*BAD")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.match(".*BAD[_]+.*BAD")
     expected = Series([True, True, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = values.str.match("BAD[_]+.*BAD")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.match("BAD[_]+.*BAD")
     expected = Series([False, True, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     values = Series(
         ["fooBAD__barBAD", "^BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
-    result = values.str.match("^BAD[_]+.*BAD")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.match("^BAD[_]+.*BAD")
     expected = Series([False, False, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = values.str.match("\\^BAD[_]+.*BAD")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = values.str.match("\\^BAD[_]+.*BAD")
     expected = Series([False, True, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -668,12 +838,20 @@ def test_match_na_kwarg(any_string_dtype):
     # GH #6609
     s = Series(["a", "b", np.nan], dtype=any_string_dtype)
 
-    result = s.str.match("a", na=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.match("a", na=False)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series([True, False, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
-    result = s.str.match("a")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = s.str.match("a")
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series([True, False, np.nan], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -681,7 +859,10 @@ def test_match_na_kwarg(any_string_dtype):
 
 def test_match_case_kwarg(any_string_dtype):
     values = Series(["ab", "AB", "abc", "ABC"], dtype=any_string_dtype)
-    result = values.str.match("ab", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = values.str.match("ab", case=False)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series([True, True, True, True], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -697,7 +878,11 @@ def test_fullmatch(any_string_dtype):
     ser = Series(
         ["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
-    result = ser.str.fullmatch(".*BAD[_]+.*BAD")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.fullmatch(".*BAD[_]+.*BAD")
     expected_dtype = "object" if any_string_dtype == "object" else "boolean"
     expected = Series([True, False, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -707,7 +892,11 @@ def test_fullmatch_na_kwarg(any_string_dtype):
     ser = Series(
         ["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
-    result = ser.str.fullmatch(".*BAD[_]+.*BAD", na=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.fullmatch(".*BAD[_]+.*BAD", na=False)
     expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"
     expected = Series([True, False, False, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -719,15 +908,25 @@ def test_fullmatch_case_kwarg(any_string_dtype):
 
     expected = Series([True, False, False, False], dtype=expected_dtype)
 
-    result = ser.str.fullmatch("ab", case=True)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.fullmatch("ab", case=True)
     tm.assert_series_equal(result, expected)
 
     expected = Series([True, True, False, False], dtype=expected_dtype)
 
-    result = ser.str.fullmatch("ab", case=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.fullmatch("ab", case=False)
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.fullmatch("ab", flags=re.IGNORECASE)
+    with tm.maybe_produces_warning(
+        PerformanceWarning, any_string_dtype == "string[pyarrow]"
+    ):
+        result = ser.str.fullmatch("ab", flags=re.IGNORECASE)
     tm.assert_series_equal(result, expected)
 
 
@@ -904,13 +1103,17 @@ def test_flags_kwarg(any_string_dtype):
 
     pat = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})"
 
+    using_pyarrow = any_string_dtype == "string[pyarrow]"
+
     result = data.str.extract(pat, flags=re.IGNORECASE, expand=True)
     assert result.iloc[0].tolist() == ["dave", "google", "com"]
 
-    result = data.str.match(pat, flags=re.IGNORECASE)
+    with tm.maybe_produces_warning(PerformanceWarning, using_pyarrow):
+        result = data.str.match(pat, flags=re.IGNORECASE)
     assert result[0]
 
-    result = data.str.fullmatch(pat, flags=re.IGNORECASE)
+    with tm.maybe_produces_warning(PerformanceWarning, using_pyarrow):
+        result = data.str.fullmatch(pat, flags=re.IGNORECASE)
     assert result[0]
 
     result = data.str.findall(pat, flags=re.IGNORECASE)
@@ -920,6 +1123,8 @@ def test_flags_kwarg(any_string_dtype):
     assert result[0] == 1
 
     msg = "has match groups"
-    with tm.assert_produces_warning(UserWarning, match=msg):
+    with tm.assert_produces_warning(
+        UserWarning, match=msg, raise_on_extra_warnings=not using_pyarrow
+    ):
         result = data.str.contains(pat, flags=re.IGNORECASE)
     assert result[0]
diff --git a/pandas/tests/strings/test_split_partition.py b/pandas/tests/strings/test_split_partition.py
index 74458c13e8df7..7d73414a672c8 100644
--- a/pandas/tests/strings/test_split_partition.py
+++ b/pandas/tests/strings/test_split_partition.py
@@ -130,6 +130,23 @@ def test_rsplit_max_number(any_string_dtype):
     tm.assert_series_equal(result, exp)
 
 
+@pytest.mark.parametrize("method", ["split", "rsplit"])
+def test_posargs_deprecation(method):
+    # GH 47423; Deprecate passing n as positional.
+    s = Series(["foo,bar,lorep"])
+
+    msg = (
+        f"In a future version of pandas all arguments of StringMethods.{method} "
+        "except for the argument 'pat' will be keyword-only"
+    )
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = getattr(s.str, method)(",", 3)
+
+    expected = Series([["foo", "bar", "lorep"]])
+    tm.assert_series_equal(result, expected)
+
+
 def test_split_blank_string(any_string_dtype):
     # expand blank split GH 20067
     values = Series([""], name="test", dtype=any_string_dtype)
diff --git a/pandas/tests/strings/test_string_array.py b/pandas/tests/strings/test_string_array.py
index 90c26a747abdd..8628aafefa4b1 100644
--- a/pandas/tests/strings/test_string_array.py
+++ b/pandas/tests/strings/test_string_array.py
@@ -10,6 +10,7 @@
 )
 
 
+@pytest.mark.filterwarnings("ignore:Falling back")
 def test_string_array(nullable_string_dtype, any_string_method):
     method_name, args, kwargs = any_string_method
 
diff --git a/pandas/tests/strings/test_strings.py b/pandas/tests/strings/test_strings.py
index b72dd111f3b25..4b25752940418 100644
--- a/pandas/tests/strings/test_strings.py
+++ b/pandas/tests/strings/test_strings.py
@@ -6,6 +6,12 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    pa_version_under2p0,
+    pa_version_under4p0,
+)
+from pandas.errors import PerformanceWarning
+
 from pandas import (
     DataFrame,
     Index,
@@ -16,6 +22,17 @@
 import pandas._testing as tm
 
 
+@pytest.mark.parametrize("pattern", [0, True, Series(["foo", "bar"])])
+def test_startswith_endswith_non_str_patterns(pattern):
+    # GH3485
+    ser = Series(["foo", "bar"])
+    msg = f"expected a string or tuple, not {type(pattern).__name__}"
+    with pytest.raises(TypeError, match=msg):
+        ser.str.startswith(pattern)
+    with pytest.raises(TypeError, match=msg):
+        ser.str.endswith(pattern)
+
+
 def assert_series_or_index_equal(left, right):
     if isinstance(left, Series):
         tm.assert_series_equal(left, right)
@@ -165,14 +182,34 @@ def test_empty_str_methods(any_string_dtype):
     assert "" == empty.str.cat()
     tm.assert_series_equal(empty_str, empty.str.title())
     tm.assert_series_equal(empty_int, empty.str.count("a"))
-    tm.assert_series_equal(empty_bool, empty.str.contains("a"))
-    tm.assert_series_equal(empty_bool, empty.str.startswith("a"))
-    tm.assert_series_equal(empty_bool, empty.str.endswith("a"))
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_bool, empty.str.contains("a"))
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_bool, empty.str.startswith("a"))
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_bool, empty.str.endswith("a"))
     tm.assert_series_equal(empty_str, empty.str.lower())
     tm.assert_series_equal(empty_str, empty.str.upper())
-    tm.assert_series_equal(empty_str, empty.str.replace("a", "b"))
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_str, empty.str.replace("a", "b"))
     tm.assert_series_equal(empty_str, empty.str.repeat(3))
-    tm.assert_series_equal(empty_bool, empty.str.match("^a"))
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_bool, empty.str.match("^a"))
     tm.assert_frame_equal(
         DataFrame(columns=[0], dtype=any_string_dtype),
         empty.str.extract("()", expand=True),
@@ -188,7 +225,11 @@ def test_empty_str_methods(any_string_dtype):
     )
     tm.assert_frame_equal(empty_df, empty.str.get_dummies())
     tm.assert_series_equal(empty_str, empty_str.str.join(""))
-    tm.assert_series_equal(empty_int, empty.str.len())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_int, empty.str.len())
     tm.assert_series_equal(empty_object, empty_str.str.findall("a"))
     tm.assert_series_equal(empty_int, empty.str.find("a"))
     tm.assert_series_equal(empty_int, empty.str.rfind("a"))
@@ -202,9 +243,21 @@ def test_empty_str_methods(any_string_dtype):
     tm.assert_frame_equal(empty_df, empty.str.rpartition("a"))
     tm.assert_series_equal(empty_str, empty.str.slice(stop=1))
     tm.assert_series_equal(empty_str, empty.str.slice(step=1))
-    tm.assert_series_equal(empty_str, empty.str.strip())
-    tm.assert_series_equal(empty_str, empty.str.lstrip())
-    tm.assert_series_equal(empty_str, empty.str.rstrip())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_str, empty.str.strip())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_str, empty.str.lstrip())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        tm.assert_series_equal(empty_str, empty.str.rstrip())
     tm.assert_series_equal(empty_str, empty.str.wrap(42))
     tm.assert_series_equal(empty_str, empty.str.get(0))
     tm.assert_series_equal(empty_object, empty_bytes.str.decode("ascii"))
@@ -213,7 +266,11 @@ def test_empty_str_methods(any_string_dtype):
     tm.assert_series_equal(empty_bool, empty.str.isalnum())
     tm.assert_series_equal(empty_bool, empty.str.isalpha())
     tm.assert_series_equal(empty_bool, empty.str.isdigit())
-    tm.assert_series_equal(empty_bool, empty.str.isspace())
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under2p0,
+    ):
+        tm.assert_series_equal(empty_bool, empty.str.isspace())
     tm.assert_series_equal(empty_bool, empty.str.islower())
     tm.assert_series_equal(empty_bool, empty.str.isupper())
     tm.assert_series_equal(empty_bool, empty.str.istitle())
@@ -264,7 +321,13 @@ def test_ismethods(method, expected, any_string_dtype):
     )
     expected_dtype = "bool" if any_string_dtype == "object" else "boolean"
     expected = Series(expected, dtype=expected_dtype)
-    result = getattr(ser.str, method)()
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]"
+        and pa_version_under2p0
+        and method == "isspace",
+    ):
+        result = getattr(ser.str, method)()
     tm.assert_series_equal(result, expected)
 
     # compare with standard library
@@ -334,7 +397,11 @@ def test_len(any_string_dtype):
         ["foo", "fooo", "fooooo", np.nan, "fooooooo", "foo\n", "あ"],
         dtype=any_string_dtype,
     )
-    result = ser.str.len()
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.len()
     expected_dtype = "float64" if any_string_dtype == "object" else "Int64"
     expected = Series([3, 4, 6, np.nan, 8, 4, 1], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
@@ -360,9 +427,7 @@ def test_len_mixed():
         ("rindex", "E", 0, 5, [4, 3, 1, 4]),
     ],
 )
-def test_index(
-    method, sub, start, end, index_or_series, any_string_dtype, expected, request
-):
+def test_index(method, sub, start, end, index_or_series, any_string_dtype, expected):
 
     obj = index_or_series(
         ["ABCDEFG", "BCDEFEF", "DEFGHIJEF", "EFGHEF"], dtype=any_string_dtype
@@ -423,7 +488,11 @@ def test_pipe_failures(any_string_dtype):
     expected = Series([["A", "B", "C"]], dtype=object)
     tm.assert_series_equal(result, expected)
 
-    result = ser.str.replace("|", " ", regex=False)
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = ser.str.replace("|", " ", regex=False)
     expected = Series(["A B C"], dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -493,7 +562,11 @@ def test_slice_replace(start, stop, repl, expected, any_string_dtype):
 def test_strip_lstrip_rstrip(any_string_dtype, method, exp):
     ser = Series(["  aa   ", " bb \n", np.nan, "cc  "], dtype=any_string_dtype)
 
-    result = getattr(ser.str, method)()
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = getattr(ser.str, method)()
     expected = Series(exp, dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -525,7 +598,11 @@ def test_strip_lstrip_rstrip_mixed_object(method, exp):
 def test_strip_lstrip_rstrip_args(any_string_dtype, method, exp):
     ser = Series(["xxABCxx", "xx BNSD", "LDFJH xx"], dtype=any_string_dtype)
 
-    result = getattr(ser.str, method)("x")
+    with tm.maybe_produces_warning(
+        PerformanceWarning,
+        any_string_dtype == "string[pyarrow]" and pa_version_under4p0,
+    ):
+        result = getattr(ser.str, method)("x")
     expected = Series(exp, dtype=any_string_dtype)
     tm.assert_series_equal(result, expected)
 
@@ -726,3 +803,45 @@ def test_str_accessor_in_apply_func():
     expected = Series(["A/D", "B/E", "C/F"])
     result = df.apply(lambda f: "/".join(f.str.upper()), axis=1)
     tm.assert_series_equal(result, expected)
+
+
+def test_zfill():
+    # https://github.com/pandas-dev/pandas/issues/20868
+    value = Series(["-1", "1", "1000", 10, np.nan])
+    expected = Series(["-01", "001", "1000", np.nan, np.nan])
+    tm.assert_series_equal(value.str.zfill(3), expected)
+
+    value = Series(["-2", "+5"])
+    expected = Series(["-0002", "+0005"])
+    tm.assert_series_equal(value.str.zfill(5), expected)
+
+
+def test_zfill_with_non_integer_argument():
+    value = Series(["-2", "+5"])
+    wid = "a"
+    msg = f"width must be of integer type, not {type(wid).__name__}"
+    with pytest.raises(TypeError, match=msg):
+        value.str.zfill(wid)
+
+
+def test_zfill_with_leading_sign():
+    value = Series(["-cat", "-1", "+dog"])
+    expected = Series(["-0cat", "-0001", "+0dog"])
+    tm.assert_series_equal(value.str.zfill(5), expected)
+
+
+def test_get_with_dict_label():
+    # GH47911
+    s = Series(
+        [
+            {"name": "Hello", "value": "World"},
+            {"name": "Goodbye", "value": "Planet"},
+            {"value": "Sea"},
+        ]
+    )
+    result = s.str.get("name")
+    expected = Series(["Hello", "Goodbye", None])
+    tm.assert_series_equal(result, expected)
+    result = s.str.get("value")
+    expected = Series(["World", "Planet", "Sea"])
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 94a20901b2f7a..80271c13cd35d 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -9,6 +9,8 @@
     algos as libalgos,
     hashtable as ht,
 )
+from pandas.compat import pa_version_under7p0
+from pandas.errors import PerformanceWarning
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import (
@@ -50,15 +52,31 @@ class TestFactorize:
     @pytest.mark.parametrize("sort", [True, False])
     def test_factorize(self, index_or_series_obj, sort):
         obj = index_or_series_obj
-        result_codes, result_uniques = obj.factorize(sort=sort)
+        with tm.maybe_produces_warning(
+            PerformanceWarning,
+            sort
+            and pa_version_under7p0
+            and getattr(obj.dtype, "storage", "") == "pyarrow",
+        ):
+            result_codes, result_uniques = obj.factorize(sort=sort)
 
         constructor = Index
         if isinstance(obj, MultiIndex):
             constructor = MultiIndex.from_tuples
         expected_uniques = constructor(obj.unique())
+        if (
+            isinstance(obj, Index)
+            and expected_uniques.dtype == bool
+            and obj.dtype == object
+        ):
+            expected_uniques = expected_uniques.astype(object)
 
         if sort:
-            expected_uniques = expected_uniques.sort_values()
+            with tm.maybe_produces_warning(
+                PerformanceWarning,
+                pa_version_under7p0 and getattr(obj.dtype, "storage", "") == "pyarrow",
+            ):
+                expected_uniques = expected_uniques.sort_values()
 
         # construct an integer ndarray so that
         # `expected_uniques.take(expected_codes)` is equal to `obj`
@@ -69,11 +87,11 @@ def test_factorize(self, index_or_series_obj, sort):
         tm.assert_numpy_array_equal(result_codes, expected_codes)
         tm.assert_index_equal(result_uniques, expected_uniques, exact=True)
 
-    def test_series_factorize_na_sentinel_none(self):
+    def test_series_factorize_use_na_sentinel_false(self):
         # GH#35667
         values = np.array([1, 2, 1, np.nan])
         ser = Series(values)
-        codes, uniques = ser.factorize(na_sentinel=None)
+        codes, uniques = ser.factorize(use_na_sentinel=False)
 
         expected_codes = np.array([0, 1, 0, 2], dtype=np.intp)
         expected_uniques = Index([1.0, 2.0, np.nan])
@@ -81,6 +99,20 @@ def test_series_factorize_na_sentinel_none(self):
         tm.assert_numpy_array_equal(codes, expected_codes)
         tm.assert_index_equal(uniques, expected_uniques)
 
+    @pytest.mark.parametrize("na_sentinel", [None, -1, -10])
+    def test_depr_na_sentinel(self, na_sentinel, index_or_series_obj):
+        # GH#46910
+        if na_sentinel is None:
+            msg = "Specifying `na_sentinel=None` is deprecated"
+        elif na_sentinel == -1:
+            msg = "Specifying `na_sentinel=-1` is deprecated"
+        else:
+            msg = "Specifying the specific value to use for `na_sentinel` is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            pd.factorize(index_or_series_obj, na_sentinel=na_sentinel)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            index_or_series_obj.factorize(na_sentinel=na_sentinel)
+
     def test_basic(self):
 
         codes, uniques = algos.factorize(["a", "b", "b", "a", "a", "c", "c", "c"])
@@ -266,20 +298,20 @@ def test_float64_factorize(self, writable):
         tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_uint64_factorize(self, writable):
-        data = np.array([2 ** 64 - 1, 1, 2 ** 64 - 1], dtype=np.uint64)
+        data = np.array([2**64 - 1, 1, 2**64 - 1], dtype=np.uint64)
         data.setflags(write=writable)
         expected_codes = np.array([0, 1, 0], dtype=np.intp)
-        expected_uniques = np.array([2 ** 64 - 1, 1], dtype=np.uint64)
+        expected_uniques = np.array([2**64 - 1, 1], dtype=np.uint64)
 
         codes, uniques = algos.factorize(data)
         tm.assert_numpy_array_equal(codes, expected_codes)
         tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_int64_factorize(self, writable):
-        data = np.array([2 ** 63 - 1, -(2 ** 63), 2 ** 63 - 1], dtype=np.int64)
+        data = np.array([2**63 - 1, -(2**63), 2**63 - 1], dtype=np.int64)
         data.setflags(write=writable)
         expected_codes = np.array([0, 1, 0], dtype=np.intp)
-        expected_uniques = np.array([2 ** 63 - 1, -(2 ** 63)], dtype=np.int64)
+        expected_uniques = np.array([2**63 - 1, -(2**63)], dtype=np.int64)
 
         codes, uniques = algos.factorize(data)
         tm.assert_numpy_array_equal(codes, expected_codes)
@@ -354,7 +386,7 @@ def test_factorize_rangeindex_decreasing(self, sort):
     def test_deprecate_order(self):
         # gh 19727 - check warning is raised for deprecated keyword, order.
         # Test not valid once order keyword is removed.
-        data = np.array([2 ** 63, 1, 2 ** 63], dtype=np.uint64)
+        data = np.array([2**63, 1, 2**63], dtype=np.uint64)
         with pytest.raises(TypeError, match="got an unexpected keyword"):
             algos.factorize(data, order=True)
         with tm.assert_produces_warning(False):
@@ -364,7 +396,7 @@ def test_deprecate_order(self):
         "data",
         [
             np.array([0, 1, 0], dtype="u8"),
-            np.array([-(2 ** 63), 1, -(2 ** 63)], dtype="i8"),
+            np.array([-(2**63), 1, -(2**63)], dtype="i8"),
             np.array(["__nan__", "foo", "__nan__"], dtype="object"),
         ],
     )
@@ -381,8 +413,8 @@ def test_parametrized_factorize_na_value_default(self, data):
         [
             (np.array([0, 1, 0, 2], dtype="u8"), 0),
             (np.array([1, 0, 1, 2], dtype="u8"), 1),
-            (np.array([-(2 ** 63), 1, -(2 ** 63), 0], dtype="i8"), -(2 ** 63)),
-            (np.array([1, -(2 ** 63), 1, 0], dtype="i8"), 1),
+            (np.array([-(2**63), 1, -(2**63), 0], dtype="i8"), -(2**63)),
+            (np.array([1, -(2**63), 1, 0], dtype="i8"), 1),
             (np.array(["a", "", "a", "b"], dtype=object), "a"),
             (np.array([(), ("a", 1), (), ("a", 2)], dtype=object), ()),
             (np.array([("a", 1), (), ("a", 1), ("a", 2)], dtype=object), ("a", 1)),
@@ -412,7 +444,12 @@ def test_parametrized_factorize_na_value(self, data, na_value):
         ids=["numpy_array", "extension_array"],
     )
     def test_factorize_na_sentinel(self, sort, na_sentinel, data, uniques):
-        codes, uniques = algos.factorize(data, sort=sort, na_sentinel=na_sentinel)
+        if na_sentinel == -1:
+            msg = "Specifying `na_sentinel=-1` is deprecated"
+        else:
+            msg = "the specific value to use for `na_sentinel` is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            codes, uniques = algos.factorize(data, sort=sort, na_sentinel=na_sentinel)
         if sort:
             expected_codes = np.array([1, 0, na_sentinel, 1], dtype=np.intp)
             expected_uniques = algos.safe_sort(uniques)
@@ -430,46 +467,46 @@ def test_factorize_na_sentinel(self, sort, na_sentinel, data, uniques):
         [
             (
                 ["a", None, "b", "a"],
-                np.array([0, 2, 1, 0], dtype=np.dtype("intp")),
-                np.array(["a", "b", np.nan], dtype=object),
+                np.array([0, 1, 2, 0], dtype=np.dtype("intp")),
+                np.array(["a", np.nan, "b"], dtype=object),
             ),
             (
                 ["a", np.nan, "b", "a"],
-                np.array([0, 2, 1, 0], dtype=np.dtype("intp")),
-                np.array(["a", "b", np.nan], dtype=object),
+                np.array([0, 1, 2, 0], dtype=np.dtype("intp")),
+                np.array(["a", np.nan, "b"], dtype=object),
             ),
         ],
     )
-    def test_object_factorize_na_sentinel_none(
+    def test_object_factorize_use_na_sentinel_false(
         self, data, expected_codes, expected_uniques
     ):
-        codes, uniques = algos.factorize(data, na_sentinel=None)
+        codes, uniques = algos.factorize(data, use_na_sentinel=False)
 
-        tm.assert_numpy_array_equal(uniques, expected_uniques)
-        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques, strict_nan=True)
+        tm.assert_numpy_array_equal(codes, expected_codes, strict_nan=True)
 
     @pytest.mark.parametrize(
         "data, expected_codes, expected_uniques",
         [
             (
                 [1, None, 1, 2],
-                np.array([0, 2, 0, 1], dtype=np.dtype("intp")),
-                np.array([1, 2, np.nan], dtype="O"),
+                np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
+                np.array([1, np.nan, 2], dtype="O"),
             ),
             (
                 [1, np.nan, 1, 2],
-                np.array([0, 2, 0, 1], dtype=np.dtype("intp")),
-                np.array([1, 2, np.nan], dtype=np.float64),
+                np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
+                np.array([1, np.nan, 2], dtype=np.float64),
             ),
         ],
     )
-    def test_int_factorize_na_sentinel_none(
+    def test_int_factorize_use_na_sentinel_false(
         self, data, expected_codes, expected_uniques
     ):
-        codes, uniques = algos.factorize(data, na_sentinel=None)
+        codes, uniques = algos.factorize(data, use_na_sentinel=False)
 
-        tm.assert_numpy_array_equal(uniques, expected_uniques)
-        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques, strict_nan=True)
+        tm.assert_numpy_array_equal(codes, expected_codes, strict_nan=True)
 
 
 class TestUnique:
@@ -601,8 +638,8 @@ def test_timedelta64_dtype_array_returned(self):
         assert result.dtype == expected.dtype
 
     def test_uint64_overflow(self):
-        s = Series([1, 2, 2 ** 63, 2 ** 63], dtype=np.uint64)
-        exp = np.array([1, 2, 2 ** 63], dtype=np.uint64)
+        s = Series([1, 2, 2**63, 2**63], dtype=np.uint64)
+        exp = np.array([1, 2, 2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(algos.unique(s), exp)
 
     def test_nan_in_object_array(self):
@@ -809,6 +846,13 @@ def test_do_not_mangle_na_values(self, unique_nulls_fixture, unique_nulls_fixtur
         assert a[0] is unique_nulls_fixture
         assert a[1] is unique_nulls_fixture2
 
+    def test_unique_masked(self, any_numeric_ea_dtype):
+        # GH#48019
+        ser = Series([1, pd.NA, 2] * 3, dtype=any_numeric_ea_dtype)
+        result = pd.unique(ser)
+        expected = pd.array([1, pd.NA, 2], dtype=any_numeric_ea_dtype)
+        tm.assert_extension_array_equal(result, expected)
+
 
 class TestIsin:
     def test_invalid(self):
@@ -1083,6 +1127,13 @@ def test_isin_float_df_string_search(self):
         expected_false = DataFrame({"values": [False, False]})
         tm.assert_frame_equal(result, expected_false)
 
+    def test_isin_unsigned_dtype(self):
+        # GH#46485
+        ser = Series([1378774140726870442], dtype=np.uint64)
+        result = ser.isin([1378774140726870528])
+        expected = Series(False)
+        tm.assert_series_equal(result, expected)
+
 
 class TestValueCounts:
     def test_value_counts(self):
@@ -1240,7 +1291,7 @@ def test_dropna(self):
 
         tm.assert_series_equal(
             Series([True] * 3 + [False] * 2 + [None] * 5).value_counts(dropna=True),
-            Series([3, 2], index=[True, False]),
+            Series([3, 2], index=Index([True, False], dtype=object)),
         )
         tm.assert_series_equal(
             Series([True] * 5 + [False] * 3 + [None] * 2).value_counts(dropna=False),
@@ -1280,14 +1331,14 @@ def test_value_counts_normalized(self, dtype):
         tm.assert_series_equal(result, expected)
 
     def test_value_counts_uint64(self):
-        arr = np.array([2 ** 63], dtype=np.uint64)
-        expected = Series([1], index=[2 ** 63])
+        arr = np.array([2**63], dtype=np.uint64)
+        expected = Series([1], index=[2**63])
         result = algos.value_counts(arr)
 
         tm.assert_series_equal(result, expected)
 
-        arr = np.array([-1, 2 ** 63], dtype=object)
-        expected = Series([1, 1], index=[-1, 2 ** 63])
+        arr = np.array([-1, 2**63], dtype=object)
+        expected = Series([1, 1], index=[-1, 2**63])
         result = algos.value_counts(arr)
 
         tm.assert_series_equal(result, expected)
@@ -1354,7 +1405,7 @@ def test_duplicated_with_nas(self):
             ),
             np.array(["a", "b", "a", "e", "c", "b", "d", "a", "e", "f"], dtype=object),
             np.array(
-                [1, 2 ** 63, 1, 3 ** 5, 10, 2 ** 63, 39, 1, 3 ** 5, 7], dtype=np.uint64
+                [1, 2**63, 1, 3**5, 10, 2**63, 39, 1, 3**5, 7], dtype=np.uint64
             ),
         ],
     )
@@ -1525,110 +1576,6 @@ def test_unique_complex_numbers(self, array, expected):
 
 
 class TestHashTable:
-    def test_string_hashtable_set_item_signature(self):
-        # GH#30419 fix typing in StringHashTable.set_item to prevent segfault
-        tbl = ht.StringHashTable()
-
-        tbl.set_item("key", 1)
-        assert tbl.get_item("key") == 1
-
-        with pytest.raises(TypeError, match="'key' has incorrect type"):
-            # key arg typed as string, not object
-            tbl.set_item(4, 6)
-        with pytest.raises(TypeError, match="'val' has incorrect type"):
-            tbl.get_item(4)
-
-    def test_lookup_nan(self, writable):
-        xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3])
-        # GH 21688 ensure we can deal with readonly memory views
-        xs.setflags(write=writable)
-        m = ht.Float64HashTable()
-        m.map_locations(xs)
-        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
-
-    def test_add_signed_zeros(self):
-        # GH 21866 inconsistent hash-function for float64
-        # default hash-function would lead to different hash-buckets
-        # for 0.0 and -0.0 if there are more than 2^30 hash-buckets
-        # but this would mean 16GB
-        N = 4  # 12 * 10**8 would trigger the error, if you have enough memory
-        m = ht.Float64HashTable(N)
-        m.set_item(0.0, 0)
-        m.set_item(-0.0, 0)
-        assert len(m) == 1  # 0.0 and -0.0 are equivalent
-
-    def test_add_different_nans(self):
-        # GH 21866 inconsistent hash-function for float64
-        # create different nans from bit-patterns:
-        NAN1 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000000))[0]
-        NAN2 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000001))[0]
-        assert NAN1 != NAN1
-        assert NAN2 != NAN2
-        # default hash function would lead to different hash-buckets
-        # for NAN1 and NAN2 even if there are only 4 buckets:
-        m = ht.Float64HashTable()
-        m.set_item(NAN1, 0)
-        m.set_item(NAN2, 0)
-        assert len(m) == 1  # NAN1 and NAN2 are equivalent
-
-    def test_lookup_overflow(self, writable):
-        xs = np.array([1, 2, 2 ** 63], dtype=np.uint64)
-        # GH 21688 ensure we can deal with readonly memory views
-        xs.setflags(write=writable)
-        m = ht.UInt64HashTable()
-        m.map_locations(xs)
-        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
-
-    def test_get_unique(self):
-        s = Series([1, 2, 2 ** 63, 2 ** 63], dtype=np.uint64)
-        exp = np.array([1, 2, 2 ** 63], dtype=np.uint64)
-        tm.assert_numpy_array_equal(s.unique(), exp)
-
-    @pytest.mark.parametrize("nvals", [0, 10])  # resizing to 0 is special case
-    @pytest.mark.parametrize(
-        "htable, uniques, dtype, safely_resizes",
-        [
-            (ht.PyObjectHashTable, ht.ObjectVector, "object", False),
-            (ht.StringHashTable, ht.ObjectVector, "object", True),
-            (ht.Float64HashTable, ht.Float64Vector, "float64", False),
-            (ht.Int64HashTable, ht.Int64Vector, "int64", False),
-            (ht.Int32HashTable, ht.Int32Vector, "int32", False),
-            (ht.UInt64HashTable, ht.UInt64Vector, "uint64", False),
-        ],
-    )
-    def test_vector_resize(
-        self, writable, htable, uniques, dtype, safely_resizes, nvals
-    ):
-        # Test for memory errors after internal vector
-        # reallocations (GH 7157)
-        vals = np.array(np.random.randn(1000), dtype=dtype)
-
-        # GH 21688 ensures we can deal with read-only memory views
-        vals.setflags(write=writable)
-
-        # initialise instances; cannot initialise in parametrization,
-        # as otherwise external views would be held on the array (which is
-        # one of the things this test is checking)
-        htable = htable()
-        uniques = uniques()
-
-        # get_labels may append to uniques
-        htable.get_labels(vals[:nvals], uniques, 0, -1)
-        # to_array() sets an external_view_exists flag on uniques.
-        tmp = uniques.to_array()
-        oldshape = tmp.shape
-
-        # subsequent get_labels() calls can no longer append to it
-        # (except for StringHashTables + ObjectVector)
-        if safely_resizes:
-            htable.get_labels(vals, uniques, 0, -1)
-        else:
-            with pytest.raises(ValueError, match="external reference.*"):
-                htable.get_labels(vals, uniques, 0, -1)
-
-        uniques.to_array()  # should not raise here
-        assert tmp.shape == oldshape
-
     @pytest.mark.parametrize(
         "htable, tm_dtype",
         [
@@ -1709,37 +1656,6 @@ def test_hashtable_factorize(self, htable, tm_dtype, writable):
         expected_reconstruct = s_duplicated.dropna().values
         tm.assert_numpy_array_equal(result_reconstruct, expected_reconstruct)
 
-    @pytest.mark.parametrize(
-        "hashtable",
-        [
-            ht.PyObjectHashTable,
-            ht.StringHashTable,
-            ht.Float64HashTable,
-            ht.Int64HashTable,
-            ht.Int32HashTable,
-            ht.UInt64HashTable,
-        ],
-    )
-    def test_hashtable_large_sizehint(self, hashtable):
-        # GH#22729 smoketest for not raising when passing a large size_hint
-        size_hint = np.iinfo(np.uint32).max + 1
-        hashtable(size_hint=size_hint)
-
-
-def test_unique_label_indices():
-
-    a = np.random.randint(1, 1 << 10, 1 << 15).astype(np.intp)
-
-    left = ht.unique_label_indices(a)
-    right = np.unique(a, return_index=True)[1]
-
-    tm.assert_numpy_array_equal(left, right, check_dtype=False)
-
-    a[np.random.choice(len(a), 10)] = -1
-    left = ht.unique_label_indices(a)
-    right = np.unique(a, return_index=True)[1][1:]
-    tm.assert_numpy_array_equal(left, right, check_dtype=False)
-
 
 class TestRank:
     @td.skip_if_no_scipy
@@ -1777,7 +1693,7 @@ def test_basic(self, writable, dtype):
     def test_uint64_overflow(self, dtype):
         exp = np.array([1, 2], dtype=np.float64)
 
-        s = Series([1, 2 ** 63], dtype=dtype)
+        s = Series([1, 2**63], dtype=dtype)
         tm.assert_numpy_array_equal(algos.rank(s), exp)
 
     def test_too_many_ndims(self):
@@ -1787,15 +1703,14 @@ def test_too_many_ndims(self):
         with pytest.raises(TypeError, match=msg):
             algos.rank(arr)
 
-    @pytest.mark.single
-    @pytest.mark.high_memory
+    @pytest.mark.single_cpu
     def test_pct_max_many_rows(self):
         # GH 18271
-        values = np.arange(2 ** 24 + 1)
+        values = np.arange(2**24 + 1)
         result = algos.rank(values, pct=True).max()
         assert result == 1
 
-        values = np.arange(2 ** 25 + 2).reshape(2 ** 24 + 1, 2)
+        values = np.arange(2**25 + 2).reshape(2**24 + 1, 2)
         result = algos.rank(values, pct=True).max()
         assert result == 1
 
@@ -2361,13 +2276,13 @@ def test_mixed_dtype(self):
         tm.assert_series_equal(ser.mode(), exp)
 
     def test_uint64_overflow(self):
-        exp = Series([2 ** 63], dtype=np.uint64)
-        ser = Series([1, 2 ** 63, 2 ** 63], dtype=np.uint64)
+        exp = Series([2**63], dtype=np.uint64)
+        ser = Series([1, 2**63, 2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
         tm.assert_series_equal(ser.mode(), exp)
 
-        exp = Series([1, 2 ** 63], dtype=np.uint64)
-        ser = Series([1, 2 ** 63], dtype=np.uint64)
+        exp = Series([1, 2**63], dtype=np.uint64)
+        ser = Series([1, 2**63], dtype=np.uint64)
         tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
         tm.assert_series_equal(ser.mode(), exp)
 
@@ -2412,6 +2327,13 @@ def test_index(self):
             # algos.mode expects Arraylike, does *not* unwrap TimedeltaIndex
             algos.mode(idx)
 
+    def test_ser_mode_with_name(self):
+        # GH 46737
+        ser = Series([1, 1, 3], name="foo")
+        result = ser.mode()
+        expected = Series([1], name="foo")
+        tm.assert_series_equal(result, expected)
+
 
 class TestDiff:
     @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 0850ba66bbdbd..d31f617b9be15 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -64,7 +64,7 @@ def test_random_state():
 
     # check array-like
     # GH32503
-    state_arr_like = npr.randint(0, 2 ** 31, size=624, dtype="uint32")
+    state_arr_like = npr.randint(0, 2**31, size=624, dtype="uint32")
     assert (
         com.random_state(state_arr_like).uniform()
         == npr.RandomState(state_arr_like).uniform()
@@ -213,3 +213,19 @@ def test_frozenlist(self):
         result = df[frozen]
         expected = df[[]]
         tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("with_exception", [True, False])
+def test_temp_setattr(with_exception):
+    # GH#45954
+    ser = Series(dtype=object)
+    ser.name = "first"
+    # Raise a ValueError in either case to satisfy pytest.raises
+    match = "Inside exception raised" if with_exception else "Outside exception raised"
+    with pytest.raises(ValueError, match=match):
+        with com.temp_setattr(ser, "name", "second"):
+            assert ser.name == "second"
+            if with_exception:
+                raise ValueError("Inside exception raised")
+        raise ValueError("Outside exception raised")
+    assert ser.name == "first"
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 3880b9ecd9da7..119ffd8cfd5a1 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -11,9 +11,17 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-from pandas import DataFrame
+from pandas import (
+    DataFrame,
+    Series,
+)
 import pandas._testing as tm
 
+# geopandas, xarray, fsspec, fastparquet all produce these
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:distutils Version classes are deprecated.*:DeprecationWarning"
+)
+
 
 def import_module(name):
     # we *only* want to skip if the module is truly not available
@@ -50,6 +58,57 @@ def test_dask(df):
         pd.set_option("compute.use_numexpr", olduse)
 
 
+@pytest.mark.filterwarnings("ignore:.*64Index is deprecated:FutureWarning")
+@pytest.mark.filterwarnings("ignore:The __array_wrap__:DeprecationWarning")
+def test_dask_ufunc():
+    # At the time of dask 2022.01.0, dask is still directly using __array_wrap__
+    # for some ufuncs (https://github.com/dask/dask/issues/8580).
+
+    # dask sets "compute.use_numexpr" to False, so catch the current value
+    # and ensure to reset it afterwards to avoid impacting other tests
+    olduse = pd.get_option("compute.use_numexpr")
+
+    try:
+        dask = import_module("dask")  # noqa:F841
+        import dask.array as da
+        import dask.dataframe as dd
+
+        s = Series([1.5, 2.3, 3.7, 4.0])
+        ds = dd.from_pandas(s, npartitions=2)
+
+        result = da.fix(ds).compute()
+        expected = np.fix(s)
+        tm.assert_series_equal(result, expected)
+    finally:
+        pd.set_option("compute.use_numexpr", olduse)
+
+
+@td.skip_if_no("dask")
+def test_construct_dask_float_array_int_dtype_match_ndarray():
+    # GH#40110 make sure we treat a float-dtype dask array with the same
+    #  rules we would for an ndarray
+    import dask.dataframe as dd
+
+    arr = np.array([1, 2.5, 3])
+    darr = dd.from_array(arr)
+
+    res = Series(darr)
+    expected = Series(arr)
+    tm.assert_series_equal(res, expected)
+
+    res = Series(darr, dtype="i8")
+    expected = Series(arr, dtype="i8")
+    tm.assert_series_equal(res, expected)
+
+    msg = "In a future version, passing float-dtype values containing NaN"
+    arr[2] = np.nan
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        res = Series(darr, dtype="i8")
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = Series(arr, dtype="i8")
+    tm.assert_series_equal(res, expected)
+
+
 def test_xarray(df):
 
     xarray = import_module("xarray")  # noqa:F841
@@ -94,6 +153,7 @@ def test_oo_optimized_datetime_index_unpickle():
     )
 
 
+@pytest.mark.network
 @tm.network
 # Cython import warning
 @pytest.mark.filterwarnings("ignore:pandas.util.testing is deprecated")
@@ -103,6 +163,10 @@ def test_oo_optimized_datetime_index_unpickle():
     # patsy needs to update their imports
     "ignore:Using or importing the ABCs from 'collections:DeprecationWarning"
 )
+@pytest.mark.filterwarnings(
+    # numpy 1.22
+    "ignore:`np.MachAr` is deprecated.*:DeprecationWarning"
+)
 def test_statsmodels():
 
     statsmodels = import_module("statsmodels")  # noqa:F841
@@ -115,7 +179,7 @@ def test_statsmodels():
 
 # Cython import warning
 @pytest.mark.filterwarnings("ignore:can't:ImportWarning")
-def test_scikit_learn(df):
+def test_scikit_learn():
 
     sklearn = import_module("sklearn")  # noqa:F841
     from sklearn import (
@@ -130,6 +194,7 @@ def test_scikit_learn(df):
 
 
 # Cython import warning and traitlets
+@pytest.mark.network
 @tm.network
 @pytest.mark.filterwarnings("ignore")
 def test_seaborn():
@@ -139,30 +204,32 @@ def test_seaborn():
     seaborn.stripplot(x="day", y="total_bill", data=tips)
 
 
-def test_pandas_gbq(df):
-
+def test_pandas_gbq():
+    # Older versions import from non-public, non-existent pandas funcs
+    pytest.importorskip("pandas_gbq", minversion="0.10.0")
     pandas_gbq = import_module("pandas_gbq")  # noqa:F841
 
 
+@pytest.mark.network
+@tm.network
 @pytest.mark.xfail(
     raises=ValueError,
     reason="The Quandl API key must be provided either through the api_key "
     "variable or through the environmental variable QUANDL_API_KEY",
 )
-@tm.network
 def test_pandas_datareader():
 
     pandas_datareader = import_module("pandas_datareader")
     pandas_datareader.DataReader("F", "quandl", "2017-01-01", "2017-02-01")
 
 
-# importing from pandas, Cython import warning
-@pytest.mark.filterwarnings("ignore:can't resolve:ImportWarning")
 def test_geopandas():
 
     geopandas = import_module("geopandas")
-    fp = geopandas.datasets.get_path("naturalearth_lowres")
-    assert geopandas.read_file(fp) is not None
+    gdf = geopandas.GeoDataFrame(
+        {"col": [1, 2, 3], "geometry": geopandas.points_from_xy([1, 2, 3], [1, 2, 3])}
+    )
+    assert gdf[["col", "geometry"]].geometry.x.equals(Series([1.0, 2.0, 3.0]))
 
 
 # Cython import warning
@@ -186,7 +253,7 @@ def test_torch_frame_construction(using_array_manager):
     if not using_array_manager:
         assert np.shares_memory(df, val_tensor)
 
-    ser = pd.Series(val_tensor[0])
+    ser = Series(val_tensor[0])
     assert np.shares_memory(ser, val_tensor)
 
 
@@ -237,3 +304,27 @@ def test_missing_required_dependency():
     output = exc.value.stdout.decode()
     for name in ["numpy", "pytz", "dateutil"]:
         assert name in output
+
+
+def test_frame_setitem_dask_array_into_new_col():
+    # GH#47128
+
+    # dask sets "compute.use_numexpr" to False, so catch the current value
+    # and ensure to reset it afterwards to avoid impacting other tests
+    olduse = pd.get_option("compute.use_numexpr")
+
+    try:
+        dask = import_module("dask")  # noqa:F841
+
+        import dask.array as da
+
+        dda = da.array([1, 2])
+        df = DataFrame({"a": ["a", "b"]})
+        df["b"] = dda
+        df["c"] = dda
+        df.loc[[False, True], "b"] = 100
+        result = df.loc[[1], :]
+        expected = DataFrame({"a": ["b"], "b": [100], "c": [2]}, index=[1])
+        tm.assert_frame_equal(result, expected)
+    finally:
+        pd.set_option("compute.use_numexpr", olduse)
diff --git a/pandas/tests/test_errors.py b/pandas/tests/test_errors.py
index 6207b886b95c7..c6ca51b7763d9 100644
--- a/pandas/tests/test_errors.py
+++ b/pandas/tests/test_errors.py
@@ -1,6 +1,9 @@
 import pytest
 
-from pandas.errors import AbstractMethodError
+from pandas.errors import (
+    AbstractMethodError,
+    UndefinedVariableError,
+)
 
 import pandas as pd
 
@@ -19,6 +22,23 @@
         "MergeError",
         "OptionError",
         "NumbaUtilError",
+        "DataError",
+        "SpecificationError",
+        "SettingWithCopyError",
+        "SettingWithCopyWarning",
+        "NumExprClobberingError",
+        "IndexingError",
+        "PyperclipException",
+        "CSSWarning",
+        "ClosedFileError",
+        "PossibleDataLossError",
+        "IncompatibilityWarning",
+        "AttributeConflictWarning",
+        "DatabaseError",
+        "PossiblePrecisionLoss",
+        "CategoricalConversionWarning",
+        "InvalidColumnName",
+        "ValueLabelTypeMismatch",
     ],
 )
 def test_exception_importable(exc):
@@ -43,6 +63,24 @@ def test_catch_oob():
         pd.Timestamp("15000101")
 
 
+@pytest.mark.parametrize(
+    "is_local",
+    [
+        True,
+        False,
+    ],
+)
+def test_catch_undefined_variable_error(is_local):
+    variable_name = "x"
+    if is_local:
+        msg = f"local variable '{variable_name}' is not defined"
+    else:
+        msg = f"name '{variable_name}' is not defined"
+
+    with pytest.raises(UndefinedVariableError, match=msg):
+        raise UndefinedVariableError(variable_name, is_local)
+
+
 class Foo:
     @classmethod
     def classmethod(cls):
diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py
index d8afb4ab83dfd..a0066ace17bc4 100644
--- a/pandas/tests/test_expressions.py
+++ b/pandas/tests/test_expressions.py
@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from pandas import set_option
+from pandas import option_context
 import pandas._testing as tm
 from pandas.core.api import (
     DataFrame,
@@ -47,10 +47,10 @@
 
 @pytest.mark.skipif(not expr.USE_NUMEXPR, reason="not using numexpr")
 class TestExpressions:
-    def setup_method(self, method):
+    def setup_method(self):
         self._MIN_ELEMENTS = expr._MIN_ELEMENTS
 
-    def teardown_method(self, method):
+    def teardown_method(self):
         expr._MIN_ELEMENTS = self._MIN_ELEMENTS
 
     @staticmethod
@@ -61,9 +61,8 @@ def call_op(df, other, flex: bool, opname: str):
         else:
             op = getattr(operator, opname)
 
-        set_option("compute.use_numexpr", False)
-        expected = op(df, other)
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            expected = op(df, other)
 
         expr.get_test_result()
 
@@ -122,9 +121,8 @@ def test_run_binary(self, df, flex, comparison_op):
         elsewhere.
         """
         arith = comparison_op.__name__
-        set_option("compute.use_numexpr", False)
-        other = df.copy() + 1
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            other = df.copy() + 1
 
         expr._MIN_ELEMENTS = 0
         expr.set_test_mode(True)
@@ -184,9 +182,9 @@ def testit():
             result = expr._can_use_numexpr(op, op_str, right, right, "evaluate")
             assert not result
 
-        set_option("compute.use_numexpr", False)
-        testit()
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            testit()
+
         expr.set_numexpr_threads(1)
         testit()
         expr.set_numexpr_threads()
@@ -220,9 +218,9 @@ def testit():
             result = expr._can_use_numexpr(op, op_str, right, f22, "evaluate")
             assert not result
 
-        set_option("compute.use_numexpr", False)
-        testit()
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            testit()
+
         expr.set_numexpr_threads(1)
         testit()
         expr.set_numexpr_threads()
@@ -238,9 +236,9 @@ def testit():
             expected = np.where(c, df.values, df.values + 1)
             tm.assert_numpy_array_equal(result, expected)
 
-        set_option("compute.use_numexpr", False)
-        testit()
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            testit()
+
         expr.set_numexpr_threads(1)
         testit()
         expr.set_numexpr_threads()
@@ -365,9 +363,8 @@ def test_frame_series_axis(self, axis, arith):
 
         op_func = getattr(df, arith)
 
-        set_option("compute.use_numexpr", False)
-        expected = op_func(other, axis=axis)
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            expected = op_func(other, axis=axis)
 
         result = op_func(other, axis=axis)
         tm.assert_frame_equal(expected, result)
@@ -392,9 +389,9 @@ def test_python_semantics_with_numexpr_installed(self, op, box, scalar):
         result = method(scalar)
 
         # compare result with numpy
-        set_option("compute.use_numexpr", False)
-        expected = method(scalar)
-        set_option("compute.use_numexpr", True)
+        with option_context("compute.use_numexpr", False):
+            expected = method(scalar)
+
         tm.assert_equal(result, expected)
 
         # compare result element-wise with Python
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 1bff5b4cc82a6..7e428821a2d50 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -9,20 +9,6 @@
 )
 import pandas._testing as tm
 
-AGG_FUNCTIONS = [
-    "sum",
-    "prod",
-    "min",
-    "max",
-    "median",
-    "mean",
-    "skew",
-    "mad",
-    "std",
-    "var",
-    "sem",
-]
-
 
 class TestMultiLevel:
     def test_reindex_level(self, multiindex_year_month_day_dataframe_random_data):
@@ -103,7 +89,7 @@ def test_groupby_transform(self, multiindex_dataframe_random_data):
         s = frame["A"]
         grouper = s.index.get_level_values(0)
 
-        grouped = s.groupby(grouper)
+        grouped = s.groupby(grouper, group_keys=False)
 
         applied = grouped.apply(lambda x: x * 2)
         expected = grouped.transform(lambda x: x * 2)
@@ -169,15 +155,15 @@ def test_alignment(self):
         exp = x.reindex(exp_index) - y.reindex(exp_index)
         tm.assert_series_equal(res, exp)
 
-    @pytest.mark.parametrize("op", AGG_FUNCTIONS)
     @pytest.mark.parametrize("level", [0, 1])
     @pytest.mark.parametrize("skipna", [True, False])
     @pytest.mark.parametrize("sort", [True, False])
     def test_series_group_min_max(
-        self, op, level, skipna, sort, series_with_multilevel_index
+        self, all_numeric_reductions, level, skipna, sort, series_with_multilevel_index
     ):
         # GH 17537
         ser = series_with_multilevel_index
+        op = all_numeric_reductions
 
         grouped = ser.groupby(level=level, sort=sort)
         # skipna=True
@@ -188,13 +174,18 @@ def test_series_group_min_max(
             rightside = rightside.sort_index(level=level)
         tm.assert_series_equal(leftside, rightside)
 
-    @pytest.mark.parametrize("op", AGG_FUNCTIONS)
     @pytest.mark.parametrize("level", [0, 1])
     @pytest.mark.parametrize("axis", [0, 1])
     @pytest.mark.parametrize("skipna", [True, False])
     @pytest.mark.parametrize("sort", [True, False])
     def test_frame_group_ops(
-        self, op, level, axis, skipna, sort, multiindex_dataframe_random_data
+        self,
+        all_numeric_reductions,
+        level,
+        axis,
+        skipna,
+        sort,
+        multiindex_dataframe_random_data,
     ):
         # GH 17537
         frame = multiindex_dataframe_random_data
@@ -212,6 +203,7 @@ def test_frame_group_ops(
         grouped = frame.groupby(level=level, axis=axis, sort=sort)
 
         pieces = []
+        op = all_numeric_reductions
 
         def aggf(x):
             pieces.append(x)
@@ -406,10 +398,10 @@ def test_sort_non_lexsorted(self):
         )
 
         df = DataFrame({"col": range(len(idx))}, index=idx, dtype="int64")
-        assert df.index.is_monotonic is False
+        assert df.index.is_monotonic_increasing is False
 
         sorted = df.sort_index()
-        assert sorted.index.is_monotonic is True
+        assert sorted.index.is_monotonic_increasing is True
 
         expected = DataFrame(
             {"col": [1, 4, 5, 2]},
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index ee451d0288581..f46d5c8e2590e 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -19,7 +19,6 @@
 import pandas.core.nanops as nanops
 
 use_bn = nanops._USE_BOTTLENECK
-has_c16 = hasattr(np, "complex128")
 
 
 @pytest.fixture(params=[True, False])
@@ -31,7 +30,7 @@ def skipna(request):
 
 
 class TestnanopsDataFrame:
-    def setup_method(self, method):
+    def setup_method(self):
         np.random.seed(11235)
         nanops._USE_BOTTLENECK = False
 
@@ -95,7 +94,7 @@ def setup_method(self, method):
         self.arr_float1_nan_1d = self.arr_float1_nan[:, 0]
         self.arr_nan_float1_1d = self.arr_nan_float1[:, 0]
 
-    def teardown_method(self, method):
+    def teardown_method(self):
         nanops._USE_BOTTLENECK = use_bn
 
     def check_results(self, targ, res, axis, check_dtype=True):
@@ -128,7 +127,7 @@ def check_results(self, targ, res, axis, check_dtype=True):
                 if targ.dtype.kind != "O":
                     res = res.astype(targ.dtype)
                 else:
-                    cast_dtype = "c16" if has_c16 else "f8"
+                    cast_dtype = "c16" if hasattr(np, "complex128") else "f8"
                     res = res.astype(cast_dtype)
                     targ = targ.astype(cast_dtype)
             # there should never be a case where numpy returns an object
@@ -305,7 +304,7 @@ def test_nanmean_overflow(self):
         # In the previous implementation mean can overflow for int dtypes, it
         # is now consistent with numpy
 
-        for a in [2 ** 55, -(2 ** 55), 20150515061816532]:
+        for a in [2**55, -(2**55), 20150515061816532]:
             s = Series(a, index=range(500), dtype=np.int64)
             result = s.mean()
             np_result = s.values.mean()
@@ -786,10 +785,10 @@ class TestNanvarFixedValues:
 
     # xref GH10242
 
-    def setup_method(self, method):
+    def setup_method(self):
         # Samples from a normal distribution.
         self.variance = variance = 3.0
-        self.samples = self.prng.normal(scale=variance ** 0.5, size=100000)
+        self.samples = self.prng.normal(scale=variance**0.5, size=100000)
 
     def test_nanvar_all_finite(self):
         samples = self.samples
@@ -811,7 +810,7 @@ def test_nanstd_nans(self):
         samples[::2] = self.samples
 
         actual_std = nanops.nanstd(samples, skipna=True)
-        tm.assert_almost_equal(actual_std, self.variance ** 0.5, rtol=1e-2)
+        tm.assert_almost_equal(actual_std, self.variance**0.5, rtol=1e-2)
 
         actual_std = nanops.nanvar(samples, skipna=False)
         tm.assert_almost_equal(actual_std, np.nan, rtol=1e-2)
@@ -903,7 +902,7 @@ class TestNanskewFixedValues:
 
     # xref GH 11974
 
-    def setup_method(self, method):
+    def setup_method(self):
         # Test data + skewness value (computed with scipy.stats.skew)
         self.samples = np.sin(np.linspace(0, 1, 200))
         self.actual_skew = -0.1875895205961754
@@ -952,7 +951,7 @@ class TestNankurtFixedValues:
 
     # xref GH 11974
 
-    def setup_method(self, method):
+    def setup_method(self):
         # Test data + kurtosis value (computed with scipy.stats.kurtosis)
         self.samples = np.sin(np.linspace(0, 1, 200))
         self.actual_kurt = -1.2058303433799713
@@ -1021,7 +1020,8 @@ def test_nanmean_skipna_false(self, dtype):
         arr[-1, -1] = "NaT"
 
         result = nanops.nanmean(arr, skipna=False)
-        assert result is pd.NaT
+        assert np.isnat(result)
+        assert result.dtype == dtype
 
         result = nanops.nanmean(arr, axis=0, skipna=False)
         expected = np.array([4, 5, "NaT"], dtype=arr.dtype)
@@ -1036,13 +1036,11 @@ def test_use_bottleneck():
 
     if nanops._BOTTLENECK_INSTALLED:
 
-        pd.set_option("use_bottleneck", True)
-        assert pd.get_option("use_bottleneck")
+        with pd.option_context("use_bottleneck", True):
+            assert pd.get_option("use_bottleneck")
 
-        pd.set_option("use_bottleneck", False)
-        assert not pd.get_option("use_bottleneck")
-
-        pd.set_option("use_bottleneck", use_bn)
+        with pd.option_context("use_bottleneck", False):
+            assert not pd.get_option("use_bottleneck")
 
 
 @pytest.mark.parametrize(
@@ -1093,3 +1091,54 @@ def test_nanops_independent_of_mask_param(operation):
     median_expected = operation(s)
     median_result = operation(s, mask=mask)
     assert median_expected == median_result
+
+
+@pytest.mark.parametrize("min_count", [-1, 0])
+def test_check_below_min_count__negative_or_zero_min_count(min_count):
+    # GH35227
+    result = nanops.check_below_min_count((21, 37), None, min_count)
+    expected_result = False
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "mask", [None, np.array([False, False, True]), np.array([True] + 9 * [False])]
+)
+@pytest.mark.parametrize("min_count, expected_result", [(1, False), (101, True)])
+def test_check_below_min_count__positive_min_count(mask, min_count, expected_result):
+    # GH35227
+    shape = (10, 10)
+    result = nanops.check_below_min_count(shape, mask, min_count)
+    assert result == expected_result
+
+
+@td.skip_if_windows
+@td.skip_if_32bit
+@pytest.mark.parametrize("min_count, expected_result", [(1, False), (2812191852, True)])
+def test_check_below_min_count__large_shape(min_count, expected_result):
+    # GH35227 large shape used to show that the issue is fixed
+    shape = (2244367, 1253)
+    result = nanops.check_below_min_count(shape, mask=None, min_count=min_count)
+    assert result == expected_result
+
+
+@pytest.mark.parametrize("func", ["nanmean", "nansum"])
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.uint8,
+        np.uint16,
+        np.uint32,
+        np.uint64,
+        np.int8,
+        np.int16,
+        np.int32,
+        np.int64,
+        np.float16,
+        np.float32,
+        np.float64,
+    ],
+)
+def test_check_bottleneck_disallow(dtype, func):
+    # GH 42878 bottleneck sometimes produces unreliable results for mean and sum
+    assert not nanops._bn_ok_dtype(dtype, func)
diff --git a/pandas/tests/test_register_accessor.py b/pandas/tests/test_register_accessor.py
index 6e224245076ee..3e4e57414269a 100644
--- a/pandas/tests/test_register_accessor.py
+++ b/pandas/tests/test_register_accessor.py
@@ -14,7 +14,7 @@ class X(accessor.DirNamesMixin):
         x = 1
         y: int
 
-        def __init__(self):
+        def __init__(self) -> None:
             self.z = 3
 
     result = [attr_name for attr_name in dir(X()) if not attr_name.startswith("_")]
@@ -38,7 +38,7 @@ def ensure_removed(obj, attr):
 
 
 class MyAccessor:
-    def __init__(self, obj):
+    def __init__(self, obj) -> None:
         self.obj = obj
         self.item = "item"
 
@@ -102,7 +102,7 @@ def test_raises_attribute_error():
 
         @pd.api.extensions.register_series_accessor("bad")
         class Bad:
-            def __init__(self, data):
+            def __init__(self, data) -> None:
                 raise AttributeError("whoops")
 
         with pytest.raises(AttributeError, match="whoops"):
diff --git a/pandas/tests/test_sorting.py b/pandas/tests/test_sorting.py
index d32c72b3df974..537792ea8263c 100644
--- a/pandas/tests/test_sorting.py
+++ b/pandas/tests/test_sorting.py
@@ -5,7 +5,13 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_windows,
+)
+
 from pandas import (
+    NA,
     DataFrame,
     MultiIndex,
     Series,
@@ -17,7 +23,7 @@
 from pandas.core.algorithms import safe_sort
 import pandas.core.common as com
 from pandas.core.sorting import (
-    decons_group_index,
+    _decons_group_index,
     get_group_index,
     is_int64_overflow_possible,
     lexsort_indexer,
@@ -384,7 +390,7 @@ def align(df):
 )
 def test_decons(codes_list, shape):
     group_index = get_group_index(codes_list, shape, sort=True, xnull=True)
-    codes_list2 = decons_group_index(group_index, shape)
+    codes_list2 = _decons_group_index(group_index, shape)
 
     for a, b in zip(codes_list, codes_list2):
         tm.assert_numpy_array_equal(a, b)
@@ -424,6 +430,11 @@ def test_codes(self, verify, codes, exp_codes, na_sentinel):
         tm.assert_numpy_array_equal(result, expected)
         tm.assert_numpy_array_equal(result_codes, expected_codes)
 
+    @pytest.mark.skipif(
+        is_platform_windows() and is_ci_environment(),
+        reason="In CI environment can crash thread with: "
+        "Windows fatal exception: access violation",
+    )
     @pytest.mark.parametrize("na_sentinel", [-1, 99])
     def test_codes_out_of_bound(self, na_sentinel):
         values = [3, 1, 2, 0, 4]
@@ -500,3 +511,15 @@ def test_mixed_str_nan():
     result = safe_sort(values)
     expected = np.array([np.nan, "a", "b", "b"], dtype=object)
     tm.assert_numpy_array_equal(result, expected)
+
+
+def test_safe_sort_multiindex():
+    # GH#48412
+    arr1 = Series([2, 1, NA, NA], dtype="Int64")
+    arr2 = [2, 1, 3, 3]
+    midx = MultiIndex.from_arrays([arr1, arr2])
+    result = safe_sort(midx)
+    expected = MultiIndex.from_arrays(
+        [Series([1, 2, NA, NA], dtype="Int64"), [1, 2, 3, 3]]
+    )
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 5d5e01084345d..0173d422ebf2b 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -5,6 +5,7 @@
 from datetime import (
     datetime,
     timedelta,
+    timezone,
 )
 from decimal import Decimal
 import locale
@@ -283,13 +284,16 @@ def test_to_datetime_format_microsecond(self, cache):
                 "%m/%d/%Y %H:%M:%S",
                 Timestamp("2010-01-10 13:56:01"),
             ],
+            # The 3 tests below are locale-dependent.
+            # They pass, except when the machine locale is zh_CN or it_IT .
             pytest.param(
                 "01/10/2010 08:14 PM",
                 "%m/%d/%Y %I:%M %p",
                 Timestamp("2010-01-10 20:14"),
                 marks=pytest.mark.xfail(
-                    locale.getlocale()[0] == "zh_CN",
-                    reason="fail on a CI build with LC_ALL=zh_CN.utf8",
+                    locale.getlocale()[0] in ("zh_CN", "it_IT"),
+                    reason="fail on a CI build with LC_ALL=zh_CN.utf8/it_IT.utf8",
+                    strict=False,
                 ),
             ),
             pytest.param(
@@ -297,8 +301,9 @@ def test_to_datetime_format_microsecond(self, cache):
                 "%m/%d/%Y %I:%M %p",
                 Timestamp("2010-01-10 07:40"),
                 marks=pytest.mark.xfail(
-                    locale.getlocale()[0] == "zh_CN",
-                    reason="fail on a CI build with LC_ALL=zh_CN.utf8",
+                    locale.getlocale()[0] in ("zh_CN", "it_IT"),
+                    reason="fail on a CI build with LC_ALL=zh_CN.utf8/it_IT.utf8",
+                    strict=False,
                 ),
             ),
             pytest.param(
@@ -306,8 +311,9 @@ def test_to_datetime_format_microsecond(self, cache):
                 "%m/%d/%Y %I:%M:%S %p",
                 Timestamp("2010-01-10 09:12:56"),
                 marks=pytest.mark.xfail(
-                    locale.getlocale()[0] == "zh_CN",
-                    reason="fail on a CI build with LC_ALL=zh_CN.utf8",
+                    locale.getlocale()[0] in ("zh_CN", "it_IT"),
+                    reason="fail on a CI build with LC_ALL=zh_CN.utf8/it_IT.utf8",
+                    strict=False,
                 ),
             ),
         ],
@@ -315,7 +321,7 @@ def test_to_datetime_format_microsecond(self, cache):
     def test_to_datetime_format_time(self, cache, value, format, dt):
         assert to_datetime(value, format=format, cache=cache) == dt
 
-    @td.skip_if_has_locale
+    @td.skip_if_not_us_locale
     def test_to_datetime_with_non_exact(self, cache):
         # GH 10834
         # 8904
@@ -455,6 +461,33 @@ def test_to_datetime_parse_timezone_keeps_name(self):
 
 
 class TestToDatetime:
+    def test_to_datetime_mixed_datetime_and_string(self):
+        # GH#47018 adapted old doctest with new behavior
+        d1 = datetime(2020, 1, 1, 17, tzinfo=timezone(-timedelta(hours=1)))
+        d2 = datetime(2020, 1, 1, 18, tzinfo=timezone(-timedelta(hours=1)))
+        res = to_datetime(["2020-01-01 17:00 -0100", d2])
+        expected = to_datetime([d1, d2]).tz_convert(pytz.FixedOffset(-60))
+        tm.assert_index_equal(res, expected)
+
+    def test_to_datetime_np_str(self):
+        # GH#32264
+        value = np.str_("2019-02-04 10:18:46.297000+0000")
+
+        ser = Series([value])
+
+        exp = Timestamp("2019-02-04 10:18:46.297000", tz="UTC")
+
+        assert to_datetime(value) == exp
+        assert to_datetime(ser.iloc[0]) == exp
+
+        res = to_datetime([value])
+        expected = Index([exp])
+        tm.assert_index_equal(res, expected)
+
+        res = to_datetime(ser)
+        expected = Series(expected)
+        tm.assert_series_equal(res, expected)
+
     @pytest.mark.parametrize(
         "s, _format, dt",
         [
@@ -582,7 +615,7 @@ def test_to_datetime_YYYYMMDD(self):
         actual = to_datetime("20080115")
         assert actual == datetime(2008, 1, 15)
 
-    def test_to_datetime_unparseable_ignore(self):
+    def test_to_datetime_unparsable_ignore(self):
         # unparsable
         ser = "Month 1, 1999"
         assert to_datetime(ser, errors="ignore") == ser
@@ -655,9 +688,10 @@ def test_to_datetime_dt64s(self, cache, dt):
         "dt", [np.datetime64("1000-01-01"), np.datetime64("5000-01-02")]
     )
     def test_to_datetime_dt64s_out_of_bounds(self, cache, dt):
-        msg = f"Out of bounds nanosecond timestamp: {dt}"
+        msg = "Out of bounds .* present at position 0"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             to_datetime(dt, errors="raise")
+        msg = f"Out of bounds nanosecond timestamp: {dt}"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             Timestamp(dt)
         assert to_datetime(dt, errors="coerce", cache=cache) is NaT
@@ -917,7 +951,7 @@ def test_datetime_invalid_scalar(self, value, format, infer):
         msg = (
             "is a bad directive in format|"
             "second must be in 0..59|"
-            "Given date string not likely a datetime"
+            f"Given date string {value} not likely a datetime"
         )
         with pytest.raises(ValueError, match=msg):
             to_datetime(
@@ -940,13 +974,13 @@ def test_datetime_outofbounds_scalar(self, value, format, infer):
         assert res is NaT
 
         if format is not None:
-            msg = "is a bad directive in format|Out of bounds nanosecond timestamp"
+            msg = "is a bad directive in format|Out of bounds .* present at position 0"
             with pytest.raises(ValueError, match=msg):
                 to_datetime(
                     value, errors="raise", format=format, infer_datetime_format=infer
                 )
         else:
-            msg = "Out of bounds nanosecond timestamp"
+            msg = "Out of bounds .* present at position 0"
             with pytest.raises(OutOfBoundsDatetime, match=msg):
                 to_datetime(
                     value, errors="raise", format=format, infer_datetime_format=infer
@@ -969,7 +1003,7 @@ def test_datetime_invalid_index(self, values, format, infer):
 
         msg = (
             "is a bad directive in format|"
-            "Given date string not likely a datetime|"
+            f"Given date string {values[0]} not likely a datetime|"
             "second must be in 0..59"
         )
         with pytest.raises(ValueError, match=msg):
@@ -982,7 +1016,7 @@ def test_datetime_invalid_index(self, values, format, infer):
     @pytest.mark.parametrize("constructor", [list, tuple, np.array, Index, deque])
     def test_to_datetime_cache(self, utc, format, constructor):
         date = "20130101 00:00:00"
-        test_dates = [date] * 10 ** 5
+        test_dates = [date] * 10**5
         data = constructor(test_dates)
 
         result = to_datetime(data, utc=utc, format=format, cache=True)
@@ -1000,7 +1034,7 @@ def test_to_datetime_from_deque(self):
     @pytest.mark.parametrize("format", ["%Y%m%d %H:%M:%S", None])
     def test_to_datetime_cache_series(self, utc, format):
         date = "20130101 00:00:00"
-        test_dates = [date] * 10 ** 5
+        test_dates = [date] * 10**5
         data = Series(test_dates)
         result = to_datetime(data, utc=utc, format=format, cache=True)
         expected = to_datetime(data, utc=utc, format=format, cache=False)
@@ -1047,6 +1081,33 @@ def test_convert_object_to_datetime_with_cache(
         )
         tm.assert_series_equal(result_series, expected_series)
 
+    @pytest.mark.parametrize("cache", [True, False])
+    @pytest.mark.parametrize(
+        ("input", "expected"),
+        (
+            (
+                Series([NaT] * 20 + [None] * 20, dtype="object"),  # type: ignore[list-item] # noqa: E501
+                Series([NaT] * 40, dtype="datetime64[ns]"),
+            ),
+            (
+                Series([NaT] * 60 + [None] * 60, dtype="object"),  # type: ignore[list-item] # noqa: E501
+                Series([NaT] * 120, dtype="datetime64[ns]"),
+            ),
+            (Series([None] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+            (Series([None] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+            (Series([""] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+            (Series([""] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+            (Series([pd.NA] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+            (Series([pd.NA] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+            (Series([np.NaN] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+            (Series([np.NaN] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+        ),
+    )
+    def test_to_datetime_converts_null_like_to_nat(self, cache, input, expected):
+        # GH35888
+        result = to_datetime(input, cache=cache)
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize(
         "date, format",
         [
@@ -1640,7 +1701,7 @@ def test_to_datetime_barely_out_of_bounds(self):
         # in an in-bounds datetime
         arr = np.array(["2262-04-11 23:47:16.854775808"], dtype=object)
 
-        msg = "Out of bounds nanosecond timestamp"
+        msg = "Out of bounds .* present at position 0"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             to_datetime(arr)
 
@@ -1692,7 +1753,7 @@ def test_to_datetime_with_space_in_series(self, cache):
         result_ignore = to_datetime(ser, errors="ignore", cache=cache)
         tm.assert_series_equal(result_ignore, ser)
 
-    @td.skip_if_has_locale
+    @td.skip_if_not_us_locale
     def test_to_datetime_with_apply(self, cache):
         # this is only locale tested with US/None locales
         # GH 5195
@@ -1702,7 +1763,7 @@ def test_to_datetime_with_apply(self, cache):
         result = td.apply(to_datetime, format="%b %y", cache=cache)
         tm.assert_series_equal(result, expected)
 
-    @td.skip_if_has_locale
+    @td.skip_if_not_us_locale
     def test_to_datetime_with_apply_with_empty_str(self, cache):
         # this is only locale tested with US/None locales
         # GH 5195
@@ -1792,14 +1853,7 @@ def test_to_datetime_list_of_integers(self):
     def test_to_datetime_overflow(self):
         # gh-17637
         # we are overflowing Timedelta range here
-
-        msg = "|".join(
-            [
-                "Python int too large to convert to C long",
-                "long too big to convert",
-                "int too big to convert",
-            ]
-        )
+        msg = "Cannot cast 139999 days, 0:00:00 to unit=ns without overflow"
         with pytest.raises(OutOfBoundsTimedelta, match=msg):
             date_range(start="1/1/1700", freq="B", periods=100000)
 
@@ -1916,8 +1970,9 @@ def test_dayfirst(self, cache):
     def test_dayfirst_warnings_valid_input(self):
         # GH 12585
         warning_msg_day_first = (
-            "Parsing '31/12/2014' in DD/MM/YYYY format. Provide "
-            "format or specify infer_datetime_format=True for consistent parsing."
+            r"Parsing dates in DD/MM/YYYY format when dayfirst=False \(the default\) "
+            "was specified. This may lead to inconsistently parsed dates! Specify a "
+            "format to ensure consistent parsing."
         )
 
         # CASE 1: valid input
@@ -1953,12 +2008,14 @@ def test_dayfirst_warnings_invalid_input(self):
         # cannot consistently process with single format
         # warnings *always* raised
         warning_msg_day_first = (
-            "Parsing '31/12/2014' in DD/MM/YYYY format. Provide "
-            "format or specify infer_datetime_format=True for consistent parsing."
+            r"Parsing dates in DD/MM/YYYY format when dayfirst=False \(the default\) "
+            "was specified. This may lead to inconsistently parsed dates! Specify a "
+            "format to ensure consistent parsing."
         )
         warning_msg_month_first = (
-            "Parsing '03/30/2011' in MM/DD/YYYY format. Provide "
-            "format or specify infer_datetime_format=True for consistent parsing."
+            r"Parsing dates in MM/DD/YYYY format when dayfirst=True "
+            "was specified. This may lead to inconsistently parsed dates! Specify a "
+            "format to ensure consistent parsing."
         )
 
         arr = ["31/12/2014", "03/30/2011"]
@@ -2163,7 +2220,7 @@ def test_day_not_in_month_raise(self, cache):
 
     @pytest.mark.parametrize("arg", ["2015-02-29", "2015-02-32", "2015-04-31"])
     def test_day_not_in_month_raise_value(self, cache, arg):
-        msg = f"time data {arg} doesn't match format specified"
+        msg = f'time data "{arg}" at position 0 doesn\'t match format specified'
         with pytest.raises(ValueError, match=msg):
             to_datetime(arg, errors="raise", format="%Y-%m-%d", cache=cache)
 
@@ -2534,10 +2591,20 @@ def test_invalid_origins_tzinfo(self):
         with pytest.raises(ValueError, match="must be tz-naive"):
             to_datetime(1, unit="D", origin=datetime(2000, 1, 1, tzinfo=pytz.utc))
 
+    def test_incorrect_value_exception(self):
+        # GH47495
+        with pytest.raises(
+            ValueError, match="Unknown string format: yesterday present at position 1"
+        ):
+            to_datetime(["today", "yesterday"])
+
     @pytest.mark.parametrize("format", [None, "%Y-%m-%d %H:%M:%S"])
     def test_to_datetime_out_of_bounds_with_format_arg(self, format):
         # see gh-23830
-        msg = "Out of bounds nanosecond timestamp"
+        msg = (
+            "Out of bounds nanosecond timestamp: 2417-10-27 00:00:00 "
+            "present at position 0"
+        )
         with pytest.raises(OutOfBoundsDatetime, match=msg):
             to_datetime("2417-10-27 00:00:00", format=format)
 
@@ -2624,7 +2691,7 @@ def test_no_slicing_errors_in_should_cache(self, listlike):
 
 def test_nullable_integer_to_datetime():
     # Test for #30050
-    ser = Series([1, 2, None, 2 ** 61, None])
+    ser = Series([1, 2, None, 2**61, None])
     ser = ser.astype("Int64")
     ser_copy = ser.copy()
 
@@ -2717,3 +2784,76 @@ def test_to_datetime_monotonic_increasing_index(cache):
     result = to_datetime(times.iloc[:, 0], cache=cache)
     expected = times.iloc[:, 0]
     tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "series_length",
+    [40, start_caching_at, (start_caching_at + 1), (start_caching_at + 5)],
+)
+def test_to_datetime_cache_coerce_50_lines_outofbounds(series_length):
+    # GH#45319
+    s = Series(
+        [datetime.fromisoformat("1446-04-12 00:00:00+00:00")]
+        + ([datetime.fromisoformat("1991-10-20 00:00:00+00:00")] * series_length)
+    )
+    result1 = to_datetime(s, errors="coerce", utc=True)
+
+    expected1 = Series(
+        [NaT] + ([Timestamp("1991-10-20 00:00:00+00:00")] * series_length)
+    )
+
+    tm.assert_series_equal(result1, expected1)
+
+    result2 = to_datetime(s, errors="ignore", utc=True)
+
+    expected2 = Series(
+        [datetime.fromisoformat("1446-04-12 00:00:00+00:00")]
+        + ([datetime.fromisoformat("1991-10-20 00:00:00+00:00")] * series_length)
+    )
+
+    tm.assert_series_equal(result2, expected2)
+
+    with pytest.raises(OutOfBoundsDatetime, match="Out of bounds nanosecond timestamp"):
+        to_datetime(s, errors="raise", utc=True)
+
+
+@pytest.mark.parametrize(
+    "arg",
+    [
+        ["1724-12-20 20:20:20+00:00", "2022-01-01 00:00:00"],
+        [
+            Timestamp("1724-12-20 20:20:20+00:00"),
+            Timestamp("2022-01-01 00:00:00"),
+        ],
+        [datetime(1724, 12, 20, 20, 20, 20, tzinfo=timezone.utc), datetime(2022, 1, 1)],
+    ],
+    ids=["string", "pd.Timestamp", "datetime.datetime"],
+)
+@pytest.mark.parametrize("tz_aware_first", [True, False])
+def test_to_datetime_mixed_tzaware_timestamp_utc_true(arg, tz_aware_first):
+    # GH 48678
+    exp_arg = ["1724-12-20 20:20:20", "2022-01-01 00:00:00"]
+    if not tz_aware_first:
+        arg.reverse()
+        exp_arg.reverse()
+    result = to_datetime(arg, utc=True)
+    expected = DatetimeIndex(exp_arg).tz_localize("UTC")
+    tm.assert_index_equal(result, expected)
+
+
+def test_to_datetime_format_f_parse_nanos():
+    # GH 48767
+    timestamp = "15/02/2020 02:03:04.123456789"
+    timestamp_format = "%d/%m/%Y %H:%M:%S.%f"
+    result = to_datetime(timestamp, format=timestamp_format)
+    expected = Timestamp(
+        year=2020,
+        month=2,
+        day=15,
+        hour=2,
+        minute=3,
+        second=4,
+        microsecond=123456,
+        nanosecond=789,
+    )
+    assert result == expected
diff --git a/pandas/tests/tools/test_to_numeric.py b/pandas/tests/tools/test_to_numeric.py
index 643a5617abbeb..38a50a10b3482 100644
--- a/pandas/tests/tools/test_to_numeric.py
+++ b/pandas/tests/tools/test_to_numeric.py
@@ -390,19 +390,19 @@ def test_timedelta(transform_assert_equal):
     assert_equal(result, expected)
 
 
-def test_period(transform_assert_equal):
+def test_period(request, transform_assert_equal):
     transform, assert_equal = transform_assert_equal
 
     idx = pd.period_range("2011-01", periods=3, freq="M", name="")
     inp = transform(idx)
 
-    if isinstance(inp, Index):
-        result = to_numeric(inp)
-        expected = transform(idx.asi8)
-        assert_equal(result, expected)
-    else:
-        # TODO: PeriodDtype, so support it in to_numeric.
-        pytest.skip("Missing PeriodDtype support in to_numeric")
+    if not isinstance(inp, Index):
+        request.node.add_marker(
+            pytest.mark.xfail(reason="Missing PeriodDtype support in to_numeric")
+        )
+    result = to_numeric(inp)
+    expected = transform(idx.asi8)
+    assert_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -572,6 +572,14 @@ def test_downcast_limits(dtype, downcast, min_max):
     assert series.dtype == dtype
 
 
+def test_downcast_float64_to_float32():
+    # GH-43693: Check float64 preservation when >= 16,777,217
+    series = Series([16777217.0, np.finfo(np.float64).max, np.nan], dtype=np.float64)
+    result = to_numeric(series, downcast="float")
+
+    assert series.dtype == result.dtype
+
+
 @pytest.mark.parametrize(
     "ser,expected",
     [
@@ -762,6 +770,8 @@ def test_to_numeric_from_nullable_string(values, nullable_string_dtype, expected
         ([-1, -1], "Int32", "unsigned", "Int32"),
         ([1, 1], "Float64", "float", "Float32"),
         ([1, 1.1], "Float64", "float", "Float32"),
+        ([1, 1], "Float32", "float", "Float32"),
+        ([1, 1.1], "Float32", "float", "Float32"),
     ),
 )
 def test_downcast_nullable_numeric(data, input_dtype, downcast, expected_dtype):
diff --git a/pandas/tests/tools/test_to_time.py b/pandas/tests/tools/test_to_time.py
index 968102ce9edde..c80b1e080a1d1 100644
--- a/pandas/tests/tools/test_to_time.py
+++ b/pandas/tests/tools/test_to_time.py
@@ -4,14 +4,19 @@
 import numpy as np
 import pytest
 
+from pandas.compat import PY311
+
 from pandas import Series
 import pandas._testing as tm
 from pandas.core.tools.datetimes import to_time as to_time_alias
 from pandas.core.tools.times import to_time
 
-fails_on_zh_cn = pytest.mark.xfail(
-    locale.getlocale()[0] == "zh_CN",
-    reason="fail on a CI build with LC_ALL=zh_CN.utf8",
+# The tests marked with this are locale-dependent.
+# They pass, except when the machine locale is zh_CN or it_IT.
+fails_on_non_english = pytest.mark.xfail(
+    locale.getlocale()[0] in ("zh_CN", "it_IT"),
+    reason="fail on a CI build with LC_ALL=zh_CN.utf8/it_IT.utf8",
+    strict=False,
 )
 
 
@@ -21,12 +26,12 @@ class TestToTime:
         [
             "14:15",
             "1415",
-            pytest.param("2:15pm", marks=fails_on_zh_cn),
-            pytest.param("0215pm", marks=fails_on_zh_cn),
+            pytest.param("2:15pm", marks=fails_on_non_english),
+            pytest.param("0215pm", marks=fails_on_non_english),
             "14:15:00",
             "141500",
-            pytest.param("2:15:00pm", marks=fails_on_zh_cn),
-            pytest.param("021500pm", marks=fails_on_zh_cn),
+            pytest.param("2:15:00pm", marks=fails_on_non_english),
+            pytest.param("021500pm", marks=fails_on_non_english),
             time(14, 15),
         ],
     )
@@ -37,8 +42,9 @@ def test_parsers_time(self, time_string):
     def test_odd_format(self):
         new_string = "14.15"
         msg = r"Cannot convert arg \['14\.15'\] to a time"
-        with pytest.raises(ValueError, match=msg):
-            to_time(new_string)
+        if not PY311:
+            with pytest.raises(ValueError, match=msg):
+                to_time(new_string)
         assert to_time(new_string, format="%H.%M") == time(14, 15)
 
     def test_arraylike(self):
diff --git a/pandas/tests/tools/test_to_timedelta.py b/pandas/tests/tools/test_to_timedelta.py
index ec6fccd42dbc9..488e266a1c5c1 100644
--- a/pandas/tests/tools/test_to_timedelta.py
+++ b/pandas/tests/tools/test_to_timedelta.py
@@ -74,7 +74,10 @@ def test_to_timedelta_units_dtypes(self, dtype, unit):
     def test_to_timedelta_oob_non_nano(self):
         arr = np.array([pd.NaT.value + 1], dtype="timedelta64[s]")
 
-        msg = r"Out of bounds for nanosecond timedelta64\[s\] -9223372036854775807"
+        msg = (
+            "Cannot convert -9223372036854775807 seconds to "
+            r"timedelta64\[ns\] without overflow"
+        )
         with pytest.raises(OutOfBoundsTimedelta, match=msg):
             to_timedelta(arr)
 
@@ -198,7 +201,8 @@ def test_to_timedelta_on_missing_values(self):
 
         actual = to_timedelta(Series(["00:00:01", np.nan]))
         expected = Series(
-            [np.timedelta64(1000000000, "ns"), timedelta_NaT], dtype="<m8[ns]"
+            [np.timedelta64(1000000000, "ns"), timedelta_NaT],
+            dtype=f"{tm.ENDIAN}m8[ns]",
         )
         tm.assert_series_equal(actual, expected)
 
@@ -217,7 +221,7 @@ def test_to_timedelta_float(self):
         # https://github.com/pandas-dev/pandas/issues/25077
         arr = np.arange(0, 1, 1e-6)[-10:]
         result = to_timedelta(arr, unit="s")
-        expected_asi8 = np.arange(999990000, 10 ** 9, 1000, dtype="int64")
+        expected_asi8 = np.arange(999990000, 10**9, 1000, dtype="int64")
         tm.assert_numpy_array_equal(result.asi8, expected_asi8)
 
     def test_to_timedelta_coerce_strings_unit(self):
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 92795245103d0..e961fdc295c96 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 
 from pandas._libs.tslibs import (
@@ -17,7 +18,7 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
     per = Period._from_ordinal(1, off)
     exp_code = to_offset(exp_freqstr)._period_dtype_code
 
-    result_code = per._get_to_timestamp_base()
+    result_code = per._dtype._get_to_timestamp_base()
     assert result_code == exp_code
 
 
@@ -37,12 +38,12 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
     ],
 )
 def test_get_attrname_from_abbrev(freqstr, expected):
-    assert Resolution.get_reso_from_freq(freqstr).attrname == expected
+    assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
 
 
 @pytest.mark.parametrize("freq", ["D", "H", "T", "S", "L", "U", "N"])
 def test_get_freq_roundtrip2(freq):
-    obj = Resolution.get_reso_from_freq(freq)
+    obj = Resolution.get_reso_from_freqstr(freq)
     result = _attrname_to_abbrevs[obj.attrname]
     assert freq == result
 
@@ -78,3 +79,19 @@ def test_cat(args):
 
     with pytest.raises(ValueError, match=msg):
         to_offset(str(args[0]) + args[1])
+
+
+@pytest.mark.parametrize(
+    "freqstr,expected",
+    [
+        ("1H", "2021-01-01T09:00:00"),
+        ("1D", "2021-01-02T08:00:00"),
+        ("1W", "2021-01-03T08:00:00"),
+        ("1M", "2021-01-31T08:00:00"),
+        ("1Y", "2021-12-31T08:00:00"),
+    ],
+)
+def test_compatibility(freqstr, expected):
+    ts_np = np.datetime64("2021-01-01T08:00:00.00")
+    do = to_offset(freqstr)
+    assert ts_np + do == np.datetime64(expected)
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index f8fde000354e0..396cb950bd8b2 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -22,6 +22,10 @@
     period_range,
 )
 import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
 from pandas.core.tools.datetimes import to_datetime
 
 import pandas.tseries.frequencies as frequencies
@@ -369,15 +373,14 @@ def test_invalid_index_types(idx):
 
 
 @pytest.mark.skipif(is_platform_windows(), reason="see gh-10822: Windows issue")
-@pytest.mark.parametrize("idx", [tm.makeStringIndex(10), tm.makeUnicodeIndex(10)])
-def test_invalid_index_types_unicode(idx):
+def test_invalid_index_types_unicode():
     # see gh-10822
     #
     # Odd error message on conversions to datetime for unicode.
     msg = "Unknown string format"
 
     with pytest.raises(ValueError, match=msg):
-        frequencies.infer_freq(idx)
+        frequencies.infer_freq(tm.makeStringIndex(10))
 
 
 def test_string_datetime_like_compat():
@@ -502,3 +505,20 @@ def test_ms_vs_capital_ms():
 
     assert left == offsets.Milli()
     assert right == offsets.MonthBegin()
+
+
+def test_infer_freq_warn_deprecated():
+    with tm.assert_produces_warning(FutureWarning):
+        frequencies.infer_freq(date_range(2022, periods=3), warn=False)
+
+
+def test_infer_freq_non_nano():
+    arr = np.arange(10).astype(np.int64).view("M8[s]")
+    dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+    res = frequencies.infer_freq(dta)
+    assert res == "S"
+
+    arr2 = arr.view("m8[ms]")
+    tda = TimedeltaArray._simple_new(arr2, dtype=arr2.dtype)
+    res2 = frequencies.infer_freq(tda)
+    assert res2 == "L"
diff --git a/pandas/tests/tseries/holiday/test_calendar.py b/pandas/tests/tseries/holiday/test_calendar.py
index a1e3c1985a4d4..57acf15443ca8 100644
--- a/pandas/tests/tseries/holiday/test_calendar.py
+++ b/pandas/tests/tseries/holiday/test_calendar.py
@@ -50,7 +50,7 @@ def test_calendar_caching():
     # see gh-9552.
 
     class TestCalendar(AbstractHolidayCalendar):
-        def __init__(self, name=None, rules=None):
+        def __init__(self, name=None, rules=None) -> None:
             super().__init__(name=name, rules=rules)
 
     jan1 = TestCalendar(rules=[Holiday("jan1", year=2015, month=1, day=1)])
diff --git a/pandas/tests/tseries/offsets/common.py b/pandas/tests/tseries/offsets/common.py
index d8e98bb0c6876..c12130544e6b2 100644
--- a/pandas/tests/tseries/offsets/common.py
+++ b/pandas/tests/tseries/offsets/common.py
@@ -14,6 +14,7 @@
 )
 from pandas._libs.tslibs.offsets import (
     FY5253,
+    BaseOffset,
     BusinessHour,
     CustomBusinessHour,
     DateOffset,
@@ -59,7 +60,7 @@ class WeekDay:
 
 
 class Base:
-    _offset: type[DateOffset] | None = None
+    _offset: type[BaseOffset] | None = None
     d = Timestamp(datetime(2008, 1, 2))
 
     timezones = [
diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py
index df68c98dca43f..72f5c4a519a3a 100644
--- a/pandas/tests/tseries/offsets/conftest.py
+++ b/pandas/tests/tseries/offsets/conftest.py
@@ -5,7 +5,11 @@
 import pandas.tseries.offsets as offsets
 
 
-@pytest.fixture(params=[getattr(offsets, o) for o in offsets.__all__])
+@pytest.fixture(
+    params=[
+        getattr(offsets, o) for o in offsets.__all__ if o not in ("Tick", "BaseOffset")
+    ]
+)
 def offset_types(request):
     """
     Fixture for all the datetime offsets available for a time series.
diff --git a/pandas/tests/tseries/offsets/test_business_day.py b/pandas/tests/tseries/offsets/test_business_day.py
index 482d697b15e98..f23772dd0bd7c 100644
--- a/pandas/tests/tseries/offsets/test_business_day.py
+++ b/pandas/tests/tseries/offsets/test_business_day.py
@@ -1,6 +1,8 @@
 """
 Tests for offsets.BDay
 """
+from __future__ import annotations
+
 from datetime import (
     date,
     datetime,
@@ -26,15 +28,14 @@
     assert_is_on_offset,
     assert_offset_equal,
 )
-from pandas.tests.tseries.offsets.test_offsets import _ApplyCases
 
 from pandas.tseries import offsets as offsets
 
 
 class TestBusinessDay(Base):
-    _offset = BDay
+    _offset: type[BDay] = BDay
 
-    def setup_method(self, method):
+    def setup_method(self):
         self.d = datetime(2008, 1, 1)
         self.nd = np.datetime64("2008-01-01 00:00:00")
 
@@ -136,7 +137,7 @@ def test_is_on_offset(self):
         for offset, d, expected in tests:
             assert_is_on_offset(offset, d, expected)
 
-    apply_cases: _ApplyCases = [
+    apply_cases: list[tuple[int, dict[datetime, datetime]]] = [
         (
             1,
             {
diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py
index 401bfe664a3a2..392991009a449 100644
--- a/pandas/tests/tseries/offsets/test_business_hour.py
+++ b/pandas/tests/tseries/offsets/test_business_hour.py
@@ -1,6 +1,8 @@
 """
 Tests for offsets.BusinessHour
 """
+from __future__ import annotations
+
 from datetime import (
     datetime,
     time as dt_time,
@@ -30,9 +32,9 @@
 
 
 class TestBusinessHour(Base):
-    _offset = BusinessHour
+    _offset: type[BusinessHour] = BusinessHour
 
-    def setup_method(self, method):
+    def setup_method(self):
         self.d = datetime(2014, 7, 1, 10, 00)
 
         self.offset1 = BusinessHour()
diff --git a/pandas/tests/tseries/offsets/test_business_month.py b/pandas/tests/tseries/offsets/test_business_month.py
index bb2049fd35489..db8aaab98a379 100644
--- a/pandas/tests/tseries/offsets/test_business_month.py
+++ b/pandas/tests/tseries/offsets/test_business_month.py
@@ -3,10 +3,14 @@
 - BMonthBegin
 - BMonthEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
 
+from pandas._libs.tslibs.offsets import MonthOffset
+
 import pandas as pd
 from pandas.tests.tseries.offsets.common import (
     Base,
@@ -44,7 +48,7 @@ def test_apply_index(cls, n):
 
 
 class TestBMonthBegin(Base):
-    _offset = BMonthBegin
+    _offset: type[MonthOffset] = BMonthBegin
 
     def test_offsets_compare_equal(self):
         # root cause of #456
@@ -132,7 +136,7 @@ def test_is_on_offset(self, case):
 
 
 class TestBMonthEnd(Base):
-    _offset = BMonthEnd
+    _offset: type[MonthOffset] = BMonthEnd
 
     def test_normalize(self):
         dt = datetime(2007, 1, 1, 3)
diff --git a/pandas/tests/tseries/offsets/test_business_quarter.py b/pandas/tests/tseries/offsets/test_business_quarter.py
index b928b47d30a0d..5c50e080f71a8 100644
--- a/pandas/tests/tseries/offsets/test_business_quarter.py
+++ b/pandas/tests/tseries/offsets/test_business_quarter.py
@@ -3,10 +3,14 @@
 - BQuarterBegin
 - BQuarterEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
 
+from pandas._libs.tslibs.offsets import QuarterOffset
+
 from pandas.tests.tseries.offsets.common import (
     Base,
     assert_is_on_offset,
@@ -44,7 +48,7 @@ def test_on_offset(offset):
 
 
 class TestBQuarterBegin(Base):
-    _offset = BQuarterBegin
+    _offset: type[QuarterOffset] = BQuarterBegin
 
     def test_repr(self):
         expected = "<BusinessQuarterBegin: startingMonth=3>"
@@ -169,7 +173,7 @@ def test_offset(self, case):
 
 
 class TestBQuarterEnd(Base):
-    _offset = BQuarterEnd
+    _offset: type[QuarterOffset] = BQuarterEnd
 
     def test_repr(self):
         expected = "<BusinessQuarterEnd: startingMonth=3>"
diff --git a/pandas/tests/tseries/offsets/test_business_year.py b/pandas/tests/tseries/offsets/test_business_year.py
index d531a586c5db2..21778acd78bfd 100644
--- a/pandas/tests/tseries/offsets/test_business_year.py
+++ b/pandas/tests/tseries/offsets/test_business_year.py
@@ -3,10 +3,14 @@
 - BYearBegin
 - BYearEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
 
+from pandas._libs.tslibs.offsets import YearOffset
+
 from pandas.tests.tseries.offsets.common import (
     Base,
     assert_is_on_offset,
@@ -20,7 +24,7 @@
 
 
 class TestBYearBegin(Base):
-    _offset = BYearBegin
+    _offset: type[YearOffset] = BYearBegin
 
     def test_misspecified(self):
         msg = "Month must go from 1 to 12"
@@ -93,7 +97,7 @@ def test_offset(self, case):
 
 
 class TestBYearEnd(Base):
-    _offset = BYearEnd
+    _offset: type[YearOffset] = BYearEnd
 
     offset_cases = []
     offset_cases.append(
@@ -166,7 +170,7 @@ def test_is_on_offset(self, case):
 
 
 class TestBYearEndLagged(Base):
-    _offset = BYearEnd
+    _offset: type[YearOffset] = BYearEnd
 
     def test_bad_month_fail(self):
         msg = "Month must go from 1 to 12"
diff --git a/pandas/tests/tseries/offsets/test_custom_business_hour.py b/pandas/tests/tseries/offsets/test_custom_business_hour.py
index dbc0ff4371fd9..9a2d24f1d0307 100644
--- a/pandas/tests/tseries/offsets/test_custom_business_hour.py
+++ b/pandas/tests/tseries/offsets/test_custom_business_hour.py
@@ -1,6 +1,8 @@
 """
 Tests for offsets.CustomBusinessHour
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import numpy as np
@@ -23,10 +25,10 @@
 
 
 class TestCustomBusinessHour(Base):
-    _offset = CustomBusinessHour
+    _offset: type[CustomBusinessHour] = CustomBusinessHour
     holidays = ["2014-06-27", datetime(2014, 6, 30), np.datetime64("2014-07-02")]
 
-    def setup_method(self, method):
+    def setup_method(self):
         # 2014 Calendar to check custom holidays
         #   Sun Mon Tue Wed Thu Fri Sat
         #  6/22  23  24  25  26  27  28
diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py
index fb0f331fa3ad3..c0f9b3cb5be87 100644
--- a/pandas/tests/tseries/offsets/test_custom_business_month.py
+++ b/pandas/tests/tseries/offsets/test_custom_business_month.py
@@ -4,6 +4,8 @@
 - CustomBusinessMonthBegin
 - CustomBusinessMonthEnd
 """
+from __future__ import annotations
+
 from datetime import (
     date,
     datetime,
@@ -17,6 +19,7 @@
     CBMonthBegin,
     CBMonthEnd,
     CDay,
+    _CustomBusinessMonth,
 )
 
 from pandas import (
@@ -35,7 +38,7 @@
 
 
 class CustomBusinessMonthBase:
-    def setup_method(self, method):
+    def setup_method(self):
         self.d = datetime(2008, 1, 1)
         self.offset = self._offset()
         self.offset1 = self.offset
@@ -66,7 +69,7 @@ def test_copy(self):
 
 
 class TestCustomBusinessMonthBegin(CustomBusinessMonthBase, Base):
-    _offset = CBMonthBegin
+    _offset: type[_CustomBusinessMonth] = CBMonthBegin
 
     def test_different_normalize_equals(self):
         # GH#21404 changed __eq__ to return False when `normalize` does not match
@@ -256,7 +259,7 @@ def test_apply_with_extra_offset(self, case):
 
 
 class TestCustomBusinessMonthEnd(CustomBusinessMonthBase, Base):
-    _offset = CBMonthEnd
+    _offset: type[_CustomBusinessMonth] = CBMonthEnd
 
     def test_different_normalize_equals(self):
         # GH#21404 changed __eq__ to return False when `normalize` does not match
diff --git a/pandas/tests/tseries/offsets/test_dst.py b/pandas/tests/tseries/offsets/test_dst.py
index 50c5a91fc2390..9c6d6a686e9a5 100644
--- a/pandas/tests/tseries/offsets/test_dst.py
+++ b/pandas/tests/tseries/offsets/test_dst.py
@@ -31,6 +31,10 @@
 )
 
 from pandas.tests.tseries.offsets.test_offsets import get_utc_offset_hours
+from pandas.util.version import Version
+
+# error: Module has no attribute "__version__"
+pytz_version = Version(pytz.__version__)  # type: ignore[attr-defined]
 
 
 class TestDST:
@@ -186,9 +190,8 @@ def test_all_offset_classes(self, tup):
             MonthBegin(66),
             "Africa/Kinshasa",
             marks=pytest.mark.xfail(
-                # error: Module has no attribute "__version__"
-                float(pytz.__version__) <= 2020.1,  # type: ignore[attr-defined]
-                reason="GH#41906",
+                pytz_version < Version("2020.5") or pytz_version == Version("2022.2"),
+                reason="GH#41906: pytz utc transition dates changed",
             ),
         ),
         (
diff --git a/pandas/tests/tseries/offsets/test_month.py b/pandas/tests/tseries/offsets/test_month.py
index 00b9d7e186a59..305b57cea17b1 100644
--- a/pandas/tests/tseries/offsets/test_month.py
+++ b/pandas/tests/tseries/offsets/test_month.py
@@ -5,6 +5,8 @@
 - MonthBegin
 - MonthEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
@@ -13,8 +15,10 @@
 from pandas._libs.tslibs.offsets import (
     MonthBegin,
     MonthEnd,
+    MonthOffset,
     SemiMonthBegin,
     SemiMonthEnd,
+    SemiMonthOffset,
 )
 
 from pandas import (
@@ -31,7 +35,7 @@
 
 
 class TestSemiMonthEnd(Base):
-    _offset = SemiMonthEnd
+    _offset: type[SemiMonthOffset] = SemiMonthEnd
     offset1 = _offset()
     offset2 = _offset(2)
 
@@ -295,7 +299,7 @@ def test_vectorized_offset_addition(self, klass):
 
 
 class TestSemiMonthBegin(Base):
-    _offset = SemiMonthBegin
+    _offset: type[SemiMonthOffset] = SemiMonthBegin
     offset1 = _offset()
     offset2 = _offset(2)
 
@@ -535,7 +539,7 @@ def test_vectorized_offset_addition(self, klass):
 
 
 class TestMonthBegin(Base):
-    _offset = MonthBegin
+    _offset: type[MonthOffset] = MonthBegin
 
     offset_cases = []
     # NOTE: I'm not entirely happy with the logic here for Begin -ss
@@ -600,7 +604,7 @@ def test_offset(self, case):
 
 
 class TestMonthEnd(Base):
-    _offset = MonthEnd
+    _offset: type[MonthOffset] = MonthEnd
 
     def test_day_of_month(self):
         dt = datetime(2007, 1, 1)
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 5dcfd0019e93f..bca4ba98f37b7 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -12,6 +12,7 @@
     List,
     Tuple,
 )
+import warnings
 
 import numpy as np
 import pytest
@@ -30,7 +31,11 @@
 from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 from pandas.errors import PerformanceWarning
 
-from pandas import DatetimeIndex
+from pandas import (
+    DatetimeIndex,
+    Series,
+    date_range,
+)
 import pandas._testing as tm
 from pandas.tests.tseries.offsets.common import (
     Base,
@@ -61,6 +66,18 @@
 
 _ApplyCases = List[Tuple[BaseOffset, Dict[datetime, datetime]]]
 
+_ARITHMETIC_DATE_OFFSET = [
+    "years",
+    "months",
+    "weeks",
+    "days",
+    "hours",
+    "minutes",
+    "seconds",
+    "milliseconds",
+    "microseconds",
+]
+
 
 class TestCommon(Base):
     # executed value created by Base._get_offset
@@ -535,9 +552,37 @@ def test_offsets_hashable(self, offset_types):
         off = self._get_offset(offset_types)
         assert hash(off) is not None
 
+    @pytest.mark.parametrize("unit", ["s", "ms", "us"])
+    def test_add_dt64_ndarray_non_nano(self, offset_types, unit, request):
+        # check that the result with non-nano matches nano
+        off = self._get_offset(offset_types)
+
+        dti = date_range("2016-01-01", periods=35, freq="D")
+
+        arr = dti._data._ndarray.astype(f"M8[{unit}]")
+        dta = type(dti._data)._simple_new(arr, dtype=arr.dtype)
+
+        with warnings.catch_warnings(record=True) as w:
+            expected = dti._data + off
+            result = dta + off
+
+        if len(w):
+            # PerformanceWarning was issued bc _apply_array raised, so we
+            #  fell back to object dtype, for which the code path does
+            #  not yet cast back to the original resolution
+            mark = pytest.mark.xfail(
+                reason="Goes through object dtype in DatetimeArray._add_offset, "
+                "doesn't restore reso in result"
+            )
+            request.node.add_marker(mark)
+
+        tm.assert_numpy_array_equal(
+            result._ndarray, expected._ndarray.astype(arr.dtype)
+        )
+
 
 class TestDateOffset(Base):
-    def setup_method(self, method):
+    def setup_method(self):
         self.d = Timestamp(datetime(2008, 1, 2))
         _offset_map.clear()
 
@@ -551,21 +596,135 @@ def test_mul(self):
         assert DateOffset(2) == 2 * DateOffset(1)
         assert DateOffset(2) == DateOffset(1) * 2
 
-    def test_constructor(self):
-
-        assert (self.d + DateOffset(months=2)) == datetime(2008, 3, 2)
-        assert (self.d - DateOffset(months=2)) == datetime(2007, 11, 2)
+    @pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+    def test_constructor(self, kwd, request):
+        if kwd == "millisecond":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason="Constructing DateOffset object with `millisecond` is not "
+                    "yet supported.",
+                )
+            )
+        offset = DateOffset(**{kwd: 2})
+        assert offset.kwds == {kwd: 2}
+        assert getattr(offset, kwd) == 2
 
+    def test_default_constructor(self):
         assert (self.d + DateOffset(2)) == datetime(2008, 1, 4)
 
+    def test_is_anchored(self):
         assert not DateOffset(2).is_anchored()
         assert DateOffset(1).is_anchored()
 
-        d = datetime(2008, 1, 31)
-        assert (d + DateOffset(months=1)) == datetime(2008, 2, 29)
-
     def test_copy(self):
         assert DateOffset(months=2).copy() == DateOffset(months=2)
+        assert DateOffset(milliseconds=1).copy() == DateOffset(milliseconds=1)
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            [
+                "2009-01-02",
+                "2008-02-02",
+                "2008-01-09",
+                "2008-01-03",
+                "2008-01-02 01:00:00",
+                "2008-01-02 00:01:00",
+                "2008-01-02 00:00:01",
+                "2008-01-02 00:00:00.001000000",
+                "2008-01-02 00:00:00.000001000",
+            ],
+        ),
+    )
+    def test_add(self, arithmatic_offset_type, expected):
+        assert DateOffset(**{arithmatic_offset_type: 1}) + self.d == Timestamp(expected)
+        assert self.d + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            [
+                "2007-01-02",
+                "2007-12-02",
+                "2007-12-26",
+                "2008-01-01",
+                "2008-01-01 23:00:00",
+                "2008-01-01 23:59:00",
+                "2008-01-01 23:59:59",
+                "2008-01-01 23:59:59.999000000",
+                "2008-01-01 23:59:59.999999000",
+            ],
+        ),
+    )
+    def test_sub(self, arithmatic_offset_type, expected):
+        assert self.d - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+        with pytest.raises(TypeError, match="Cannot subtract datetime from offset"):
+            DateOffset(**{arithmatic_offset_type: 1}) - self.d
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, n, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            range(1, 10),
+            [
+                "2009-01-02",
+                "2008-03-02",
+                "2008-01-23",
+                "2008-01-06",
+                "2008-01-02 05:00:00",
+                "2008-01-02 00:06:00",
+                "2008-01-02 00:00:07",
+                "2008-01-02 00:00:00.008000000",
+                "2008-01-02 00:00:00.000009000",
+            ],
+        ),
+    )
+    def test_mul_add(self, arithmatic_offset_type, n, expected):
+        assert DateOffset(**{arithmatic_offset_type: 1}) * n + self.d == Timestamp(
+            expected
+        )
+        assert n * DateOffset(**{arithmatic_offset_type: 1}) + self.d == Timestamp(
+            expected
+        )
+        assert self.d + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(
+            expected
+        )
+        assert self.d + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(
+            expected
+        )
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, n, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            range(1, 10),
+            [
+                "2007-01-02",
+                "2007-11-02",
+                "2007-12-12",
+                "2007-12-29",
+                "2008-01-01 19:00:00",
+                "2008-01-01 23:54:00",
+                "2008-01-01 23:59:53",
+                "2008-01-01 23:59:59.992000000",
+                "2008-01-01 23:59:59.999991000",
+            ],
+        ),
+    )
+    def test_mul_sub(self, arithmatic_offset_type, n, expected):
+        assert self.d - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(
+            expected
+        )
+        assert self.d - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(
+            expected
+        )
+
+    def test_leap_year(self):
+        d = datetime(2008, 1, 31)
+        assert (d + DateOffset(months=1)) == datetime(2008, 2, 29)
 
     def test_eq(self):
         offset1 = DateOffset(days=1)
@@ -573,6 +732,8 @@ def test_eq(self):
 
         assert offset1 != offset2
 
+        assert DateOffset(milliseconds=3) != DateOffset(milliseconds=7)
+
 
 class TestOffsetNames:
     def test_get_offset_name(self):
@@ -622,7 +783,7 @@ def test_get_offset_legacy():
 
 
 class TestOffsetAliases:
-    def setup_method(self, method):
+    def setup_method(self):
         _offset_map.clear()
 
     def test_alias_equality(self):
@@ -741,7 +902,15 @@ def test_month_offset_name(month_classes):
 
 
 @pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
-def test_valid_relativedelta_kwargs(kwd):
+def test_valid_relativedelta_kwargs(kwd, request):
+    if kwd == "millisecond":
+        request.node.add_marker(
+            pytest.mark.xfail(
+                raises=NotImplementedError,
+                reason="Constructing DateOffset object with `millisecond` is not "
+                "yet supported.",
+            )
+        )
     # Check that all the arguments specified in liboffsets._relativedelta_kwds
     # are in fact valid relativedelta keyword args
     DateOffset(**{kwd: 1})
@@ -819,7 +988,7 @@ def test_dateoffset_add_sub(offset_kwargs, expected_arg):
     assert result == expected
 
 
-def test_dataoffset_add_sub_timestamp_with_nano():
+def test_dateoffset_add_sub_timestamp_with_nano():
     offset = DateOffset(minutes=2, nanoseconds=9)
     ts = Timestamp(4)
     result = ts + offset
@@ -854,3 +1023,36 @@ def test_dateoffset_misc():
     oset.freqstr
 
     assert not offsets.DateOffset(months=2) == 2
+
+
+@pytest.mark.parametrize("n", [-1, 1, 3])
+def test_construct_int_arg_no_kwargs_assumed_days(n):
+    # GH 45890, 45643
+    offset = DateOffset(n)
+    assert offset._offset == timedelta(1)
+    result = Timestamp(2022, 1, 2) + offset
+    expected = Timestamp(2022, 1, 2 + n)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "offset, expected",
+    [
+        (
+            DateOffset(minutes=7, nanoseconds=18),
+            Timestamp("2022-01-01 00:07:00.000000018"),
+        ),
+        (DateOffset(nanoseconds=3), Timestamp("2022-01-01 00:00:00.000000003")),
+    ],
+)
+def test_dateoffset_add_sub_timestamp_series_with_nano(offset, expected):
+    # GH 47856
+    start_time = Timestamp("2022-01-01")
+    teststamp = start_time
+    testseries = Series([start_time])
+    testseries = testseries + offset
+    assert testseries[0] == expected
+    testseries -= offset
+    assert testseries[0] == teststamp
+    testseries = offset + testseries
+    assert testseries[0] == expected
diff --git a/pandas/tests/tseries/offsets/test_offsets_properties.py b/pandas/tests/tseries/offsets/test_offsets_properties.py
index 5071c816c313d..1b4fa9292c403 100644
--- a/pandas/tests/tseries/offsets/test_offsets_properties.py
+++ b/pandas/tests/tseries/offsets/test_offsets_properties.py
@@ -10,7 +10,6 @@
 from hypothesis import (
     assume,
     given,
-    settings,
 )
 import pytest
 import pytz
@@ -46,7 +45,6 @@ def test_on_offset_implementations(dt, offset):
 
 
 @given(YQM_OFFSET)
-@settings(deadline=None)  # GH 45118
 def test_shift_across_dst(offset):
     # GH#18319 check that 1) timezone is correctly normalized and
     # 2) that hour is not incorrectly changed by this normalization
diff --git a/pandas/tests/tseries/offsets/test_quarter.py b/pandas/tests/tseries/offsets/test_quarter.py
index e076fb9f4d53b..9063b71cdece4 100644
--- a/pandas/tests/tseries/offsets/test_quarter.py
+++ b/pandas/tests/tseries/offsets/test_quarter.py
@@ -3,6 +3,8 @@
 - QuarterBegin
 - QuarterEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
@@ -152,7 +154,7 @@ def test_offset(self, case):
 
 
 class TestQuarterEnd(Base):
-    _offset = QuarterEnd
+    _offset: type[QuarterEnd] = QuarterEnd
 
     def test_repr(self):
         expected = "<QuarterEnd: startingMonth=3>"
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index 47e7b2aa4d401..7a174b89baa9b 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -10,7 +10,6 @@
     assume,
     example,
     given,
-    settings,
 )
 import numpy as np
 import pytest
@@ -62,7 +61,6 @@ def test_delta_to_tick():
 
 
 @pytest.mark.parametrize("cls", tick_classes)
-@settings(deadline=None)  # GH 24641
 @example(n=2, m=3)
 @example(n=800, m=300)
 @example(n=1000, m=5)
@@ -84,7 +82,6 @@ def test_tick_add_sub(cls, n, m):
 
 @pytest.mark.arm_slow
 @pytest.mark.parametrize("cls", tick_classes)
-@settings(deadline=None)
 @example(n=2, m=3)
 @given(n=INT_NEG_999_TO_POS_999, m=INT_NEG_999_TO_POS_999)
 def test_tick_equality(cls, n, m):
diff --git a/pandas/tests/tseries/offsets/test_week.py b/pandas/tests/tseries/offsets/test_week.py
index be574fd963eff..fcf11899d8a56 100644
--- a/pandas/tests/tseries/offsets/test_week.py
+++ b/pandas/tests/tseries/offsets/test_week.py
@@ -4,6 +4,8 @@
 - WeekOfMonth
 - LastWeekOfMonth
 """
+from __future__ import annotations
+
 from datetime import (
     datetime,
     timedelta,
@@ -17,6 +19,7 @@
     LastWeekOfMonth,
     Week,
     WeekOfMonth,
+    WeekOfMonthMixin,
 )
 
 from pandas.tests.tseries.offsets.common import (
@@ -28,7 +31,7 @@
 
 
 class TestWeek(Base):
-    _offset = Week
+    _offset: type[Week] = Week
     d = Timestamp(datetime(2008, 1, 2))
     offset1 = _offset()
     offset2 = _offset(2)
@@ -151,7 +154,7 @@ def test_week_add_invalid(self):
 
 
 class TestWeekOfMonth(Base):
-    _offset = WeekOfMonth
+    _offset: type[WeekOfMonthMixin] = WeekOfMonth
     offset1 = _offset()
     offset2 = _offset(2)
 
@@ -267,7 +270,7 @@ def test_is_on_offset_nanoseconds(self, n, week, date, tz):
 
 
 class TestLastWeekOfMonth(Base):
-    _offset = LastWeekOfMonth
+    _offset: type[WeekOfMonthMixin] = LastWeekOfMonth
     offset1 = _offset()
     offset2 = _offset(2)
 
diff --git a/pandas/tests/tseries/offsets/test_year.py b/pandas/tests/tseries/offsets/test_year.py
index 85994adb6f19d..55c3057b23cb0 100644
--- a/pandas/tests/tseries/offsets/test_year.py
+++ b/pandas/tests/tseries/offsets/test_year.py
@@ -3,10 +3,14 @@
 - YearBegin
 - YearEnd
 """
+from __future__ import annotations
+
 from datetime import datetime
 
 import pytest
 
+from pandas._libs.tslibs.offsets import YearOffset
+
 from pandas.tests.tseries.offsets.common import (
     Base,
     assert_is_on_offset,
@@ -20,7 +24,7 @@
 
 
 class TestYearBegin(Base):
-    _offset = YearBegin
+    _offset: type[YearOffset] = YearBegin
 
     def test_misspecified(self):
         with pytest.raises(ValueError, match="Month must go from 1 to 12"):
@@ -174,7 +178,7 @@ def test_is_on_offset(self, case):
 
 
 class TestYearEnd(Base):
-    _offset = YearEnd
+    _offset: type[YearOffset] = YearEnd
 
     def test_misspecified(self):
         with pytest.raises(ValueError, match="Month must go from 1 to 12"):
diff --git a/pandas/tests/tslibs/test_api.py b/pandas/tests/tslibs/test_api.py
index d7abb19530837..2d195fad83644 100644
--- a/pandas/tests/tslibs/test_api.py
+++ b/pandas/tests/tslibs/test_api.py
@@ -46,9 +46,16 @@ def test_namespace():
         "delta_to_nanoseconds",
         "ints_to_pytimedelta",
         "localize_pydatetime",
+        "tz_convert_from_utc",
         "tz_convert_from_utc_single",
         "to_offset",
         "tz_compare",
+        "is_unitless",
+        "astype_overflowsafe",
+        "get_unit_from_dtype",
+        "periods_per_day",
+        "periods_per_second",
+        "is_supported_unit",
     ]
 
     expected = set(submodules + api)
diff --git a/pandas/tests/tslibs/test_array_to_datetime.py b/pandas/tests/tslibs/test_array_to_datetime.py
index a0fafc227e001..64a45f6507810 100644
--- a/pandas/tests/tslibs/test_array_to_datetime.py
+++ b/pandas/tests/tslibs/test_array_to_datetime.py
@@ -125,7 +125,7 @@ def test_coerce_outside_ns_bounds(invalid_date, errors):
     kwargs = {"values": arr, "errors": errors}
 
     if errors == "raise":
-        msg = "Out of bounds nanosecond timestamp"
+        msg = "Out of bounds .* present at position 0"
 
         with pytest.raises(ValueError, match=msg):
             tslib.array_to_datetime(**kwargs)
@@ -170,7 +170,9 @@ def test_to_datetime_barely_out_of_bounds():
     # Close enough to bounds that dropping nanos
     # would result in an in-bounds datetime.
     arr = np.array(["2262-04-11 23:47:16.854775808"], dtype=object)
-    msg = "Out of bounds nanosecond timestamp: 2262-04-11 23:47:16"
+    msg = (
+        "Out of bounds nanosecond timestamp: 2262-04-11 23:47:16 present at position 0"
+    )
 
     with pytest.raises(tslib.OutOfBoundsDatetime, match=msg):
         tslib.array_to_datetime(arr)
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
index 41eb7ae85d032..bf9a45c6d9d7a 100644
--- a/pandas/tests/tslibs/test_conversion.py
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -6,9 +6,11 @@
 
 from pandas._libs.tslibs import (
     OutOfBoundsTimedelta,
+    astype_overflowsafe,
     conversion,
     iNaT,
     timezones,
+    tz_convert_from_utc,
     tzconversion,
 )
 
@@ -23,7 +25,7 @@ def _compare_utc_to_local(tz_didx):
     def f(x):
         return tzconversion.tz_convert_from_utc_single(x, tz_didx.tz)
 
-    result = tzconversion.tz_convert_from_utc(tz_didx.asi8, tz_didx.tz)
+    result = tz_convert_from_utc(tz_didx.asi8, tz_didx.tz)
     expected = np.vectorize(f)(tz_didx.asi8)
 
     tm.assert_numpy_array_equal(result, expected)
@@ -50,6 +52,18 @@ def _compare_local_to_utc(tz_didx, naive_didx):
         tm.assert_numpy_array_equal(result, expected)
 
 
+def test_tz_localize_to_utc_copies():
+    # GH#46460
+    arr = np.arange(5, dtype="i8")
+    result = tz_convert_from_utc(arr, tz=UTC)
+    tm.assert_numpy_array_equal(result, arr)
+    assert not np.shares_memory(arr, result)
+
+    result = tz_convert_from_utc(arr, tz=None)
+    tm.assert_numpy_array_equal(result, arr)
+    assert not np.shares_memory(arr, result)
+
+
 def test_tz_convert_single_matches_tz_convert_hourly(tz_aware_fixture):
     tz = tz_aware_fixture
     tz_didx = date_range("2014-03-01", "2015-01-10", freq="H", tz=tz)
@@ -77,7 +91,7 @@ def test_tz_convert_single_matches_tz_convert(tz_aware_fixture, freq):
     ],
 )
 def test_tz_convert_corner(arr):
-    result = tzconversion.tz_convert_from_utc(arr, timezones.maybe_get_tz("Asia/Tokyo"))
+    result = tz_convert_from_utc(arr, timezones.maybe_get_tz("Asia/Tokyo"))
     tm.assert_numpy_array_equal(result, arr)
 
 
@@ -85,7 +99,7 @@ def test_tz_convert_readonly():
     # GH#35530
     arr = np.array([0], dtype=np.int64)
     arr.setflags(write=False)
-    result = tzconversion.tz_convert_from_utc(arr, UTC)
+    result = tz_convert_from_utc(arr, UTC)
     tm.assert_numpy_array_equal(result, arr)
 
 
@@ -93,14 +107,20 @@ def test_tz_convert_readonly():
 @pytest.mark.parametrize("dtype", ["M8[ns]", "M8[s]"])
 def test_length_zero_copy(dtype, copy):
     arr = np.array([], dtype=dtype)
-    result = conversion.ensure_datetime64ns(arr, copy=copy)
-    assert result.base is (None if copy else arr)
+    result = astype_overflowsafe(arr, copy=copy, dtype=np.dtype("M8[ns]"))
+    if copy:
+        assert not np.shares_memory(result, arr)
+    else:
+        if arr.dtype == result.dtype:
+            assert result is arr
+        else:
+            assert not np.shares_memory(result, arr)
 
 
 def test_ensure_datetime64ns_bigendian():
     # GH#29684
     arr = np.array([np.datetime64(1, "ms")], dtype=">M8[ms]")
-    result = conversion.ensure_datetime64ns(arr)
+    result = astype_overflowsafe(arr, dtype=np.dtype("M8[ns]"))
 
     expected = np.array([np.datetime64(1, "ms")], dtype="M8[ns]")
     tm.assert_numpy_array_equal(result, expected)
@@ -108,9 +128,9 @@ def test_ensure_datetime64ns_bigendian():
 
 def test_ensure_timedelta64ns_overflows():
     arr = np.arange(10).astype("m8[Y]") * 100
-    msg = r"Out of bounds for nanosecond timedelta64\[Y\] 900"
+    msg = r"Cannot convert 300 years to timedelta64\[ns\] without overflow"
     with pytest.raises(OutOfBoundsTimedelta, match=msg):
-        conversion.ensure_timedelta64ns(arr)
+        astype_overflowsafe(arr, dtype=np.dtype("m8[ns]"))
 
 
 class SubDatetime(datetime):
diff --git a/pandas/tests/tslibs/test_fields.py b/pandas/tests/tslibs/test_fields.py
index 9d0b3ff4fca80..9e6464f7727bd 100644
--- a/pandas/tests/tslibs/test_fields.py
+++ b/pandas/tests/tslibs/test_fields.py
@@ -8,7 +8,7 @@
 
 @pytest.fixture
 def dtindex():
-    dtindex = np.arange(5, dtype=np.int64) * 10 ** 9 * 3600 * 24 * 32
+    dtindex = np.arange(5, dtype=np.int64) * 10**9 * 3600 * 24 * 32
     dtindex.flags.writeable = False
     return dtindex
 
diff --git a/pandas/tests/tslibs/test_np_datetime.py b/pandas/tests/tslibs/test_np_datetime.py
new file mode 100644
index 0000000000000..02edf1a093877
--- /dev/null
+++ b/pandas/tests/tslibs/test_np_datetime.py
@@ -0,0 +1,222 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+    astype_overflowsafe,
+    is_unitless,
+    py_get_unit_from_dtype,
+    py_td64_to_tdstruct,
+)
+
+import pandas._testing as tm
+
+
+def test_is_unitless():
+    dtype = np.dtype("M8[ns]")
+    assert not is_unitless(dtype)
+
+    dtype = np.dtype("datetime64")
+    assert is_unitless(dtype)
+
+    dtype = np.dtype("m8[ns]")
+    assert not is_unitless(dtype)
+
+    dtype = np.dtype("timedelta64")
+    assert is_unitless(dtype)
+
+    msg = "dtype must be datetime64 or timedelta64"
+    with pytest.raises(ValueError, match=msg):
+        is_unitless(np.dtype(np.int64))
+
+    msg = "Argument 'dtype' has incorrect type"
+    with pytest.raises(TypeError, match=msg):
+        is_unitless("foo")
+
+
+def test_get_unit_from_dtype():
+    # datetime64
+    assert py_get_unit_from_dtype(np.dtype("M8[Y]")) == NpyDatetimeUnit.NPY_FR_Y.value
+    assert py_get_unit_from_dtype(np.dtype("M8[M]")) == NpyDatetimeUnit.NPY_FR_M.value
+    assert py_get_unit_from_dtype(np.dtype("M8[W]")) == NpyDatetimeUnit.NPY_FR_W.value
+    # B has been deprecated and removed -> no 3
+    assert py_get_unit_from_dtype(np.dtype("M8[D]")) == NpyDatetimeUnit.NPY_FR_D.value
+    assert py_get_unit_from_dtype(np.dtype("M8[h]")) == NpyDatetimeUnit.NPY_FR_h.value
+    assert py_get_unit_from_dtype(np.dtype("M8[m]")) == NpyDatetimeUnit.NPY_FR_m.value
+    assert py_get_unit_from_dtype(np.dtype("M8[s]")) == NpyDatetimeUnit.NPY_FR_s.value
+    assert py_get_unit_from_dtype(np.dtype("M8[ms]")) == NpyDatetimeUnit.NPY_FR_ms.value
+    assert py_get_unit_from_dtype(np.dtype("M8[us]")) == NpyDatetimeUnit.NPY_FR_us.value
+    assert py_get_unit_from_dtype(np.dtype("M8[ns]")) == NpyDatetimeUnit.NPY_FR_ns.value
+    assert py_get_unit_from_dtype(np.dtype("M8[ps]")) == NpyDatetimeUnit.NPY_FR_ps.value
+    assert py_get_unit_from_dtype(np.dtype("M8[fs]")) == NpyDatetimeUnit.NPY_FR_fs.value
+    assert py_get_unit_from_dtype(np.dtype("M8[as]")) == NpyDatetimeUnit.NPY_FR_as.value
+
+    # timedelta64
+    assert py_get_unit_from_dtype(np.dtype("m8[Y]")) == NpyDatetimeUnit.NPY_FR_Y.value
+    assert py_get_unit_from_dtype(np.dtype("m8[M]")) == NpyDatetimeUnit.NPY_FR_M.value
+    assert py_get_unit_from_dtype(np.dtype("m8[W]")) == NpyDatetimeUnit.NPY_FR_W.value
+    # B has been deprecated and removed -> no 3
+    assert py_get_unit_from_dtype(np.dtype("m8[D]")) == NpyDatetimeUnit.NPY_FR_D.value
+    assert py_get_unit_from_dtype(np.dtype("m8[h]")) == NpyDatetimeUnit.NPY_FR_h.value
+    assert py_get_unit_from_dtype(np.dtype("m8[m]")) == NpyDatetimeUnit.NPY_FR_m.value
+    assert py_get_unit_from_dtype(np.dtype("m8[s]")) == NpyDatetimeUnit.NPY_FR_s.value
+    assert py_get_unit_from_dtype(np.dtype("m8[ms]")) == NpyDatetimeUnit.NPY_FR_ms.value
+    assert py_get_unit_from_dtype(np.dtype("m8[us]")) == NpyDatetimeUnit.NPY_FR_us.value
+    assert py_get_unit_from_dtype(np.dtype("m8[ns]")) == NpyDatetimeUnit.NPY_FR_ns.value
+    assert py_get_unit_from_dtype(np.dtype("m8[ps]")) == NpyDatetimeUnit.NPY_FR_ps.value
+    assert py_get_unit_from_dtype(np.dtype("m8[fs]")) == NpyDatetimeUnit.NPY_FR_fs.value
+    assert py_get_unit_from_dtype(np.dtype("m8[as]")) == NpyDatetimeUnit.NPY_FR_as.value
+
+
+def test_td64_to_tdstruct():
+    val = 12454636234  # arbitrary value
+
+    res1 = py_td64_to_tdstruct(val, NpyDatetimeUnit.NPY_FR_ns.value)
+    exp1 = {
+        "days": 0,
+        "hrs": 0,
+        "min": 0,
+        "sec": 12,
+        "ms": 454,
+        "us": 636,
+        "ns": 234,
+        "seconds": 12,
+        "microseconds": 454636,
+        "nanoseconds": 234,
+    }
+    assert res1 == exp1
+
+    res2 = py_td64_to_tdstruct(val, NpyDatetimeUnit.NPY_FR_us.value)
+    exp2 = {
+        "days": 0,
+        "hrs": 3,
+        "min": 27,
+        "sec": 34,
+        "ms": 636,
+        "us": 234,
+        "ns": 0,
+        "seconds": 12454,
+        "microseconds": 636234,
+        "nanoseconds": 0,
+    }
+    assert res2 == exp2
+
+    res3 = py_td64_to_tdstruct(val, NpyDatetimeUnit.NPY_FR_ms.value)
+    exp3 = {
+        "days": 144,
+        "hrs": 3,
+        "min": 37,
+        "sec": 16,
+        "ms": 234,
+        "us": 0,
+        "ns": 0,
+        "seconds": 13036,
+        "microseconds": 234000,
+        "nanoseconds": 0,
+    }
+    assert res3 == exp3
+
+    # Note this out of bounds for nanosecond Timedelta
+    res4 = py_td64_to_tdstruct(val, NpyDatetimeUnit.NPY_FR_s.value)
+    exp4 = {
+        "days": 144150,
+        "hrs": 21,
+        "min": 10,
+        "sec": 34,
+        "ms": 0,
+        "us": 0,
+        "ns": 0,
+        "seconds": 76234,
+        "microseconds": 0,
+        "nanoseconds": 0,
+    }
+    assert res4 == exp4
+
+
+class TestAstypeOverflowSafe:
+    def test_pass_non_dt64_array(self):
+        # check that we raise, not segfault
+        arr = np.arange(5)
+        dtype = np.dtype("M8[ns]")
+
+        msg = (
+            "astype_overflowsafe values.dtype and dtype must be either "
+            "both-datetime64 or both-timedelta64"
+        )
+        with pytest.raises(TypeError, match=msg):
+            astype_overflowsafe(arr, dtype, copy=True)
+
+        with pytest.raises(TypeError, match=msg):
+            astype_overflowsafe(arr, dtype, copy=False)
+
+    def test_pass_non_dt64_dtype(self):
+        # check that we raise, not segfault
+        arr = np.arange(5, dtype="i8").view("M8[D]")
+        dtype = np.dtype("m8[ns]")
+
+        msg = (
+            "astype_overflowsafe values.dtype and dtype must be either "
+            "both-datetime64 or both-timedelta64"
+        )
+        with pytest.raises(TypeError, match=msg):
+            astype_overflowsafe(arr, dtype, copy=True)
+
+        with pytest.raises(TypeError, match=msg):
+            astype_overflowsafe(arr, dtype, copy=False)
+
+    def test_astype_overflowsafe_dt64(self):
+        dtype = np.dtype("M8[ns]")
+
+        dt = np.datetime64("2262-04-05", "D")
+        arr = dt + np.arange(10, dtype="m8[D]")
+
+        # arr.astype silently overflows, so this
+        wrong = arr.astype(dtype)
+        roundtrip = wrong.astype(arr.dtype)
+        assert not (wrong == roundtrip).all()
+
+        msg = "Out of bounds nanosecond timestamp"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            astype_overflowsafe(arr, dtype)
+
+        # But converting to microseconds is fine, and we match numpy's results.
+        dtype2 = np.dtype("M8[us]")
+        result = astype_overflowsafe(arr, dtype2)
+        expected = arr.astype(dtype2)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_astype_overflowsafe_td64(self):
+        dtype = np.dtype("m8[ns]")
+
+        dt = np.datetime64("2262-04-05", "D")
+        arr = dt + np.arange(10, dtype="m8[D]")
+        arr = arr.view("m8[D]")
+
+        # arr.astype silently overflows, so this
+        wrong = arr.astype(dtype)
+        roundtrip = wrong.astype(arr.dtype)
+        assert not (wrong == roundtrip).all()
+
+        msg = r"Cannot convert 106752 days to timedelta64\[ns\] without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            astype_overflowsafe(arr, dtype)
+
+        # But converting to microseconds is fine, and we match numpy's results.
+        dtype2 = np.dtype("m8[us]")
+        result = astype_overflowsafe(arr, dtype2)
+        expected = arr.astype(dtype2)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_astype_overflowsafe_disallow_rounding(self):
+        arr = np.array([-1500, 1500], dtype="M8[ns]")
+        dtype = np.dtype("M8[us]")
+
+        msg = "Cannot losslessly cast '-1500 ns' to us"
+        with pytest.raises(ValueError, match=msg):
+            astype_overflowsafe(arr, dtype, round_ok=False)
+
+        result = astype_overflowsafe(arr, dtype, round_ok=True)
+        expected = arr.astype(dtype)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/tslibs/test_parsing.py b/pandas/tests/tslibs/test_parsing.py
index 3d2daec442c38..4dae6c586e306 100644
--- a/pandas/tests/tslibs/test_parsing.py
+++ b/pandas/tests/tslibs/test_parsing.py
@@ -23,6 +23,12 @@ def test_parse_time_string():
     assert parsed == parsed_lower
 
 
+def test_parse_time_string_nanosecond_reso():
+    # GH#46811
+    parsed, reso = parse_time_string("2022-04-20 09:19:19.123456789")
+    assert reso == "nanosecond"
+
+
 def test_parse_time_string_invalid_type():
     # Raise on invalid input, don't just return it
     msg = "Argument 'arg' has incorrect type (expected str, got tuple)"
@@ -183,7 +189,7 @@ def test_guess_datetime_format_with_dayfirst(dayfirst, expected):
     assert result == expected
 
 
-@td.skip_if_has_locale
+@td.skip_if_not_us_locale
 @pytest.mark.parametrize(
     "string,fmt",
     [
diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period_asfreq.py
index 2592fdbb2d361..7c9047b3e7c60 100644
--- a/pandas/tests/tslibs/test_period_asfreq.py
+++ b/pandas/tests/tslibs/test_period_asfreq.py
@@ -1,15 +1,23 @@
+import numpy as np
 import pytest
 
-from pandas._libs.tslibs import to_offset
+from pandas._libs.tslibs import (
+    iNaT,
+    to_offset,
+)
 from pandas._libs.tslibs.period import (
+    extract_ordinals,
     period_asfreq,
     period_ordinal,
 )
 
+import pandas._testing as tm
+
 
 def get_freq_code(freqstr: str) -> int:
     off = to_offset(freqstr)
-    code = off._period_dtype_code
+    # error: "BaseOffset" has no attribute "_period_dtype_code"
+    code = off._period_dtype_code  # type: ignore[attr-defined]
     return code
 
 
@@ -88,3 +96,21 @@ def test_period_ordinal_business_day(day, expected):
     # 5000 is PeriodDtypeCode for BusinessDay
     args = (2013, 10, day, 0, 0, 0, 0, 0, 5000)
     assert period_ordinal(*args) == expected
+
+
+class TestExtractOrdinals:
+    def test_extract_ordinals_raises(self):
+        # with non-object, make sure we raise TypeError, not segfault
+        arr = np.arange(5)
+        freq = to_offset("D")
+        with pytest.raises(TypeError, match="values must be object-dtype"):
+            extract_ordinals(arr, freq)
+
+    def test_extract_ordinals_2d(self):
+        freq = to_offset("D")
+        arr = np.empty(10, dtype=object)
+        arr[:] = iNaT
+
+        res = extract_ordinals(arr, freq)
+        res2 = extract_ordinals(arr.reshape(5, 2), freq)
+        tm.assert_numpy_array_equal(res, res2.reshape(-1))
diff --git a/pandas/tests/tslibs/test_resolution.py b/pandas/tests/tslibs/test_resolution.py
new file mode 100644
index 0000000000000..7b2268f16a85f
--- /dev/null
+++ b/pandas/tests/tslibs/test_resolution.py
@@ -0,0 +1,24 @@
+import numpy as np
+import pytz
+
+from pandas._libs.tslibs import (
+    Resolution,
+    get_resolution,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
+
+def test_get_resolution_nano():
+    # don't return the fallback RESO_DAY
+    arr = np.array([1], dtype=np.int64)
+    res = get_resolution(arr)
+    assert res == Resolution.RESO_NS
+
+
+def test_get_resolution_non_nano_data():
+    arr = np.array([1], dtype=np.int64)
+    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)
+    assert res == Resolution.RESO_US
diff --git a/pandas/tests/tslibs/test_timedeltas.py b/pandas/tests/tslibs/test_timedeltas.py
index c72d279580cca..36ca02d32dbbd 100644
--- a/pandas/tests/tslibs/test_timedeltas.py
+++ b/pandas/tests/tslibs/test_timedeltas.py
@@ -1,12 +1,19 @@
+import re
+
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs.timedeltas import delta_to_nanoseconds
+from pandas._libs.tslibs.timedeltas import (
+    array_to_timedelta64,
+    delta_to_nanoseconds,
+    ints_to_pytimedelta,
+)
 
 from pandas import (
     Timedelta,
     offsets,
 )
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -25,9 +32,6 @@
             24 * 3600e9 + 111,
         ),  # GH43764
         (offsets.Nano(125), 125),
-        (1, 1),
-        (np.int64(2), 2),
-        (np.int32(3), 3),
     ],
 )
 def test_delta_to_nanoseconds(obj, expected):
@@ -41,8 +45,93 @@ def test_delta_to_nanoseconds_error():
     with pytest.raises(TypeError, match="<class 'numpy.ndarray'>"):
         delta_to_nanoseconds(obj)
 
+    with pytest.raises(TypeError, match="float"):
+        delta_to_nanoseconds(1.5)
+    with pytest.raises(TypeError, match="int"):
+        delta_to_nanoseconds(1)
+    with pytest.raises(TypeError, match="int"):
+        delta_to_nanoseconds(np.int64(2))
+    with pytest.raises(TypeError, match="int"):
+        delta_to_nanoseconds(np.int32(3))
+
+
+def test_delta_to_nanoseconds_td64_MY_raises():
+    msg = (
+        "delta_to_nanoseconds does not support Y or M units, "
+        "as their duration in nanoseconds is ambiguous"
+    )
+
+    td = np.timedelta64(1234, "Y")
+
+    with pytest.raises(ValueError, match=msg):
+        delta_to_nanoseconds(td)
+
+    td = np.timedelta64(1234, "M")
+
+    with pytest.raises(ValueError, match=msg):
+        delta_to_nanoseconds(td)
+
 
 def test_huge_nanoseconds_overflow():
     # GH 32402
     assert delta_to_nanoseconds(Timedelta(1e10)) == 1e10
     assert delta_to_nanoseconds(Timedelta(nanoseconds=1e10)) == 1e10
+
+
+@pytest.mark.parametrize(
+    "kwargs", [{"Seconds": 1}, {"seconds": 1, "Nanoseconds": 1}, {"Foo": 2}]
+)
+def test_kwarg_assertion(kwargs):
+    err_message = (
+        "cannot construct a Timedelta from the passed arguments, "
+        "allowed keywords are "
+        "[weeks, days, hours, minutes, seconds, "
+        "milliseconds, microseconds, nanoseconds]"
+    )
+
+    with pytest.raises(ValueError, match=re.escape(err_message)):
+        Timedelta(**kwargs)
+
+
+class TestArrayToTimedelta64:
+    def test_array_to_timedelta64_string_with_unit_2d_raises(self):
+        # check the 'unit is not None and errors != "coerce"' path
+        #  in array_to_timedelta64 raises correctly with 2D values
+        values = np.array([["1", 2], [3, "4"]], dtype=object)
+        with pytest.raises(ValueError, match="unit must not be specified"):
+            array_to_timedelta64(values, unit="s")
+
+    def test_array_to_timedelta64_non_object_raises(self):
+        # check we raise, not segfault
+        values = np.arange(5)
+
+        msg = "'values' must have object dtype"
+        with pytest.raises(TypeError, match=msg):
+            array_to_timedelta64(values)
+
+
+@pytest.mark.parametrize("unit", ["s", "ms", "us"])
+def test_ints_to_pytimedelta(unit):
+    # tests for non-nanosecond cases
+    arr = np.arange(6, dtype=np.int64).view(f"m8[{unit}]")
+
+    res = ints_to_pytimedelta(arr, box=False)
+    # For non-nanosecond, .astype(object) gives pytimedelta objects
+    #  instead of integers
+    expected = arr.astype(object)
+    tm.assert_numpy_array_equal(res, expected)
+
+    res = ints_to_pytimedelta(arr, box=True)
+    expected = np.array([Timedelta(x) for x in arr], dtype=object)
+    tm.assert_numpy_array_equal(res, expected)
+
+
+@pytest.mark.parametrize("unit", ["Y", "M", "ps", "fs", "as"])
+def test_ints_to_pytimedelta_unsupported(unit):
+    arr = np.arange(6, dtype=np.int64).view(f"m8[{unit}]")
+
+    with pytest.raises(NotImplementedError, match=r"\d{1,2}"):
+        ints_to_pytimedelta(arr, box=False)
+    msg = "Only resolutions 's', 'ms', 'us', 'ns' are supported"
+    with pytest.raises(NotImplementedError, match=msg):
+        ints_to_pytimedelta(arr, box=True)
diff --git a/pandas/tests/tslibs/test_timezones.py b/pandas/tests/tslibs/test_timezones.py
index 7ab0ad0856af0..aa10ab15f4744 100644
--- a/pandas/tests/tslibs/test_timezones.py
+++ b/pandas/tests/tslibs/test_timezones.py
@@ -23,9 +23,6 @@ def test_is_utc(utc_fixture):
 
 @pytest.mark.parametrize("tz_name", list(pytz.common_timezones))
 def test_cache_keys_are_distinct_for_pytz_vs_dateutil(tz_name):
-    if tz_name == "UTC":
-        pytest.skip("UTC: special case in dateutil")
-
     tz_p = timezones.maybe_get_tz(tz_name)
     tz_d = timezones.maybe_get_tz("dateutil/" + tz_name)
 
diff --git a/pandas/tests/tslibs/test_tzconversion.py b/pandas/tests/tslibs/test_tzconversion.py
new file mode 100644
index 0000000000000..c1a56ffb71b02
--- /dev/null
+++ b/pandas/tests/tslibs/test_tzconversion.py
@@ -0,0 +1,23 @@
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs.tzconversion import tz_localize_to_utc
+
+
+class TestTZLocalizeToUTC:
+    def test_tz_localize_to_utc_ambiguous_infer(self):
+        # val is a timestamp that is ambiguous when localized to US/Eastern
+        val = 1_320_541_200_000_000_000
+        vals = np.array([val, val - 1, val], dtype=np.int64)
+
+        with pytest.raises(pytz.AmbiguousTimeError, match="2011-11-06 01:00:00"):
+            tz_localize_to_utc(vals, pytz.timezone("US/Eastern"), ambiguous="infer")
+
+        with pytest.raises(pytz.AmbiguousTimeError, match="are no repeated times"):
+            tz_localize_to_utc(vals[:1], pytz.timezone("US/Eastern"), ambiguous="infer")
+
+        vals[1] += 1
+        msg = "There are 2 dst switches when there should only be 1"
+        with pytest.raises(pytz.AmbiguousTimeError, match=msg):
+            tz_localize_to_utc(vals, pytz.timezone("US/Eastern"), ambiguous="infer")
diff --git a/pandas/tests/util/test_assert_almost_equal.py b/pandas/tests/util/test_assert_almost_equal.py
index ab53707771be6..4e6c420341bc2 100644
--- a/pandas/tests/util/test_assert_almost_equal.py
+++ b/pandas/tests/util/test_assert_almost_equal.py
@@ -458,3 +458,87 @@ def test_assert_almost_equal_iterable_values_mismatch():
 
     with pytest.raises(AssertionError, match=msg):
         tm.assert_almost_equal([1, 2], [1, 3])
+
+
+subarr = np.empty(2, dtype=object)
+subarr[:] = [np.array([None, "b"], dtype=object), np.array(["c", "d"], dtype=object)]
+
+NESTED_CASES = [
+    # nested array
+    (
+        np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+        np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+    ),
+    # >1 level of nesting
+    (
+        np.array(
+            [
+                np.array([np.array([50, 70]), np.array([90])], dtype=object),
+                np.array([np.array([20, 30])], dtype=object),
+            ],
+            dtype=object,
+        ),
+        np.array(
+            [
+                np.array([np.array([50, 70]), np.array([90])], dtype=object),
+                np.array([np.array([20, 30])], dtype=object),
+            ],
+            dtype=object,
+        ),
+    ),
+    # lists
+    (
+        np.array([[50, 70, 90], [20, 30]], dtype=object),
+        np.array([[50, 70, 90], [20, 30]], dtype=object),
+    ),
+    # mixed array/list
+    (
+        np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+        np.array([[1, 2, 3], [4, 5]], dtype=object),
+    ),
+    (
+        np.array(
+            [
+                np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+                np.array(
+                    [np.array([6]), np.array([7, 8]), np.array([9])], dtype=object
+                ),
+            ],
+            dtype=object,
+        ),
+        np.array([[[1, 2, 3], [4, 5]], [[6], [7, 8], [9]]], dtype=object),
+    ),
+    # same-length lists
+    (
+        np.array([subarr, None], dtype=object),
+        np.array([list([[None, "b"], ["c", "d"]]), None], dtype=object),
+    ),
+    # dicts
+    (
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+    ),
+    (
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+        np.array([{"f1": 1, "f2": ["a", "b"]}], dtype=object),
+    ),
+    # array/list of dicts
+    (
+        np.array(
+            [
+                np.array(
+                    [{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object
+                ),
+                np.array([], dtype=object),
+            ],
+            dtype=object,
+        ),
+        np.array([[{"f1": 1, "f2": ["a", "b"]}], []], dtype=object),
+    ),
+]
+
+
+@pytest.mark.filterwarnings("ignore:elementwise comparison failed:DeprecationWarning")
+@pytest.mark.parametrize("a,b", NESTED_CASES)
+def test_assert_almost_equal_array_nested(a, b):
+    _assert_almost_equal_both(a, b)
diff --git a/pandas/tests/util/test_assert_attr_equal.py b/pandas/tests/util/test_assert_attr_equal.py
index 115ef58e085cc..bbbb0bf2172b1 100644
--- a/pandas/tests/util/test_assert_attr_equal.py
+++ b/pandas/tests/util/test_assert_attr_equal.py
@@ -10,7 +10,7 @@
 def test_assert_attr_equal(nulls_fixture):
     obj = SimpleNamespace()
     obj.na_value = nulls_fixture
-    assert tm.assert_attr_equal("na_value", obj, obj)
+    tm.assert_attr_equal("na_value", obj, obj)
 
 
 def test_assert_attr_equal_different_nulls(nulls_fixture, nulls_fixture2):
@@ -21,13 +21,13 @@ def test_assert_attr_equal_different_nulls(nulls_fixture, nulls_fixture2):
     obj2.na_value = nulls_fixture2
 
     if nulls_fixture is nulls_fixture2:
-        assert tm.assert_attr_equal("na_value", obj, obj2)
+        tm.assert_attr_equal("na_value", obj, obj2)
     elif is_float(nulls_fixture) and is_float(nulls_fixture2):
         # we consider float("nan") and np.float64("nan") to be equivalent
-        assert tm.assert_attr_equal("na_value", obj, obj2)
+        tm.assert_attr_equal("na_value", obj, obj2)
     elif type(nulls_fixture) is type(nulls_fixture2):
         # e.g. Decimal("NaN")
-        assert tm.assert_attr_equal("na_value", obj, obj2)
+        tm.assert_attr_equal("na_value", obj, obj2)
     else:
         with pytest.raises(AssertionError, match='"na_value" are different'):
             tm.assert_attr_equal("na_value", obj, obj2)
diff --git a/pandas/tests/util/test_assert_extension_array_equal.py b/pandas/tests/util/test_assert_extension_array_equal.py
index 545f0dcbf695f..dec10e5b76894 100644
--- a/pandas/tests/util/test_assert_extension_array_equal.py
+++ b/pandas/tests/util/test_assert_extension_array_equal.py
@@ -35,7 +35,7 @@ def test_assert_extension_array_equal_not_exact(kwargs):
 
 @pytest.mark.parametrize("decimals", range(10))
 def test_assert_extension_array_equal_less_precise(decimals):
-    rtol = 0.5 * 10 ** -decimals
+    rtol = 0.5 * 10**-decimals
     arr1 = SparseArray([0.5, 0.123456])
     arr2 = SparseArray([0.5, 0.123457])
 
diff --git a/pandas/tests/util/test_assert_frame_equal.py b/pandas/tests/util/test_assert_frame_equal.py
index faea0a54dc330..48611c5cd0ed9 100644
--- a/pandas/tests/util/test_assert_frame_equal.py
+++ b/pandas/tests/util/test_assert_frame_equal.py
@@ -323,9 +323,45 @@ def test_frame_equal_mixed_dtypes(frame_or_series, any_numeric_ea_dtype, indexer
         tm.assert_equal(obj1, obj2, check_exact=True, check_dtype=False)
 
 
-def test_assert_series_equal_check_like_different_indexes():
+def test_assert_frame_equal_check_like_different_indexes():
     # GH#39739
     df1 = DataFrame(index=pd.Index([], dtype="object"))
     df2 = DataFrame(index=pd.RangeIndex(start=0, stop=0, step=1))
     with pytest.raises(AssertionError, match="DataFrame.index are different"):
         tm.assert_frame_equal(df1, df2, check_like=True)
+
+
+def test_assert_frame_equal_checking_allow_dups_flag():
+    # GH#45554
+    left = DataFrame([[1, 2], [3, 4]])
+    left.flags.allows_duplicate_labels = False
+
+    right = DataFrame([[1, 2], [3, 4]])
+    right.flags.allows_duplicate_labels = True
+    tm.assert_frame_equal(left, right, check_flags=False)
+
+    with pytest.raises(AssertionError, match="allows_duplicate_labels"):
+        tm.assert_frame_equal(left, right, check_flags=True)
+
+
+def test_assert_frame_equal_check_like_categorical_midx():
+    # GH#48975
+    left = DataFrame(
+        [[1], [2], [3]],
+        index=pd.MultiIndex.from_arrays(
+            [
+                pd.Categorical(["a", "b", "c"]),
+                pd.Categorical(["a", "b", "c"]),
+            ]
+        ),
+    )
+    right = DataFrame(
+        [[3], [2], [1]],
+        index=pd.MultiIndex.from_arrays(
+            [
+                pd.Categorical(["c", "b", "a"]),
+                pd.Categorical(["c", "b", "a"]),
+            ]
+        ),
+    )
+    tm.assert_frame_equal(left, right, check_like=True)
diff --git a/pandas/tests/util/test_assert_index_equal.py b/pandas/tests/util/test_assert_index_equal.py
index 8211b52fed650..8c7f364b03e53 100644
--- a/pandas/tests/util/test_assert_index_equal.py
+++ b/pandas/tests/util/test_assert_index_equal.py
@@ -2,6 +2,7 @@
 import pytest
 
 from pandas import (
+    NA,
     Categorical,
     CategoricalIndex,
     Index,
@@ -238,7 +239,41 @@ def test_index_equal_range_categories(check_categorical, exact):
         )
 
 
+def test_assert_index_equal_different_names_check_order_false():
+    # GH#47328
+    idx1 = Index([1, 3], name="a")
+    idx2 = Index([3, 1], name="b")
+    with pytest.raises(AssertionError, match='"names" are different'):
+        tm.assert_index_equal(idx1, idx2, check_order=False, check_names=True)
+
+
 def test_assert_index_equal_mixed_dtype():
     # GH#39168
     idx = Index(["foo", "bar", 42])
     tm.assert_index_equal(idx, idx, check_order=False)
+
+
+def test_assert_index_equal_ea_dtype_order_false(any_numeric_ea_dtype):
+    # GH#47207
+    idx1 = Index([1, 3], dtype=any_numeric_ea_dtype)
+    idx2 = Index([3, 1], dtype=any_numeric_ea_dtype)
+    tm.assert_index_equal(idx1, idx2, check_order=False)
+
+
+def test_assert_index_equal_object_ints_order_false():
+    # GH#47207
+    idx1 = Index([1, 3], dtype="object")
+    idx2 = Index([3, 1], dtype="object")
+    tm.assert_index_equal(idx1, idx2, check_order=False)
+
+
+@pytest.mark.parametrize("check_categorical", [True, False])
+@pytest.mark.parametrize("check_names", [True, False])
+def test_assert_ea_index_equal_non_matching_na(check_names, check_categorical):
+    # GH#48608
+    idx1 = Index([1, 2], dtype="Int64")
+    idx2 = Index([1, NA], dtype="Int64")
+    with pytest.raises(AssertionError, match="50.0 %"):
+        tm.assert_index_equal(
+            idx1, idx2, check_names=check_names, check_categorical=check_categorical
+        )
diff --git a/pandas/tests/util/test_assert_produces_warning.py b/pandas/tests/util/test_assert_produces_warning.py
index e3eb083e1a383..70a95bd7cdb48 100644
--- a/pandas/tests/util/test_assert_produces_warning.py
+++ b/pandas/tests/util/test_assert_produces_warning.py
@@ -179,6 +179,14 @@ def test_same_category_different_messages_last_match():
         warnings.warn("Match this", category)
 
 
+def test_match_multiple_warnings():
+    # https://github.com/pandas-dev/pandas/issues/47829
+    category = (FutureWarning, UserWarning)
+    with tm.assert_produces_warning(category, match=r"^Match this"):
+        warnings.warn("Match this", FutureWarning)
+        warnings.warn("Match this too", UserWarning)
+
+
 def test_right_category_wrong_match_raises(pair_different_warnings):
     target_category, other_category = pair_different_warnings
     with pytest.raises(AssertionError, match="Did not see warning.*matching"):
diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index 150e7e8f3d738..25f5b31eb4664 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 
 from pandas.core.dtypes.common import is_extension_array_dtype
@@ -110,7 +111,7 @@ def test_series_not_equal_metadata_mismatch(kwargs):
 @pytest.mark.parametrize("dtype", ["float32", "float64", "Float32"])
 @pytest.mark.parametrize("decimals", [0, 1, 2, 3, 5, 10])
 def test_less_precise(data1, data2, dtype, decimals):
-    rtol = 10 ** -decimals
+    rtol = 10**-decimals
     s1 = Series([data1], dtype=dtype)
     s2 = Series([data2], dtype=dtype)
 
@@ -158,6 +159,39 @@ def test_series_equal_index_dtype(s1, s2, msg, check_index_type):
         tm.assert_series_equal(s1, s2, **kwargs)
 
 
+@pytest.mark.parametrize("check_like", [True, False])
+def test_series_equal_order_mismatch(check_like):
+    s1 = Series([1, 2, 3], index=["a", "b", "c"])
+    s2 = Series([3, 2, 1], index=["c", "b", "a"])
+
+    if not check_like:  # Do not ignore index ordering.
+        with pytest.raises(AssertionError, match="Series.index are different"):
+            tm.assert_series_equal(s1, s2, check_like=check_like)
+    else:
+        _assert_series_equal_both(s1, s2, check_like=check_like)
+
+
+@pytest.mark.parametrize("check_index", [True, False])
+def test_series_equal_index_mismatch(check_index):
+    s1 = Series([1, 2, 3], index=["a", "b", "c"])
+    s2 = Series([1, 2, 3], index=["c", "b", "a"])
+
+    if check_index:  # Do not ignore index.
+        with pytest.raises(AssertionError, match="Series.index are different"):
+            tm.assert_series_equal(s1, s2, check_index=check_index)
+    else:
+        _assert_series_equal_both(s1, s2, check_index=check_index)
+
+
+def test_series_invalid_param_combination():
+    left = Series(dtype=object)
+    right = Series(dtype=object)
+    with pytest.raises(
+        ValueError, match="check_like must be False if check_index is False"
+    ):
+        tm.assert_series_equal(left, right, check_index=False, check_like=True)
+
+
 def test_series_equal_length_mismatch(rtol):
     msg = """Series are different
 
@@ -351,3 +385,29 @@ def test_assert_series_equal_identical_na(nulls_fixture):
     # while we're here do Index too
     idx = pd.Index(ser)
     tm.assert_index_equal(idx, idx.copy(deep=True))
+
+
+def test_identical_nested_series_is_equal():
+    # GH#22400
+    x = Series(
+        [
+            0,
+            0.0131142231938,
+            1.77774652865e-05,
+            np.array([0.4722720840328748, 0.4216929783681722]),
+        ]
+    )
+    y = Series(
+        [
+            0,
+            0.0131142231938,
+            1.77774652865e-05,
+            np.array([0.4722720840328748, 0.4216929783681722]),
+        ]
+    )
+    # These two arrays should be equal, nesting could cause issue
+
+    tm.assert_series_equal(x, x)
+    tm.assert_series_equal(x, x, check_exact=True)
+    tm.assert_series_equal(x, y)
+    tm.assert_series_equal(x, y, check_exact=True)
diff --git a/pandas/tests/util/test_deprecate_nonkeyword_arguments.py b/pandas/tests/util/test_deprecate_nonkeyword_arguments.py
index c03639811d9d5..f6501fa8315e4 100644
--- a/pandas/tests/util/test_deprecate_nonkeyword_arguments.py
+++ b/pandas/tests/util/test_deprecate_nonkeyword_arguments.py
@@ -2,6 +2,7 @@
 Tests for the `deprecate_nonkeyword_arguments` decorator
 """
 
+import inspect
 import warnings
 
 from pandas.util._decorators import deprecate_nonkeyword_arguments
@@ -9,11 +10,17 @@
 import pandas._testing as tm
 
 
-@deprecate_nonkeyword_arguments(version="1.1", allowed_args=["a", "b"])
+@deprecate_nonkeyword_arguments(
+    version="1.1", allowed_args=["a", "b"], name="f_add_inputs"
+)
 def f(a, b=0, c=0, d=0):
     return a + b + c + d
 
 
+def test_f_signature():
+    assert str(inspect.signature(f)) == "(a, b=0, *, c=0, d=0)"
+
+
 def test_one_argument():
     with tm.assert_produces_warning(None):
         assert f(19) == 19
@@ -44,12 +51,29 @@ def test_four_arguments():
         assert f(1, 2, 3, 4) == 10
 
 
+def test_three_arguments_with_name_in_warning():
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        assert f(6, 3, 3) == 12
+        assert len(w) == 1
+        for actual_warning in w:
+            assert actual_warning.category == FutureWarning
+            assert str(actual_warning.message) == (
+                "Starting with pandas version 1.1 all arguments of f_add_inputs "
+                "except for the arguments 'a' and 'b' will be keyword-only."
+            )
+
+
 @deprecate_nonkeyword_arguments(version="1.1")
 def g(a, b=0, c=0, d=0):
     with tm.assert_produces_warning(None):
         return a + b + c + d
 
 
+def test_g_signature():
+    assert str(inspect.signature(g)) == "(a, *, b=0, c=0, d=0)"
+
+
 def test_one_and_three_arguments_default_allowed_args():
     with tm.assert_produces_warning(None):
         assert g(1, b=3, c=3, d=5) == 12
@@ -78,6 +102,10 @@ def h(a=0, b=0, c=0, d=0):
     return a + b + c + d
 
 
+def test_h_signature():
+    assert str(inspect.signature(h)) == "(*, a=0, b=0, c=0, d=0)"
+
+
 def test_all_keyword_arguments():
     with tm.assert_produces_warning(None):
         assert h(a=1, b=2) == 3
@@ -101,12 +129,25 @@ def test_one_positional_argument_with_warning_message_analysis():
             )
 
 
+@deprecate_nonkeyword_arguments(version="1.1")
+def i(a=0, /, b=0, *, c=0, d=0):
+    return a + b + c + d
+
+
+def test_i_signature():
+    assert str(inspect.signature(i)) == "(*, a=0, b=0, c=0, d=0)"
+
+
 class Foo:
     @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "bar"])
     def baz(self, bar=None, foobar=None):
         ...
 
 
+def test_foo_signature():
+    assert str(inspect.signature(Foo.baz)) == "(self, bar=None, *, foobar=None)"
+
+
 def test_class():
     msg = (
         r"In a future version of pandas all arguments of Foo\.baz "
diff --git a/pandas/tests/util/test_hashing.py b/pandas/tests/util/test_hashing.py
index 6eee756f67a2e..c2977b81a9b4a 100644
--- a/pandas/tests/util/test_hashing.py
+++ b/pandas/tests/util/test_hashing.py
@@ -71,6 +71,15 @@ def test_hash_array_errors(val):
         hash_array(val)
 
 
+def test_hash_array_index_exception():
+    # GH42003 TypeError instead of AttributeError
+    obj = pd.DatetimeIndex(["2018-10-28 01:20:00"], tz="Europe/Berlin")
+
+    msg = "Use hash_pandas_object instead"
+    with pytest.raises(TypeError, match=msg):
+        hash_array(obj)
+
+
 def test_hash_tuples():
     tuples = [(1, "one"), (1, "two"), (2, "one")]
     result = hash_tuples(tuples)
diff --git a/pandas/tests/util/test_make_objects.py b/pandas/tests/util/test_make_objects.py
new file mode 100644
index 0000000000000..6f5f2d3924e1f
--- /dev/null
+++ b/pandas/tests/util/test_make_objects.py
@@ -0,0 +1,15 @@
+"""
+Tests for tm.makeFoo functions.
+"""
+
+
+import numpy as np
+
+import pandas._testing as tm
+
+
+def test_make_multiindex_respects_k():
+    # GH#38795 respect 'k' arg
+    N = np.random.randint(0, 100)
+    mi = tm.makeMultiIndex(k=N)
+    assert len(mi) == N
diff --git a/pandas/tests/util/test_rewrite_warning.py b/pandas/tests/util/test_rewrite_warning.py
new file mode 100644
index 0000000000000..f847a06d8ea8d
--- /dev/null
+++ b/pandas/tests/util/test_rewrite_warning.py
@@ -0,0 +1,39 @@
+import warnings
+
+import pytest
+
+from pandas.util._exceptions import rewrite_warning
+
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "target_category, target_message, hit",
+    [
+        (FutureWarning, "Target message", True),
+        (FutureWarning, "Target", True),
+        (FutureWarning, "get mess", True),
+        (FutureWarning, "Missed message", False),
+        (DeprecationWarning, "Target message", False),
+    ],
+)
+@pytest.mark.parametrize(
+    "new_category",
+    [
+        None,
+        DeprecationWarning,
+    ],
+)
+def test_rewrite_warning(target_category, target_message, hit, new_category):
+    new_message = "Rewritten message"
+    if hit:
+        expected_category = new_category if new_category else target_category
+        expected_message = new_message
+    else:
+        expected_category = FutureWarning
+        expected_message = "Target message"
+    with tm.assert_produces_warning(expected_category, match=expected_message):
+        with rewrite_warning(
+            target_message, target_category, new_message, new_category
+        ):
+            warnings.warn(message="Target message", category=FutureWarning)
diff --git a/pandas/tests/util/test_show_versions.py b/pandas/tests/util/test_show_versions.py
index 7a1363099e7a0..99c7e0a1a8956 100644
--- a/pandas/tests/util/test_show_versions.py
+++ b/pandas/tests/util/test_show_versions.py
@@ -32,6 +32,7 @@
     # https://github.com/pandas-dev/pandas/issues/35252
     "ignore:Distutils:UserWarning"
 )
+@pytest.mark.filterwarnings("ignore:Setuptools is replacing distutils:UserWarning")
 def test_show_versions(tmpdir):
     # GH39701
     as_json = os.path.join(tmpdir, "test_output.json")
@@ -82,7 +83,9 @@ def test_show_versions_console(capsys):
 
     # check required dependency
     # 2020-12-09 npdev has "dirty" in the tag
-    assert re.search(r"numpy\s*:\s([0-9\.\+a-g\_]|dev)+(dirty)?\n", result)
+    # 2022-05-25 npdev released with RC wo/ "dirty".
+    # Just ensure we match [0-9]+\..* since npdev version is variable
+    assert re.search(r"numpy\s*:\s[0-9]+\..*\n", result)
 
     # check optional dependency
     assert re.search(r"pyarrow\s*:\s([0-9\.]+|None)\n", result)
diff --git a/pandas/tests/util/test_validate_args.py b/pandas/tests/util/test_validate_args.py
index db532480efe07..77e6b01ba1180 100644
--- a/pandas/tests/util/test_validate_args.py
+++ b/pandas/tests/util/test_validate_args.py
@@ -20,8 +20,8 @@ def test_bad_arg_length_max_value_single():
     max_length = len(compat_args) + min_fname_arg_count
     actual_length = len(args) + min_fname_arg_count
     msg = (
-        fr"{_fname}\(\) takes at most {max_length} "
-        fr"argument \({actual_length} given\)"
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"argument \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -36,8 +36,8 @@ def test_bad_arg_length_max_value_multiple():
     max_length = len(compat_args) + min_fname_arg_count
     actual_length = len(args) + min_fname_arg_count
     msg = (
-        fr"{_fname}\(\) takes at most {max_length} "
-        fr"arguments \({actual_length} given\)"
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"arguments \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -49,7 +49,7 @@ def test_not_all_defaults(i):
     bad_arg = "foo"
     msg = (
         f"the '{bad_arg}' parameter is not supported "
-        fr"in the pandas implementation of {_fname}\(\)"
+        rf"in the pandas implementation of {_fname}\(\)"
     )
 
     compat_args = {"foo": 2, "bar": -1, "baz": 3}
diff --git a/pandas/tests/util/test_validate_args_and_kwargs.py b/pandas/tests/util/test_validate_args_and_kwargs.py
index 941ba86c61319..54d94d2194909 100644
--- a/pandas/tests/util/test_validate_args_and_kwargs.py
+++ b/pandas/tests/util/test_validate_args_and_kwargs.py
@@ -15,8 +15,8 @@ def test_invalid_total_length_max_length_one():
     actual_length = len(kwargs) + len(args) + min_fname_arg_count
 
     msg = (
-        fr"{_fname}\(\) takes at most {max_length} "
-        fr"argument \({actual_length} given\)"
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"argument \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -33,8 +33,8 @@ def test_invalid_total_length_max_length_multiple():
     actual_length = len(kwargs) + len(args) + min_fname_arg_count
 
     msg = (
-        fr"{_fname}\(\) takes at most {max_length} "
-        fr"arguments \({actual_length} given\)"
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"arguments \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -49,8 +49,8 @@ def test_missing_args_or_kwargs(args, kwargs):
     compat_args = {"foo": -5, bad_arg: 1}
 
     msg = (
-        fr"the '{bad_arg}' parameter is not supported "
-        fr"in the pandas implementation of {_fname}\(\)"
+        rf"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
     )
 
     with pytest.raises(ValueError, match=msg):
@@ -64,7 +64,7 @@ def test_duplicate_argument():
     kwargs = {"foo": None, "bar": None}
     args = (None,)  # duplicate value for "foo"
 
-    msg = fr"{_fname}\(\) got multiple values for keyword argument 'foo'"
+    msg = rf"{_fname}\(\) got multiple values for keyword argument 'foo'"
 
     with pytest.raises(TypeError, match=msg):
         validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
diff --git a/pandas/tests/util/test_validate_kwargs.py b/pandas/tests/util/test_validate_kwargs.py
index 0e271ef42ca93..de49cdd5e247d 100644
--- a/pandas/tests/util/test_validate_kwargs.py
+++ b/pandas/tests/util/test_validate_kwargs.py
@@ -15,7 +15,7 @@ def test_bad_kwarg():
     compat_args = {good_arg: "foo", bad_arg + "o": "bar"}
     kwargs = {good_arg: "foo", bad_arg: "bar"}
 
-    msg = fr"{_fname}\(\) got an unexpected keyword argument '{bad_arg}'"
+    msg = rf"{_fname}\(\) got an unexpected keyword argument '{bad_arg}'"
 
     with pytest.raises(TypeError, match=msg):
         validate_kwargs(_fname, kwargs, compat_args)
@@ -25,8 +25,8 @@ def test_bad_kwarg():
 def test_not_all_none(i):
     bad_arg = "foo"
     msg = (
-        fr"the '{bad_arg}' parameter is not supported "
-        fr"in the pandas implementation of {_fname}\(\)"
+        rf"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
     )
 
     compat_args = {"foo": 1, "bar": "s", "baz": None}
diff --git a/pandas/tests/window/conftest.py b/pandas/tests/window/conftest.py
index 09233e3f31c89..d05bb3d51bcde 100644
--- a/pandas/tests/window/conftest.py
+++ b/pandas/tests/window/conftest.py
@@ -12,7 +12,6 @@
     DataFrame,
     Series,
     bdate_range,
-    to_datetime,
 )
 
 
@@ -22,27 +21,6 @@ def raw(request):
     return request.param
 
 
-@pytest.fixture(
-    params=[
-        "triang",
-        "blackman",
-        "hamming",
-        "bartlett",
-        "bohman",
-        "blackmanharris",
-        "nuttall",
-        "barthann",
-    ]
-)
-def win_types(request):
-    return request.param
-
-
-@pytest.fixture(params=["kaiser", "gaussian", "general_gaussian", "exponential"])
-def win_types_special(request):
-    return request.param
-
-
 @pytest.fixture(
     params=[
         "sum",
@@ -62,28 +40,6 @@ def arithmetic_win_operators(request):
     return request.param
 
 
-@pytest.fixture(
-    params=[
-        ["sum", {}],
-        ["mean", {}],
-        ["median", {}],
-        ["max", {}],
-        ["min", {}],
-        ["var", {}],
-        ["var", {"ddof": 0}],
-        ["std", {}],
-        ["std", {"ddof": 0}],
-    ]
-)
-def arithmetic_numba_supported_operators(request):
-    return request.param
-
-
-@pytest.fixture(params=["right", "left", "both", "neither"])
-def closed(request):
-    return request.param
-
-
 @pytest.fixture(params=[True, False])
 def center(request):
     return request.param
@@ -94,12 +50,6 @@ def min_periods(request):
     return request.param
 
 
-@pytest.fixture(params=["single", "table"])
-def method(request):
-    """method keyword in rolling/expanding/ewm constructor"""
-    return request.param
-
-
 @pytest.fixture(params=[True, False])
 def parallel(request):
     """parallel keyword argument for numba.jit"""
@@ -134,6 +84,12 @@ def ignore_na(request):
     return request.param
 
 
+@pytest.fixture(params=[True, False])
+def numeric_only(request):
+    """numeric_only keyword argument"""
+    return request.param
+
+
 @pytest.fixture(params=[pytest.param("numba", marks=td.skip_if_no("numba")), "cython"])
 def engine(request):
     """engine keyword argument for rolling.apply"""
@@ -152,95 +108,12 @@ def engine_and_raw(request):
     return request.param
 
 
-@pytest.fixture
-def times_frame():
-    """Frame for testing times argument in EWM groupby."""
-    return DataFrame(
-        {
-            "A": ["a", "b", "c", "a", "b", "c", "a", "b", "c", "a"],
-            "B": [0, 0, 0, 1, 1, 1, 2, 2, 2, 3],
-            "C": to_datetime(
-                [
-                    "2020-01-01",
-                    "2020-01-01",
-                    "2020-01-01",
-                    "2020-01-02",
-                    "2020-01-10",
-                    "2020-01-22",
-                    "2020-01-03",
-                    "2020-01-23",
-                    "2020-01-23",
-                    "2020-01-04",
-                ]
-            ),
-        }
-    )
-
-
-@pytest.fixture(params=["1 day", timedelta(days=1)])
+@pytest.fixture(params=["1 day", timedelta(days=1), np.timedelta64(1, "D")])
 def halflife_with_times(request):
     """Halflife argument for EWM when times is specified."""
     return request.param
 
 
-@pytest.fixture(
-    params=[
-        "object",
-        "category",
-        "int8",
-        "int16",
-        "int32",
-        "int64",
-        "uint8",
-        "uint16",
-        "uint32",
-        "uint64",
-        "float16",
-        "float32",
-        "float64",
-        "m8[ns]",
-        "M8[ns]",
-        "datetime64[ns, UTC]",
-    ]
-)
-def dtypes(request):
-    """Dtypes for window tests"""
-    return request.param
-
-
-@pytest.fixture(
-    params=[
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 1]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", "C"]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1.0, 0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0.0, 1]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", 1]),
-        DataFrame([[2.0, 4.0], [1.0, 2.0], [5.0, 2.0], [8.0, 1.0]], columns=[1, 0.0]),
-        DataFrame([[2, 4.0], [1, 2.0], [5, 2.0], [8, 1.0]], columns=[0, 1.0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1.0]], columns=[1.0, "X"]),
-    ]
-)
-def pairwise_frames(request):
-    """Pairwise frames test_pairwise"""
-    return request.param
-
-
-@pytest.fixture
-def pairwise_target_frame():
-    """Pairwise target frame for test_pairwise"""
-    return DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0, 1])
-
-
-@pytest.fixture
-def pairwise_other_frame():
-    """Pairwise other frame for test_pairwise"""
-    return DataFrame(
-        [[None, 1, 1], [None, 1, 2], [None, 3, 2], [None, 8, 1]],
-        columns=["Y", "Z", "X"],
-    )
-
-
 @pytest.fixture
 def series():
     """Make mocked series as fixture."""
@@ -259,3 +132,9 @@ def frame():
         index=bdate_range(datetime(2009, 1, 1), periods=100),
         columns=np.arange(10),
     )
+
+
+@pytest.fixture(params=[None, 1, 2, 5, 10])
+def step(request):
+    """step keyword argument for rolling window operations."""
+    return request.param
diff --git a/pandas/tests/window/moments/conftest.py b/pandas/tests/window/moments/conftest.py
index 8f7c20fe03a02..fccf80c3c7a58 100644
--- a/pandas/tests/window/moments/conftest.py
+++ b/pandas/tests/window/moments/conftest.py
@@ -41,7 +41,6 @@ def is_constant(x):
         for obj in itertools.chain(create_series(), create_dataframes())
         if is_constant(obj)
     ),
-    scope="module",
 )
 def consistent_data(request):
     return request.param
@@ -68,12 +67,6 @@ def all_data(request):
     return request.param
 
 
-@pytest.fixture(params=[(1, 0), (5, 1)])
-def rolling_consistency_cases(request):
-    """window, min_periods"""
-    return request.param
-
-
 @pytest.fixture(params=[0, 2])
 def min_periods(request):
     return request.param
diff --git a/pandas/tests/window/moments/test_moments_consistency_ewm.py b/pandas/tests/window/moments/test_moments_consistency_ewm.py
index f9f09bffb14b1..aaa1010a4798b 100644
--- a/pandas/tests/window/moments/test_moments_consistency_ewm.py
+++ b/pandas/tests/window/moments/test_moments_consistency_ewm.py
@@ -220,9 +220,10 @@ def test_ewm_consistency_series_cov_corr(
 
     # check that corr(x, y) == cov(x, y) / (std(x) *
     # std(y))
-    corr_x_y = series_data.ewm(
-        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-    ).corr(series_data, bias=bias)
+    with tm.assert_produces_warning(FutureWarning, match="Passing additional kwargs"):
+        corr_x_y = series_data.ewm(
+            com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+        ).corr(series_data, bias=bias)
     std_x = series_data.ewm(
         com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
     ).std(bias=bias)
diff --git a/pandas/tests/window/moments/test_moments_consistency_rolling.py b/pandas/tests/window/moments/test_moments_consistency_rolling.py
index daca19b0993bf..62bfc66b124f3 100644
--- a/pandas/tests/window/moments/test_moments_consistency_rolling.py
+++ b/pandas/tests/window/moments/test_moments_consistency_rolling.py
@@ -13,6 +13,12 @@ def all_na(x):
     return x.isnull().all().all()
 
 
+@pytest.fixture(params=[(1, 0), (5, 1)])
+def rolling_consistency_cases(request):
+    """window, min_periods"""
+    return request.param
+
+
 @pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum, np.sum])
 def test_rolling_apply_consistency_sum(
     request, all_data, rolling_consistency_cases, center, f
diff --git a/pandas/tests/window/test_api.py b/pandas/tests/window/test_api.py
index f84a579247630..6495f7411938c 100644
--- a/pandas/tests/window/test_api.py
+++ b/pandas/tests/window/test_api.py
@@ -1,6 +1,11 @@
 import numpy as np
 import pytest
 
+from pandas.errors import (
+    SpecificationError,
+    UnsupportedFunctionCall,
+)
+
 from pandas import (
     DataFrame,
     Index,
@@ -13,23 +18,22 @@
     timedelta_range,
 )
 import pandas._testing as tm
-from pandas.core.base import SpecificationError
 
 
-def test_getitem():
+def test_getitem(step):
     frame = DataFrame(np.random.randn(5, 5))
-    r = frame.rolling(window=5)
-    tm.assert_index_equal(r._selected_obj.columns, frame.columns)
+    r = frame.rolling(window=5, step=step)
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns)
 
-    r = frame.rolling(window=5)[1]
-    assert r._selected_obj.name == frame.columns[1]
+    r = frame.rolling(window=5, step=step)[1]
+    assert r._selected_obj.name == frame[::step].columns[1]
 
     # technically this is allowed
-    r = frame.rolling(window=5)[1, 3]
-    tm.assert_index_equal(r._selected_obj.columns, frame.columns[[1, 3]])
+    r = frame.rolling(window=5, step=step)[1, 3]
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns[[1, 3]])
 
-    r = frame.rolling(window=5)[[1, 3]]
-    tm.assert_index_equal(r._selected_obj.columns, frame.columns[[1, 3]])
+    r = frame.rolling(window=5, step=step)[[1, 3]]
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns[[1, 3]])
 
 
 def test_select_bad_cols():
@@ -53,21 +57,21 @@ def test_attribute_access():
         r.F
 
 
-def tests_skip_nuisance():
+def tests_skip_nuisance(step):
 
     df = DataFrame({"A": range(5), "B": range(5, 10), "C": "foo"})
-    r = df.rolling(window=3)
+    r = df.rolling(window=3, step=step)
     result = r[["A", "B"]].sum()
     expected = DataFrame(
         {"A": [np.nan, np.nan, 3, 6, 9], "B": [np.nan, np.nan, 18, 21, 24]},
         columns=list("AB"),
-    )
+    )[::step]
     tm.assert_frame_equal(result, expected)
 
 
-def test_skip_sum_object_raises():
+def test_skip_sum_object_raises(step):
     df = DataFrame({"A": range(5), "B": range(5, 10), "C": "foo"})
-    r = df.rolling(window=3)
+    r = df.rolling(window=3, step=step)
     msg = r"nuisance columns.*Dropped columns were Index\(\['C'\], dtype='object'\)"
     with tm.assert_produces_warning(FutureWarning, match=msg):
         # GH#42738
@@ -75,14 +79,14 @@ def test_skip_sum_object_raises():
     expected = DataFrame(
         {"A": [np.nan, np.nan, 3, 6, 9], "B": [np.nan, np.nan, 18, 21, 24]},
         columns=list("AB"),
-    )
+    )[::step]
     tm.assert_frame_equal(result, expected)
 
 
-def test_agg():
+def test_agg(step):
     df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
 
-    r = df.rolling(window=3)
+    r = df.rolling(window=3, step=step)
     a_mean = r["A"].mean()
     a_std = r["A"].std()
     a_sum = r["A"].sum()
@@ -127,6 +131,17 @@ def test_agg():
     tm.assert_frame_equal(result, expected, check_like=True)
 
 
+@pytest.mark.parametrize(
+    "func", [["min"], ["mean", "max"], {"b": "sum"}, {"b": "prod", "c": "median"}]
+)
+def test_multi_axis_1_raises(func):
+    # GH#46904
+    df = DataFrame({"a": [1, 1, 2], "b": [3, 4, 5], "c": [6, 7, 8]})
+    r = df.rolling(window=3, axis=1)
+    with pytest.raises(NotImplementedError, match="axis other than 0 is not supported"):
+        r.agg(func)
+
+
 def test_agg_apply(raw):
 
     # passed lambda
@@ -141,10 +156,10 @@ def test_agg_apply(raw):
     tm.assert_frame_equal(result, expected, check_like=True)
 
 
-def test_agg_consistency():
+def test_agg_consistency(step):
 
     df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
-    r = df.rolling(window=3)
+    r = df.rolling(window=3, step=step)
 
     result = r.agg([np.sum, np.mean]).columns
     expected = MultiIndex.from_product([list("AB"), ["sum", "mean"]])
@@ -182,7 +197,7 @@ def test_agg_nested_dicts():
         r.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
 
 
-def test_count_nonnumeric_types():
+def test_count_nonnumeric_types(step):
     # GH12541
     cols = [
         "int",
@@ -239,13 +254,13 @@ def test_count_nonnumeric_types():
             "periods_nat": [1.0, 2.0, 1.0],
         },
         columns=cols,
-    )
+    )[::step]
 
-    result = df.rolling(window=2, min_periods=0).count()
+    result = df.rolling(window=2, min_periods=0, step=step).count()
     tm.assert_frame_equal(result, expected)
 
-    result = df.rolling(1, min_periods=0).count()
-    expected = df.notna().astype(float)
+    result = df.rolling(1, min_periods=0, step=step).count()
+    expected = df.notna().astype(float)[::step]
     tm.assert_frame_equal(result, expected)
 
 
@@ -339,11 +354,11 @@ def test_validate_deprecated():
 
 @pytest.mark.filterwarnings("ignore:min_periods:FutureWarning")
 def test_dont_modify_attributes_after_methods(
-    arithmetic_win_operators, closed, center, min_periods
+    arithmetic_win_operators, closed, center, min_periods, step
 ):
     # GH 39554
     roll_obj = Series(range(1)).rolling(
-        1, center=center, closed=closed, min_periods=min_periods
+        1, center=center, closed=closed, min_periods=min_periods, step=step
     )
     expected = {attr: getattr(roll_obj, attr) for attr in roll_obj._attributes}
     getattr(roll_obj, arithmetic_win_operators)()
@@ -351,40 +366,124 @@ def test_dont_modify_attributes_after_methods(
     assert result == expected
 
 
-def test_centered_axis_validation():
+def test_centered_axis_validation(step):
 
     # ok
-    Series(np.ones(10)).rolling(window=3, center=True, axis=0).mean()
+    Series(np.ones(10)).rolling(window=3, center=True, axis=0, step=step).mean()
 
     # bad axis
     msg = "No axis named 1 for object type Series"
     with pytest.raises(ValueError, match=msg):
-        Series(np.ones(10)).rolling(window=3, center=True, axis=1).mean()
+        Series(np.ones(10)).rolling(window=3, center=True, axis=1, step=step).mean()
 
     # ok ok
-    DataFrame(np.ones((10, 10))).rolling(window=3, center=True, axis=0).mean()
-    DataFrame(np.ones((10, 10))).rolling(window=3, center=True, axis=1).mean()
+    DataFrame(np.ones((10, 10))).rolling(
+        window=3, center=True, axis=0, step=step
+    ).mean()
+    DataFrame(np.ones((10, 10))).rolling(
+        window=3, center=True, axis=1, step=step
+    ).mean()
 
     # bad axis
     msg = "No axis named 2 for object type DataFrame"
     with pytest.raises(ValueError, match=msg):
-        (DataFrame(np.ones((10, 10))).rolling(window=3, center=True, axis=2).mean())
+        (
+            DataFrame(np.ones((10, 10)))
+            .rolling(window=3, center=True, axis=2, step=step)
+            .mean()
+        )
 
 
-def test_rolling_min_min_periods():
+def test_rolling_min_min_periods(step):
     a = Series([1, 2, 3, 4, 5])
-    result = a.rolling(window=100, min_periods=1).min()
-    expected = Series(np.ones(len(a)))
+    result = a.rolling(window=100, min_periods=1, step=step).min()
+    expected = Series(np.ones(len(a)))[::step]
     tm.assert_series_equal(result, expected)
     msg = "min_periods 5 must be <= window 3"
     with pytest.raises(ValueError, match=msg):
-        Series([1, 2, 3]).rolling(window=3, min_periods=5).min()
+        Series([1, 2, 3]).rolling(window=3, min_periods=5, step=step).min()
 
 
-def test_rolling_max_min_periods():
+def test_rolling_max_min_periods(step):
     a = Series([1, 2, 3, 4, 5], dtype=np.float64)
-    b = a.rolling(window=100, min_periods=1).max()
-    tm.assert_almost_equal(a, b)
+    result = a.rolling(window=100, min_periods=1, step=step).max()
+    expected = a[::step]
+    tm.assert_almost_equal(result, expected)
     msg = "min_periods 5 must be <= window 3"
     with pytest.raises(ValueError, match=msg):
-        Series([1, 2, 3]).rolling(window=3, min_periods=5).max()
+        Series([1, 2, 3]).rolling(window=3, min_periods=5, step=step).max()
+
+
+@pytest.mark.parametrize(
+    "roll_type, class_name",
+    [
+        ("rolling", "Rolling"),
+        ("expanding", "Expanding"),
+        ("ewm", "ExponentialMovingWindow"),
+    ],
+)
+@pytest.mark.parametrize(
+    "kernel, has_args, raises",
+    [
+        ("sum", True, True),
+        ("max", True, True),
+        ("min", True, True),
+        ("mean", True, True),
+        ("median", False, False),
+        ("std", True, True),
+        ("var", True, True),
+        ("skew", False, False),
+        ("sem", True, True),
+        ("kurt", False, False),
+        ("quantile", False, False),
+        ("rank", False, False),
+        ("cov", False, False),
+        ("corr", False, False),
+    ],
+)
+def test_args_kwargs_depr(roll_type, class_name, kernel, has_args, raises):
+    # GH#47836
+    r = getattr(Series([2, 4, 6]), roll_type)(2)
+    error_msg = "numpy operations are not valid with window objects"
+    if kernel == "quantile":
+        required_args = (0.5,)
+    else:
+        required_args = ()
+
+    if roll_type == "ewm" and kernel not in (
+        "sum",
+        "mean",
+        "std",
+        "var",
+        "cov",
+        "corr",
+    ):
+        # kernels not implemented for ewm
+        with pytest.raises(AttributeError, match=f"has no attribute '{kernel}'"):
+            getattr(r, kernel)
+    else:
+        warn_msg = f"Passing additional kwargs to {class_name}.{kernel}"
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            if raises:
+                with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+                    getattr(r, kernel)(*required_args, dtype=np.float64)
+            else:
+                getattr(r, kernel)(*required_args, dtype=np.float64)
+
+        if has_args:
+            warn_msg = f"Passing additional args to {class_name}.{kernel}"
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                # sem raises for rolling but not expanding
+                if raises and (roll_type != "expanding" or kernel != "sem"):
+                    with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+                        getattr(r, kernel)(*required_args, 1, 2, 3, 4)
+                else:
+                    getattr(r, kernel)(*required_args, 1, 2, 3, 4)
+
+            warn_msg = f"Passing additional args and kwargs to {class_name}.{kernel}"
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                if raises:
+                    with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+                        getattr(r, kernel)(*required_args, 1, 2, 3, 4, dtype=np.float64)
+                else:
+                    getattr(r, kernel)(*required_args, 1, 2, 3, 4, dtype=np.float64)
diff --git a/pandas/tests/window/test_apply.py b/pandas/tests/window/test_apply.py
index 886ed676dabb2..12f9cb27e8cbe 100644
--- a/pandas/tests/window/test_apply.py
+++ b/pandas/tests/window/test_apply.py
@@ -74,20 +74,24 @@ def f(x):
         df.rolling(window).apply(f, raw=True)
 
 
-def test_rolling_apply(engine_and_raw):
+def test_rolling_apply(engine_and_raw, step):
     engine, raw = engine_and_raw
 
     expected = Series([], dtype="float64")
-    result = expected.rolling(10).apply(lambda x: x.mean(), engine=engine, raw=raw)
+    result = expected.rolling(10, step=step).apply(
+        lambda x: x.mean(), engine=engine, raw=raw
+    )
     tm.assert_series_equal(result, expected)
 
     # gh-8080
     s = Series([None, None, None])
-    result = s.rolling(2, min_periods=0).apply(lambda x: len(x), engine=engine, raw=raw)
-    expected = Series([1.0, 2.0, 2.0])
+    result = s.rolling(2, min_periods=0, step=step).apply(
+        lambda x: len(x), engine=engine, raw=raw
+    )
+    expected = Series([1.0, 2.0, 2.0])[::step]
     tm.assert_series_equal(result, expected)
 
-    result = s.rolling(2, min_periods=0).apply(len, engine=engine, raw=raw)
+    result = s.rolling(2, min_periods=0, step=step).apply(len, engine=engine, raw=raw)
     tm.assert_series_equal(result, expected)
 
 
@@ -214,7 +218,8 @@ def test_center(raw):
     expected = (
         concat([obj, Series([np.NaN] * 9)])
         .rolling(20, min_periods=15)
-        .apply(f, raw=raw)[9:]
+        .apply(f, raw=raw)
+        .iloc[9:]
         .reset_index(drop=True)
     )
     tm.assert_series_equal(result, expected)
@@ -265,9 +270,13 @@ def test_time_rule_frame(raw, frame):
 
 
 @pytest.mark.parametrize("minp", [0, 99, 100])
-def test_min_periods(raw, series, minp):
-    result = series.rolling(len(series) + 1, min_periods=minp).apply(f, raw=raw)
-    expected = series.rolling(len(series), min_periods=minp).apply(f, raw=raw)
+def test_min_periods(raw, series, minp, step):
+    result = series.rolling(len(series) + 1, min_periods=minp, step=step).apply(
+        f, raw=raw
+    )
+    expected = series.rolling(len(series), min_periods=minp, step=step).apply(
+        f, raw=raw
+    )
     nan_mask = isna(result)
     tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -307,3 +316,11 @@ def test_center_reindex_frame(raw, frame):
     )
     frame_rs = frame.rolling(window=25, min_periods=minp, center=True).apply(f, raw=raw)
     tm.assert_frame_equal(frame_xp, frame_rs)
+
+
+def test_axis1(raw):
+    # GH 45912
+    df = DataFrame([1, 2])
+    result = df.rolling(window=1, axis=1).apply(np.sum, raw=raw)
+    expected = DataFrame([1.0, 2.0])
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/window/test_base_indexer.py b/pandas/tests/window/test_base_indexer.py
index 5593aa8351c69..eb5278c2b33ea 100644
--- a/pandas/tests/window/test_base_indexer.py
+++ b/pandas/tests/window/test_base_indexer.py
@@ -46,7 +46,7 @@ def test_indexer_constructor_arg():
     df = DataFrame({"values": range(5)})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -68,11 +68,17 @@ def test_indexer_accepts_rolling_args():
     df = DataFrame({"values": range(5)})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
-                if center and min_periods == 1 and closed == "both" and i == 2:
+                if (
+                    center
+                    and min_periods == 1
+                    and closed == "both"
+                    and step == 1
+                    and i == 2
+                ):
                     start[i] = 0
                     end[i] = num_values
                 else:
@@ -81,7 +87,9 @@ def get_window_bounds(self, num_values, min_periods, center, closed):
             return start, end
 
     indexer = CustomIndexer(window_size=1)
-    result = df.rolling(indexer, center=True, min_periods=1, closed="both").sum()
+    result = df.rolling(
+        indexer, center=True, min_periods=1, closed="both", step=1
+    ).sum()
     expected = DataFrame({"values": [0.0, 1.0, 10.0, 3.0, 4.0]})
     tm.assert_frame_equal(result, expected)
 
@@ -141,7 +149,7 @@ def get_window_bounds(self, num_values, min_periods, center, closed):
     ],
 )
 @pytest.mark.filterwarnings("ignore:min_periods:FutureWarning")
-def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs):
+def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs, step):
     # GH 32865
     values = np.arange(10.0)
     values[5] = 100.0
@@ -158,11 +166,11 @@ def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs)
         rolling = constructor(values).rolling(window=indexer, closed="right")
         getattr(rolling, func)()
 
-    rolling = constructor(values).rolling(window=indexer, min_periods=2)
+    rolling = constructor(values).rolling(window=indexer, min_periods=2, step=step)
     result = getattr(rolling, func)()
 
     # Check that the function output matches the explicitly provided array
-    expected = constructor(expected)
+    expected = constructor(expected)[::step]
     tm.assert_equal(result, expected)
 
     # Check that the rolling function output matches applying an alternative
@@ -182,12 +190,12 @@ def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs)
 
 
 @pytest.mark.parametrize("constructor", [Series, DataFrame])
-def test_rolling_forward_skewness(constructor):
+def test_rolling_forward_skewness(constructor, step):
     values = np.arange(10.0)
     values[5] = 100.0
 
     indexer = FixedForwardWindowIndexer(window_size=5)
-    rolling = constructor(values).rolling(window=indexer, min_periods=3)
+    rolling = constructor(values).rolling(window=indexer, min_periods=3, step=step)
     result = rolling.skew()
 
     expected = constructor(
@@ -203,7 +211,7 @@ def test_rolling_forward_skewness(constructor):
             np.nan,
             np.nan,
         ]
-    )
+    )[::step]
     tm.assert_equal(result, expected)
 
 
@@ -239,7 +247,7 @@ def test_rolling_forward_cov_corr(func, expected):
     # We are interested in checking only pairwise covariance / correlation
     result = getattr(rolling, func)().loc[(slice(None), 1), 0]
     result = result.reset_index(drop=True)
-    expected = Series(expected)
+    expected = Series(expected).reset_index(drop=True)
     expected.name = result.name
     tm.assert_equal(result, expected)
 
@@ -261,12 +269,12 @@ def test_non_fixed_variable_window_indexer(closed, expected_data):
     tm.assert_frame_equal(result, expected)
 
 
-def test_fixed_forward_indexer_count():
+def test_fixed_forward_indexer_count(step):
     # GH: 35579
     df = DataFrame({"b": [None, None, None, 7]})
     indexer = FixedForwardWindowIndexer(window_size=2)
-    result = df.rolling(window=indexer, min_periods=0).count()
-    expected = DataFrame({"b": [0.0, 0.0, 1.0, 1.0]})
+    result = df.rolling(window=indexer, min_periods=0, step=step).count()
+    expected = DataFrame({"b": [0.0, 0.0, 1.0, 1.0]})[::step]
     tm.assert_frame_equal(result, expected)
 
 
@@ -277,7 +285,7 @@ def test_fixed_forward_indexer_count():
 def test_indexer_quantile_sum(end_value, values, func, args):
     # GH 37153
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -338,14 +346,16 @@ def test_indexers_are_reusable_after_groupby_rolling(
     ],
 )
 def test_fixed_forward_indexer_bounds(
-    window_size, num_values, expected_start, expected_end
+    window_size, num_values, expected_start, expected_end, step
 ):
     # GH 43267
     indexer = FixedForwardWindowIndexer(window_size=window_size)
-    start, end = indexer.get_window_bounds(num_values=num_values)
+    start, end = indexer.get_window_bounds(num_values=num_values, step=step)
 
-    tm.assert_numpy_array_equal(start, np.array(expected_start), check_dtype=False)
-    tm.assert_numpy_array_equal(end, np.array(expected_end), check_dtype=False)
+    tm.assert_numpy_array_equal(
+        start, np.array(expected_start[::step]), check_dtype=False
+    )
+    tm.assert_numpy_array_equal(end, np.array(expected_end[::step]), check_dtype=False)
     assert len(start) == len(end)
 
 
@@ -456,7 +466,7 @@ def test_rolling_groupby_with_fixed_forward_many(group_keys, window_size):
 
 def test_unequal_start_end_bounds():
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             return np.array([1]), np.array([1, 2])
 
     indexer = CustomIndexer()
@@ -478,7 +488,7 @@ def get_window_bounds(self, num_values, min_periods, center, closed):
 def test_unequal_bounds_to_object():
     # GH 44470
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             return np.array([1]), np.array([2])
 
     indexer = CustomIndexer()
diff --git a/pandas/tests/window/test_cython_aggregations.py b/pandas/tests/window/test_cython_aggregations.py
new file mode 100644
index 0000000000000..c60cb6ea74ec0
--- /dev/null
+++ b/pandas/tests/window/test_cython_aggregations.py
@@ -0,0 +1,111 @@
+from functools import partial
+import sys
+
+import numpy as np
+import pytest
+
+import pandas._libs.window.aggregations as window_aggregations
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def _get_rolling_aggregations():
+    # list pairs of name and function
+    # each function has this signature:
+    # (const float64_t[:] values, ndarray[int64_t] start,
+    #  ndarray[int64_t] end, int64_t minp) -> np.ndarray
+    named_roll_aggs = (
+        [
+            ("roll_sum", window_aggregations.roll_sum),
+            ("roll_mean", window_aggregations.roll_mean),
+        ]
+        + [
+            (f"roll_var({ddof})", partial(window_aggregations.roll_var, ddof=ddof))
+            for ddof in [0, 1]
+        ]
+        + [
+            ("roll_skew", window_aggregations.roll_skew),
+            ("roll_kurt", window_aggregations.roll_kurt),
+            ("roll_median_c", window_aggregations.roll_median_c),
+            ("roll_max", window_aggregations.roll_max),
+            ("roll_min", window_aggregations.roll_min),
+        ]
+        + [
+            (
+                f"roll_quantile({quantile},{interpolation})",
+                partial(
+                    window_aggregations.roll_quantile,
+                    quantile=quantile,
+                    interpolation=interpolation,
+                ),
+            )
+            for quantile in [0.0001, 0.5, 0.9999]
+            for interpolation in window_aggregations.interpolation_types
+        ]
+        + [
+            (
+                f"roll_rank({percentile},{method},{ascending})",
+                partial(
+                    window_aggregations.roll_rank,
+                    percentile=percentile,
+                    method=method,
+                    ascending=ascending,
+                ),
+            )
+            for percentile in [True, False]
+            for method in window_aggregations.rolling_rank_tiebreakers.keys()
+            for ascending in [True, False]
+        ]
+    )
+    # unzip to a list of 2 tuples, names and functions
+    unzipped = list(zip(*named_roll_aggs))
+    return {"ids": unzipped[0], "params": unzipped[1]}
+
+
+_rolling_aggregations = _get_rolling_aggregations()
+
+
+@pytest.fixture(
+    params=_rolling_aggregations["params"], ids=_rolling_aggregations["ids"]
+)
+def rolling_aggregation(request):
+    """Make a rolling aggregation function as fixture."""
+    return request.param
+
+
+def test_rolling_aggregation_boundary_consistency(rolling_aggregation):
+    # GH-45647
+    minp, step, width, size, selection = 0, 1, 3, 11, [2, 7]
+    values = np.arange(1, 1 + size, dtype=np.float64)
+    end = np.arange(width, size, step, dtype=np.int64)
+    start = end - width
+    selarr = np.array(selection, dtype=np.int32)
+    result = Series(rolling_aggregation(values, start[selarr], end[selarr], minp))
+    expected = Series(rolling_aggregation(values, start, end, minp)[selarr])
+    tm.assert_equal(expected, result)
+
+
+def test_rolling_aggregation_with_unused_elements(rolling_aggregation):
+    # GH-45647
+    minp, width = 0, 5  # width at least 4 for kurt
+    size = 2 * width + 5
+    values = np.arange(1, size + 1, dtype=np.float64)
+    values[width : width + 2] = sys.float_info.min
+    values[width + 2] = np.nan
+    values[width + 3 : width + 5] = sys.float_info.max
+    start = np.array([0, size - width], dtype=np.int64)
+    end = np.array([width, size], dtype=np.int64)
+    loc = np.array(
+        [j for i in range(len(start)) for j in range(start[i], end[i])],
+        dtype=np.int32,
+    )
+    result = Series(rolling_aggregation(values, start, end, minp))
+    compact_values = np.array(values[loc], dtype=np.float64)
+    compact_start = np.arange(0, len(start) * width, width, dtype=np.int64)
+    compact_end = compact_start + width
+    expected = Series(
+        rolling_aggregation(compact_values, compact_start, compact_end, minp)
+    )
+    assert np.isfinite(expected.values).all(), "Not all expected values are finite"
+    tm.assert_equal(expected, result)
diff --git a/pandas/tests/window/test_dtypes.py b/pandas/tests/window/test_dtypes.py
index 02b5f8a313825..52011a2d5f760 100644
--- a/pandas/tests/window/test_dtypes.py
+++ b/pandas/tests/window/test_dtypes.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas.errors import DataError
+
 from pandas.core.dtypes.common import pandas_dtype
 
 from pandas import (
@@ -9,7 +11,6 @@
     Series,
 )
 import pandas._testing as tm
-from pandas.core.base import DataError
 
 # gh-12373 : rolling functions error on float32 data
 # make sure rolling functions works for different dtypes
@@ -24,6 +25,31 @@ def get_dtype(dtype, coerce_int=None):
     return pandas_dtype(dtype)
 
 
+@pytest.fixture(
+    params=[
+        "object",
+        "category",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        "float16",
+        "float32",
+        "float64",
+        "m8[ns]",
+        "M8[ns]",
+        "datetime64[ns, UTC]",
+    ]
+)
+def dtypes(request):
+    """Dtypes for window tests"""
+    return request.param
+
+
 @pytest.mark.parametrize(
     "method, data, expected_data, coerce_int, min_periods",
     [
@@ -65,9 +91,11 @@ def get_dtype(dtype, coerce_int=None):
         ),
     ],
 )
-def test_series_dtypes(method, data, expected_data, coerce_int, dtypes, min_periods):
+def test_series_dtypes(
+    method, data, expected_data, coerce_int, dtypes, min_periods, step
+):
     ser = Series(data, dtype=get_dtype(dtypes, coerce_int=coerce_int))
-    rolled = ser.rolling(2, min_periods=min_periods)
+    rolled = ser.rolling(2, min_periods=min_periods, step=step)
 
     if dtypes in ("m8[ns]", "M8[ns]", "datetime64[ns, UTC]") and method != "count":
         msg = "No numeric types to aggregate"
@@ -75,15 +103,15 @@ def test_series_dtypes(method, data, expected_data, coerce_int, dtypes, min_peri
             getattr(rolled, method)()
     else:
         result = getattr(rolled, method)()
-        expected = Series(expected_data, dtype="float64")
+        expected = Series(expected_data, dtype="float64")[::step]
         tm.assert_almost_equal(result, expected)
 
 
-def test_series_nullable_int(any_signed_int_ea_dtype):
+def test_series_nullable_int(any_signed_int_ea_dtype, step):
     # GH 43016
     ser = Series([0, 1, NA], dtype=any_signed_int_ea_dtype)
-    result = ser.rolling(2).mean()
-    expected = Series([np.nan, 0.5, np.nan])
+    result = ser.rolling(2, step=step).mean()
+    expected = Series([np.nan, 0.5, np.nan])[::step]
     tm.assert_series_equal(result, expected)
 
 
@@ -131,10 +159,10 @@ def test_series_nullable_int(any_signed_int_ea_dtype):
         ),
     ],
 )
-def test_dataframe_dtypes(method, expected_data, dtypes, min_periods):
+def test_dataframe_dtypes(method, expected_data, dtypes, min_periods, step):
 
     df = DataFrame(np.arange(10).reshape((5, 2)), dtype=get_dtype(dtypes))
-    rolled = df.rolling(2, min_periods=min_periods)
+    rolled = df.rolling(2, min_periods=min_periods, step=step)
 
     if dtypes in ("m8[ns]", "M8[ns]", "datetime64[ns, UTC]") and method != "count":
         msg = "No numeric types to aggregate"
@@ -142,5 +170,5 @@ def test_dataframe_dtypes(method, expected_data, dtypes, min_periods):
             getattr(rolled, method)()
     else:
         result = getattr(rolled, method)()
-        expected = DataFrame(expected_data, dtype="float64")
+        expected = DataFrame(expected_data, dtype="float64")[::step]
         tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/window/test_ewm.py b/pandas/tests/window/test_ewm.py
index 23c3a0ef27fef..b524eb5978fa0 100644
--- a/pandas/tests/window/test_ewm.py
+++ b/pandas/tests/window/test_ewm.py
@@ -69,12 +69,16 @@ def test_numpy_compat(method):
     # see gh-12811
     e = ExponentialMovingWindow(Series([2, 4, 6]), alpha=0.5)
 
-    msg = "numpy operations are not valid with window objects"
+    error_msg = "numpy operations are not valid with window objects"
 
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(e, method)(1, 2, 3)
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(e, method)(dtype=np.float64)
+    warn_msg = f"Passing additional args to ExponentialMovingWindow.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(e, method)(1, 2, 3)
+    warn_msg = f"Passing additional kwargs to ExponentialMovingWindow.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(e, method)(dtype=np.float64)
 
 
 def test_ewma_times_not_datetime_type():
@@ -90,7 +94,7 @@ def test_ewma_times_not_same_length():
 
 
 def test_ewma_halflife_not_correct_type():
-    msg = "halflife must be a string or datetime.timedelta object"
+    msg = "halflife must be a timedelta convertible object"
     with pytest.raises(ValueError, match=msg):
         Series(range(5)).ewm(halflife=1, times=np.arange(5).astype("datetime64[ns]"))
 
@@ -552,11 +556,11 @@ def test_ew_min_periods(min_periods, name):
 
 @pytest.mark.parametrize("name", ["cov", "corr"])
 def test_ewm_corr_cov(name):
-    A = Series(np.random.randn(50), index=np.arange(50))
+    A = Series(np.random.randn(50), index=range(50))
     B = A[2:] + np.random.randn(48)
 
     A[:10] = np.NaN
-    B[-10:] = np.NaN
+    B.iloc[-10:] = np.NaN
 
     result = getattr(A.ewm(com=20, min_periods=5), name)(B)
     assert np.isnan(result.values[:14]).all()
@@ -567,11 +571,11 @@ def test_ewm_corr_cov(name):
 @pytest.mark.parametrize("name", ["cov", "corr"])
 def test_ewm_corr_cov_min_periods(name, min_periods):
     # GH 7898
-    A = Series(np.random.randn(50), index=np.arange(50))
+    A = Series(np.random.randn(50), index=range(50))
     B = A[2:] + np.random.randn(48)
 
     A[:10] = np.NaN
-    B[-10:] = np.NaN
+    B.iloc[-10:] = np.NaN
 
     result = getattr(A.ewm(com=20, min_periods=min_periods), name)(B)
     # binary functions (ewmcov, ewmcorr) with bias=False require at
@@ -593,7 +597,7 @@ def test_ewm_corr_cov_min_periods(name, min_periods):
 
 @pytest.mark.parametrize("name", ["cov", "corr"])
 def test_different_input_array_raise_exception(name):
-    A = Series(np.random.randn(50), index=np.arange(50))
+    A = Series(np.random.randn(50), index=range(50))
     A[:10] = np.NaN
 
     msg = "other must be a DataFrame or Series"
@@ -666,3 +670,86 @@ def test_ewm_pairwise_cov_corr(func, frame):
     result.index = result.index.droplevel(1)
     expected = getattr(frame[1].ewm(span=10, min_periods=5), func)(frame[5])
     tm.assert_series_equal(result, expected, check_names=False)
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    ewm = df.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel, None)
+    if op is not None:
+        result = op(numeric_only=numeric_only)
+
+        columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+        expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+        assert list(expected.columns) == columns
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    ewm = df.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    ewm2 = df2.ewm(span=2, min_periods=1)
+    op2 = getattr(ewm2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    ewm = ser.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel, None)
+    if op is None:
+        # Nothing to test
+        return
+    if numeric_only and dtype is object:
+        msg = f"ExponentialMovingWindow.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    ewm = ser.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel)
+    if numeric_only and dtype is object:
+        msg = f"ExponentialMovingWindow.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        ewm2 = ser2.ewm(span=2, min_periods=1)
+        op2 = getattr(ewm2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py
index 7ba81e84dfe3e..a12997018052d 100644
--- a/pandas/tests/window/test_expanding.py
+++ b/pandas/tests/window/test_expanding.py
@@ -59,12 +59,16 @@ def test_numpy_compat(method):
     # see gh-12811
     e = Expanding(Series([2, 4, 6]))
 
-    msg = "numpy operations are not valid with window objects"
+    error_msg = "numpy operations are not valid with window objects"
 
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(e, method)(1, 2, 3)
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(e, method)(dtype=np.float64)
+    warn_msg = f"Passing additional args to Expanding.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(e, method)(1, 2, 3)
+    warn_msg = f"Passing additional kwargs to Expanding.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(e, method)(dtype=np.float64)
 
 
 @pytest.mark.parametrize(
@@ -651,3 +655,83 @@ def mean_w_arg(x, const):
 
     result = df.expanding().apply(mean_w_arg, raw=raw, kwargs={"const": 20})
     tm.assert_frame_equal(result, expected)
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    expanding = df.expanding()
+    op = getattr(expanding, kernel, None)
+    if op is not None:
+        result = op(numeric_only=numeric_only)
+
+        columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+        expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+        assert list(expected.columns) == columns
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    expanding = df.expanding()
+    op = getattr(expanding, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    expanding2 = df2.expanding()
+    op2 = getattr(expanding2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    expanding = ser.expanding()
+    op = getattr(expanding, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Expanding.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    expanding = ser.expanding()
+    op = getattr(expanding, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Expanding.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        expanding2 = ser2.expanding()
+        op2 = getattr(expanding2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_groupby.py b/pandas/tests/window/test_groupby.py
index 6ec19e4899d53..5f4805eaa01d2 100644
--- a/pandas/tests/window/test_groupby.py
+++ b/pandas/tests/window/test_groupby.py
@@ -15,24 +15,51 @@
 from pandas.core.groupby.groupby import get_groupby
 
 
-class TestRolling:
-    def setup_method(self):
-        self.frame = DataFrame({"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)})
+@pytest.fixture
+def times_frame():
+    """Frame for testing times argument in EWM groupby."""
+    return DataFrame(
+        {
+            "A": ["a", "b", "c", "a", "b", "c", "a", "b", "c", "a"],
+            "B": [0, 0, 0, 1, 1, 1, 2, 2, 2, 3],
+            "C": to_datetime(
+                [
+                    "2020-01-01",
+                    "2020-01-01",
+                    "2020-01-01",
+                    "2020-01-02",
+                    "2020-01-10",
+                    "2020-01-22",
+                    "2020-01-03",
+                    "2020-01-23",
+                    "2020-01-23",
+                    "2020-01-04",
+                ]
+            ),
+        }
+    )
+
 
-    def test_mutated(self):
+@pytest.fixture
+def roll_frame():
+    return DataFrame({"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)})
+
+
+class TestRolling:
+    def test_mutated(self, roll_frame):
 
         msg = r"groupby\(\) got an unexpected keyword argument 'foo'"
         with pytest.raises(TypeError, match=msg):
-            self.frame.groupby("A", foo=1)
+            roll_frame.groupby("A", foo=1)
 
-        g = self.frame.groupby("A")
+        g = roll_frame.groupby("A")
         assert not g.mutated
-        g = get_groupby(self.frame, by="A", mutated=True)
+        g = get_groupby(roll_frame, by="A", mutated=True)
         assert g.mutated
 
-    def test_getitem(self):
-        g = self.frame.groupby("A")
-        g_mutated = get_groupby(self.frame, by="A", mutated=True)
+    def test_getitem(self, roll_frame):
+        g = roll_frame.groupby("A")
+        g_mutated = get_groupby(roll_frame, by="A", mutated=True)
 
         expected = g_mutated.B.apply(lambda x: x.rolling(2).mean())
 
@@ -45,15 +72,15 @@ def test_getitem(self):
         result = g.B.rolling(2).mean()
         tm.assert_series_equal(result, expected)
 
-        result = self.frame.B.groupby(self.frame.A).rolling(2).mean()
+        result = roll_frame.B.groupby(roll_frame.A).rolling(2).mean()
         tm.assert_series_equal(result, expected)
 
-    def test_getitem_multiple(self):
+    def test_getitem_multiple(self, roll_frame):
 
         # GH 13174
-        g = self.frame.groupby("A")
+        g = roll_frame.groupby("A")
         r = g.rolling(2, min_periods=0)
-        g_mutated = get_groupby(self.frame, by="A", mutated=True)
+        g_mutated = get_groupby(roll_frame, by="A", mutated=True)
         expected = g_mutated.B.apply(lambda x: x.rolling(2, min_periods=0).count())
 
         result = r.B.count()
@@ -77,8 +104,8 @@ def test_getitem_multiple(self):
             "skew",
         ],
     )
-    def test_rolling(self, f):
-        g = self.frame.groupby("A")
+    def test_rolling(self, f, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
         r = g.rolling(window=4)
 
         result = getattr(r, f)()
@@ -86,13 +113,13 @@ def test_rolling(self, f):
         # groupby.apply doesn't drop the grouped-by column
         expected = expected.drop("A", axis=1)
         # GH 39732
-        expected_index = MultiIndex.from_arrays([self.frame["A"], range(40)])
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
         expected.index = expected_index
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("f", ["std", "var"])
-    def test_rolling_ddof(self, f):
-        g = self.frame.groupby("A")
+    def test_rolling_ddof(self, f, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
         r = g.rolling(window=4)
 
         result = getattr(r, f)(ddof=1)
@@ -100,15 +127,15 @@ def test_rolling_ddof(self, f):
         # groupby.apply doesn't drop the grouped-by column
         expected = expected.drop("A", axis=1)
         # GH 39732
-        expected_index = MultiIndex.from_arrays([self.frame["A"], range(40)])
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
         expected.index = expected_index
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
     )
-    def test_rolling_quantile(self, interpolation):
-        g = self.frame.groupby("A")
+    def test_rolling_quantile(self, interpolation, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
         r = g.rolling(window=4)
 
         result = r.quantile(0.4, interpolation=interpolation)
@@ -118,7 +145,7 @@ def test_rolling_quantile(self, interpolation):
         # groupby.apply doesn't drop the grouped-by column
         expected = expected.drop("A", axis=1)
         # GH 39732
-        expected_index = MultiIndex.from_arrays([self.frame["A"], range(40)])
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
         expected.index = expected_index
         tm.assert_frame_equal(result, expected)
 
@@ -148,14 +175,14 @@ def test_rolling_corr_cov_other_same_size_as_groups(self, f, expected_val):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("f", ["corr", "cov"])
-    def test_rolling_corr_cov_other_diff_size_as_groups(self, f):
-        g = self.frame.groupby("A")
+    def test_rolling_corr_cov_other_diff_size_as_groups(self, f, roll_frame):
+        g = roll_frame.groupby("A")
         r = g.rolling(window=4)
 
-        result = getattr(r, f)(self.frame)
+        result = getattr(r, f)(roll_frame)
 
         def func(x):
-            return getattr(x.rolling(4), f)(self.frame)
+            return getattr(x.rolling(4), f)(roll_frame)
 
         expected = g.apply(func)
         # GH 39591: The grouped column should be all np.nan
@@ -164,8 +191,8 @@ def func(x):
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("f", ["corr", "cov"])
-    def test_rolling_corr_cov_pairwise(self, f):
-        g = self.frame.groupby("A")
+    def test_rolling_corr_cov_pairwise(self, f, roll_frame):
+        g = roll_frame.groupby("A")
         r = g.rolling(window=4)
 
         result = getattr(r.B, f)(pairwise=True)
@@ -212,8 +239,8 @@ def test_rolling_corr_cov_unordered(self, func, expected_values):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_rolling_apply(self, raw):
-        g = self.frame.groupby("A")
+    def test_rolling_apply(self, raw, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
         r = g.rolling(window=4)
 
         # reduction
@@ -222,7 +249,7 @@ def test_rolling_apply(self, raw):
         # groupby.apply doesn't drop the grouped-by column
         expected = expected.drop("A", axis=1)
         # GH 39732
-        expected_index = MultiIndex.from_arrays([self.frame["A"], range(40)])
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
         expected.index = expected_index
         tm.assert_frame_equal(result, expected)
 
@@ -421,7 +448,12 @@ def test_groupby_rolling_custom_indexer(self):
         # GH 35557
         class SimpleIndexer(BaseIndexer):
             def get_window_bounds(
-                self, num_values=0, min_periods=None, center=None, closed=None
+                self,
+                num_values=0,
+                min_periods=None,
+                center=None,
+                closed=None,
+                step=None,
             ):
                 min_periods = self.window_size if min_periods is None else 0
                 end = np.arange(num_values, dtype=np.int64) + 1
@@ -651,7 +683,7 @@ def test_groupby_rolling_nans_in_index(self, rollings, key):
         )
         if key == "index":
             df = df.set_index("a")
-        with pytest.raises(ValueError, match=f"{key} must be monotonic"):
+        with pytest.raises(ValueError, match=f"{key} values must not have NaT"):
             df.groupby("c").rolling("60min", **rollings)
 
     @pytest.mark.parametrize("group_keys", [True, False])
@@ -753,9 +785,9 @@ def test_groupby_rolling_resulting_multiindex3(self):
         )
         tm.assert_index_equal(result.index, expected_index, exact="equiv")
 
-    def test_groupby_rolling_object_doesnt_affect_groupby_apply(self):
+    def test_groupby_rolling_object_doesnt_affect_groupby_apply(self, roll_frame):
         # GH 39732
-        g = self.frame.groupby("A")
+        g = roll_frame.groupby("A", group_keys=False)
         expected = g.apply(lambda x: x.rolling(4).sum()).index
         _ = g.rolling(window=4)
         result = g.apply(lambda x: x.rolling(4).sum()).index
@@ -895,6 +927,83 @@ def test_nan_and_zero_endpoints(self):
         )
         tm.assert_series_equal(result, expected)
 
+    def test_groupby_rolling_non_monotonic(self):
+        # GH 43909
+
+        shuffled = [3, 0, 1, 2]
+        sec = 1_000
+        df = DataFrame(
+            [{"t": Timestamp(2 * x * sec), "x": x + 1, "c": 42} for x in shuffled]
+        )
+        with pytest.raises(ValueError, match=r".* must be monotonic"):
+            df.groupby("c").rolling(on="t", window="3s")
+
+    def test_groupby_monotonic(self):
+
+        # GH 15130
+        # we don't need to validate monotonicity when grouping
+
+        # GH 43909 we should raise an error here to match
+        # behaviour of non-groupby rolling.
+
+        data = [
+            ["David", "1/1/2015", 100],
+            ["David", "1/5/2015", 500],
+            ["David", "5/30/2015", 50],
+            ["David", "7/25/2015", 50],
+            ["Ryan", "1/4/2014", 100],
+            ["Ryan", "1/19/2015", 500],
+            ["Ryan", "3/31/2016", 50],
+            ["Joe", "7/1/2015", 100],
+            ["Joe", "9/9/2015", 500],
+            ["Joe", "10/15/2015", 50],
+        ]
+
+        df = DataFrame(data=data, columns=["name", "date", "amount"])
+        df["date"] = to_datetime(df["date"])
+        df = df.sort_values("date")
+
+        expected = (
+            df.set_index("date")
+            .groupby("name")
+            .apply(lambda x: x.rolling("180D")["amount"].sum())
+        )
+        result = df.groupby("name").rolling("180D", on="date")["amount"].sum()
+        tm.assert_series_equal(result, expected)
+
+    def test_datelike_on_monotonic_within_each_group(self):
+        # GH 13966 (similar to #15130, closed by #15175)
+
+        # superseded by 43909
+        # GH 46061: OK if the on is monotonic relative to each each group
+
+        dates = date_range(start="2016-01-01 09:30:00", periods=20, freq="s")
+        df = DataFrame(
+            {
+                "A": [1] * 20 + [2] * 12 + [3] * 8,
+                "B": np.concatenate((dates, dates)),
+                "C": np.arange(40),
+            }
+        )
+
+        expected = (
+            df.set_index("B").groupby("A").apply(lambda x: x.rolling("4s")["C"].mean())
+        )
+        result = df.groupby("A").rolling("4s", on="B").C.mean()
+        tm.assert_series_equal(result, expected)
+
+    def test_datelike_on_not_monotonic_within_each_group(self):
+        # GH 46061
+        df = DataFrame(
+            {
+                "A": [1] * 3 + [2] * 3,
+                "B": [Timestamp(year, 1, 1) for year in [2020, 2021, 2019]] * 2,
+                "C": range(6),
+            }
+        )
+        with pytest.raises(ValueError, match="Each group within B must be monotonic."):
+            df.groupby("A").rolling("365D", on="B")
+
 
 class TestExpanding:
     def setup_method(self):
@@ -904,7 +1013,7 @@ def setup_method(self):
         "f", ["sum", "mean", "min", "max", "count", "kurt", "skew"]
     )
     def test_expanding(self, f):
-        g = self.frame.groupby("A")
+        g = self.frame.groupby("A", group_keys=False)
         r = g.expanding()
 
         result = getattr(r, f)()
@@ -918,7 +1027,7 @@ def test_expanding(self, f):
 
     @pytest.mark.parametrize("f", ["std", "var"])
     def test_expanding_ddof(self, f):
-        g = self.frame.groupby("A")
+        g = self.frame.groupby("A", group_keys=False)
         r = g.expanding()
 
         result = getattr(r, f)(ddof=0)
@@ -934,7 +1043,7 @@ def test_expanding_ddof(self, f):
         "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
     )
     def test_expanding_quantile(self, interpolation):
-        g = self.frame.groupby("A")
+        g = self.frame.groupby("A", group_keys=False)
         r = g.expanding()
 
         result = r.quantile(0.4, interpolation=interpolation)
@@ -977,7 +1086,7 @@ def func(x):
         tm.assert_series_equal(result, expected)
 
     def test_expanding_apply(self, raw):
-        g = self.frame.groupby("A")
+        g = self.frame.groupby("A", group_keys=False)
         r = g.expanding()
 
         # reduction
@@ -1020,12 +1129,10 @@ def test_methods(self, method, expected_data):
 
         with tm.assert_produces_warning(FutureWarning, match="nuisance"):
             # GH#42738
-            expected = df.groupby("A").apply(
+            expected = df.groupby("A", group_keys=True).apply(
                 lambda x: getattr(x.ewm(com=1.0), method)()
             )
-
-        # There may be a bug in the above statement; not returning the correct index
-        tm.assert_frame_equal(result.reset_index(drop=True), expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "method, expected_data",
@@ -1097,13 +1204,10 @@ def test_times_vs_apply(self, times_frame):
         with tm.assert_produces_warning(FutureWarning, match="nuisance"):
             # GH#42738
             result = times_frame.groupby("A").ewm(halflife=halflife, times="C").mean()
-            expected = (
-                times_frame.groupby("A")
-                .apply(lambda x: x.ewm(halflife=halflife, times="C").mean())
-                .iloc[[0, 3, 6, 9, 1, 4, 7, 2, 5, 8]]
-                .reset_index(drop=True)
+            expected = times_frame.groupby("A", group_keys=True).apply(
+                lambda x: x.ewm(halflife=halflife, times="C").mean()
             )
-        tm.assert_frame_equal(result.reset_index(drop=True), expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_times_array(self, times_frame):
         # GH 40951
diff --git a/pandas/tests/window/test_numba.py b/pandas/tests/window/test_numba.py
index a14515ca9c018..89e00af270a02 100644
--- a/pandas/tests/window/test_numba.py
+++ b/pandas/tests/window/test_numba.py
@@ -1,6 +1,11 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_mac,
+    is_platform_windows,
+)
 from pandas.errors import NumbaUtilError
 import pandas.util._test_decorators as td
 
@@ -11,15 +16,45 @@
     to_datetime,
 )
 import pandas._testing as tm
-from pandas.core.util.numba_ import NUMBA_FUNC_CACHE
+
+# TODO(GH#44584): Mark these as pytest.mark.single_cpu
+pytestmark = pytest.mark.skipif(
+    is_ci_environment() and (is_platform_windows() or is_platform_mac()),
+    reason="On GHA CI, Windows can fail with "
+    "'Windows fatal exception: stack overflow' "
+    "and MacOS can timeout",
+)
+
+
+@pytest.fixture(params=["single", "table"])
+def method(request):
+    """method keyword in rolling/expanding/ewm constructor"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ["sum", {}],
+        ["mean", {}],
+        ["median", {}],
+        ["max", {}],
+        ["min", {}],
+        ["var", {}],
+        ["var", {"ddof": 0}],
+        ["std", {}],
+        ["std", {"ddof": 0}],
+    ]
+)
+def arithmetic_numba_supported_operators(request):
+    return request.param
 
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 class TestEngine:
     @pytest.mark.parametrize("jit", [True, False])
-    def test_numba_vs_cython_apply(self, jit, nogil, parallel, nopython, center):
+    def test_numba_vs_cython_apply(self, jit, nogil, parallel, nopython, center, step):
         def f(x, *args):
             arg_sum = 0
             for arg in args:
@@ -35,38 +70,49 @@ def f(x, *args):
         args = (2,)
 
         s = Series(range(10))
-        result = s.rolling(2, center=center).apply(
+        result = s.rolling(2, center=center, step=step).apply(
             f, args=args, engine="numba", engine_kwargs=engine_kwargs, raw=True
         )
-        expected = s.rolling(2, center=center).apply(
+        expected = s.rolling(2, center=center, step=step).apply(
             f, engine="cython", args=args, raw=True
         )
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "data", [DataFrame(np.eye(5)), Series(range(5), name="foo")]
+        "data",
+        [
+            DataFrame(np.eye(5)),
+            DataFrame(
+                [
+                    [5, 7, 7, 7, np.nan, np.inf, 4, 3, 3, 3],
+                    [5, 7, 7, 7, np.nan, np.inf, 7, 3, 3, 3],
+                    [np.nan, np.nan, 5, 6, 7, 5, 5, 5, 5, 5],
+                ]
+            ).T,
+            Series(range(5), name="foo"),
+            Series([20, 10, 10, np.inf, 1, 1, 2, 3]),
+            Series([20, 10, 10, np.nan, 10, 1, 2, 3]),
+        ],
     )
     def test_numba_vs_cython_rolling_methods(
-        self, data, nogil, parallel, nopython, arithmetic_numba_supported_operators
+        self,
+        data,
+        nogil,
+        parallel,
+        nopython,
+        arithmetic_numba_supported_operators,
+        step,
     ):
 
         method, kwargs = arithmetic_numba_supported_operators
 
         engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
 
-        roll = data.rolling(2)
+        roll = data.rolling(3, step=step)
         result = getattr(roll, method)(
             engine="numba", engine_kwargs=engine_kwargs, **kwargs
         )
         expected = getattr(roll, method)(engine="cython", **kwargs)
-
-        # Check the cache
-        if method not in ("mean", "sum", "var", "std", "max", "min"):
-            assert (
-                getattr(np, f"nan{method}"),
-                "Rolling_apply_single",
-            ) in NUMBA_FUNC_CACHE
-
         tm.assert_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -86,18 +132,10 @@ def test_numba_vs_cython_expanding_methods(
             engine="numba", engine_kwargs=engine_kwargs, **kwargs
         )
         expected = getattr(expand, method)(engine="cython", **kwargs)
-
-        # Check the cache
-        if method not in ("mean", "sum", "var", "std", "max", "min"):
-            assert (
-                getattr(np, f"nan{method}"),
-                "Expanding_apply_single",
-            ) in NUMBA_FUNC_CACHE
-
         tm.assert_equal(result, expected)
 
     @pytest.mark.parametrize("jit", [True, False])
-    def test_cache_apply(self, jit, nogil, parallel, nopython):
+    def test_cache_apply(self, jit, nogil, parallel, nopython, step):
         # Test that the functions are cached correctly if we switch functions
         def func_1(x):
             return np.mean(x) + 4
@@ -113,16 +151,13 @@ def func_2(x):
 
         engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
 
-        roll = Series(range(10)).rolling(2)
+        roll = Series(range(10)).rolling(2, step=step)
         result = roll.apply(
             func_1, engine="numba", engine_kwargs=engine_kwargs, raw=True
         )
         expected = roll.apply(func_1, engine="cython", raw=True)
         tm.assert_series_equal(result, expected)
 
-        # func_1 should be in the cache now
-        assert (func_1, "Rolling_apply_single") in NUMBA_FUNC_CACHE
-
         result = roll.apply(
             func_2, engine="numba", engine_kwargs=engine_kwargs, raw=True
         )
@@ -164,6 +199,32 @@ def add(values, x):
         expected = DataFrame({"value": [2.0, 2.0, 2.0]})
         tm.assert_frame_equal(result, expected)
 
+    def test_dont_cache_engine_kwargs(self):
+        # If the user passes a different set of engine_kwargs don't return the same
+        # jitted function
+        nogil = False
+        parallel = True
+        nopython = True
+
+        def func(x):
+            return nogil + parallel + nopython
+
+        engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+        df = DataFrame({"value": [0, 0, 0]})
+        result = df.rolling(1).apply(
+            func, raw=True, engine="numba", engine_kwargs=engine_kwargs
+        )
+        expected = DataFrame({"value": [2.0, 2.0, 2.0]})
+        tm.assert_frame_equal(result, expected)
+
+        parallel = False
+        engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+        result = df.rolling(1).apply(
+            func, raw=True, engine="numba", engine_kwargs=engine_kwargs
+        )
+        expected = DataFrame({"value": [1.0, 1.0, 1.0]})
+        tm.assert_frame_equal(result, expected)
+
 
 @td.skip_if_no("numba")
 class TestEWM:
@@ -270,7 +331,7 @@ def test_invalid_kwargs_nopython():
 
 @td.skip_if_no("numba")
 @pytest.mark.slow
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
 # Filter warnings when parallel=True and the function can't be parallelized by Numba
 class TestTableMethod:
     def test_table_series_valueerror(self):
@@ -285,21 +346,29 @@ def f(x):
             )
 
     def test_table_method_rolling_methods(
-        self, axis, nogil, parallel, nopython, arithmetic_numba_supported_operators
+        self,
+        axis,
+        nogil,
+        parallel,
+        nopython,
+        arithmetic_numba_supported_operators,
+        step,
     ):
         method, kwargs = arithmetic_numba_supported_operators
 
         engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
 
         df = DataFrame(np.eye(3))
-        roll_table = df.rolling(2, method="table", axis=axis, min_periods=0)
+        roll_table = df.rolling(2, method="table", axis=axis, min_periods=0, step=step)
         if method in ("var", "std"):
             with pytest.raises(NotImplementedError, match=f"{method} not supported"):
                 getattr(roll_table, method)(
                     engine_kwargs=engine_kwargs, engine="numba", **kwargs
                 )
         else:
-            roll_single = df.rolling(2, method="single", axis=axis, min_periods=0)
+            roll_single = df.rolling(
+                2, method="single", axis=axis, min_periods=0, step=step
+            )
             result = getattr(roll_table, method)(
                 engine_kwargs=engine_kwargs, engine="numba", **kwargs
             )
@@ -308,29 +377,29 @@ def test_table_method_rolling_methods(
             )
             tm.assert_frame_equal(result, expected)
 
-    def test_table_method_rolling_apply(self, axis, nogil, parallel, nopython):
+    def test_table_method_rolling_apply(self, axis, nogil, parallel, nopython, step):
         engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
 
         def f(x):
             return np.sum(x, axis=0) + 1
 
         df = DataFrame(np.eye(3))
-        result = df.rolling(2, method="table", axis=axis, min_periods=0).apply(
-            f, raw=True, engine_kwargs=engine_kwargs, engine="numba"
-        )
-        expected = df.rolling(2, method="single", axis=axis, min_periods=0).apply(
-            f, raw=True, engine_kwargs=engine_kwargs, engine="numba"
-        )
+        result = df.rolling(
+            2, method="table", axis=axis, min_periods=0, step=step
+        ).apply(f, raw=True, engine_kwargs=engine_kwargs, engine="numba")
+        expected = df.rolling(
+            2, method="single", axis=axis, min_periods=0, step=step
+        ).apply(f, raw=True, engine_kwargs=engine_kwargs, engine="numba")
         tm.assert_frame_equal(result, expected)
 
-    def test_table_method_rolling_weighted_mean(self):
+    def test_table_method_rolling_weighted_mean(self, step):
         def weighted_mean(x):
             arr = np.ones((1, x.shape[1]))
             arr[:, :2] = (x[:, :2] * x[:, 2]).sum(axis=0) / x[:, 2].sum()
             return arr
 
         df = DataFrame([[1, 2, 0.6], [2, 3, 0.4], [3, 4, 0.2], [4, 5, 0.7]])
-        result = df.rolling(2, method="table", min_periods=0).apply(
+        result = df.rolling(2, method="table", min_periods=0, step=step).apply(
             weighted_mean, raw=True, engine="numba"
         )
         expected = DataFrame(
@@ -340,7 +409,7 @@ def weighted_mean(x):
                 [3.333333, 2.333333, 1.0],
                 [1.555556, 7, 1.0],
             ]
-        )
+        )[::step]
         tm.assert_frame_equal(result, expected)
 
     def test_table_method_expanding_apply(self, axis, nogil, parallel, nopython):
diff --git a/pandas/tests/window/test_online.py b/pandas/tests/window/test_online.py
index 80cf1c55958ee..88f462869d8b6 100644
--- a/pandas/tests/window/test_online.py
+++ b/pandas/tests/window/test_online.py
@@ -1,6 +1,11 @@
 import numpy as np
 import pytest
 
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_mac,
+    is_platform_windows,
+)
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -9,9 +14,18 @@
 )
 import pandas._testing as tm
 
+# TODO(GH#44584): Mark these as pytest.mark.single_cpu
+pytestmark = pytest.mark.skipif(
+    is_ci_environment() and (is_platform_windows() or is_platform_mac()),
+    reason="On GHA CI, Windows can fail with "
+    "'Windows fatal exception: stack overflow' "
+    "and MacOS can timeout",
+)
+
 
 @td.skip_if_no("numba")
-@pytest.mark.filterwarnings("ignore:\n")
+@pytest.mark.filterwarnings("ignore")
+# Filter warnings when parallel=True and the function can't be parallelized by Numba
 class TestEWM:
     def test_invalid_update(self):
         df = DataFrame({"a": range(5), "b": range(5)})
diff --git a/pandas/tests/window/test_pairwise.py b/pandas/tests/window/test_pairwise.py
index 77ff6ae03d836..6c3f3f7075ce0 100644
--- a/pandas/tests/window/test_pairwise.py
+++ b/pandas/tests/window/test_pairwise.py
@@ -14,6 +14,39 @@
 from pandas.core.algorithms import safe_sort
 
 
+@pytest.fixture(
+    params=[
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", "C"]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1.0, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0.0, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", 1]),
+        DataFrame([[2.0, 4.0], [1.0, 2.0], [5.0, 2.0], [8.0, 1.0]], columns=[1, 0.0]),
+        DataFrame([[2, 4.0], [1, 2.0], [5, 2.0], [8, 1.0]], columns=[0, 1.0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1.0]], columns=[1.0, "X"]),
+    ]
+)
+def pairwise_frames(request):
+    """Pairwise frames test_pairwise"""
+    return request.param
+
+
+@pytest.fixture
+def pairwise_target_frame():
+    """Pairwise target frame for test_pairwise"""
+    return DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0, 1])
+
+
+@pytest.fixture
+def pairwise_other_frame():
+    """Pairwise other frame for test_pairwise"""
+    return DataFrame(
+        [[None, 1, 1], [None, 1, 2], [None, 3, 2], [None, 8, 1]],
+        columns=["Y", "Z", "X"],
+    )
+
+
 def test_rolling_cov(series):
     A = series
     B = A + np.random.randn(len(A))
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 814bd6b998182..c9ec2985488be 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -26,8 +26,11 @@
 )
 import pandas._testing as tm
 from pandas.api.indexers import BaseIndexer
+from pandas.core.indexers.objects import VariableOffsetWindowIndexer
 from pandas.core.window import Rolling
 
+from pandas.tseries.offsets import BusinessDay
+
 
 def test_doc_string():
 
@@ -81,6 +84,37 @@ def test_invalid_constructor(frame_or_series, w):
         c(window=2, min_periods=1, center=w)
 
 
+@pytest.mark.parametrize(
+    "window",
+    [
+        timedelta(days=3),
+        Timedelta(days=3),
+        "3D",
+        VariableOffsetWindowIndexer(
+            index=date_range("2015-12-25", periods=5), offset=BusinessDay(1)
+        ),
+    ],
+)
+def test_freq_window_not_implemented(window):
+    # GH 15354
+    df = DataFrame(
+        np.arange(10),
+        index=date_range("2015-12-24", periods=10, freq="D"),
+    )
+    with pytest.raises(
+        NotImplementedError, match="step is not supported with frequency windows"
+    ):
+        df.rolling("3D", step=3)
+
+
+@pytest.mark.parametrize("agg", ["cov", "corr"])
+def test_step_not_implemented_for_cov_corr(agg):
+    # GH 15354
+    roll = DataFrame(range(2)).rolling(1, step=2)
+    with pytest.raises(NotImplementedError, match="step not implemented"):
+        getattr(roll, agg)()
+
+
 @pytest.mark.parametrize("window", [timedelta(days=3), Timedelta(days=3)])
 def test_constructor_with_timedelta_window(window):
     # GH 15440
@@ -124,14 +158,19 @@ def test_numpy_compat(method):
     # see gh-12811
     r = Rolling(Series([2, 4, 6]), window=2)
 
-    msg = "numpy operations are not valid with window objects"
+    error_msg = "numpy operations are not valid with window objects"
 
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(r, method)(1, 2, 3)
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(r, method)(dtype=np.float64)
+    warn_msg = f"Passing additional args to Rolling.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(r, method)(1, 2, 3)
+    warn_msg = f"Passing additional kwargs to Rolling.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(r, method)(dtype=np.float64)
 
 
+@pytest.mark.parametrize("closed", ["right", "left", "both", "neither"])
 def test_closed_fixed(closed, arithmetic_win_operators):
     # GH 34315
     func_name = arithmetic_win_operators
@@ -299,7 +338,7 @@ def test_even_number_window_alignment():
     tm.assert_series_equal(result, expected)
 
 
-def test_closed_fixed_binary_col(center):
+def test_closed_fixed_binary_col(center, step):
     # GH 34315
     data = [0, 1, 1, 0, 0, 1, 0, 1]
     df = DataFrame(
@@ -316,9 +355,11 @@ def test_closed_fixed_binary_col(center):
         expected_data,
         columns=["binary_col"],
         index=date_range(start="2020-01-01", freq="min", periods=len(expected_data)),
-    )
+    )[::step]
 
-    rolling = df.rolling(window=len(df), closed="left", min_periods=1, center=center)
+    rolling = df.rolling(
+        window=len(df), closed="left", min_periods=1, center=center, step=step
+    )
     result = rolling.mean()
     tm.assert_frame_equal(result, expected)
 
@@ -1166,6 +1207,9 @@ def test_rolling_var_numerical_issues(func, third_value, values):
     result = getattr(ds.rolling(2), func)()
     expected = Series([np.nan] + values)
     tm.assert_series_equal(result, expected)
+    # GH 42064
+    # new `roll_var` will output 0.0 correctly
+    tm.assert_series_equal(result == 0, expected == 0)
 
 
 def test_timeoffset_as_window_parameter_for_corr():
@@ -1361,7 +1405,7 @@ def test_rolling_non_monotonic(method, expected):
     df = DataFrame({"values": np.arange(len(use_expanding)) ** 2})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -1391,7 +1435,7 @@ def test_rolling_corr_timedelta_index(index, window):
     # GH: 31286
     x = Series([1, 2, 3, 4, 5], index=index)
     y = x.copy()
-    x[0:2] = 0.0
+    x.iloc[0:2] = 0.0
     result = x.rolling(window).corr(y)
     expected = Series([np.nan, np.nan, 1, 1, 1], index=index)
     tm.assert_almost_equal(result, expected)
@@ -1419,18 +1463,6 @@ def test_groupby_rolling_nan_included():
     tm.assert_frame_equal(result, expected)
 
 
-def test_groupby_rolling_non_monotonic():
-    # GH 43909
-
-    shuffled = [3, 0, 1, 2]
-    sec = 1_000
-    df = DataFrame(
-        [{"t": Timestamp(2 * x * sec), "x": x + 1, "c": 42} for x in shuffled]
-    )
-    with pytest.raises(ValueError, match=r".* must be monotonic"):
-        df.groupby("c").rolling(on="t", window="3s")
-
-
 @pytest.mark.parametrize("method", ["skew", "kurt"])
 def test_rolling_skew_kurt_numerical_stability(method):
     # GH#6929
@@ -1484,6 +1516,9 @@ def test_rolling_var_floating_artifact_precision():
     result = s.rolling(3).var()
     expected = Series([np.nan, np.nan, 4 / 3, 0])
     tm.assert_series_equal(result, expected, atol=1.0e-15, rtol=1.0e-15)
+    # GH 42064
+    # new `roll_var` will output 0.0 correctly
+    tm.assert_series_equal(result == 0, expected == 0)
 
 
 def test_rolling_std_small_values():
@@ -1734,3 +1769,188 @@ def test_rolling_std_neg_sqrt():
 
     b = a.ewm(span=3).std()
     assert np.isfinite(b[2:]).all()
+
+
+def test_step_not_integer_raises():
+    with pytest.raises(ValueError, match="step must be an integer"):
+        DataFrame(range(2)).rolling(1, step="foo")
+
+
+def test_step_not_positive_raises():
+    with pytest.raises(ValueError, match="step must be >= 0"):
+        DataFrame(range(2)).rolling(1, step=-1)
+
+
+@pytest.mark.parametrize(
+    ["values", "window", "min_periods", "expected"],
+    [
+        [
+            [20, 10, 10, np.inf, 1, 1, 2, 3],
+            3,
+            1,
+            [np.nan, 50, 100 / 3, 0, 40.5, 0, 1 / 3, 1],
+        ],
+        [
+            [20, 10, 10, np.nan, 10, 1, 2, 3],
+            3,
+            1,
+            [np.nan, 50, 100 / 3, 0, 0, 40.5, 73 / 3, 1],
+        ],
+        [
+            [np.nan, 5, 6, 7, 5, 5, 5],
+            3,
+            3,
+            [np.nan] * 3 + [1, 1, 4 / 3, 0],
+        ],
+        [
+            [5, 7, 7, 7, np.nan, np.inf, 4, 3, 3, 3],
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3, 0] + [np.nan] * 4 + [1 / 3, 0],
+        ],
+        [
+            [5, 7, 7, 7, np.nan, np.inf, 7, 3, 3, 3],
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3, 0] + [np.nan] * 4 + [16 / 3, 0],
+        ],
+        [
+            [5, 7] * 4,
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3] * 6,
+        ],
+        [
+            [5, 7, 5, np.nan, 7, 5, 7],
+            3,
+            2,
+            [np.nan, 2, 4 / 3] + [2] * 3 + [4 / 3],
+        ],
+    ],
+)
+def test_rolling_var_same_value_count_logic(values, window, min_periods, expected):
+    # GH 42064.
+
+    expected = Series(expected)
+    sr = Series(values)
+
+    # With new algo implemented, result will be set to .0 in rolling var
+    # if sufficient amount of consecutively same values are found.
+    result_var = sr.rolling(window, min_periods=min_periods).var()
+
+    # use `assert_series_equal` twice to check for equality,
+    # because `check_exact=True` will fail in 32-bit tests due to
+    # precision loss.
+
+    # 1. result should be close to correct value
+    # non-zero values can still differ slightly from "truth"
+    # as the result of online algorithm
+    tm.assert_series_equal(result_var, expected)
+    # 2. zeros should be exactly the same since the new algo takes effect here
+    tm.assert_series_equal(expected == 0, result_var == 0)
+
+    # std should also pass as it's just a sqrt of var
+    result_std = sr.rolling(window, min_periods=min_periods).std()
+    tm.assert_series_equal(result_std, np.sqrt(expected))
+    tm.assert_series_equal(expected == 0, result_std == 0)
+
+
+def test_rolling_mean_sum_floating_artifacts():
+    # GH 42064.
+
+    sr = Series([1 / 3, 4, 0, 0, 0, 0, 0])
+    r = sr.rolling(3)
+    result = r.mean()
+    assert (result[-3:] == 0).all()
+    result = r.sum()
+    assert (result[-3:] == 0).all()
+
+
+def test_rolling_skew_kurt_floating_artifacts():
+    # GH 42064 46431
+
+    sr = Series([1 / 3, 4, 0, 0, 0, 0, 0])
+    r = sr.rolling(4)
+    result = r.skew()
+    assert (result[-2:] == 0).all()
+    result = r.kurt()
+    assert (result[-2:] == -3).all()
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    rolling = df.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    result = op(numeric_only=numeric_only)
+
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+    assert list(expected.columns) == columns
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    rolling = df.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    rolling2 = df2.rolling(2, min_periods=1)
+    op2 = getattr(rolling2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    rolling = ser.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Rolling.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    rolling = ser.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Rolling.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        rolling2 = ser2.rolling(2, min_periods=1)
+        op2 = getattr(rolling2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_rolling_functions.py b/pandas/tests/window/test_rolling_functions.py
index c788b3d88cb63..9ab4ff13796d6 100644
--- a/pandas/tests/window/test_rolling_functions.py
+++ b/pandas/tests/window/test_rolling_functions.py
@@ -38,10 +38,11 @@
         [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}],
     ],
 )
-def test_series(series, compare_func, roll_func, kwargs):
-    result = getattr(series.rolling(50), roll_func)(**kwargs)
+def test_series(series, compare_func, roll_func, kwargs, step):
+    result = getattr(series.rolling(50, step=step), roll_func)(**kwargs)
     assert isinstance(result, Series)
-    tm.assert_almost_equal(result.iloc[-1], compare_func(series[-50:]))
+    end = range(0, len(series), step or 1)[-1] + 1
+    tm.assert_almost_equal(result.iloc[-1], compare_func(series[end - 50 : end]))
 
 
 @pytest.mark.parametrize(
@@ -64,12 +65,13 @@ def test_series(series, compare_func, roll_func, kwargs):
         [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}],
     ],
 )
-def test_frame(raw, frame, compare_func, roll_func, kwargs):
-    result = getattr(frame.rolling(50), roll_func)(**kwargs)
+def test_frame(raw, frame, compare_func, roll_func, kwargs, step):
+    result = getattr(frame.rolling(50, step=step), roll_func)(**kwargs)
     assert isinstance(result, DataFrame)
+    end = range(0, len(frame), step or 1)[-1] + 1
     tm.assert_series_equal(
         result.iloc[-1, :],
-        frame.iloc[-50:, :].apply(compare_func, axis=0, raw=raw),
+        frame.iloc[end - 50 : end, :].apply(compare_func, axis=0, raw=raw),
         check_names=False,
     )
 
@@ -200,13 +202,13 @@ def test_nans_count():
     ],
 )
 @pytest.mark.parametrize("minp", [0, 99, 100])
-def test_min_periods(series, minp, roll_func, kwargs):
-    result = getattr(series.rolling(len(series) + 1, min_periods=minp), roll_func)(
-        **kwargs
-    )
-    expected = getattr(series.rolling(len(series), min_periods=minp), roll_func)(
-        **kwargs
-    )
+def test_min_periods(series, minp, roll_func, kwargs, step):
+    result = getattr(
+        series.rolling(len(series) + 1, min_periods=minp, step=step), roll_func
+    )(**kwargs)
+    expected = getattr(
+        series.rolling(len(series), min_periods=minp, step=step), roll_func
+    )(**kwargs)
     nan_mask = isna(result)
     tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -214,9 +216,9 @@ def test_min_periods(series, minp, roll_func, kwargs):
     tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
 
 
-def test_min_periods_count(series):
-    result = series.rolling(len(series) + 1, min_periods=0).count()
-    expected = series.rolling(len(series), min_periods=0).count()
+def test_min_periods_count(series, step):
+    result = series.rolling(len(series) + 1, min_periods=0, step=step).count()
+    expected = series.rolling(len(series), min_periods=0, step=step).count()
     nan_mask = isna(result)
     tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -247,9 +249,13 @@ def test_center(roll_func, kwargs, minp):
     result = getattr(obj.rolling(20, min_periods=minp, center=True), roll_func)(
         **kwargs
     )
-    expected = getattr(
-        concat([obj, Series([np.NaN] * 9)]).rolling(20, min_periods=minp), roll_func
-    )(**kwargs)[9:].reset_index(drop=True)
+    expected = (
+        getattr(
+            concat([obj, Series([np.NaN] * 9)]).rolling(20, min_periods=minp), roll_func
+        )(**kwargs)
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
     tm.assert_series_equal(result, expected)
 
 
@@ -360,7 +366,7 @@ def test_rolling_functions_window_non_shrinkage(f):
     tm.assert_frame_equal(df_result, df_expected)
 
 
-def test_rolling_max_gh6297():
+def test_rolling_max_gh6297(step):
     """Replicate result expected in GH #6297"""
     indices = [datetime(1975, 1, i) for i in range(1, 6)]
     # So that we can have 2 datapoints on one of the days
@@ -374,12 +380,12 @@ def test_rolling_max_gh6297():
     expected = Series(
         [1.0, 2.0, 6.0, 4.0, 5.0],
         index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
-    )
-    x = series.resample("D").max().rolling(window=1).max()
+    )[::step]
+    x = series.resample("D").max().rolling(window=1, step=step).max()
     tm.assert_series_equal(expected, x)
 
 
-def test_rolling_max_resample():
+def test_rolling_max_resample(step):
 
     indices = [datetime(1975, 1, i) for i in range(1, 6)]
     # So that we can have 3 datapoints on last day (4, 10, and 20)
@@ -395,16 +401,16 @@ def test_rolling_max_resample():
     expected = Series(
         [0.0, 1.0, 2.0, 3.0, 20.0],
         index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
-    )
-    x = series.resample("D").max().rolling(window=1).max()
+    )[::step]
+    x = series.resample("D").max().rolling(window=1, step=step).max()
     tm.assert_series_equal(expected, x)
 
     # Now specify median (10.0)
     expected = Series(
         [0.0, 1.0, 2.0, 3.0, 10.0],
         index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
-    )
-    x = series.resample("D").median().rolling(window=1).max()
+    )[::step]
+    x = series.resample("D").median().rolling(window=1, step=step).max()
     tm.assert_series_equal(expected, x)
 
     # Now specify mean (4+10+20)/3
@@ -412,12 +418,12 @@ def test_rolling_max_resample():
     expected = Series(
         [0.0, 1.0, 2.0, 3.0, v],
         index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
-    )
-    x = series.resample("D").mean().rolling(window=1).max()
+    )[::step]
+    x = series.resample("D").mean().rolling(window=1, step=step).max()
     tm.assert_series_equal(expected, x)
 
 
-def test_rolling_min_resample():
+def test_rolling_min_resample(step):
 
     indices = [datetime(1975, 1, i) for i in range(1, 6)]
     # So that we can have 3 datapoints on last day (4, 10, and 20)
@@ -433,8 +439,8 @@ def test_rolling_min_resample():
     expected = Series(
         [0.0, 1.0, 2.0, 3.0, 4.0],
         index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
-    )
-    r = series.resample("D").min().rolling(window=1)
+    )[::step]
+    r = series.resample("D").min().rolling(window=1, step=step)
     tm.assert_series_equal(expected, r.min())
 
 
diff --git a/pandas/tests/window/test_rolling_quantile.py b/pandas/tests/window/test_rolling_quantile.py
index 56681c2aaa57e..815ee419590f7 100644
--- a/pandas/tests/window/test_rolling_quantile.py
+++ b/pandas/tests/window/test_rolling_quantile.py
@@ -34,21 +34,23 @@ def scoreatpercentile(a, per):
 
 
 @pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
-def test_series(series, q):
+def test_series(series, q, step):
     compare_func = partial(scoreatpercentile, per=q)
-    result = series.rolling(50).quantile(q)
+    result = series.rolling(50, step=step).quantile(q)
     assert isinstance(result, Series)
-    tm.assert_almost_equal(result.iloc[-1], compare_func(series[-50:]))
+    end = range(0, len(series), step or 1)[-1] + 1
+    tm.assert_almost_equal(result.iloc[-1], compare_func(series[end - 50 : end]))
 
 
 @pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
-def test_frame(raw, frame, q):
+def test_frame(raw, frame, q, step):
     compare_func = partial(scoreatpercentile, per=q)
-    result = frame.rolling(50).quantile(q)
+    result = frame.rolling(50, step=step).quantile(q)
     assert isinstance(result, DataFrame)
+    end = range(0, len(frame), step or 1)[-1] + 1
     tm.assert_series_equal(
         result.iloc[-1, :],
-        frame.iloc[-50:, :].apply(compare_func, axis=0, raw=raw),
+        frame.iloc[end - 50 : end, :].apply(compare_func, axis=0, raw=raw),
         check_names=False,
     )
 
@@ -113,9 +115,9 @@ def test_nans(q):
 
 @pytest.mark.parametrize("minp", [0, 99, 100])
 @pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
-def test_min_periods(series, minp, q):
-    result = series.rolling(len(series) + 1, min_periods=minp).quantile(q)
-    expected = series.rolling(len(series), min_periods=minp).quantile(q)
+def test_min_periods(series, minp, q, step):
+    result = series.rolling(len(series) + 1, min_periods=minp, step=step).quantile(q)
+    expected = series.rolling(len(series), min_periods=minp, step=step).quantile(q)
     nan_mask = isna(result)
     tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -133,7 +135,8 @@ def test_center(q):
     expected = (
         concat([obj, Series([np.NaN] * 9)])
         .rolling(20)
-        .quantile(q)[9:]
+        .quantile(q)
+        .iloc[9:]
         .reset_index(drop=True)
     )
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_rolling_skew_kurt.py b/pandas/tests/window/test_rolling_skew_kurt.py
index 2c275ed6f4a28..4489fada9c11e 100644
--- a/pandas/tests/window/test_rolling_skew_kurt.py
+++ b/pandas/tests/window/test_rolling_skew_kurt.py
@@ -112,9 +112,13 @@ def test_nans(sp_func, roll_func):
 
 @pytest.mark.parametrize("minp", [0, 99, 100])
 @pytest.mark.parametrize("roll_func", ["kurt", "skew"])
-def test_min_periods(series, minp, roll_func):
-    result = getattr(series.rolling(len(series) + 1, min_periods=minp), roll_func)()
-    expected = getattr(series.rolling(len(series), min_periods=minp), roll_func)()
+def test_min_periods(series, minp, roll_func, step):
+    result = getattr(
+        series.rolling(len(series) + 1, min_periods=minp, step=step), roll_func
+    )()
+    expected = getattr(
+        series.rolling(len(series), min_periods=minp, step=step), roll_func
+    )()
     nan_mask = isna(result)
     tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -129,9 +133,11 @@ def test_center(roll_func):
     obj[-10:] = np.NaN
 
     result = getattr(obj.rolling(20, center=True), roll_func)()
-    expected = getattr(concat([obj, Series([np.NaN] * 9)]).rolling(20), roll_func)()[
-        9:
-    ].reset_index(drop=True)
+    expected = (
+        getattr(concat([obj, Series([np.NaN] * 9)]).rolling(20), roll_func)()
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
     tm.assert_series_equal(result, expected)
 
 
@@ -170,55 +176,61 @@ def test_center_reindex_frame(frame, roll_func):
     tm.assert_frame_equal(frame_xp, frame_rs)
 
 
-def test_rolling_skew_edge_cases():
-
-    all_nan = Series([np.NaN] * 5)
+def test_rolling_skew_edge_cases(step):
 
+    expected = Series([np.NaN] * 4 + [0.0])[::step]
     # yields all NaN (0 variance)
     d = Series([1] * 5)
-    x = d.rolling(window=5).skew()
-    tm.assert_series_equal(all_nan, x)
+    x = d.rolling(window=5, step=step).skew()
+    # index 4 should be 0 as it contains 5 same obs
+    tm.assert_series_equal(expected, x)
 
+    expected = Series([np.NaN] * 5)[::step]
     # yields all NaN (window too small)
     d = Series(np.random.randn(5))
-    x = d.rolling(window=2).skew()
-    tm.assert_series_equal(all_nan, x)
+    x = d.rolling(window=2, step=step).skew()
+    tm.assert_series_equal(expected, x)
 
     # yields [NaN, NaN, NaN, 0.177994, 1.548824]
     d = Series([-1.50837035, -0.1297039, 0.19501095, 1.73508164, 0.41941401])
-    expected = Series([np.NaN, np.NaN, np.NaN, 0.177994, 1.548824])
-    x = d.rolling(window=4).skew()
+    expected = Series([np.NaN, np.NaN, np.NaN, 0.177994, 1.548824])[::step]
+    x = d.rolling(window=4, step=step).skew()
     tm.assert_series_equal(expected, x)
 
 
-def test_rolling_kurt_edge_cases():
+def test_rolling_kurt_edge_cases(step):
 
-    all_nan = Series([np.NaN] * 5)
+    expected = Series([np.NaN] * 4 + [-3.0])[::step]
 
     # yields all NaN (0 variance)
     d = Series([1] * 5)
-    x = d.rolling(window=5).kurt()
-    tm.assert_series_equal(all_nan, x)
+    x = d.rolling(window=5, step=step).kurt()
+    tm.assert_series_equal(expected, x)
 
     # yields all NaN (window too small)
+    expected = Series([np.NaN] * 5)[::step]
     d = Series(np.random.randn(5))
-    x = d.rolling(window=3).kurt()
-    tm.assert_series_equal(all_nan, x)
+    x = d.rolling(window=3, step=step).kurt()
+    tm.assert_series_equal(expected, x)
 
     # yields [NaN, NaN, NaN, 1.224307, 2.671499]
     d = Series([-1.50837035, -0.1297039, 0.19501095, 1.73508164, 0.41941401])
-    expected = Series([np.NaN, np.NaN, np.NaN, 1.224307, 2.671499])
-    x = d.rolling(window=4).kurt()
+    expected = Series([np.NaN, np.NaN, np.NaN, 1.224307, 2.671499])[::step]
+    x = d.rolling(window=4, step=step).kurt()
     tm.assert_series_equal(expected, x)
 
 
-def test_rolling_skew_eq_value_fperr():
+def test_rolling_skew_eq_value_fperr(step):
     # #18804 all rolling skew for all equal values should return Nan
-    a = Series([1.1] * 15).rolling(window=10).skew()
-    assert np.isnan(a).all()
+    # #46717 update: all equal values should return 0 instead of NaN
+    a = Series([1.1] * 15).rolling(window=10, step=step).skew()
+    assert (a[a.index >= 9] == 0).all()
+    assert a[a.index < 9].isna().all()
 
 
-def test_rolling_kurt_eq_value_fperr():
+def test_rolling_kurt_eq_value_fperr(step):
     # #18804 all rolling kurt for all equal values should return Nan
-    a = Series([1.1] * 15).rolling(window=10).kurt()
-    assert np.isnan(a).all()
+    # #46717 update: all equal values should return -3 instead of NaN
+    a = Series([1.1] * 15).rolling(window=10, step=step).kurt()
+    assert (a[a.index >= 9] == -3).all()
+    assert a[a.index < 9].isna().all()
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index f2cf7bd47e15b..907c654570273 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -5,35 +5,40 @@
     DataFrame,
     Index,
     MultiIndex,
+    NaT,
     Series,
     Timestamp,
     date_range,
-    to_datetime,
 )
 import pandas._testing as tm
 
 import pandas.tseries.offsets as offsets
 
 
-class TestRollingTS:
+@pytest.fixture
+def regular():
+    return DataFrame(
+        {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+    ).set_index("A")
 
-    # rolling time-series friendly
-    # xref GH13327
 
-    def setup_method(self, method):
+@pytest.fixture
+def ragged():
+    df = DataFrame({"B": range(5)})
+    df.index = [
+        Timestamp("20130101 09:00:00"),
+        Timestamp("20130101 09:00:02"),
+        Timestamp("20130101 09:00:03"),
+        Timestamp("20130101 09:00:05"),
+        Timestamp("20130101 09:00:06"),
+    ]
+    return df
 
-        self.regular = DataFrame(
-            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
-        ).set_index("A")
 
-        self.ragged = DataFrame({"B": range(5)})
-        self.ragged.index = [
-            Timestamp("20130101 09:00:00"),
-            Timestamp("20130101 09:00:02"),
-            Timestamp("20130101 09:00:03"),
-            Timestamp("20130101 09:00:05"),
-            Timestamp("20130101 09:00:06"),
-        ]
+class TestRollingTS:
+
+    # rolling time-series friendly
+    # xref GH13327
 
     def test_doc_string(self):
 
@@ -50,42 +55,42 @@ def test_doc_string(self):
         df
         df.rolling("2s").sum()
 
-    def test_invalid_window_non_int(self):
+    def test_invalid_window_non_int(self, regular):
 
         # not a valid freq
         msg = "passed window foobar is not compatible with a datetimelike index"
         with pytest.raises(ValueError, match=msg):
-            self.regular.rolling(window="foobar")
+            regular.rolling(window="foobar")
         # not a datetimelike index
         msg = "window must be an integer"
         with pytest.raises(ValueError, match=msg):
-            self.regular.reset_index().rolling(window="foobar")
+            regular.reset_index().rolling(window="foobar")
 
     @pytest.mark.parametrize("freq", ["2MS", offsets.MonthBegin(2)])
-    def test_invalid_window_nonfixed(self, freq):
+    def test_invalid_window_nonfixed(self, freq, regular):
 
         # non-fixed freqs
         msg = "\\<2 \\* MonthBegins\\> is a non-fixed frequency"
         with pytest.raises(ValueError, match=msg):
-            self.regular.rolling(window=freq)
+            regular.rolling(window=freq)
 
     @pytest.mark.parametrize("freq", ["1D", offsets.Day(2), "2ms"])
-    def test_valid_window(self, freq):
-        self.regular.rolling(window=freq)
+    def test_valid_window(self, freq, regular):
+        regular.rolling(window=freq)
 
     @pytest.mark.parametrize("minp", [1.0, "foo", np.array([1, 2, 3])])
-    def test_invalid_minp(self, minp):
+    def test_invalid_minp(self, minp, regular):
         # non-integer min_periods
         msg = (
             r"local variable 'minp' referenced before assignment|"
             "min_periods must be an integer"
         )
         with pytest.raises(ValueError, match=msg):
-            self.regular.rolling(window="1D", min_periods=minp)
+            regular.rolling(window="1D", min_periods=minp)
 
-    def test_on(self):
+    def test_on(self, regular):
 
-        df = self.regular
+        df = regular
 
         # not a valid column
         msg = (
@@ -115,11 +120,11 @@ def test_monotonic_on(self):
             {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
         )
 
-        assert df.A.is_monotonic
+        assert df.A.is_monotonic_increasing
         df.rolling("2s", on="A").sum()
 
         df = df.set_index("A")
-        assert df.index.is_monotonic
+        assert df.index.is_monotonic_increasing
         df.rolling("2s").sum()
 
     def test_non_monotonic_on(self):
@@ -132,9 +137,9 @@ def test_non_monotonic_on(self):
         non_monotonic_index[0] = non_monotonic_index[3]
         df.index = non_monotonic_index
 
-        assert not df.index.is_monotonic
+        assert not df.index.is_monotonic_increasing
 
-        msg = "index must be monotonic"
+        msg = "index values must be monotonic"
         with pytest.raises(ValueError, match=msg):
             df.rolling("2s").sum()
 
@@ -217,9 +222,9 @@ def test_frame_on2(self):
         result = df.rolling("2s", on="C")[["A", "B", "C"]].sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_basic_regular(self):
+    def test_basic_regular(self, regular):
 
-        df = self.regular.copy()
+        df = regular.copy()
 
         df.index = date_range("20130101", periods=5, freq="D")
         expected = df.rolling(window=1, min_periods=1).sum()
@@ -239,10 +244,10 @@ def test_basic_regular(self):
         result = df.rolling(window="2D").sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_min_periods(self):
+    def test_min_periods(self, regular):
 
         # compare for min_periods
-        df = self.regular
+        df = regular
 
         # these slightly different
         expected = df.rolling(2, min_periods=1).sum()
@@ -253,7 +258,7 @@ def test_min_periods(self):
         result = df.rolling("2s", min_periods=1).sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_closed(self):
+    def test_closed(self, regular):
 
         # xref GH13965
 
@@ -271,7 +276,7 @@ def test_closed(self):
         # closed must be 'right', 'left', 'both', 'neither'
         msg = "closed must be 'right', 'left', 'both' or 'neither'"
         with pytest.raises(ValueError, match=msg):
-            self.regular.rolling(window="2s", closed="blabla")
+            regular.rolling(window="2s", closed="blabla")
 
         expected = df.copy()
         expected["A"] = [1.0, 2, 2, 2, 1]
@@ -297,9 +302,9 @@ def test_closed(self):
         result = df.rolling("2s", closed="neither").sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_sum(self):
+    def test_ragged_sum(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).sum()
         expected = df.copy()
         expected["B"] = [0.0, 1, 2, 3, 4]
@@ -340,9 +345,9 @@ def test_ragged_sum(self):
         expected["B"] = [0.0, 1, 3, 6, 10]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_mean(self):
+    def test_ragged_mean(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).mean()
         expected = df.copy()
         expected["B"] = [0.0, 1, 2, 3, 4]
@@ -353,9 +358,9 @@ def test_ragged_mean(self):
         expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_median(self):
+    def test_ragged_median(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).median()
         expected = df.copy()
         expected["B"] = [0.0, 1, 2, 3, 4]
@@ -366,9 +371,9 @@ def test_ragged_median(self):
         expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_quantile(self):
+    def test_ragged_quantile(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).quantile(0.5)
         expected = df.copy()
         expected["B"] = [0.0, 1, 2, 3, 4]
@@ -379,9 +384,9 @@ def test_ragged_quantile(self):
         expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_std(self):
+    def test_ragged_std(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).std(ddof=0)
         expected = df.copy()
         expected["B"] = [0.0] * 5
@@ -402,9 +407,9 @@ def test_ragged_std(self):
         expected["B"] = [np.nan, 0.707107, 1.0, 1.0, 1.290994]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_var(self):
+    def test_ragged_var(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).var(ddof=0)
         expected = df.copy()
         expected["B"] = [0.0] * 5
@@ -425,9 +430,9 @@ def test_ragged_var(self):
         expected["B"] = [np.nan, 0.5, 1.0, 1.0, 1 + 2 / 3.0]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_skew(self):
+    def test_ragged_skew(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="3s", min_periods=1).skew()
         expected = df.copy()
         expected["B"] = [np.nan] * 5
@@ -438,9 +443,9 @@ def test_ragged_skew(self):
         expected["B"] = [np.nan] * 2 + [0.0, 0.0, 0.0]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_kurt(self):
+    def test_ragged_kurt(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="3s", min_periods=1).kurt()
         expected = df.copy()
         expected["B"] = [np.nan] * 5
@@ -451,15 +456,15 @@ def test_ragged_kurt(self):
         expected["B"] = [np.nan] * 4 + [-1.2]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_count(self):
+    def test_ragged_count(self, ragged):
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s", min_periods=1).count()
         expected = df.copy()
         expected["B"] = [1.0, 1, 1, 1, 1]
         tm.assert_frame_equal(result, expected)
 
-        df = self.ragged
+        df = ragged
         result = df.rolling(window="1s").count()
         tm.assert_frame_equal(result, expected)
 
@@ -498,9 +503,9 @@ def test_regular_min(self):
         expected["B"] = [5.0, 4, 3, 3, 3]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_min(self):
+    def test_ragged_min(self, ragged):
 
-        df = self.ragged
+        df = ragged
 
         result = df.rolling(window="1s", min_periods=1).min()
         expected = df.copy()
@@ -532,9 +537,9 @@ def test_perf_min(self):
         result = dfp.rolling("200s").min()
         assert ((result - expected) < 0.01).all().bool()
 
-    def test_ragged_max(self):
+    def test_ragged_max(self, ragged):
 
-        df = self.ragged
+        df = ragged
 
         result = df.rolling(window="1s", min_periods=1).max()
         expected = df.copy()
@@ -600,10 +605,10 @@ def test_freqs_ops(self, freq, op, result_data):
             "max",
         ],
     )
-    def test_all(self, f):
+    def test_all(self, f, regular):
 
         # simple comparison of integer vs time-based windowing
-        df = self.regular * 2
+        df = regular * 2
         er = df.rolling(window=1)
         r = df.rolling(window="1s")
 
@@ -643,65 +648,6 @@ def agg_by_day(x):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_groupby_monotonic(self):
-
-        # GH 15130
-        # we don't need to validate monotonicity when grouping
-
-        # GH 43909 we should raise an error here to match
-        # behaviour of non-groupby rolling.
-
-        data = [
-            ["David", "1/1/2015", 100],
-            ["David", "1/5/2015", 500],
-            ["David", "5/30/2015", 50],
-            ["David", "7/25/2015", 50],
-            ["Ryan", "1/4/2014", 100],
-            ["Ryan", "1/19/2015", 500],
-            ["Ryan", "3/31/2016", 50],
-            ["Joe", "7/1/2015", 100],
-            ["Joe", "9/9/2015", 500],
-            ["Joe", "10/15/2015", 50],
-        ]
-
-        df = DataFrame(data=data, columns=["name", "date", "amount"])
-        df["date"] = to_datetime(df["date"])
-        df = df.sort_values("date")
-
-        expected = (
-            df.set_index("date")
-            .groupby("name")
-            .apply(lambda x: x.rolling("180D")["amount"].sum())
-        )
-        result = df.groupby("name").rolling("180D", on="date")["amount"].sum()
-        tm.assert_series_equal(result, expected)
-
-    def test_non_monotonic_raises(self):
-        # GH 13966 (similar to #15130, closed by #15175)
-
-        # superseded by 43909
-
-        dates = date_range(start="2016-01-01 09:30:00", periods=20, freq="s")
-        df = DataFrame(
-            {
-                "A": [1] * 20 + [2] * 12 + [3] * 8,
-                "B": np.concatenate((dates, dates)),
-                "C": np.arange(40),
-            }
-        )
-
-        expected = (
-            df.set_index("B").groupby("A").apply(lambda x: x.rolling("4s")["C"].mean())
-        )
-        with pytest.raises(ValueError, match=r".* must be monotonic"):
-            df.groupby("A").rolling(
-                "4s", on="B"
-            ).C.mean()  # should raise for non-monotonic t series
-
-        df2 = df.sort_values("B")
-        result = df2.groupby("A").rolling("4s", on="B").C.mean()
-        tm.assert_series_equal(result, expected)
-
     def test_rolling_cov_offset(self):
         # GH16058
 
@@ -757,3 +703,12 @@ def test_rolling_on_multi_index_level(self):
             {"column": [0.0, 1.0, 3.0, 6.0, 10.0, 15.0]}, index=df.index
         )
         tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("msg, axis", [["column", 1], ["index", 0]])
+def test_nat_axis_error(msg, axis):
+    idx = [Timestamp("2020"), NaT]
+    kwargs = {"columns" if axis == 1 else "index": idx}
+    df = DataFrame(np.eye(2), **kwargs)
+    with pytest.raises(ValueError, match=f"{msg} values must not have NaT"):
+        df.rolling("D", axis=axis).mean()
diff --git a/pandas/tests/window/test_win_type.py b/pandas/tests/window/test_win_type.py
index 6e0edc9e8500c..ba80ac19a6b6a 100644
--- a/pandas/tests/window/test_win_type.py
+++ b/pandas/tests/window/test_win_type.py
@@ -15,6 +15,27 @@
 from pandas.api.indexers import BaseIndexer
 
 
+@pytest.fixture(
+    params=[
+        "triang",
+        "blackman",
+        "hamming",
+        "bartlett",
+        "bohman",
+        "blackmanharris",
+        "nuttall",
+        "barthann",
+    ]
+)
+def win_types(request):
+    return request.param
+
+
+@pytest.fixture(params=["kaiser", "gaussian", "general_gaussian", "exponential"])
+def win_types_special(request):
+    return request.param
+
+
 @td.skip_if_no_scipy
 def test_constructor(frame_or_series):
     # GH 12669
@@ -58,12 +79,16 @@ def test_numpy_compat(method):
     # see gh-12811
     w = Series([2, 4, 6]).rolling(window=2)
 
-    msg = "numpy operations are not valid with window objects"
+    error_msg = "numpy operations are not valid with window objects"
 
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(w, method)(1, 2, 3)
-    with pytest.raises(UnsupportedFunctionCall, match=msg):
-        getattr(w, method)(dtype=np.float64)
+    warn_msg = f"Passing additional args to Rolling.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(w, method)(1, 2, 3)
+    warn_msg = f"Passing additional kwargs to Rolling.{method}"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        with pytest.raises(UnsupportedFunctionCall, match=error_msg):
+            getattr(w, method)(dtype=np.float64)
 
 
 @td.skip_if_no_scipy
@@ -104,10 +129,10 @@ def test_constructor_with_win_type_invalid(frame_or_series):
 
 @td.skip_if_no_scipy
 @pytest.mark.filterwarnings("ignore:can't resolve:ImportWarning")
-def test_window_with_args():
+def test_window_with_args(step):
     # make sure that we are aggregating window functions correctly with arg
     r = Series(np.random.randn(100)).rolling(
-        window=10, min_periods=1, win_type="gaussian"
+        window=10, min_periods=1, win_type="gaussian", step=step
     )
     expected = concat([r.mean(std=10), r.mean(std=0.01)], axis=1)
     expected.columns = ["<lambda>", "<lambda>"]
@@ -152,7 +177,7 @@ def test_win_type_freq_return_deprecation():
 @td.skip_if_no_scipy
 def test_win_type_not_implemented():
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
             return np.array([0, 1]), np.array([1, 2])
 
     df = DataFrame({"values": range(2)})
@@ -162,10 +187,10 @@ def get_window_bounds(self, num_values, min_periods, center, closed):
 
 
 @td.skip_if_no_scipy
-def test_cmov_mean():
+def test_cmov_mean(step):
     # GH 8238
     vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
-    result = Series(vals).rolling(5, center=True).mean()
+    result = Series(vals).rolling(5, center=True, step=step).mean()
     expected_values = [
         np.nan,
         np.nan,
@@ -178,15 +203,15 @@ def test_cmov_mean():
         np.nan,
         np.nan,
     ]
-    expected = Series(expected_values)
+    expected = Series(expected_values)[::step]
     tm.assert_series_equal(expected, result)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window():
+def test_cmov_window(step):
     # GH 8238
     vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
-    result = Series(vals).rolling(5, win_type="boxcar", center=True).mean()
+    result = Series(vals).rolling(5, win_type="boxcar", center=True, step=step).mean()
     expected_values = [
         np.nan,
         np.nan,
@@ -199,28 +224,28 @@ def test_cmov_window():
         np.nan,
         np.nan,
     ]
-    expected = Series(expected_values)
+    expected = Series(expected_values)[::step]
     tm.assert_series_equal(expected, result)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_corner():
+def test_cmov_window_corner(step):
     # GH 8238
     # all nan
     vals = Series([np.nan] * 10)
-    result = vals.rolling(5, center=True, win_type="boxcar").mean()
+    result = vals.rolling(5, center=True, win_type="boxcar", step=step).mean()
     assert np.isnan(result).all()
 
     # empty
     vals = Series([], dtype=object)
-    result = vals.rolling(5, center=True, win_type="boxcar").mean()
+    result = vals.rolling(5, center=True, win_type="boxcar", step=step).mean()
     assert len(result) == 0
 
     # shorter than window
     vals = Series(np.random.randn(5))
-    result = vals.rolling(10, win_type="boxcar").mean()
+    result = vals.rolling(10, win_type="boxcar", step=step).mean()
     assert np.isnan(result).all()
-    assert len(result) == 5
+    assert len(result) == len(range(0, 5, step or 1))
 
 
 @td.skip_if_no_scipy
@@ -289,7 +314,7 @@ def test_cmov_window_corner():
         ),
     ],
 )
-def test_cmov_window_frame(f, xp):
+def test_cmov_window_frame(f, xp, step):
     # Gh 8238
     df = DataFrame(
         np.array(
@@ -307,28 +332,30 @@ def test_cmov_window_frame(f, xp):
             ]
         )
     )
-    xp = DataFrame(np.array(xp))
+    xp = DataFrame(np.array(xp))[::step]
 
-    roll = df.rolling(5, win_type="boxcar", center=True)
+    roll = df.rolling(5, win_type="boxcar", center=True, step=step)
     rs = getattr(roll, f)()
 
     tm.assert_frame_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_na_min_periods():
+def test_cmov_window_na_min_periods(step):
     # min_periods
     vals = Series(np.random.randn(10))
     vals[4] = np.nan
     vals[8] = np.nan
 
-    xp = vals.rolling(5, min_periods=4, center=True).mean()
-    rs = vals.rolling(5, win_type="boxcar", min_periods=4, center=True).mean()
+    xp = vals.rolling(5, min_periods=4, center=True, step=step).mean()
+    rs = vals.rolling(
+        5, win_type="boxcar", min_periods=4, center=True, step=step
+    ).mean()
     tm.assert_series_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_regular(win_types):
+def test_cmov_window_regular(win_types, step):
     # GH 8238
     vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
     xps = {
@@ -430,26 +457,26 @@ def test_cmov_window_regular(win_types):
         ],
     }
 
-    xp = Series(xps[win_types])
-    rs = Series(vals).rolling(5, win_type=win_types, center=True).mean()
+    xp = Series(xps[win_types])[::step]
+    rs = Series(vals).rolling(5, win_type=win_types, center=True, step=step).mean()
     tm.assert_series_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_regular_linear_range(win_types):
+def test_cmov_window_regular_linear_range(win_types, step):
     # GH 8238
     vals = np.array(range(10), dtype=float)
     xp = vals.copy()
     xp[:2] = np.nan
     xp[-2:] = np.nan
-    xp = Series(xp)
+    xp = Series(xp)[::step]
 
-    rs = Series(vals).rolling(5, win_type=win_types, center=True).mean()
+    rs = Series(vals).rolling(5, win_type=win_types, center=True, step=step).mean()
     tm.assert_series_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_regular_missing_data(win_types):
+def test_cmov_window_regular_missing_data(win_types, step):
     # GH 8238
     vals = np.array(
         [6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, np.nan, 10.63, 14.48]
@@ -553,13 +580,13 @@ def test_cmov_window_regular_missing_data(win_types):
         ],
     }
 
-    xp = Series(xps[win_types])
-    rs = Series(vals).rolling(5, win_type=win_types, min_periods=3).mean()
+    xp = Series(xps[win_types])[::step]
+    rs = Series(vals).rolling(5, win_type=win_types, min_periods=3, step=step).mean()
     tm.assert_series_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_special(win_types_special):
+def test_cmov_window_special(win_types_special, step):
     # GH 8238
     kwds = {
         "kaiser": {"beta": 1.0},
@@ -621,17 +648,17 @@ def test_cmov_window_special(win_types_special):
         ],
     }
 
-    xp = Series(xps[win_types_special])
+    xp = Series(xps[win_types_special])[::step]
     rs = (
         Series(vals)
-        .rolling(5, win_type=win_types_special, center=True)
+        .rolling(5, win_type=win_types_special, center=True, step=step)
         .mean(**kwds[win_types_special])
     )
     tm.assert_series_equal(xp, rs)
 
 
 @td.skip_if_no_scipy
-def test_cmov_window_special_linear_range(win_types_special):
+def test_cmov_window_special_linear_range(win_types_special, step):
     # GH 8238
     kwds = {
         "kaiser": {"beta": 1.0},
@@ -645,11 +672,36 @@ def test_cmov_window_special_linear_range(win_types_special):
     xp = vals.copy()
     xp[:2] = np.nan
     xp[-2:] = np.nan
-    xp = Series(xp)
+    xp = Series(xp)[::step]
 
     rs = (
         Series(vals)
-        .rolling(5, win_type=win_types_special, center=True)
+        .rolling(5, win_type=win_types_special, center=True, step=step)
         .mean(**kwds[win_types_special])
     )
     tm.assert_series_equal(xp, rs)
+
+
+@td.skip_if_no_scipy
+def test_weighted_var_big_window_no_segfault(win_types, center):
+    # Github Issue #46772
+    x = Series(0)
+    result = x.rolling(window=16, center=center, win_type=win_types).var()
+    expected = Series(np.NaN)
+
+    tm.assert_series_equal(result, expected)
+
+
+@td.skip_if_no_scipy
+def test_rolling_center_axis_1():
+    df = DataFrame(
+        {"a": [1, 1, 0, 0, 0, 1], "b": [1, 0, 0, 1, 0, 0], "c": [1, 0, 0, 1, 0, 1]}
+    )
+
+    result = df.rolling(window=3, axis=1, win_type="boxcar", center=True).sum()
+
+    expected = DataFrame(
+        {"a": [np.nan] * 6, "b": [3.0, 1.0, 0.0, 2.0, 0.0, 2.0], "c": [np.nan] * 6}
+    )
+
+    tm.assert_frame_equal(result, expected, check_dtype=True)
diff --git a/pandas/tseries/api.py b/pandas/tseries/api.py
index 59666fa0048dd..e274838d45b27 100644
--- a/pandas/tseries/api.py
+++ b/pandas/tseries/api.py
@@ -2,7 +2,7 @@
 Timeseries API
 """
 
-# flake8: noqa:F401
-
 from pandas.tseries.frequencies import infer_freq
 import pandas.tseries.offsets as offsets
+
+__all__ = ["infer_freq", "offsets"]
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 415af96a29aa3..9f553686ca829 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -7,7 +7,9 @@
 from pandas._libs.algos import unique_deltas
 from pandas._libs.tslibs import (
     Timestamp,
-    tzconversion,
+    get_unit_from_dtype,
+    periods_per_day,
+    tz_convert_from_utc,
 )
 from pandas._libs.tslibs.ccalendar import (
     DAYS,
@@ -20,7 +22,8 @@
     build_field_sarray,
     month_position_check,
 )
-from pandas._libs.tslibs.offsets import (  # noqa:F401
+from pandas._libs.tslibs.offsets import (
+    BaseOffset,
     DateOffset,
     Day,
     _get_offset,
@@ -36,17 +39,13 @@
     is_period_dtype,
     is_timedelta64_dtype,
 )
-from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.generic import (
+    ABCIndex,
+    ABCSeries,
+)
 
 from pandas.core.algorithms import unique
 
-_ONE_MICRO = 1000
-_ONE_MILLI = _ONE_MICRO * 1000
-_ONE_SECOND = _ONE_MILLI * 1000
-_ONE_MINUTE = 60 * _ONE_SECOND
-_ONE_HOUR = 60 * _ONE_MINUTE
-_ONE_DAY = 24 * _ONE_HOUR
-
 # ---------------------------------------------------------------------
 # Offset names ("time rules") and related functions
 
@@ -103,7 +102,7 @@ def get_period_alias(offset_str: str) -> str | None:
     return _offset_to_period_map.get(offset_str, None)
 
 
-def get_offset(name: str) -> DateOffset:
+def get_offset(name: str) -> BaseOffset:
     """
     Return DateOffset object associated with rule name.
 
@@ -128,14 +127,14 @@ def get_offset(name: str) -> DateOffset:
 
 def infer_freq(index, warn: bool = True) -> str | None:
     """
-    Infer the most likely frequency given the input index. If the frequency is
-    uncertain, a warning will be printed.
+    Infer the most likely frequency given the input index.
 
     Parameters
     ----------
     index : DatetimeIndex or TimedeltaIndex
       If passed a Series will use the values of the series (NOT THE INDEX).
     warn : bool, default True
+      .. deprecated:: 1.5.0
 
     Returns
     -------
@@ -208,18 +207,35 @@ class _FrequencyInferer:
     Not sure if I can avoid the state machine here
     """
 
-    def __init__(self, index, warn: bool = True):
+    def __init__(self, index, warn: bool = True) -> None:
         self.index = index
         self.i8values = index.asi8
 
+        # For get_unit_from_dtype we need the dtype to the underlying ndarray,
+        #  which for tz-aware is not the same as index.dtype
+        if isinstance(index, ABCIndex):
+            # error: Item "ndarray[Any, Any]" of "Union[ExtensionArray,
+            # ndarray[Any, Any]]" has no attribute "_ndarray"
+            self._reso = get_unit_from_dtype(
+                index._data._ndarray.dtype  # type: ignore[union-attr]
+            )
+        else:
+            # otherwise we have DTA/TDA
+            self._reso = get_unit_from_dtype(index._ndarray.dtype)
+
         # This moves the values, which are implicitly in UTC, to the
         # the timezone so they are in local time
         if hasattr(index, "tz"):
             if index.tz is not None:
-                self.i8values = tzconversion.tz_convert_from_utc(
-                    self.i8values, index.tz
-                )
-
+                self.i8values = tz_convert_from_utc(self.i8values, index.tz)
+
+        if warn is not True:
+            warnings.warn(
+                "warn is deprecated (and never implemented) and "
+                "will be removed in a future version.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
         self.warn = warn
 
         if len(index) < 3:
@@ -260,7 +276,8 @@ def get_freq(self) -> str | None:
             return None
 
         delta = self.deltas[0]
-        if delta and _is_multiple(delta, _ONE_DAY):
+        ppd = periods_per_day(self._reso)
+        if delta and _is_multiple(delta, ppd):
             return self._infer_daily_rule()
 
         # Business hourly, maybe. 17: one day / 65: one weekend
@@ -274,42 +291,47 @@ def get_freq(self) -> str | None:
             return None
 
         delta = self.deltas_asi8[0]
-        if _is_multiple(delta, _ONE_HOUR):
+        pph = ppd // 24
+        ppm = pph // 60
+        pps = ppm // 60
+        if _is_multiple(delta, pph):
             # Hours
-            return _maybe_add_count("H", delta / _ONE_HOUR)
-        elif _is_multiple(delta, _ONE_MINUTE):
+            return _maybe_add_count("H", delta / pph)
+        elif _is_multiple(delta, ppm):
             # Minutes
-            return _maybe_add_count("T", delta / _ONE_MINUTE)
-        elif _is_multiple(delta, _ONE_SECOND):
+            return _maybe_add_count("T", delta / ppm)
+        elif _is_multiple(delta, pps):
             # Seconds
-            return _maybe_add_count("S", delta / _ONE_SECOND)
-        elif _is_multiple(delta, _ONE_MILLI):
+            return _maybe_add_count("S", delta / pps)
+        elif _is_multiple(delta, (pps // 1000)):
             # Milliseconds
-            return _maybe_add_count("L", delta / _ONE_MILLI)
-        elif _is_multiple(delta, _ONE_MICRO):
+            return _maybe_add_count("L", delta / (pps // 1000))
+        elif _is_multiple(delta, (pps // 1_000_000)):
             # Microseconds
-            return _maybe_add_count("U", delta / _ONE_MICRO)
+            return _maybe_add_count("U", delta / (pps // 1_000_000))
         else:
             # Nanoseconds
             return _maybe_add_count("N", delta)
 
     @cache_readonly
-    def day_deltas(self):
-        return [x / _ONE_DAY for x in self.deltas]
+    def day_deltas(self) -> list[int]:
+        ppd = periods_per_day(self._reso)
+        return [x / ppd for x in self.deltas]
 
     @cache_readonly
-    def hour_deltas(self):
-        return [x / _ONE_HOUR for x in self.deltas]
+    def hour_deltas(self) -> list[int]:
+        pph = periods_per_day(self._reso) // 24
+        return [x / pph for x in self.deltas]
 
     @cache_readonly
     def fields(self) -> np.ndarray:  # structured array of fields
-        return build_field_sarray(self.i8values)
+        return build_field_sarray(self.i8values, reso=self._reso)
 
     @cache_readonly
-    def rep_stamp(self):
+    def rep_stamp(self) -> Timestamp:
         return Timestamp(self.i8values[0])
 
-    def month_position_check(self):
+    def month_position_check(self) -> str | None:
         return month_position_check(self.fields, self.index.dayofweek)
 
     @cache_readonly
@@ -354,7 +376,8 @@ def _infer_daily_rule(self) -> str | None:
         return None
 
     def _get_daily_rule(self) -> str | None:
-        days = self.deltas[0] / _ONE_DAY
+        ppd = periods_per_day(self._reso)
+        days = self.deltas[0] / ppd
         if days % 7 == 0:
             # Weekly
             wd = int_to_weekday[self.rep_stamp.weekday()]
@@ -371,7 +394,11 @@ def _get_annual_rule(self) -> str | None:
             return None
 
         pos_check = self.month_position_check()
-        return {"cs": "AS", "bs": "BAS", "ce": "A", "be": "BA"}.get(pos_check)
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "AS", "bs": "BAS", "ce": "A", "be": "BA"}.get(pos_check)
 
     def _get_quarterly_rule(self) -> str | None:
         if len(self.mdiffs) > 1:
@@ -381,13 +408,21 @@ def _get_quarterly_rule(self) -> str | None:
             return None
 
         pos_check = self.month_position_check()
-        return {"cs": "QS", "bs": "BQS", "ce": "Q", "be": "BQ"}.get(pos_check)
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "QS", "bs": "BQS", "ce": "Q", "be": "BQ"}.get(pos_check)
 
     def _get_monthly_rule(self) -> str | None:
         if len(self.mdiffs) > 1:
             return None
         pos_check = self.month_position_check()
-        return {"cs": "MS", "bs": "BMS", "ce": "M", "be": "BM"}.get(pos_check)
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "MS", "bs": "BMS", "ce": "M", "be": "BM"}.get(pos_check)
 
     def _is_business_daily(self) -> bool:
         # quick check: cannot be business daily
@@ -397,7 +432,8 @@ def _is_business_daily(self) -> bool:
         # probably business daily, but need to confirm
         first_weekday = self.index[0].weekday()
         shifts = np.diff(self.index.asi8)
-        shifts = np.floor_divide(shifts, _ONE_DAY)
+        ppd = periods_per_day(self._reso)
+        shifts = np.floor_divide(shifts, ppd)
         weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
 
         return bool(
@@ -611,3 +647,14 @@ def _is_monthly(rule: str) -> bool:
 def _is_weekly(rule: str) -> bool:
     rule = rule.upper()
     return rule == "W" or rule.startswith("W-")
+
+
+__all__ = [
+    "Day",
+    "get_offset",
+    "get_period_alias",
+    "infer_freq",
+    "is_subperiod",
+    "is_superperiod",
+    "to_offset",
+]
diff --git a/pandas/tseries/holiday.py b/pandas/tseries/holiday.py
index 10b09cbc34443..6426dbcd54489 100644
--- a/pandas/tseries/holiday.py
+++ b/pandas/tseries/holiday.py
@@ -6,7 +6,7 @@
 )
 import warnings
 
-from dateutil.relativedelta import (  # noqa:F401
+from dateutil.relativedelta import (
     FR,
     MO,
     SA,
@@ -160,7 +160,7 @@ def __init__(
         start_date=None,
         end_date=None,
         days_of_week=None,
-    ):
+    ) -> None:
         """
         Parameters
         ----------
@@ -177,35 +177,37 @@ class from pandas.tseries.offsets
 
         Examples
         --------
-        >>> from pandas.tseries.holiday import Holiday, nearest_workday
         >>> from dateutil.relativedelta import MO
 
-        >>> USMemorialDay = Holiday(
+        >>> USMemorialDay = pd.tseries.holiday.Holiday(
         ...     "Memorial Day", month=5, day=31, offset=pd.DateOffset(weekday=MO(-1))
         ... )
         >>> USMemorialDay
         Holiday: Memorial Day (month=5, day=31, offset=<DateOffset: weekday=MO(-1)>)
 
-        >>> USLaborDay = Holiday(
+        >>> USLaborDay = pd.tseries.holiday.Holiday(
         ...     "Labor Day", month=9, day=1, offset=pd.DateOffset(weekday=MO(1))
         ... )
         >>> USLaborDay
         Holiday: Labor Day (month=9, day=1, offset=<DateOffset: weekday=MO(+1)>)
 
-        >>> July3rd = Holiday("July 3rd", month=7, day=3)
+        >>> July3rd = pd.tseries.holiday.Holiday("July 3rd", month=7, day=3)
         >>> July3rd
         Holiday: July 3rd (month=7, day=3, )
 
-        >>> NewYears = Holiday(
+        >>> NewYears = pd.tseries.holiday.Holiday(
         ...     "New Years Day", month=1,  day=1,
-        ...      observance=nearest_workday
+        ...      observance=pd.tseries.holiday.nearest_workday
         ... )
         >>> NewYears  # doctest: +SKIP
         Holiday: New Years Day (
             month=1, day=1, observance=<function nearest_workday at 0x66545e9bc440>
         )
 
-        >>> July3rd = Holiday("July 3rd", month=7, day=3, days_of_week=(0, 1, 2, 3))
+        >>> July3rd = pd.tseries.holiday.Holiday(
+        ...     "July 3rd", month=7, day=3,
+        ...     days_of_week=(0, 1, 2, 3)
+        ... )
         >>> July3rd
         Holiday: July 3rd (month=7, day=3, )
         """
@@ -391,7 +393,7 @@ class AbstractHolidayCalendar(metaclass=HolidayCalendarMetaClass):
     end_date = Timestamp(datetime(2200, 12, 31))
     _cache = None
 
-    def __init__(self, name=None, rules=None):
+    def __init__(self, name=None, rules=None) -> None:
         """
         Initializes holiday object with a given set a rules.  Normally
         classes just have the rules defined within them.
@@ -580,3 +582,27 @@ def HolidayCalendarFactory(name, base, other, base_class=AbstractHolidayCalendar
     rules = AbstractHolidayCalendar.merge_class(base, other)
     calendar_class = type(name, (base_class,), {"rules": rules, "name": name})
     return calendar_class
+
+
+__all__ = [
+    "after_nearest_workday",
+    "before_nearest_workday",
+    "FR",
+    "get_calendar",
+    "HolidayCalendarFactory",
+    "MO",
+    "nearest_workday",
+    "next_monday",
+    "next_monday_or_tuesday",
+    "next_workday",
+    "previous_friday",
+    "previous_workday",
+    "register",
+    "SA",
+    "SU",
+    "sunday_to_monday",
+    "TH",
+    "TU",
+    "WE",
+    "weekend_to_monday",
+]
diff --git a/pandas/tseries/offsets.py b/pandas/tseries/offsets.py
index cee99d23f8d90..169c9cc18a7fd 100644
--- a/pandas/tseries/offsets.py
+++ b/pandas/tseries/offsets.py
@@ -1,4 +1,6 @@
-from pandas._libs.tslibs.offsets import (  # noqa:F401
+from __future__ import annotations
+
+from pandas._libs.tslibs.offsets import (
     FY5253,
     BaseOffset,
     BDay,
@@ -45,9 +47,14 @@
 
 __all__ = [
     "Day",
+    "BaseOffset",
     "BusinessDay",
+    "BusinessMonthBegin",
+    "BusinessMonthEnd",
     "BDay",
     "CustomBusinessDay",
+    "CustomBusinessMonthBegin",
+    "CustomBusinessMonthEnd",
     "CDay",
     "CBMonthEnd",
     "CBMonthBegin",
@@ -73,6 +80,7 @@
     "Week",
     "WeekOfMonth",
     "Easter",
+    "Tick",
     "Hour",
     "Minute",
     "Second",
diff --git a/pandas/util/__init__.py b/pandas/util/__init__.py
index 7adfca73c2f1e..6e6006dd28165 100644
--- a/pandas/util/__init__.py
+++ b/pandas/util/__init__.py
@@ -1,3 +1,4 @@
+# pyright: reportUnusedImport = false
 from pandas.util._decorators import (  # noqa:F401
     Appender,
     Substitution,
diff --git a/pandas/util/_decorators.py b/pandas/util/_decorators.py
index 39a729bc51f35..aa4b7cccf823c 100644
--- a/pandas/util/_decorators.py
+++ b/pandas/util/_decorators.py
@@ -11,8 +11,12 @@
 )
 import warnings
 
-from pandas._libs.properties import cache_readonly  # noqa:F401
-from pandas._typing import F
+from pandas._libs.properties import cache_readonly
+from pandas._typing import (
+    F,
+    T,
+)
+from pandas.util._exceptions import find_stack_level
 
 
 def deprecate(
@@ -260,7 +264,7 @@ def future_version_msg(version: str | None) -> str:
 def deprecate_nonkeyword_arguments(
     version: str | None,
     allowed_args: list[str] | None = None,
-    stacklevel: int = 2,
+    name: str | None = None,
 ) -> Callable[[F], F]:
     """
     Decorator to deprecate a use of non-keyword arguments of a function.
@@ -279,37 +283,56 @@ def deprecate_nonkeyword_arguments(
         defaults to list of all arguments not having the
         default value.
 
-    stacklevel : int, default=2
-        The stack level for warnings.warn
+    name : str, optional
+        The specific name of the function to show in the warning
+        message. If None, then the Qualified name of the function
+        is used.
     """
 
     def decorate(func):
+        old_sig = inspect.signature(func)
+
         if allowed_args is not None:
             allow_args = allowed_args
         else:
-            spec = inspect.getfullargspec(func)
+            allow_args = [
+                p.name
+                for p in old_sig.parameters.values()
+                if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                and p.default is p.empty
+            ]
 
-            # We must have some defaults if we are deprecating default-less
-            assert spec.defaults is not None  # for mypy
-            allow_args = spec.args[: -len(spec.defaults)]
+        new_params = [
+            p.replace(kind=p.KEYWORD_ONLY)
+            if (
+                p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                and p.name not in allow_args
+            )
+            else p
+            for p in old_sig.parameters.values()
+        ]
+        new_params.sort(key=lambda p: p.kind)
+        new_sig = old_sig.replace(parameters=new_params)
 
         num_allow_args = len(allow_args)
         msg = (
             f"{future_version_msg(version)} all arguments of "
-            f"{func.__qualname__}{{arguments}} will be keyword-only."
+            f"{name or func.__qualname__}{{arguments}} will be keyword-only."
         )
 
         @wraps(func)
         def wrapper(*args, **kwargs):
-            arguments = _format_argument_list(allow_args)
             if len(args) > num_allow_args:
                 warnings.warn(
-                    msg.format(arguments=arguments),
+                    msg.format(arguments=_format_argument_list(allow_args)),
                     FutureWarning,
-                    stacklevel=stacklevel,
+                    stacklevel=find_stack_level(),
                 )
             return func(*args, **kwargs)
 
+        # error: "Callable[[VarArg(Any), KwArg(Any)], Any]" has no
+        # attribute "__signature__"
+        wrapper.__signature__ = new_sig  # type: ignore[attr-defined]
         return wrapper
 
     return decorate
@@ -317,7 +340,7 @@ def wrapper(*args, **kwargs):
 
 def rewrite_axis_style_signature(
     name: str, extra_params: list[tuple[str, Any]]
-) -> Callable[..., Any]:
+) -> Callable[[F], F]:
     def decorate(func: F) -> F:
         @wraps(func)
         def wrapper(*args, **kwargs) -> Callable[..., Any]:
@@ -435,7 +458,7 @@ def some_function(x):
         "%s %s wrote the Raven"
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         if args and kwargs:
             raise AssertionError("Only positional or keyword args are allowed")
 
@@ -475,14 +498,14 @@ def my_dog(has='fleas'):
 
     addendum: str | None
 
-    def __init__(self, addendum: str | None, join: str = "", indents: int = 0):
+    def __init__(self, addendum: str | None, join: str = "", indents: int = 0) -> None:
         if indents > 0:
             self.addendum = indent(addendum, indents=indents)
         else:
             self.addendum = addendum
         self.join = join
 
-    def __call__(self, func: F) -> F:
+    def __call__(self, func: T) -> T:
         func.__doc__ = func.__doc__ if func.__doc__ else ""
         self.addendum = self.addendum if self.addendum else ""
         docitems = [func.__doc__, self.addendum]
@@ -495,3 +518,16 @@ def indent(text: str | None, indents: int = 1) -> str:
         return ""
     jointext = "".join(["\n"] + ["    "] * indents)
     return jointext.join(text.split("\n"))
+
+
+__all__ = [
+    "Appender",
+    "cache_readonly",
+    "deprecate",
+    "deprecate_kwarg",
+    "deprecate_nonkeyword_arguments",
+    "doc",
+    "future_version_msg",
+    "rewrite_axis_style_signature",
+    "Substitution",
+]
diff --git a/pandas/util/_doctools.py b/pandas/util/_doctools.py
index 0d90d9b2871d9..cb4ceb052a8e0 100644
--- a/pandas/util/_doctools.py
+++ b/pandas/util/_doctools.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Iterable
+
 import numpy as np
 
 import pandas as pd
@@ -16,7 +18,7 @@ def __init__(
         cell_width: float = 0.37,
         cell_height: float = 0.25,
         font_size: float = 7.5,
-    ):
+    ) -> None:
         self.cell_width = cell_width
         self.cell_height = cell_height
         self.font_size = font_size
@@ -41,7 +43,7 @@ def _get_cells(self, left, right, vertical) -> tuple[int, int]:
             hcells = sum([self._shape(df)[1] for df in left] + [self._shape(right)[1]])
         return hcells, vcells
 
-    def plot(self, left, right, labels=None, vertical: bool = True):
+    def plot(self, left, right, labels: Iterable[str] = (), vertical: bool = True):
         """
         Plot left / right DataFrames in specified layout.
 
diff --git a/pandas/util/_exceptions.py b/pandas/util/_exceptions.py
index 806e2abe83a92..f300f2c52f175 100644
--- a/pandas/util/_exceptions.py
+++ b/pandas/util/_exceptions.py
@@ -3,10 +3,13 @@
 import contextlib
 import inspect
 import os
+import re
+from typing import Iterator
+import warnings
 
 
 @contextlib.contextmanager
-def rewrite_exception(old_name: str, new_name: str):
+def rewrite_exception(old_name: str, new_name: str) -> Iterator[None]:
     """
     Rewrite the message of an exception.
     """
@@ -29,17 +32,63 @@ def find_stack_level() -> int:
     Find the first place in the stack that is not inside pandas
     (tests notwithstanding).
     """
-    stack = inspect.stack()
 
     import pandas as pd
 
     pkg_dir = os.path.dirname(pd.__file__)
     test_dir = os.path.join(pkg_dir, "tests")
 
-    for n in range(len(stack)):
-        fname = stack[n].filename
+    # https://stackoverflow.com/questions/17407119/python-inspect-stack-is-slow
+    frame = inspect.currentframe()
+    n = 0
+    while frame:
+        fname = inspect.getfile(frame)
         if fname.startswith(pkg_dir) and not fname.startswith(test_dir):
-            continue
+            frame = frame.f_back
+            n += 1
         else:
             break
     return n
+
+
+@contextlib.contextmanager
+def rewrite_warning(
+    target_message: str,
+    target_category: type[Warning],
+    new_message: str,
+    new_category: type[Warning] | None = None,
+) -> Iterator[None]:
+    """
+    Rewrite the message of a warning.
+
+    Parameters
+    ----------
+    target_message : str
+        Warning message to match.
+    target_category : Warning
+        Warning type to match.
+    new_message : str
+        New warning message to emit.
+    new_category : Warning or None, default None
+        New warning type to emit. When None, will be the same as target_category.
+    """
+    if new_category is None:
+        new_category = target_category
+    with warnings.catch_warnings(record=True) as record:
+        yield
+    if len(record) > 0:
+        match = re.compile(target_message)
+        for warning in record:
+            if warning.category is target_category and re.search(
+                match, str(warning.message)
+            ):
+                category = new_category
+                message: Warning | str = new_message
+            else:
+                category, message = warning.category, warning.message
+            warnings.warn_explicit(
+                message=message,
+                category=category,
+                filename=warning.filename,
+                lineno=warning.lineno,
+            )
diff --git a/pandas/util/_print_versions.py b/pandas/util/_print_versions.py
index 289900c47375c..91d518d1ab496 100644
--- a/pandas/util/_print_versions.py
+++ b/pandas/util/_print_versions.py
@@ -60,8 +60,8 @@ def _get_dependency_info() -> dict[str, JSONSerializable]:
         "pytz",
         "dateutil",
         # install / build,
-        "pip",
         "setuptools",
+        "pip",
         "Cython",
         # test
         "pytest",
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 7c5c0959ceaa0..dc49dc6adf378 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -27,7 +27,10 @@ def test_foo():
 
 from contextlib import contextmanager
 import locale
-from typing import Callable
+from typing import (
+    Callable,
+    Iterator,
+)
 import warnings
 
 import numpy as np
@@ -35,6 +38,7 @@ def test_foo():
 
 from pandas._config import get_option
 
+from pandas._typing import F
 from pandas.compat import (
     IS64,
     is_platform_windows,
@@ -72,10 +76,31 @@ def safe_import(mod_name: str, min_version: str | None = None):
             message=".*decorator is deprecated since Python 3.8.*",
         )
 
+        # fastparquet import accesses pd.Int64Index
+        warnings.filterwarnings(
+            "ignore",
+            category=FutureWarning,
+            module="fastparquet",
+            message=".*Int64Index.*",
+        )
+
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message="distutils Version classes are deprecated.*",
+        )
+
         try:
             mod = __import__(mod_name)
         except ImportError:
             return False
+        except SystemError:
+            # TODO: numba is incompatible with numpy 1.24+.
+            # Once that's fixed, this block should be removed.
+            if mod_name == "numba":
+                return False
+            else:
+                raise
 
     if not min_version:
         return mod
@@ -101,12 +126,6 @@ def _skip_if_no_mpl():
         return True
 
 
-def _skip_if_has_locale():
-    lang, _ = locale.getlocale()
-    if lang is not None:
-        return True
-
-
 def _skip_if_not_us_locale():
     lang, _ = locale.getlocale()
     if lang != "en_US":
@@ -184,9 +203,6 @@ def skip_if_no(package: str, min_version: str | None = None):
 skip_if_mpl = pytest.mark.skipif(not _skip_if_no_mpl(), reason="matplotlib is present")
 skip_if_32bit = pytest.mark.skipif(not IS64, reason="skipping for 32 bit")
 skip_if_windows = pytest.mark.skipif(is_platform_windows(), reason="Running on Windows")
-skip_if_has_locale = pytest.mark.skipif(
-    _skip_if_has_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
-)
 skip_if_not_us_locale = pytest.mark.skipif(
     _skip_if_not_us_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
 )
@@ -211,7 +227,7 @@ def skip_if_np_lt(ver_str: str, *args, reason: str | None = None):
     )
 
 
-def parametrize_fixture_doc(*args):
+def parametrize_fixture_doc(*args) -> Callable[[F], F]:
     """
     Intended for use as a decorator for parametrized fixture,
     this function will wrap the decorated function with a pytest
@@ -247,12 +263,13 @@ def check_file_leaks(func) -> Callable:
 
 
 @contextmanager
-def file_leak_context():
+def file_leak_context() -> Iterator[None]:
     """
     ContextManager analogue to check_file_leaks.
     """
     psutil = safe_import("psutil")
-    if not psutil:
+    if not psutil or is_platform_windows():
+        # Checking for file leaks can hang on Windows CI
         yield
     else:
         proc = psutil.Process()
@@ -283,7 +300,7 @@ def async_mark():
     return async_mark
 
 
-def mark_array_manager_not_yet_implemented(request):
+def mark_array_manager_not_yet_implemented(request) -> None:
     mark = pytest.mark.xfail(reason="Not yet implemented for ArrayManager")
     request.node.add_marker(mark)
 
diff --git a/pandas/util/_tester.py b/pandas/util/_tester.py
index 541776619a2d3..1b018a6a1ba34 100644
--- a/pandas/util/_tester.py
+++ b/pandas/util/_tester.py
@@ -1,21 +1,29 @@
 """
 Entrypoint for testing from the top-level namespace.
 """
+from __future__ import annotations
+
 import os
 import sys
 
+from pandas.compat._optional import import_optional_dependency
+
 PKG = os.path.dirname(os.path.dirname(__file__))
 
 
-def test(extra_args=None):
-    try:
-        import pytest
-    except ImportError as err:
-        raise ImportError("Need pytest>=5.0.1 to run tests") from err
-    try:
-        import hypothesis  # noqa:F401
-    except ImportError as err:
-        raise ImportError("Need hypothesis>=3.58 to run tests") from err
+def test(extra_args: list[str] | None = None):
+    """
+    Run the pandas test suite using pytest.
+
+    By default, runs with the marks --skip-slow, --skip-network, --skip-db
+
+    Parameters
+    ----------
+    extra_args : list[str], default None
+        Extra marks to run the tests.
+    """
+    pytest = import_optional_dependency("pytest")
+    import_optional_dependency("hypothesis")
     cmd = ["--skip-slow", "--skip-network", "--skip-db"]
     if extra_args:
         if not isinstance(extra_args, list):
diff --git a/pandas/util/_validators.py b/pandas/util/_validators.py
index 8e3de9404fbee..3ac391cb87b52 100644
--- a/pandas/util/_validators.py
+++ b/pandas/util/_validators.py
@@ -5,8 +5,11 @@
 from __future__ import annotations
 
 from typing import (
+    Any,
     Iterable,
     Sequence,
+    TypeVar,
+    overload,
 )
 import warnings
 
@@ -19,6 +22,9 @@
     is_integer,
 )
 
+BoolishT = TypeVar("BoolishT", bool, int)
+BoolishNoneT = TypeVar("BoolishNoneT", bool, int, None)
+
 
 def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
     """
@@ -78,7 +84,7 @@ def _check_for_default_values(fname, arg_val_dict, compat_args):
             )
 
 
-def validate_args(fname, args, max_fname_arg_count, compat_args):
+def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
     """
     Checks whether the length of the `*args` argument passed into a function
     has at most `len(compat_args)` arguments and whether or not all of these
@@ -132,7 +138,7 @@ def _check_for_invalid_keys(fname, kwargs, compat_args):
         raise TypeError(f"{fname}() got an unexpected keyword argument '{bad_arg}'")
 
 
-def validate_kwargs(fname, kwargs, compat_args):
+def validate_kwargs(fname, kwargs, compat_args) -> None:
     """
     Checks whether parameters passed to the **kwargs argument in a
     function `fname` are valid parameters as specified in `*compat_args`
@@ -159,7 +165,9 @@ def validate_kwargs(fname, kwargs, compat_args):
     _check_for_default_values(fname, kwds, compat_args)
 
 
-def validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, compat_args):
+def validate_args_and_kwargs(
+    fname, args, kwargs, max_fname_arg_count, compat_args
+) -> None:
     """
     Checks whether parameters passed to the *args and **kwargs argument in a
     function `fname` are valid parameters as specified in `*compat_args`
@@ -215,7 +223,9 @@ def validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, compat_ar
     validate_kwargs(fname, kwargs, compat_args)
 
 
-def validate_bool_kwarg(value, arg_name, none_allowed=True, int_allowed=False):
+def validate_bool_kwarg(
+    value: BoolishNoneT, arg_name, none_allowed=True, int_allowed=False
+) -> BoolishNoneT:
     """
     Ensure that argument passed in arg_name can be interpreted as boolean.
 
@@ -255,7 +265,9 @@ def validate_bool_kwarg(value, arg_name, none_allowed=True, int_allowed=False):
     return value
 
 
-def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
+def validate_axis_style_args(
+    data, args, kwargs, arg_name, method_name
+) -> dict[str, Any]:
     """
     Argument handler for mixed index, columns / axis functions
 
@@ -351,7 +363,7 @@ def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
     return out
 
 
-def validate_fillna_kwargs(value, method, validate_scalar_dict_value=True):
+def validate_fillna_kwargs(value, method, validate_scalar_dict_value: bool = True):
     """
     Validate the keyword arguments to 'fillna'.
 
@@ -424,12 +436,22 @@ def validate_percentile(q: float | Iterable[float]) -> np.ndarray:
     return q_arr
 
 
+@overload
+def validate_ascending(ascending: BoolishT) -> BoolishT:
+    ...
+
+
+@overload
+def validate_ascending(ascending: Sequence[BoolishT]) -> list[BoolishT]:
+    ...
+
+
 def validate_ascending(
-    ascending: bool | int | Sequence[bool | int] = True,
-):
+    ascending: bool | int | Sequence[BoolishT],
+) -> bool | int | list[BoolishT]:
     """Validate ``ascending`` kwargs for ``sort_index`` method."""
     kwargs = {"none_allowed": False, "int_allowed": True}
-    if not isinstance(ascending, (list, tuple)):
+    if not isinstance(ascending, Sequence):
         return validate_bool_kwarg(ascending, "ascending", **kwargs)
 
     return [validate_bool_kwarg(item, "ascending", **kwargs) for item in ascending]
diff --git a/pyproject.toml b/pyproject.toml
index 4455df705fc3f..54edbfb8ea938 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,8 +4,8 @@
 requires = [
     "setuptools>=51.0.0",
     "wheel",
-    "Cython>=0.29.24,<3",  # Note: sync with setup.py, environment.yml and asv.conf.json
-    "oldest-supported-numpy>=0.10"
+    "Cython>=0.29.32,<3",  # Note: sync with setup.py, environment.yml and asv.conf.json
+    "oldest-supported-numpy>=2022.8.16"
 ]
 # uncomment to enable pep517 after versioneer problem is fixed.
 # https://github.com/python-versioneer/python-versioneer/issues/193
@@ -34,7 +34,7 @@ exclude = '''
 [tool.pytest.ini_options]
 # sync minversion with pyproject.toml & install.rst
 minversion =  "6.0"
-addopts = "--strict-data-files --strict-markers --capture=no --durations=30 --junitxml=test-data.xml"
+addopts = "--strict-data-files --strict-markers --strict-config --capture=no --durations=30 --junitxml=test-data.xml"
 xfail_strict = true
 testpaths = "pandas"
 doctest_optionflags = [
@@ -45,18 +45,23 @@ doctest_optionflags = [
 filterwarnings = [
   "error:Sparse:FutureWarning",
   "error:The SparseArray:FutureWarning",
+  # Deprecation gives warning on import during pytest collection
+  "ignore:pandas.core.index is deprecated:FutureWarning:importlib",
+  "ignore:pandas.util.testing is deprecated:FutureWarning:importlib",
+  # Will be fixed in numba 0.56: https://github.com/numba/numba/issues/7758
+  "ignore:`np.MachAr` is deprecated:DeprecationWarning:numba",
 ]
 junit_family = "xunit2"
 markers = [
-  "single: mark a test as single cpu only",
+  "single_cpu: tests that should run on a single cpu only",
   "slow: mark a test as slow",
   "network: mark a test as network",
   "db: tests requiring a database (mysql or postgres)",
-  "high_memory: mark a test as a high-memory only",
   "clipboard: mark a pd.read_clipboard test",
   "arm_slow: mark a test as slow for arm64 architecture",
   "arraymanager: mark a test to run with ArrayManager enabled",
 ]
+asyncio_mode = "strict"
 
 [tool.mypy]
 # Import discovery
@@ -97,6 +102,7 @@ warn_unreachable = false # GH#27396
 # Suppressing errors
 show_none_errors = true
 ignore_errors = false
+enable_error_code = "ignore-without-code"
 # Miscellaneous strictness flags
 allow_untyped_globals = false
 allow_redefinition = false
@@ -149,37 +155,25 @@ skip = "pandas/__init__.py"
 
 [tool.pyright]
 pythonVersion = "3.8"
-typeCheckingMode = "strict"
+typeCheckingMode = "basic"
 include = ["pandas", "typings"]
 exclude = ["pandas/tests", "pandas/io/clipboard", "pandas/util/version"]
+# enable subset of "strict"
+reportDuplicateImport = true
+reportInvalidStubStatement = true
+reportOverlappingOverload = true
+reportPropertyTypeMismatch = true
+reportUntypedClassDecorator = true
+reportUntypedFunctionDecorator = true
+reportUntypedNamedTuple = true
+reportUnusedImport = true
+# disable subset of "basic"
 reportGeneralTypeIssues = false
-reportConstantRedefinition = false
-reportFunctionMemberAccess = false
-reportImportCycles = false
-reportIncompatibleMethodOverride = false
-reportIncompatibleVariableOverride = false
 reportMissingModuleSource = false
-reportMissingParameterType = false
-reportMissingTypeArgument = false
-reportMissingTypeStubs = false
 reportOptionalCall = false
 reportOptionalIterable = false
 reportOptionalMemberAccess = false
 reportOptionalOperand = false
 reportOptionalSubscript = false
 reportPrivateImportUsage = false
-reportPrivateUsage = false
 reportUnboundVariable = false
-reportUnknownArgumentType = false
-reportUnknownLambdaType = false
-reportUnknownMemberType = false
-reportUnknownParameterType = false
-reportUnknownVariableType = false
-reportUnnecessaryComparison = false
-reportUnnecessaryIsInstance = false
-reportUnsupportedDunderAll = false
-reportUntypedBaseClass = false
-reportUnusedClass = false
-reportUnusedFunction = false
-reportUnusedImport = false
-reportUnusedVariable = false
diff --git a/pyright_reportGeneralTypeIssues.json b/pyright_reportGeneralTypeIssues.json
new file mode 100644
index 0000000000000..3f20611f2c46d
--- /dev/null
+++ b/pyright_reportGeneralTypeIssues.json
@@ -0,0 +1,112 @@
+# this becomes obsolete when reportGeneralTypeIssues can be enabled in pyproject.toml
+{
+    "typeCheckingMode": "off",
+    "reportGeneralTypeIssues": true,
+    "include":
+      [
+        "pandas",
+        "typings"
+      ],
+    "exclude":
+      [
+        # exclude tests
+        "pandas/tests",
+        # exclude vendored files
+        "pandas/io/clipboard",
+        "pandas/util/version",
+        # and all files that currently don't pass
+        "pandas/_testing/__init__.py",
+        "pandas/_testing/_hypothesis.py",
+        "pandas/core/algorithms.py",
+        "pandas/core/apply.py",
+        "pandas/core/array_algos/take.py",
+        "pandas/core/arrays/_mixins.py",
+        "pandas/core/arrays/arrow/array.py",
+        "pandas/core/arrays/base.py",
+        "pandas/core/arrays/boolean.py",
+        "pandas/core/arrays/categorical.py",
+        "pandas/core/arrays/datetimelike.py",
+        "pandas/core/arrays/datetimes.py",
+        "pandas/core/arrays/interval.py",
+        "pandas/core/arrays/masked.py",
+        "pandas/core/arrays/period.py",
+        "pandas/core/arrays/sparse/array.py",
+        "pandas/core/arrays/sparse/dtype.py",
+        "pandas/core/arrays/string_.py",
+        "pandas/core/arrays/string_arrow.py",
+        "pandas/core/arrays/timedeltas.py",
+        "pandas/core/computation/align.py",
+        "pandas/core/construction.py",
+        "pandas/core/dtypes/cast.py",
+        "pandas/core/dtypes/common.py",
+        "pandas/core/dtypes/concat.py",
+        "pandas/core/dtypes/dtypes.py",
+        "pandas/core/frame.py",
+        "pandas/core/generic.py",
+        "pandas/core/groupby/generic.py",
+        "pandas/core/groupby/groupby.py",
+        "pandas/core/groupby/grouper.py",
+        "pandas/core/groupby/ops.py",
+        "pandas/core/indexers/objects.py",
+        "pandas/core/indexers/utils.py",
+        "pandas/core/indexes/base.py",
+        "pandas/core/indexes/category.py",
+        "pandas/core/indexes/datetimelike.py",
+        "pandas/core/indexes/datetimes.py",
+        "pandas/core/indexes/extension.py",
+        "pandas/core/indexes/interval.py",
+        "pandas/core/indexes/multi.py",
+        "pandas/core/indexes/numeric.py",
+        "pandas/core/indexes/period.py",
+        "pandas/core/indexes/timedeltas.py",
+        "pandas/core/indexing.py",
+        "pandas/core/internals/api.py",
+        "pandas/core/internals/array_manager.py",
+        "pandas/core/internals/blocks.py",
+        "pandas/core/internals/concat.py",
+        "pandas/core/internals/construction.py",
+        "pandas/core/internals/managers.py",
+        "pandas/core/missing.py",
+        "pandas/core/nanops.py",
+        "pandas/core/resample.py",
+        "pandas/core/reshape/concat.py",
+        "pandas/core/reshape/merge.py",
+        "pandas/core/reshape/pivot.py",
+        "pandas/core/reshape/reshape.py",
+        "pandas/core/reshape/tile.py",
+        "pandas/core/series.py",
+        "pandas/core/sorting.py",
+        "pandas/core/strings/accessor.py",
+        "pandas/core/tools/datetimes.py",
+        "pandas/core/tools/timedeltas.py",
+        "pandas/core/util/hashing.py",
+        "pandas/core/window/ewm.py",
+        "pandas/core/window/rolling.py",
+        "pandas/io/common.py",
+        "pandas/io/excel/_base.py",
+        "pandas/io/excel/_odfreader.py",
+        "pandas/io/excel/_odswriter.py",
+        "pandas/io/excel/_openpyxl.py",
+        "pandas/io/excel/_pyxlsb.py",
+        "pandas/io/excel/_xlrd.py",
+        "pandas/io/formats/csvs.py",
+        "pandas/io/formats/excel.py",
+        "pandas/io/formats/format.py",
+        "pandas/io/formats/info.py",
+        "pandas/io/formats/printing.py",
+        "pandas/io/formats/style.py",
+        "pandas/io/formats/style_render.py",
+        "pandas/io/formats/xml.py",
+        "pandas/io/json/_json.py",
+        "pandas/io/parquet.py",
+        "pandas/io/parsers/arrow_parser_wrapper.py",
+        "pandas/io/parsers/base_parser.py",
+        "pandas/io/parsers/c_parser_wrapper.py",
+        "pandas/io/pytables.py",
+        "pandas/io/sas/sas_xport.py",
+        "pandas/io/sql.py",
+        "pandas/io/stata.py",
+        "pandas/io/xml.py",
+        "pandas/tseries/frequencies.py",
+      ],
+}
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 17881500bfa0c..95291e4ab5452 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,89 +1,103 @@
 # This file is auto-generated from environment.yml, do not modify.
 # See that file for comments about the need/usage of each dependency.
 
-numpy>=1.18.5, <1.22.0
-python-dateutil>=2.8.1
+cython==0.29.32
+pytest>=6.0
+pytest-cov
+pytest-xdist>=1.31
+psutil
+pytest-asyncio>=0.17
+boto3
+python-dateutil
+numpy
 pytz
+beautifulsoup4
+blosc
+brotlipy
+bottleneck
+fastparquet
+fsspec
+html5lib
+hypothesis
+gcsfs
+jinja2
+lxml
+matplotlib>=3.6.1
+numba>=0.53.1
+numexpr>=2.8.0
+openpyxl
+odfpy
+pandas-gbq
+psycopg2
+pyarrow<10
+pymysql
+pyreadstat
+tables
+python-snappy
+pyxlsb
+s3fs>=2021.08.0
+scipy
+sqlalchemy<1.4.46
+tabulate
+tzdata>=2022.1
+xarray
+xlrd
+xlsxwriter
+xlwt
+zstandard
+aiobotocore<2.0.0
+botocore
+cftime
+dask
+ipython
+geopandas
+seaborn
+scikit-learn
+statsmodels
+coverage
+pandas-datareader
+pyyaml
+py
+torch
+moto
+flask
 asv
-cython>=0.29.24
-black==21.5b2
+black==22.3.0
 cpplint
-flake8==4.0.1
-flake8-bugbear==21.3.2
-flake8-comprehensions==3.7.0
+flake8==5.0.4
+flake8-bugbear==22.7.1
 isort>=5.2.1
-mypy==0.930
-pre-commit>=2.9.2
+mypy==0.971
+pre-commit>=2.15.0
 pycodestyle
 pyupgrade
 gitpython
 gitdb
+natsort
+numpydoc
+pandas-dev-flaker==0.5.0
+pydata-sphinx-theme<0.11
+pytest-cython
 sphinx
 sphinx-panels
-numpydoc < 1.2
+sphinx-copybutton
 types-python-dateutil
 types-PyMySQL
 types-pytz
 types-setuptools
-nbconvert>=5.4.1
+nbconvert>=6.4.5
 nbsphinx
 pandoc
-dask
-toolz>=0.7.3
-partd>=0.3.10
-cloudpickle>=0.2.1
-markdown
-feedparser
-pyyaml
-requests
-boto3
-botocore>=1.11
-hypothesis>=5.5.3
-moto
-flask
-pytest>=6.0
-pytest-cov
-pytest-xdist>=1.31
-pytest-asyncio
-pytest-instafail
-seaborn
-statsmodels
 ipywidgets
 nbformat
 notebook>=6.0.3
-pip
-blosc
-bottleneck>=1.3.1
 ipykernel
-ipython>=7.11.1
 jinja2
-matplotlib>=3.3.2
-numexpr>=2.7.1
-scipy>=1.4.1
-numba>=0.50.1
-beautifulsoup4>=4.8.2
-html5lib
-lxml
-openpyxl
-xlrd
-xlsxwriter
-xlwt
-odfpy
-fastparquet>=0.4.0
-pyarrow>2.0.1
-python-snappy
-tables>=3.6.1
-s3fs>=0.4.0
-aiobotocore<2.0.0
-fsspec>=0.7.4
-gcsfs>=0.6.0
-sqlalchemy
-xarray<0.19
-cftime
-pyreadstat
-tabulate>=0.8.3
-natsort
-git+https://github.com/pydata/pydata-sphinx-theme.git@41764f5
-pandas-dev-flaker==0.2.0
-pytest-cython
+markdown
+feedparser
+pyyaml
+requests
+jupyterlab >=3.4,<4
+jupyterlite==0.1.0b10
+sphinx-toggleprompt
 setuptools>=51.0.0
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index 2ea50fa3ac8d4..a27d089cdb9e8 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -21,7 +21,8 @@
 import yaml
 
 EXCLUDE = {"python", "c-compiler", "cxx-compiler"}
-RENAME = {"pytables": "tables", "dask-core": "dask"}
+REMAP_VERSION = {"tzdata": "2022.1"}
+RENAME = {"pytables": "tables", "geopandas-base": "geopandas", "pytorch": "torch"}
 
 
 def conda_package_to_pip(package: str):
@@ -41,7 +42,8 @@ def conda_package_to_pip(package: str):
             pkg, version = package.split(compare)
             if pkg in EXCLUDE:
                 return
-
+            if pkg in REMAP_VERSION:
+                return "".join((pkg, compare, REMAP_VERSION[pkg]))
             if pkg in RENAME:
                 return "".join((RENAME[pkg], compare, version))
 
diff --git a/scripts/list_future_warnings.sh b/scripts/list_future_warnings.sh
index 121f4f5a92abb..a75aea905a4c8 100755
--- a/scripts/list_future_warnings.sh
+++ b/scripts/list_future_warnings.sh
@@ -6,7 +6,7 @@
 # This is useful to detect features that have been deprecated, and should be
 # removed from the code. For example, if a line of code contains:
 #
-#     warning.warn('Method deprecated', FutureWarning, stacklevel=2)
+#     warning.warn('Method deprecated', FutureWarning, stacklevel=find_stack_level())
 #
 # Which is released in Pandas 0.20.0, then it is expected that the method
 # is removed before releasing Pandas 0.24.0, including the warning. If it
diff --git a/scripts/pandas_errors_documented.py b/scripts/pandas_errors_documented.py
index 4024cd24c558e..18db5fa10a8f9 100644
--- a/scripts/pandas_errors_documented.py
+++ b/scripts/pandas_errors_documented.py
@@ -14,7 +14,7 @@
 import sys
 from typing import Sequence
 
-API_PATH = pathlib.Path("doc/source/reference/general_utility_functions.rst").resolve()
+API_PATH = pathlib.Path("doc/source/reference/testing.rst").resolve()
 
 
 def get_defined_errors(content: str) -> set[str]:
@@ -22,7 +22,7 @@ def get_defined_errors(content: str) -> set[str]:
     for node in ast.walk(ast.parse(content)):
         if isinstance(node, ast.ClassDef):
             errors.add(node.name)
-        elif isinstance(node, ast.ImportFrom):
+        elif isinstance(node, ast.ImportFrom) and node.module != "__future__":
             for alias in node.names:
                 errors.add(alias.name)
     return errors
@@ -41,7 +41,7 @@ def main(argv: Sequence[str] | None = None) -> None:
     missing = file_errors.difference(doc_errors)
     if missing:
         sys.stdout.write(
-            f"The follow exceptions and/or warnings are not documented "
+            f"The following exceptions and/or warnings are not documented "
             f"in {API_PATH}: {missing}"
         )
         sys.exit(1)
diff --git a/scripts/run_stubtest.py b/scripts/run_stubtest.py
new file mode 100644
index 0000000000000..8cf5b81ba398c
--- /dev/null
+++ b/scripts/run_stubtest.py
@@ -0,0 +1,85 @@
+import os
+from pathlib import Path
+import sys
+import tempfile
+import warnings
+
+from mypy import stubtest
+
+import pandas as pd
+
+# fail early if pandas is not installed
+if not getattr(pd, "__version__", ""):
+    # fail on the CI, soft fail during local development
+    warnings.warn("You need to install the development version of pandas")
+    if pd.compat.is_ci_environment():
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+_ALLOWLIST = [  # should be empty
+    # TODO (child classes implement these methods)
+    "pandas._libs.hashtable.HashTable.__contains__",
+    "pandas._libs.hashtable.HashTable.__len__",
+    "pandas._libs.hashtable.HashTable.factorize",
+    "pandas._libs.hashtable.HashTable.get_item",
+    "pandas._libs.hashtable.HashTable.get_labels",
+    "pandas._libs.hashtable.HashTable.get_state",
+    "pandas._libs.hashtable.HashTable.lookup",
+    "pandas._libs.hashtable.HashTable.map_locations",
+    "pandas._libs.hashtable.HashTable.set_item",
+    "pandas._libs.hashtable.HashTable.sizeof",
+    "pandas._libs.hashtable.HashTable.unique",
+    # stubtest might be too sensitive
+    "pandas._libs.lib.NoDefault",
+    "pandas._libs.lib._NoDefault.no_default",
+    # internal type alias (should probably be private)
+    "pandas._libs.lib.ndarray_obj_2d",
+    # workaround for mypy (cache_readonly = property)
+    "pandas._libs.properties.cache_readonly.__get__",
+    "pandas._libs.properties.cache_readonly.deleter",
+    "pandas._libs.properties.cache_readonly.getter",
+    "pandas._libs.properties.cache_readonly.setter",
+    # TODO (child classes implement these methods)
+    "pandas._libs.sparse.SparseIndex.__init__",
+    "pandas._libs.sparse.SparseIndex.equals",
+    "pandas._libs.sparse.SparseIndex.indices",
+    "pandas._libs.sparse.SparseIndex.intersect",
+    "pandas._libs.sparse.SparseIndex.lookup",
+    "pandas._libs.sparse.SparseIndex.lookup_array",
+    "pandas._libs.sparse.SparseIndex.make_union",
+    "pandas._libs.sparse.SparseIndex.nbytes",
+    "pandas._libs.sparse.SparseIndex.ngaps",
+    "pandas._libs.sparse.SparseIndex.to_block_index",
+    "pandas._libs.sparse.SparseIndex.to_int_index",
+    # TODO (decorator changes argument names)
+    "pandas._libs.tslibs.offsets.BaseOffset._apply_array",
+    "pandas._libs.tslibs.offsets.BusinessHour.rollback",
+    "pandas._libs.tslibs.offsets.BusinessHour.rollforward ",
+    # type alias
+    "pandas._libs.tslibs.timedeltas.UnitChoices",
+]
+
+if __name__ == "__main__":
+    # find pyi files
+    root = Path.cwd()
+    pyi_modules = [
+        str(pyi.relative_to(root).with_suffix("")).replace(os.sep, ".")
+        for pyi in root.glob("pandas/**/*.pyi")
+    ]
+
+    # create allowlist
+    with tempfile.NamedTemporaryFile(mode="w+t") as allow:
+        allow.write("\n".join(_ALLOWLIST))
+        allow.flush()
+
+        args = pyi_modules + [
+            "--ignore-missing-stub",
+            "--concise",
+            "--mypy-config-file",
+            "pyproject.toml",
+            "--allowlist",
+            allow.name,
+        ]
+        sys.exit(stubtest.test_stubs(stubtest.parse_options(args)))
diff --git a/scripts/run_vulture.py b/scripts/run_vulture.py
new file mode 100644
index 0000000000000..edf0a1588305c
--- /dev/null
+++ b/scripts/run_vulture.py
@@ -0,0 +1,21 @@
+"""Look for unreachable code."""
+
+import argparse
+import sys
+
+from vulture import Vulture
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("files", nargs="*")
+    args = parser.parse_args()
+
+    v = Vulture()
+    v.scavenge(args.files)
+    ret = 0
+    for item in v.get_unused_code(min_confidence=100):
+        if item.typ == "unreachable_code":
+            print(item.get_report())
+            ret = 1
+
+    sys.exit(ret)
diff --git a/scripts/sync_flake8_versions.py b/scripts/sync_flake8_versions.py
index 370924cdfa199..d19501051349f 100644
--- a/scripts/sync_flake8_versions.py
+++ b/scripts/sync_flake8_versions.py
@@ -73,7 +73,7 @@ def _validate_additional_dependencies(
     for dep in flake8_additional_dependencies:
         if dep not in environment_additional_dependencies:
             sys.stdout.write(
-                f"Mismatch of '{dep.name}' version between 'enviroment.yml' "
+                f"Mismatch of '{dep.name}' version between 'environment.yml' "
                 "and additional dependencies of 'flake8' in '.pre-commit-config.yaml'\n"
             )
             sys.exit(1)
diff --git a/scripts/tests/test_sync_flake8_versions.py b/scripts/tests/test_sync_flake8_versions.py
index 21c3b743830ee..743ece34e0b56 100644
--- a/scripts/tests/test_sync_flake8_versions.py
+++ b/scripts/tests/test_sync_flake8_versions.py
@@ -71,7 +71,7 @@ def test_wrong_env_add_dep(capsys):
         get_revisions(precommit_config, environment)
     result, _ = capsys.readouterr()
     expected = (
-        "Mismatch of 'flake8-bugs' version between 'enviroment.yml' "
+        "Mismatch of 'flake8-bugs' version between 'environment.yml' "
         "and additional dependencies of 'flake8' in '.pre-commit-config.yaml'\n"
     )
     assert result == expected
@@ -87,7 +87,7 @@ def test_get_revisions_no_failure(capsys):
                     {
                         "id": "flake8",
                         "additional_dependencies": [
-                            "pandas-dev-flaker==0.2.0",
+                            "pandas-dev-flaker==0.4.0",
                             "flake8-bugs==1.1.1",
                         ],
                     }
@@ -101,7 +101,7 @@ def test_get_revisions_no_failure(capsys):
                         "id": "yesqa",
                         "additional_dependencies": [
                             "flake8==0.1.1",
-                            "pandas-dev-flaker==0.2.0",
+                            "pandas-dev-flaker==0.4.0",
                             "flake8-bugs==1.1.1",
                         ],
                     }
@@ -116,7 +116,7 @@ def test_get_revisions_no_failure(capsys):
             {
                 "pip": [
                     "git+https://github.com/pydata/pydata-sphinx-theme.git@master",
-                    "pandas-dev-flaker==0.2.0",
+                    "pandas-dev-flaker==0.4.0",
                 ]
             },
         ]
diff --git a/scripts/tests/test_use_io_common_urlopen.py b/scripts/tests/test_use_io_common_urlopen.py
new file mode 100644
index 0000000000000..4bba550a4cc0e
--- /dev/null
+++ b/scripts/tests/test_use_io_common_urlopen.py
@@ -0,0 +1,23 @@
+import pytest
+
+from scripts.use_io_common_urlopen import use_io_common_urlopen
+
+PATH = "t.py"
+
+
+def test_inconsistent_usage(capsys):
+    content = "from urllib.request import urlopen"
+    result_msg = (
+        "t.py:1:0: Don't use urllib.request.urlopen, "
+        "use pandas.io.common.urlopen instead\n"
+    )
+    with pytest.raises(SystemExit, match=None):
+        use_io_common_urlopen(content, PATH)
+    expected_msg, _ = capsys.readouterr()
+    assert result_msg == expected_msg
+
+
+def test_consistent_usage():
+    # should not raise
+    content = "from pandas.io.common import urlopen"
+    use_io_common_urlopen(content, PATH)
diff --git a/scripts/use_io_common_urlopen.py b/scripts/use_io_common_urlopen.py
new file mode 100644
index 0000000000000..11d8378fce574
--- /dev/null
+++ b/scripts/use_io_common_urlopen.py
@@ -0,0 +1,63 @@
+"""
+Check that pandas/core imports pandas.array as pd_array.
+
+This makes it easier to grep for usage of pandas array.
+
+This is meant to be run as a pre-commit hook - to run it manually, you can do:
+
+    pre-commit run use-io-common-urlopen --all-files
+
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import sys
+from typing import Sequence
+
+ERROR_MESSAGE = (
+    "{path}:{lineno}:{col_offset}: "
+    "Don't use urllib.request.urlopen, use pandas.io.common.urlopen instead\n"
+)
+
+
+class Visitor(ast.NodeVisitor):
+    def __init__(self, path: str) -> None:
+        self.path = path
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        # Check that pandas.io.common.urlopen is used instead of
+        # urllib.request.urlopen
+        if (
+            node.module is not None
+            and node.module.startswith("urllib.request")
+            and any(i.name == "urlopen" for i in node.names)
+        ):
+            msg = ERROR_MESSAGE.format(
+                path=self.path, lineno=node.lineno, col_offset=node.col_offset
+            )
+            sys.stdout.write(msg)
+            sys.exit(1)
+        super().generic_visit(node)
+
+
+def use_io_common_urlopen(content: str, path: str) -> None:
+    tree = ast.parse(content)
+    visitor = Visitor(path)
+    visitor.visit(tree)
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("paths", nargs="*")
+    args = parser.parse_args(argv)
+
+    for path in args.paths:
+        with open(path, encoding="utf-8") as fd:
+            content = fd.read()
+        use_io_common_urlopen(content, path)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/validate_docstrings.py b/scripts/validate_docstrings.py
index dcb002fd975c4..cbf02bc0a0156 100755
--- a/scripts/validate_docstrings.py
+++ b/scripts/validate_docstrings.py
@@ -29,8 +29,9 @@
 import matplotlib
 import matplotlib.pyplot as plt
 import numpy
+from numpydoc.docscrape import get_doc_object
 from numpydoc.validate import (
-    Docstring,
+    Validator,
     validate,
 )
 
@@ -39,7 +40,16 @@
 # With template backend, matplotlib plots nothing
 matplotlib.use("template")
 
-
+# Styler methods are Jinja2 objects who's docstrings we don't own.
+IGNORE_VALIDATION = {
+    "Styler.env",
+    "Styler.template_html",
+    "Styler.template_html_style",
+    "Styler.template_html_table",
+    "Styler.template_latex",
+    "Styler.template_string",
+    "Styler.loader",
+}
 PRIVATE_CLASSES = ["NDFrame", "IndexOpsMixin"]
 ERROR_MSGS = {
     "GL04": "Private classes ({mentioned_private_classes}) should not be "
@@ -120,6 +130,8 @@ def get_api_items(api_doc_fd):
                 position = None
                 continue
             item = line.strip()
+            if item in IGNORE_VALIDATION:
+                continue
             func = importlib.import_module(current_module)
             for part in item.split("."):
                 func = getattr(func, part)
@@ -134,7 +146,17 @@ def get_api_items(api_doc_fd):
         previous_line = line
 
 
-class PandasDocstring(Docstring):
+class PandasDocstring(Validator):
+    def __init__(self, func_name: str, doc_obj=None) -> None:
+        self.func_name = func_name
+        if doc_obj is None:
+            doc_obj = get_doc_object(Validator._load_obj(func_name))
+        super().__init__(doc_obj)
+
+    @property
+    def name(self):
+        return self.func_name
+
     @property
     def mentioned_private_classes(self):
         return [klass for klass in PRIVATE_CLASSES if klass in self.raw_doc]
@@ -218,8 +240,11 @@ def pandas_validate(func_name: str):
     dict
         Information about the docstring and the errors found.
     """
-    doc = PandasDocstring(func_name)
-    result = validate(func_name)
+    func_obj = Validator._load_obj(func_name)
+    # Some objects are instances, e.g. IndexSlice, which numpydoc can't validate
+    doc_obj = get_doc_object(func_obj, doc=func_obj.__doc__)
+    doc = PandasDocstring(func_name, doc_obj)
+    result = validate(doc_obj)
 
     mentioned_errs = doc.mentioned_private_classes
     if mentioned_errs:
diff --git a/scripts/validate_min_versions_in_sync.py b/scripts/validate_min_versions_in_sync.py
new file mode 100755
index 0000000000000..cb6a204094bf5
--- /dev/null
+++ b/scripts/validate_min_versions_in_sync.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Check pandas required and optional dependencies are synced across:
+
+ci/deps/actions-.*-minimum_versions.yaml
+pandas/compat/_optional.py
+
+TODO: doc/source/getting_started/install.rst
+
+This is meant to be run as a pre-commit hook - to run it manually, you can do:
+
+    pre-commit run validate-min-versions-in-sync --all-files
+"""
+from __future__ import annotations
+
+import pathlib
+import sys
+
+DOC_PATH = pathlib.Path("doc/source/getting_started/install.rst").resolve()
+CI_PATH = next(
+    pathlib.Path("ci/deps").absolute().glob("actions-*-minimum_versions.yaml")
+)
+CODE_PATH = pathlib.Path("pandas/compat/_optional.py").resolve()
+EXCLUDE_DEPS = {"tzdata"}
+# pandas package is not available
+# in pre-commit environment
+sys.path.append("pandas/compat")
+sys.path.append("pandas/util")
+import _exceptions
+import version
+
+sys.modules["pandas.util.version"] = version
+sys.modules["pandas.util._exceptions"] = _exceptions
+import _optional
+
+
+def get_versions_from_code() -> dict[str, str]:
+    install_map = _optional.INSTALL_MAPPING
+    versions = _optional.VERSIONS
+    for item in EXCLUDE_DEPS:
+        versions.pop(item)
+    return {
+        install_map.get(k, k).casefold(): v
+        for k, v in versions.items()
+        if k != "pytest"
+    }
+
+
+def get_versions_from_ci(content: list[str]) -> tuple[dict[str, str], dict[str, str]]:
+    # Don't parse with pyyaml because it ignores comments we're looking for
+    seen_required = False
+    seen_optional = False
+    required_deps = {}
+    optional_deps = {}
+    for line in content:
+        if "# required dependencies" in line:
+            seen_required = True
+        elif "# optional dependencies" in line:
+            seen_optional = True
+        elif seen_required and line.strip():
+            package, version = line.strip().split("=")
+            package = package[2:]
+            if package in EXCLUDE_DEPS:
+                continue
+            if not seen_optional:
+                required_deps[package] = version
+            else:
+                optional_deps[package] = version
+    return required_deps, optional_deps
+
+
+def main():
+    with open(CI_PATH, encoding="utf-8") as f:
+        _, ci_optional = get_versions_from_ci(f.readlines())
+    code_optional = get_versions_from_code()
+    diff = set(ci_optional.items()).symmetric_difference(code_optional.items())
+    if diff:
+        sys.stdout.write(
+            f"The follow minimum version differences were found between  "
+            f"{CI_PATH} and {CODE_PATH}. Please ensure these are aligned: "
+            f"{diff}\n"
+        )
+        sys.exit(1)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/validate_rst_title_capitalization.py b/scripts/validate_rst_title_capitalization.py
index 9aca47dbddbf2..e7233484e16b6 100755
--- a/scripts/validate_rst_title_capitalization.py
+++ b/scripts/validate_rst_title_capitalization.py
@@ -150,6 +150,7 @@
     "LZMA",
     "Numba",
     "Timestamp",
+    "PyArrow",
 }
 
 CAP_EXCEPTIONS_DICT = {word.lower(): word for word in CAPITALIZATION_EXCEPTIONS}
diff --git a/setup.cfg b/setup.cfg
index 9deebb835eff7..dbf05957896f8 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -7,7 +7,7 @@ url = https://pandas.pydata.org
 author = The Pandas Development Team
 author_email = pandas-dev@python.org
 license = BSD-3-Clause
-license_file = LICENSE
+license_files = LICENSE
 platforms = any
 classifiers =
     Development Status :: 5 - Production/Stable
@@ -22,19 +22,19 @@ classifiers =
     Programming Language :: Python :: 3.8
     Programming Language :: Python :: 3.9
     Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
     Topic :: Scientific/Engineering
 project_urls =
     Bug Tracker = https://github.com/pandas-dev/pandas/issues
-    Documentation = https://pandas.pydata.org/pandas-docs/stable
+    Documentation = https://pandas.pydata.org/docs/
     Source Code = https://github.com/pandas-dev/pandas
 
 [options]
 packages = find:
 install_requires =
-    numpy>=1.18.5; platform_machine!='aarch64' and platform_machine!='arm64' and python_version<'3.10'
-    numpy>=1.19.2; platform_machine=='aarch64' and python_version<'3.10'
-    numpy>=1.20.0; platform_machine=='arm64' and python_version<'3.10'
+    numpy>=1.20.3; python_version<'3.10'
     numpy>=1.21.0; python_version>='3.10'
+    numpy>=1.23.2; python_version>='3.11'
     python-dateutil>=2.8.1
     pytz>=2020.1
 python_requires = >=3.8
@@ -45,15 +45,17 @@ zip_safe = False
 pandas_plotting_backends =
     matplotlib = pandas:plotting._matplotlib
 
+[options.exclude_package_data]
+* =
+    *.c
+    *.h
+
 [options.extras_require]
 test =
     hypothesis>=5.5.3
     pytest>=6.0
     pytest-xdist>=1.31
 
-[options.package_data]
-* = templates/*, _libs/**/*.dll
-
 [build_ext]
 inplace = True
 
@@ -103,7 +105,27 @@ ignore =
     # tests use comparisons but not their returned value
     B015,
     # false positives
-    B301
+    B019,
+    # Use of functools.lru_cache or functools.cache on methods can lead to memory leaks.
+    B020
+    # Loop control variable overrides iterable it iterates
+    B023
+    # Functions defined inside a loop must not use variables redefined in the loop
+    B301,
+    # single-letter variables
+    PDF023,
+    # "use 'pandas._testing' instead" in non-test code
+    PDF025,
+    # If test must be a simple comparison against sys.platform or sys.version_info
+    Y002,
+    # Use "_typeshed.Self" instead of class-bound TypeVar
+    Y019,
+    # Docstrings should not be included in stubs
+    Y021,
+    # Use typing_extensions.TypeAlias for type aliases
+    Y026,
+    # Use "collections.abc.*" instead of "typing.*" (PEP 585 syntax)
+    Y027
 exclude =
     doc/sphinxext/*.py,
     doc/build/*.py,
@@ -121,6 +143,8 @@ per-file-ignores =
     doc/make.py:PDF008
     # import from pandas._testing
     pandas/testing.py:PDF014
+    # can't use fixtures in asv
+    asv_bench/*:PDF016
 
 
 [flake8-rst]
@@ -157,7 +181,7 @@ exclude =
 
 [codespell]
 ignore-words-list = ba,blocs,coo,hist,nd,sav,ser
-ignore-regex = https://(\w+\.)+
+ignore-regex = https://([\w/\.])+
 
 [coverage:run]
 branch = True
diff --git a/setup.py b/setup.py
index db65ea72e4a96..12e8aa36c3794 100755
--- a/setup.py
+++ b/setup.py
@@ -38,7 +38,7 @@ def is_platform_mac():
 
 
 # note: sync with pyproject.toml, environment.yml and asv.conf.json
-min_cython_ver = "0.29.24"
+min_cython_ver = "0.29.32"
 
 try:
     from Cython import (
@@ -333,7 +333,7 @@ def run(self):
         extra_compile_args.append("/Z7")
         extra_link_args.append("/DEBUG")
 else:
-    # PANDAS_CI=1 is set by ci/setup_env.sh
+    # PANDAS_CI=1 is set in CI
     if os.environ.get("PANDAS_CI", "0") == "1":
         extra_compile_args.append("-Werror")
     if debugging_symbols_requested:
@@ -492,7 +492,11 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     "_libs.properties": {"pyxfile": "_libs/properties"},
     "_libs.reshape": {"pyxfile": "_libs/reshape", "depends": []},
     "_libs.sparse": {"pyxfile": "_libs/sparse", "depends": _pxi_dep["sparse"]},
-    "_libs.tslib": {"pyxfile": "_libs/tslib", "depends": tseries_depends},
+    "_libs.tslib": {
+        "pyxfile": "_libs/tslib",
+        "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
+    },
     "_libs.tslibs.base": {"pyxfile": "_libs/tslibs/base"},
     "_libs.tslibs.ccalendar": {"pyxfile": "_libs/tslibs/ccalendar"},
     "_libs.tslibs.dtypes": {"pyxfile": "_libs/tslibs/dtypes"},
@@ -504,6 +508,7 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     "_libs.tslibs.fields": {
         "pyxfile": "_libs/tslibs/fields",
         "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.nattype": {"pyxfile": "_libs/tslibs/nattype"},
     "_libs.tslibs.np_datetime": {
@@ -517,6 +522,7 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     "_libs.tslibs.offsets": {
         "pyxfile": "_libs/tslibs/offsets",
         "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.parsing": {
         "pyxfile": "_libs/tslibs/parsing",
@@ -536,17 +542,24 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     "_libs.tslibs.timedeltas": {
         "pyxfile": "_libs/tslibs/timedeltas",
         "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.timestamps": {
         "pyxfile": "_libs/tslibs/timestamps",
         "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.timezones": {"pyxfile": "_libs/tslibs/timezones"},
     "_libs.tslibs.tzconversion": {
         "pyxfile": "_libs/tslibs/tzconversion",
         "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
+    },
+    "_libs.tslibs.vectorized": {
+        "pyxfile": "_libs/tslibs/vectorized",
+        "depends": tseries_depends,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
-    "_libs.tslibs.vectorized": {"pyxfile": "_libs/tslibs/vectorized"},
     "_libs.testing": {"pyxfile": "_libs/testing"},
     "_libs.window.aggregations": {
         "pyxfile": "_libs/window/aggregations",
diff --git a/test_fast.bat b/test_fast.bat
index 642e0549f3228..85ce305ab2d64 100644
--- a/test_fast.bat
+++ b/test_fast.bat
@@ -1,3 +1,3 @@
 :: test on windows
 set PYTHONHASHSEED=314159265
-pytest --skip-slow --skip-network --skip-db -m "not single" -n 4 -r sXX pandas
+pytest --skip-slow --skip-network --skip-db -m "not single_cpu" -n 4 -r sXX pandas
diff --git a/test_fast.sh b/test_fast.sh
index 9d446964cf501..0120c712e3df8 100755
--- a/test_fast.sh
+++ b/test_fast.sh
@@ -5,4 +5,4 @@
 # https://github.com/pytest-dev/pytest/issues/1075
 export PYTHONHASHSEED=$(python -c 'import random; print(random.randint(1, 4294967295))')
 
-pytest pandas --skip-slow --skip-network --skip-db -m "not single" -n 4 -r sxX "$@"
+pytest pandas --skip-slow --skip-network --skip-db -m "not single_cpu" -n 4 -r sxX "$@"
diff --git a/typings/numba.pyi b/typings/numba.pyi
index f877cbf339a8b..36cccb894049b 100644
--- a/typings/numba.pyi
+++ b/typings/numba.pyi
@@ -12,9 +12,7 @@ from pandas._typing import F
 
 def __getattr__(name: str) -> Any: ...  # incomplete
 @overload
-def jit(
-    signature_or_function: F = ...,
-) -> F: ...
+def jit(signature_or_function: F) -> F: ...
 @overload
 def jit(
     signature_or_function: str
diff --git a/versioneer.py b/versioneer.py
index 68c9bb161f206..c98dbd83271d7 100644
--- a/versioneer.py
+++ b/versioneer.py
@@ -691,7 +691,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%%s'"
                                %% describe_out)
             return pieces
@@ -1105,7 +1105,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out
             return pieces
 
diff --git a/web/interactive_terminal/README.md b/web/interactive_terminal/README.md
new file mode 100644
index 0000000000000..865cf282676c9
--- /dev/null
+++ b/web/interactive_terminal/README.md
@@ -0,0 +1,35 @@
+# The interactive `pandas` terminal
+
+An interactive terminal to easily try `pandas` in the browser, powered by JupyterLite.
+
+![image](https://user-images.githubusercontent.com/591645/175000291-e8c69f6f-5f2c-48d7-817c-cff05ab2cde9.png)
+
+## Build
+
+The interactive terminal is built with the `jupyterlite` CLI.
+
+First make sure `jupyterlite` is installed:
+
+```bash
+python -m pip install jupyterlite
+```
+
+Then in `web/interactive_terminal`, run the following command:
+
+```bash
+jupyter lite build
+```
+
+## Configuration
+
+This folder contains configuration files for the interactive terminal powered by JupyterLite:
+
+- `jupyter_lite_config.json`: build time configuration, used when building the assets with the `jupyter lite build` command
+- `jupyter-lite.json` run time configuration applied when launching the application in the browser
+
+The interactive `pandas` terminal application enables a couple of optimizations to only include the `repl` app in the generated static assets.
+To learn more about it, check out the JupyterLite documentation:
+
+- Optimizations: https://jupyterlite.readthedocs.io/en/latest/howto/configure/advanced/optimizations.html
+- JupyterLite schema: https://jupyterlite.readthedocs.io/en/latest/reference/schema-v0.html
+- CLI reference: https://jupyterlite.readthedocs.io/en/latest/reference/cli.html
diff --git a/web/interactive_terminal/jupyter-lite.json b/web/interactive_terminal/jupyter-lite.json
new file mode 100644
index 0000000000000..473fb5a3dcc1a
--- /dev/null
+++ b/web/interactive_terminal/jupyter-lite.json
@@ -0,0 +1,13 @@
+{
+    "jupyter-lite-schema-version": 0,
+    "jupyter-config-data": {
+      "appName": "Pandas REPL",
+      "appUrl": "./repl",
+      "disabledExtensions": [
+        "@jupyter-widgets/jupyterlab-manager"
+      ],
+      "enableMemoryStorage": true,
+      "settingsStorageDrivers": ["memoryStorageDriver"],
+      "contentsStorageDrivers": ["memoryStorageDriver"]
+    }
+  }
diff --git a/web/interactive_terminal/jupyter_lite_config.json b/web/interactive_terminal/jupyter_lite_config.json
new file mode 100644
index 0000000000000..8a8c4eb1ae051
--- /dev/null
+++ b/web/interactive_terminal/jupyter_lite_config.json
@@ -0,0 +1,7 @@
+{
+    "LiteBuildConfig": {
+      "apps": ["repl"],
+      "no_unused_shared_packages": true,
+      "output_dir": "../build/lite"
+    }
+  }
diff --git a/web/pandas/_templates/layout.html b/web/pandas/_templates/layout.html
index 52e06a9bec55b..3cad22bf938b0 100644
--- a/web/pandas/_templates/layout.html
+++ b/web/pandas/_templates/layout.html
@@ -69,6 +69,11 @@
         </main>
         <footer class="container pt-4 pt-md-5 border-top">
             <ul class="list-inline social-buttons float-end">
+                <li class="list-inline-item">
+                    <a href="https://t.me/s/pandas_dev">
+                        <i class="fab fa-telegram"></i>
+                    </a>
+                </li>
                 <li class="list-inline-item">
                     <a href="https://twitter.com/pandas_dev/">
                         <i class="fab fa-twitter"></i>
@@ -86,7 +91,7 @@
                 </li>
             </ul>
             <p>
-                pandas is a fiscally sponsored project of <a href="https://numfocus.org/">NumFOCUS.</a>
+                &copy; {{ current_year }} pandas via <a href="https://numfocus.org/">NumFOCUS, Inc.</a> Hosted by <a href="https://www.ovhcloud.com/">OVHcloud</a>.
             </p>
         </footer>
         
diff --git a/web/pandas/about/citing.md b/web/pandas/about/citing.md
index e2821dbc19a4e..b4c7848e5db00 100644
--- a/web/pandas/about/citing.md
+++ b/web/pandas/about/citing.md
@@ -5,7 +5,7 @@
 If you use _pandas_ for a scientific publication, we would appreciate citations to the published software and the
 following paper:
 
-- [pandas on Zenodo](https://zenodo.org/record/3715232#.XoqFyC2ZOL8),
+- [pandas on Zenodo](https://zenodo.org/search?page=1&size=20&q=conceptrecid%3A%223509134%22&sort=-version&all_versions=True),
    Please find us on Zenodo and replace with the citation for the version you are using. You can replace the full author
    list from there with "The pandas development team" like in the example below.
 
diff --git a/web/pandas/about/governance.md b/web/pandas/about/governance.md
new file mode 100644
index 0000000000000..92923db6e6763
--- /dev/null
+++ b/web/pandas/about/governance.md
@@ -0,0 +1,317 @@
+# Project governance
+
+The official version of this document, along with a list of
+individuals and institutions in the roles defined in the governance
+section below, is contained in the
+[Project governance](https://pandas.pydata.org/about/governance.html)
+page of the pandas website.
+
+## The Project
+
+The pandas Project (The Project) is an open source software project affiliated
+with the 501(c)3 NumFOCUS Foundation. The goal of The Project is to develop open
+source software for data ingest, data preparation, data analysis, and data
+visualization for the Python programming language. The Software developed by
+The Project is released under the BSD (or similar) open source license,
+developed openly and hosted in public GitHub repositories under the [pandas
+GitHub organization](https://github.com/pandas-dev). Examples of Project Software
+include the main pandas code repository and the pandas-stubs library.
+
+Through its affiliation with NumFOCUS, The Project has the right to receive
+tax-deductible donations in the United States of America.
+
+The Project is developed by a team of distributed developers, called
+Contributors. Contributors are individuals who have contributed code,
+documentation, designs or other work to one or more Project repositories.
+Anyone can be a Contributor. Contributors can be affiliated with any legal
+entity or none. Contributors participate in the project by submitting,
+reviewing and discussing GitHub Pull Requests and Issues and participating in
+open and public Project discussions on GitHub, mailing lists, and
+elsewhere. The foundation of Project participation is openness and
+transparency.
+
+Here is a list of the current Contributors to the main pandas repository:
+
+[https://github.com/pandas-dev/pandas/graphs/contributors](https://github.com/pandas-dev/pandas/graphs/contributors)
+
+There are also many other Contributors listed in the logs of other repositories of
+the pandas project.
+
+The Project Community consists of all Contributors and Users of the Project.
+Contributors work on behalf of and are responsible to the larger Project
+Community and we strive to keep the barrier between Contributors and Users as
+low as possible.
+
+The Project is formally affiliated with the 501(c)3 NumFOCUS Foundation
+([https://numfocus.org](https://numfocus.org)), which serves as its fiscal
+sponsor, may hold project trademarks and other intellectual property, helps
+manage project donations and acts as a parent legal entity. NumFOCUS is the
+only legal entity that has a formal relationship with the project (see
+Institutional Partners section below).
+
+## Governance
+
+This section describes the governance and leadership model of The Project.
+
+The foundations of Project governance are:
+
+-   Openness & Transparency
+-   Active Contribution
+-   Institutional Neutrality
+
+Traditionally, Project leadership was provided by a BDFL (Wes McKinney) and
+subset of Contributors, called the Core Team, whose active and consistent
+contributions have been recognized by their receiving “commit rights” to the
+Project GitHub repositories. In general all Project decisions are made through
+consensus among the Core Team with input from the Community. The BDFL can, but
+rarely chooses to, override the Core Team and make a final decision on a
+matter.
+
+While this approach has served us well, as the Project grows and faces more
+legal and financial decisions and interacts with other institutions, we see a
+need for a more formal governance model. Moving forward The Project leadership
+will consist of a BDFL and Core Team. We view this governance model as the
+formalization of what we are already doing, rather than a change in direction.
+
+### BDFL
+
+The Project will have a BDFL (Benevolent Dictator for Life), who is currently
+Wes McKinney. As Dictator, the BDFL has the authority to make all final
+decisions for The Project. As Benevolent, the BDFL, in practice chooses to
+defer that authority to the consensus of the community discussion channels and
+the Core Team. It is expected, and in the past has been the case, that the BDFL
+will only rarely assert his/her final authority. Because it is rarely used, we
+refer to BDFL’s final authority as a “special” or “overriding” vote. When it
+does occur, the BDFL override typically happens in situations where there is a
+deadlock in the Core Team or if the Core Team ask the BDFL to make a decision
+on a specific matter. To ensure the benevolence of the BDFL, The Project
+encourages others to fork the project if they disagree with the overall
+direction the BDFL is taking. The BDFL is chair of the Core Team (see below)
+and may delegate his/her authority on a particular decision or set of decisions
+to any other Core Team Member at his/her discretion.
+
+The BDFL can appoint his/her successor, but it is expected that the Core Team
+would be consulted on this decision. If the BDFL is unable to appoint a
+successor (e.g. due to death or illness), the Core Team will choose a successor
+by voting with at least 2/3 of the Core Team members voting in favor of the
+chosen successor. At least 80% of the Core Team must participate in the
+vote. If no BDFL candidate receives 2/3 of the votes of the Core Team, the Core
+Team members shall propose the BDFL candidates to the Main NumFOCUS board, who
+will then make the final decision.
+
+### Core Team
+
+The Project's Core Team will consist of Project Contributors who have produced
+contributions that are substantial in quality and quantity, and sustained over
+at least one year. The overall role of the Core Team is to ensure, through
+working with the BDFL and taking input from the Community, the long-term
+well-being of the project, both technically and as a community.
+
+During the everyday project activities, Core Team participate in all
+discussions, code review and other project activities as peers with all other
+Contributors and the Community. In these everyday activities, Core Team do not
+have any special power or privilege through their membership on the Core
+Team. However, it is expected that because of the quality and quantity of their
+contributions and their expert knowledge of the Project Software that the Core
+Team will provide useful guidance, both technical and in terms of project
+direction, to potentially less experienced contributors.
+
+The Core Team and its Members play a special role in certain situations.
+In particular, the Core Team may:
+
+-   Make decisions about the overall scope, vision and direction of the
+    project.
+-   Make decisions about strategic collaborations with other organizations or
+    individuals.
+-   Make decisions about specific technical issues, features, bugs and pull
+    requests. They are the primary mechanism of guiding the code review process
+    and merging pull requests.
+-   Make decisions about the Services that are run by The Project and manage
+    those Services for the benefit of the Project and Community.
+-   Make decisions when regular community discussion doesn’t produce consensus
+    on an issue in a reasonable time frame.
+
+### Core Team membership
+
+To become eligible for being a Core Team Member an individual must be a Project
+Contributor who has produced contributions that are substantial in quality and
+quantity, and sustained over at least one year. Potential Core Team Members are
+nominated by existing Core members and voted upon by the existing Core Team
+after asking if the potential Member is interested and willing to serve in that
+capacity. The Core Team will be initially formed from the set of existing
+Contributors who have been granted commit rights as of late 2015.
+
+When considering potential Members, the Core Team will look at candidates with
+a comprehensive view of their contributions. This will include but is not
+limited to code, code review, infrastructure work, mailing list and chat
+participation, community help/building, education and outreach, design work,
+etc. We are deliberately not setting arbitrary quantitative metrics (like “100
+commits in this repo”) to avoid encouraging behavior that plays to the metrics
+rather than the project’s overall well-being. We want to encourage a diverse
+array of backgrounds, viewpoints and talents in our team, which is why we
+explicitly do not define code as the sole metric on which Core Team membership
+will be evaluated.
+
+If a Core Team member becomes inactive in the project for a period of one year,
+they will be considered for removal from the Core Team. Before removal,
+inactive Member will be approached by the BDFL to see if they plan on returning
+to active participation. If not they will be removed immediately upon a Core
+Team vote. If they plan on returning to active participation soon, they will be
+given a grace period of one year. If they don’t return to active participation
+within that time period they will be removed by vote of the Core Team without
+further grace period. All former Core Team members can be considered for
+membership again at any time in the future, like any other Project Contributor.
+Retired Core Team members will be listed on the project website, acknowledging
+the period during which they were active in the Core Team.
+
+The Core Team reserves the right to eject current Members, other than the BDFL,
+if they are deemed to be actively harmful to the project’s well-being, and
+attempts at communication and conflict resolution have failed.
+
+### Conflict of interest
+
+It is expected that the BDFL and Core Team Members will be employed at a wide
+range of companies, universities and non-profit organizations. Because of this,
+it is possible that Members will have conflict of interests. Such conflict of
+interests include, but are not limited to:
+
+-   Financial interests, such as investments, employment or contracting work,
+    outside of The Project that may influence their work on The Project.
+-   Access to proprietary information of their employer that could potentially
+    leak into their work with the Project.
+
+All members of the Core Team, BDFL included, shall disclose to the rest of the
+Core Team any conflict of interest they may have. Members with a conflict of
+interest in a particular issue may participate in Core Team discussions on that
+issue, but must recuse themselves from voting on the issue. If the BDFL has
+recused his/herself for a particular decision, they will appoint a substitute
+BDFL for that decision.
+
+### Private communications of the Core Team
+
+Unless specifically required, all Core Team discussions and activities will be
+public and done in collaboration and discussion with the Project Contributors
+and Community. The Core Team will have a private mailing list that will be used
+sparingly and only when a specific matter requires privacy. When private
+communications and decisions are needed, the Core Team will do its best to
+summarize those to the Community after eliding personal/private/sensitive
+information that should not be posted to the public internet.
+
+### Subcommittees
+
+The Core Team can create subcommittees that provide leadership and guidance for
+specific aspects of the project. Like the Core Team as a whole, subcommittees
+should conduct their business in an open and public manner unless privacy is
+specifically called for. Private subcommittee communications should happen on
+the main private mailing list of the Core Team unless specifically called for.
+
+Question: if the BDFL is not on a subcommittee, do they still have override
+authority?
+
+Suggestion: they do, but they should appoint a delegate who plays that role
+most of the time, and explicit BDFL intervention is sought only if the
+committee disagrees with that delegate’s decision and no resolution is possible
+within the team. This is different from a BDFL delegate for a specific decision
+(or a recusal situation), where the BDFL is literally giving up his/her
+authority to someone else in full. It’s more like what Linus Torvalds uses with his
+“lieutenants” model.
+
+### NumFOCUS Subcommittee
+
+The Core Team will maintain one narrowly focused subcommittee to manage its
+interactions with NumFOCUS.
+
+- The NumFOCUS Subcommittee is comprised of at least 5 persons who manage
+  project funding that comes through NumFOCUS. It is expected that these funds
+  will be spent in a manner that is consistent with the non-profit mission of
+  NumFOCUS and the direction of the Project as determined by the full Core
+  Team.
+- This Subcommittee shall NOT make decisions about the direction, scope or
+  technical direction of the Project.
+- This Subcommittee will have at least 5 members. No more than 2 Subcommitee
+  Members can report to one person (either directly or indirectly) through
+  employment or contracting work (including the reportee, i.e. the reportee + 1
+  is the max). This avoids effective majorities resting on one person.
+
+## Institutional Partners and Funding
+
+The BDFL and Core Team are the primary leadership for the project. No outside
+institution, individual or legal entity has the ability to own, control, usurp
+or influence the project other than by participating in the Project as
+Contributors and Core Team. However, because institutions are the primary
+funding mechanism for the project, it is important to formally acknowledge
+institutional participation in the project. These are Institutional Partners.
+
+An Institutional Contributor is any individual Project Contributor who
+contributes to the project as part of their official duties at an Institutional
+Partner. Likewise, an Institutional Core Team Member is any Core Team Member
+who contributes to the project as part of their official duties at an
+Institutional Partner.
+
+With these definitions, an Institutional Partner is any recognized legal entity
+in the United States or elsewhere that employs at least one Institutional
+Contributor or Institutional Core Team Member. Institutional Partners can be
+for-profit or non-profit entities.
+
+Institutions become eligible to become an Institutional Partner by employing
+individuals who actively contribute to The Project as part of their official
+duties. To state this another way, the only way for an Institutional Partner to
+influence the project is by actively contributing to the open development of
+the project, on equal terms with any other member of the community of
+Contributors and Core Team Members. Merely using pandas Software or Services in
+an institutional context does not allow an entity to become an Institutional
+Partner. Financial gifts do not enable an entity to become an Institutional
+Partner. Once an institution becomes eligible for Institutional Partnership,
+the Core Team must nominate and approve the Partnership.
+
+If an existing Institutional Partner no longer has a contributing employee,
+they will be given a one-year grace period for other employees to begin
+contributing.
+
+An Institutional Partner is free to pursue funding for their work on The
+Project through any legal means. This could involve a non-profit organization
+raising money from private foundations and donors or a for-profit company
+building proprietary products and services that leverage Project Software and
+Services. Funding acquired by Institutional Partners to work on The Project is
+called Institutional Funding. However, no funding obtained by an Institutional
+Partner can override The Project BDFL and Core Team. If a Partner has funding
+to do pandas work and the Core Team decides to not pursue that work as a
+project, the Partner is free to pursue it on their own. However in this
+situation, that part of the Partner’s work will not be under the pandas
+umbrella and cannot use the Project trademarks in a way that suggests a formal
+relationship.
+
+To acknowledge institutional contributions, there are two levels of
+Institutional Partners, with associated benefits:
+
+**Tier 1** = an institution with at least one Institutional Core Team Member
+
+- Acknowledged on the pandas website, in talks and T-shirts.
+- Ability to acknowledge their own funding sources on the pandas website, in
+  talks and T-shirts.
+- Ability to influence the project through the participation of their Core Team
+  Member.
+
+**Tier 2** = an institution with at least one Institutional Contributor
+
+## Breach
+
+Non-compliance with the terms of the governance documents shall be reported to
+the Core Team either through public or private channels as deemed appropriate.
+
+## Changing the Governance
+
+Changes to the governance are submitted via a GitHub pull request to The Project's
+[governance page](https://github.com/pandas-dev/pandas/blob/main/web/pandas/about/governance.md).
+The pull request is then refined in response to public comment and review, with
+the goal being consensus in the community.  After this open period, a Core Team
+Member proposes to the Core Team that the changes be ratified and the pull
+request merged (accepting the proposed changes) or proposes that the pull
+request be closed without merging (rejecting the proposed changes). The Member
+should state the final commit hash in the pull request being proposed for
+acceptance or rejection and briefly summarize the pull request. A minimum of
+80% of the Core Team must vote and at least 2/3 of the votes must be positive
+to carry out the proposed action (fractions of a vote rounded up to the nearest
+integer). Since the BDFL holds ultimate authority in The Project, the BDFL has
+authority to act alone in accepting or rejecting changes or overriding Core
+Team decisions.
diff --git a/web/pandas/about/index.md b/web/pandas/about/index.md
index 02caaa3b8c53c..4c809a148b328 100644
--- a/web/pandas/about/index.md
+++ b/web/pandas/about/index.md
@@ -54,7 +54,7 @@ This will help ensure the success of development of _pandas_ as a world-class op
   series without losing data;
 
 - Highly **optimized for performance**, with critical code paths written in
-  [Cython](http://www.cython.org/) or C.
+  [Cython](https://cython.org) or C.
 
 - Python with *pandas* is in use in a wide variety of **academic and
   commercial** domains, including Finance, Neuroscience, Economics,
diff --git a/web/pandas/about/roadmap.md b/web/pandas/about/roadmap.md
index 35a6b3361f32e..64e730fc42eed 100644
--- a/web/pandas/about/roadmap.md
+++ b/web/pandas/about/roadmap.md
@@ -15,10 +15,35 @@ fundamental changes to the project that are likely to take months or
 years of developer time. Smaller-scoped items will continue to be
 tracked on our [issue tracker](https://github.com/pandas-dev/pandas/issues).
 
-See [Roadmap evolution](#roadmap-evolution) for proposing
-changes to this document.
+The roadmap is defined as a set of major enhancement proposals named PDEPs.
+For more information about PDEPs, and how to submit one, please refer to
+[PEDP-1](/pdeps/0001-purpose-and-guidelines.html).
 
-## Extensibility
+## PDEPs
+
+{% for pdep_type in ["Under discussion", "Accepted", "Implemented", "Rejected"] %}
+
+<h3 id="pdeps-{{pdep_type}}">{{ pdep_type.replace("_", " ").capitalize() }}</h3>
+
+<ul>
+{% for pdep in pdeps[pdep_type] %}
+    <li><a href="https://github.com/%7B%7B%20pdep.url%20%7D%7D">{{ pdep.title }}</a></li>
+{% else %}
+    <li>There are currently no PDEPs with this status</li>
+{% endfor %}
+</ul>
+
+{% endfor %}
+
+## Roadmap points pending a PDEP
+
+<div class="alert alert-warning" role="alert">
+  pandas is in the process of moving roadmap points to PDEPs (implemented in
+  August 2022). During the transition, some roadmap points will exist as PDEPs,
+  while others will exist as sections below.
+</div>
+
+### Extensibility
 
 Pandas `extending.extension-types` allow
 for extending NumPy types with custom data types and array storage.
@@ -33,7 +58,7 @@ library, making their behavior more consistent with the handling of
 NumPy arrays. We'll do this by cleaning up pandas' internals and
 adding new methods to the extension array interface.
 
-## String data type
+### String data type
 
 Currently, pandas stores text data in an `object` -dtype NumPy array.
 The current implementation has two primary drawbacks: First, `object`
@@ -54,7 +79,7 @@ work, we may need to implement certain operations expected by pandas
 users (for example the algorithm used in, `Series.str.upper`). That work
 may be done outside of pandas.
 
-## Apache Arrow interoperability
+### Apache Arrow interoperability
 
 [Apache Arrow](https://arrow.apache.org) is a cross-language development
 platform for in-memory data. The Arrow logical types are closely aligned
@@ -65,7 +90,7 @@ data types within pandas. This will let us take advantage of its I/O
 capabilities and provide for better interoperability with other
 languages and libraries using Arrow.
 
-## Block manager rewrite
+### Block manager rewrite
 
 We'd like to replace pandas current internal data structures (a
 collection of 1 or 2-D arrays) with a simpler collection of 1-D arrays.
@@ -92,7 +117,7 @@ See [these design
 documents](https://dev.pandas.io/pandas2/internal-architecture.html#removal-of-blockmanager-new-dataframe-internals)
 for more.
 
-## Decoupling of indexing and internals
+### Decoupling of indexing and internals
 
 The code for getting and setting values in pandas' data structures
 needs refactoring. In particular, we must clearly separate code that
@@ -103,11 +128,54 @@ uses label-based, rather than position-based, indexing. We propose that
 it should only work with positional indexing, and the translation of
 keys to positions should be entirely done at a higher level.
 
-Indexing is a complicated API with many subtleties. This refactor will
-require care and attention. More details are discussed at
-<https://github.com/pandas-dev/pandas/wiki/(Tentative)-rules-for-restructuring-indexing-code>
+Indexing is a complicated API with many subtleties. This refactor will require care
+and attention. The following principles should inspire refactoring of indexing code and
+should result on cleaner, simpler, and more performant code.
+
+1. Label indexing must never involve looking in an axis twice for the same label(s).
+This implies that any validation step must either:
+
+  * limit validation to general features (e.g. dtype/structure of the key/index), or
+  * reuse the result for the actual indexing.
+
+2. Indexers must never rely on an explicit call to other indexers.
+For instance, it is OK to have some internal method of `.loc` call some
+internal method of `__getitem__` (or of their common base class),
+but never in the code flow of `.loc` should `the_obj[something]` appear.
+
+3. Execution of positional indexing must never involve labels (as currently, sadly, happens).
+That is, the code flow of a getter call (or a setter call in which the right hand side is non-indexed)
+to `.iloc` should never involve the axes of the object in any way.
+
+4. Indexing must never involve accessing/modifying values (i.e., act on `._data` or `.values`) more than once.
+The following steps must hence be clearly decoupled:
+
+  * find positions we need to access/modify on each axis
+  * (if we are accessing) derive the type of object we need to return (dimensionality)
+  * actually access/modify the values
+  * (if we are accessing) construct the return object
 
-## Numba-accelerated operations
+5. As a corollary to the decoupling between 4.i and 4.iii, any code which deals on how data is stored
+(including any combination of handling multiple dtypes, and sparse storage, categoricals, third-party types)
+must be independent from code that deals with identifying affected rows/columns,
+and take place only once step 4.i is completed.
+
+  * In particular, such code should most probably not live in `pandas/core/indexing.py`
+  * ... and must not depend in any way on the type(s) of axes (e.g. no `MultiIndex` special cases)
+
+6. As a corollary to point 1.i, `Index` (sub)classes must provide separate methods for any desired validity check of label(s) which does not involve actual lookup,
+on the one side, and for any required conversion/adaptation/lookup of label(s), on the other.
+
+7. Use of trial and error should be limited, and anyway restricted to catch only exceptions
+which are actually expected (typically `KeyError`).
+
+  * In particular, code should never (intentionally) raise new exceptions in the `except` portion of a `try... exception`
+
+8. Any code portion which is not specific to setters and getters must be shared,
+and when small differences in behavior are expected (e.g. getting with `.loc` raises for
+missing labels, setting still doesn't), they can be managed with a specific parameter.
+
+### Numba-accelerated operations
 
 [Numba](https://numba.pydata.org) is a JIT compiler for Python code.
 We'd like to provide ways for users to apply their own Numba-jitted
@@ -119,7 +187,7 @@ window contexts). This will improve the performance of
 user-defined-functions in these operations by staying within compiled
 code.
 
-## Documentation improvements
+### Documentation improvements
 
 We'd like to improve the content, structure, and presentation of the
 pandas documentation. Some specific goals include
@@ -134,7 +202,7 @@ pandas documentation. Some specific goals include
     subsections of the documentation to make navigation and finding
     content easier.
 
-## Performance monitoring
+### Performance monitoring
 
 Pandas uses [airspeed velocity](https://asv.readthedocs.io/en/stable/)
 to monitor for performance regressions. ASV itself is a fabulous tool,
@@ -154,29 +222,3 @@ We'd like to fund improvements and maintenance of these tools to
     <https://pyperf.readthedocs.io/en/latest/system.html>
 -   Build a GitHub bot to request ASV runs *before* a PR is merged.
     Currently, the benchmarks are only run nightly.
-
-## Roadmap Evolution
-
-Pandas continues to evolve. The direction is primarily determined by
-community interest. Everyone is welcome to review existing items on the
-roadmap and to propose a new item.
-
-Each item on the roadmap should be a short summary of a larger design
-proposal. The proposal should include
-
-1.  Short summary of the changes, which would be appropriate for
-    inclusion in the roadmap if accepted.
-2.  Motivation for the changes.
-3.  An explanation of why the change is in scope for pandas.
-4.  Detailed design: Preferably with example-usage (even if not
-    implemented yet) and API documentation
-5.  API Change: Any API changes that may result from the proposal.
-
-That proposal may then be submitted as a GitHub issue, where the pandas
-maintainers can review and comment on the design. The [pandas mailing
-list](https://mail.python.org/mailman/listinfo/pandas-dev) should be
-notified of the proposal.
-
-When there's agreement that an implementation would be welcome, the
-roadmap should be updated to include the summary and a link to the
-discussion issue.
diff --git a/web/pandas/about/team.md b/web/pandas/about/team.md
index c8318dd8758ed..bdd5d5d2b2468 100644
--- a/web/pandas/about/team.md
+++ b/web/pandas/about/team.md
@@ -6,10 +6,11 @@ _pandas_ is made with love by more than [2,000 volunteer contributors](https://g
 
 If you want to support pandas development, you can find information in the [donations page](../donate.html).
 
-## Maintainers
+## Active maintainers
 
 <div class="card-group maintainers">
-    {% for person in maintainers.people %}
+    {% for username in maintainers.active %}
+        {% set person = maintainers.github_info.get(username) %}
         <div class="card">
             <img class="card-img-top" alt="" src="https://github.com/%7B%7B%20person.avatar_url%20%7D%7D"/>
             <div class="card-body">
@@ -42,7 +43,7 @@ If you want to support pandas development, you can find information in the [dona
 
 Wes McKinney is the Benevolent Dictator for Life (BDFL).
 
-The project governance is available in the [project governance documents](https://github.com/pandas-dev/pandas-governance).
+The project governance is available in the [project governance page](governance.html).
 
 ## Code of conduct committee
 
@@ -60,10 +61,15 @@ The project governance is available in the [project governance documents](https:
     {% endfor %}
 </ul>
 
-## Emeritus maintainers
+## Inactive maintainers
 
 <ul>
-    {% for person in maintainers.emeritus %}
-        <li>{{ person }}</li>
+    {% for username in maintainers.inactive %}
+        {% set person = maintainers.github_info.get(username) %}
+        <li>
+            <a href="https://github.com/%7B%7B%20person.blog%20or%20person.html_url%20%7D%7D">
+                {{ person.name or person.login }}
+            </a>
+        </li>
     {% endfor %}
 </ul>
diff --git a/web/pandas/community/blog/2019-user-survey.md b/web/pandas/community/blog/2019-user-survey.md
index 73c426e7cbec9..312ee49bdf387 100644
--- a/web/pandas/community/blog/2019-user-survey.md
+++ b/web/pandas/community/blog/2019-user-survey.md
@@ -26,11 +26,11 @@ This analysis and the raw data can be found [on GitHub](https://github.com/panda
 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pandas-dev/pandas-user-surveys/master?filepath=2019.ipynb)
 
 
-We had about 1250 repsonses over the 15 days we ran the survey in the summer of 2019.
+We had about 1250 responses over the 15 days we ran the survey in the summer of 2019.
 
 ## About the Respondents
 
-There was a fair amount of representation across pandas experience and frequeny of use, though the majority of respondents are on the more experienced side.
+There was a fair amount of representation across pandas experience and frequency of use, though the majority of respondents are on the more experienced side.
 
 
 
@@ -101,7 +101,7 @@ CSV and Excel are (for better or worse) the most popular formats.
 ![png]({{ base_url }}/static/img/blog/2019-user-survey/2019_18_0.png)
 
 
-In preperation for a possible refactor of pandas internals, we wanted to get a sense for
+In preparation for a possible refactor of pandas internals, we wanted to get a sense for
 how common wide (100s of columns or more) DataFrames are.
 
 
@@ -109,7 +109,7 @@ how common wide (100s of columns or more) DataFrames are.
 ![png]({{ base_url }}/static/img/blog/2019-user-survey/2019_20_0.png)
 
 
-Pandas is slowly growing new exentension types. Categoricals are the most popular,
+Pandas is slowly growing new extension types. Categoricals are the most popular,
 and the nullable integer type is already almost as popular as datetime with timezone.
 
 
@@ -139,7 +139,7 @@ Of these, the clear standout is "scaling" to large datasets. A couple observatio
 1. Perhaps pandas' documentation should do a better job of promoting libraries that provide scalable dataframes (like [Dask](https://dask.org), [vaex](https://dask.org), and [modin](https://modin.readthedocs.io/en/latest/))
 2. Memory efficiency (perhaps from a native string data type, fewer internal copies, etc.) is a valuable goal.
 
-After that, the next-most critical improvement is integer missing values. Those were actually added in [Pandas 0.24](https://pandas.pydata.org/pandas-docs/stable/whatsnew/v0.24.0.html#optional-integer-na-support), but they're not the default, and there's still some incompatibilites with the rest of pandas API.
+After that, the next-most critical improvement is integer missing values. Those were actually added in [Pandas 0.24](https://pandas.pydata.org/pandas-docs/stable/whatsnew/v0.24.0.html#optional-integer-na-support), but they're not the default, and there's still some incompatibilities with the rest of pandas API.
 
 Pandas is a less conservative library than, say, NumPy. We're approaching 1.0, but on the way we've made many deprecations and some outright API breaking changes. Fortunately, most people are OK with the tradeoff.
 
diff --git a/web/pandas/community/blog/asv-pandas-grant.md b/web/pandas/community/blog/asv-pandas-grant.md
new file mode 100644
index 0000000000000..205c2222fec94
--- /dev/null
+++ b/web/pandas/community/blog/asv-pandas-grant.md
@@ -0,0 +1,141 @@
+Title: Write up of the NumFOCUS grant to improve pandas benchmarks and diversity
+Date: 2022-04-01
+
+# Write up of the NumFOCUS grant to improve pandas benchmarks and diversity
+
+*By Lucy Jiménez and Dorothy Kabarozi B.*
+
+We want to share our experience working on **Improvements to the**
+**ASV benchmarking framework and diversity efforts** sponsored by
+[NumFOCUS](https://numfocus.org/) to the [pandas](https://pandas.pydata.org/)
+project.
+
+This grant focused on two aspects: the first one is to improve the
+[asv library](https://asv.readthedocs.io/en/stable/), a tool used by
+benchmarking Python packages and used by pandas; this project was
+unmaintained, and the codebase was quite old; additionally, it didn't
+adhere to modern standards, had Python 2 compatibility code that could
+be removed, and also the CI could be improved. The second aspect is
+encouraging more underrepresented groups to contribute to open source
+projects. This grant was held over 10 weeks, working around 20 hours a
+week. It was developed by Dorothy Kabarozi B. from Uganda and Lucy
+Jiménez from Colombia, under the mentoring of Marc Garcia.
+
+## Why were we part of the grant?
+
+Even when we come from different backgrounds, Dorothy from systems
+engineering and Lucy from computational chemistry, we have always been
+interested in participating and contributing to open source software
+projects. For that reason, we have been running the PyLadies meetups in
+our communities ([PyLadies Kampala](https://twitter.com/pyladieskla),
+[PyLadies Colombia](https://twitter.com/pyladies_co)) and have always
+been on the lookout for any opportunities that lead us to contribute.
+
+It all happened through Marc Garcia; he had put out a call ​through a post
+on social media to mentor ladies from diverse backgrounds. Dorothy got to
+be part of the pandas mentorship group. At the same time, Lucy was
+co-organizer of the SciPy Latam conference, and it is from here she met
+Marc, who was the speaker at that conference, and through this mutual
+connection, we were able to learn about this benchmarks grant.
+
+In brief, by attending conferences, meetups, and social media, you can
+make connections and links that will lead you to these opportunities.
+
+## Learning from the source code
+
+At the beginning of the grant, we started from the basics. We noticed that
+we could improve our skills in managing Git and GitHub. For example, we had
+some troubles with the git workflow, so we had to read and practice more
+about it. One of the valuable resources was the explanation from Marc about
+[how to make an open source contribution](https://tubedu.org/w/kjnHEg72j76StmSFmjzbnE),
+which we invite you to take a look at it.
+
+We learned a lot from the source code and gained immense knowledge about
+best practices and code quality through this grant. We have been working
+on: updating the code to improve the style to follow the PEP-8 guidelines,
+removing Python 2 compatibility code and six dependencies, and finding
+unused code and removing it. We also learned about GitHub actions, and we
+started building the CI on GitHub actions for the asv package; for that we
+have been working on add linting with Flake8, testing with pytest, building
+docs, and running CI on different python versions.
+
+Additionally, we were able to identify bugs in the source code, review
+pull request from other contributors, and create new issues, something we
+thought only maintainers could do but not contributors. Finally, not only
+is reviewing the code itself a learning experience, but also the structure
+and folder hierarchy in the project started to be more transparent.
+
+## Our experience
+
+For this grant, we had a fantastic Mentor, Marc Garcia. He was always
+willing to share his knowledge, explain unclear concepts and share helpful
+feedback. Whenever we would implement that feedback, it felt easier to work
+on more issues faster. We felt the growth from the time we started on this
+project, and we will carry it along as we contribute to more open source
+projects; this all goes back to Marc for his fantastic mentorship. It is
+also important to note that we received feedback from other contributors,
+stakeholders, and core devs during this process, which gave us a broader
+look at the work in open source projects.
+
+We also built a strong teamwork partnership. We helped each other a lot as
+we had numerous one-on-one calls to understand the tasks better. We always
+looked for ways to support each other from the technical side and encouraged
+each other when needed. For us, it was professional and human growth.
+
+## Running an open source software sprint
+
+The knowledge and experience acquired in this process allowed us to
+organize two virtual sprints. The events were carried out in the company
+of local PyLadies communities; the first one was on February 26th with
+[PyLadies Kampala](https://twitter.com/pyladieskla) and on March 21
+with [PyLadies Colombia](https://bit.ly/sprint-asv).
+
+While organizing these events, we learned how to organize and conduct a
+virtual sprint. Some participants in the sprint ultimately had no idea
+about open source, and it was great explaining open source concepts and
+taking them through the Git workflow. Finally, they were able to make their
+first contribution. We learned how to follow up on contributors, helping
+them along the way until their PRs were merged and by reviewing their
+contributions on GitHub.
+
+The most outstanding achievement was mentoring new contributors and
+sharing the knowledge acquired from this grant with others participants
+in our respective communities. Most new contributors after the experience
+have gone ahead to apply for outreach and the upcoming
+[Google Summer of Code](https://summerofcode.withgoogle.com/)
+to apply the skills they learned from these sprints.
+
+## Conclusion
+
+In conclusion, we learned a lot from this experience from the code part,
+the workflow on the open source projects, how to be resilient in difficult
+moments, and encouraging more women and people from our local communities
+to contribute to open source projects.
+
+Finally, if you want to be part of an open source project, we invite you
+to check out GitHub repos for different projects you are interested in and
+search for the easy issues to work on and get started. Also, you can contact
+the maintainers of the projects with specific questions, search for the
+open source communities in your country or contact us for more help.
+
+## Acknowledgments
+
+Many thanks to [NumFOCUS](https://numfocus.org/) for giving us this support
+through [Small Development Grants](https://numfocus.org/programs/small-development-grants)
+and Marc for the excellent mentoring he generously gave us throughout these
+weeks.
+
+We are looking forward to contributing more and impacting our communities
+and the open source community!
+
+___
+If you want to know more, please don't hesitate to connect with us through
+these channels:
+
+*Lucy Jiménez*
+* [Twitter](https://twitter.com/JimenezLucyJ)
+* [LinkedIn](https://www.linkedin.com/in/lucy-j/)
+
+*Dorothy Kabarozi*
+* [Twitter](https://twitter.com/kizdorothy)
+* [LinkedIn](https://www.linkedin.com/in/dorothy-kabarozi/)
diff --git a/web/pandas/community/blog/extension-arrays.md b/web/pandas/community/blog/extension-arrays.md
index 61a77738a259c..80a187bb3fc3c 100644
--- a/web/pandas/community/blog/extension-arrays.md
+++ b/web/pandas/community/blog/extension-arrays.md
@@ -212,7 +212,7 @@ partners][partners] involved in the pandas community.
 [ml]: https://mail.python.org/mailman/listinfo/pandas-dev
 [twitter]: https://twitter.com/pandas_dev
 [tracker]: https://github.com/pandas-dev/pandas/issues
-[partners]: https://github.com/pandas-dev/pandas-governance/blob/master/people.md
+[partners]: https://pandas.pydata.org/about/sponsors.html
 [eco]: http://pandas.pydata.org/pandas-docs/stable/ecosystem.html#extension-data-types
 [whatsnew]: http://pandas.pydata.org/pandas-docs/version/0.24/whatsnew/v0.24.0.html
 [geopandas]: https://github.com/geopandas/geopandas
diff --git a/web/pandas/community/blog/pandas-1.0.md b/web/pandas/community/blog/pandas-1.0.md
index b07c34a4ab6b5..d190ed6e897b3 100644
--- a/web/pandas/community/blog/pandas-1.0.md
+++ b/web/pandas/community/blog/pandas-1.0.md
@@ -19,7 +19,7 @@ We're [working with those projects](https://datapythonista.me/blog/dataframe-sum
 
 ## Community and Project Health
 
-This release cycle is the first to involve any kind of grant funding for pandas. [Pandas received funding](https://chanzuckerberg.com/eoss/proposals/) as part of the CZI’s [*Essential Open Source Software for Science*](https://medium.com/@cziscience/the-invisible-foundations-of-biomedicine-4ab7f8d4f5dd) [program](https://medium.com/@cziscience/the-invisible-foundations-of-biomedicine-4ab7f8d4f5dd). The pandas project relies overwhelmingly on volunteer contributors. These volunteer contributions are shepherded and augmented by some maintainers who are given time from their employers — our [institutional partners](https://github.com/pandas-dev/pandas-governance/blob/master/people.md#institutional-partners). The largest work item in our grant award was library maintenance, which specifically includes working with community members to address our large backlog of open issues and pull requests.
+This release cycle is the first to involve any kind of grant funding for pandas. [Pandas received funding](https://chanzuckerberg.com/eoss/proposals/) as part of the CZI’s [*Essential Open Source Software for Science*](https://medium.com/@cziscience/the-invisible-foundations-of-biomedicine-4ab7f8d4f5dd) [program](https://medium.com/@cziscience/the-invisible-foundations-of-biomedicine-4ab7f8d4f5dd). The pandas project relies overwhelmingly on volunteer contributors. These volunteer contributions are shepherded and augmented by some maintainers who are given time from their employers — our [institutional partners](../about/sponsors.html). The largest work item in our grant award was library maintenance, which specifically includes working with community members to address our large backlog of open issues and pull requests.
 
 While a “1.0.0” version might seem arbitrary or anti-climactic (given that pandas as a codebase is nearly 12 years old), we see it as a symbolic milestone celebrating the growth of our core developer team and depth of our contributor base.  Few open source projects are ever truly “done” and pandas is no different. We recognize the essential role that pandas now occupies, and we intend to continue to evolve the project and adapt to the needs of the world’s data wranglers.
 
diff --git a/web/pandas/community/ecosystem.md b/web/pandas/community/ecosystem.md
index e744889070d8e..89d243555a358 100644
--- a/web/pandas/community/ecosystem.md
+++ b/web/pandas/community/ecosystem.md
@@ -29,7 +29,7 @@ modeling functionality that is out of pandas' scope. Statsmodels
 leverages pandas objects as the underlying data container for
 computation.
 
-### [sklearn-pandas](https://github.com/paulgb/sklearn-pandas)
+### [sklearn-pandas](https://github.com/scikit-learn-contrib/sklearn-pandas)
 
 Use pandas DataFrames in your [scikit-learn](https://scikit-learn.org/)
 ML pipeline.
@@ -60,7 +60,7 @@ top of the powerful Vega-Lite JSON specification. This elegant
 simplicity produces beautiful and effective visualizations with a
 minimal amount of code. Altair works with Pandas DataFrames.
 
-### [Bokeh](https://bokeh.pydata.org)
+### [Bokeh](https://docs.bokeh.org)
 
 Bokeh is a Python interactive visualization library for large datasets
 that natively uses the latest web technologies. Its goal is to provide
@@ -172,20 +172,20 @@ inspection and rich visualization capabilities of a scientific
 environment like MATLAB or Rstudio.
 
 Its [Variable
-Explorer](https://docs.spyder-ide.org/variableexplorer.html) allows
+Explorer](https://docs.spyder-ide.org/current/panes/variableexplorer.html) allows
 users to view, manipulate and edit pandas `Index`, `Series`, and
 `DataFrame` objects like a "spreadsheet", including copying and
 modifying values, sorting, displaying a "heatmap", converting data
 types and more. Pandas objects can also be renamed, duplicated, new
-columns added, copyed/pasted to/from the clipboard (as TSV), and
+columns added, copied/pasted to/from the clipboard (as TSV), and
 saved/loaded to/from a file. Spyder can also import data from a variety
 of plain text and binary files or the clipboard into a new pandas
 DataFrame via a sophisticated import wizard.
 
 Most pandas classes, methods and data attributes can be autocompleted in
-Spyder's [Editor](https://docs.spyder-ide.org/editor.html) and [IPython
-Console](https://docs.spyder-ide.org/ipythonconsole.html), and Spyder's
-[Help pane](https://docs.spyder-ide.org/help.html) can retrieve and
+Spyder's [Editor](https://docs.spyder-ide.org/current/panes/editor.html) and [IPython
+Console](https://docs.spyder-ide.org/current/panes/ipythonconsole.html), and Spyder's
+[Help pane](https://docs.spyder-ide.org/current/panes/help.html) can retrieve and
 render Numpydoc documentation on pandas objects in rich text with Sphinx
 both automatically and on-demand.
 
@@ -233,7 +233,7 @@ package requires valid credentials for this API (non free).
 ### [pandaSDMX](https://pandasdmx.readthedocs.io)
 
 pandaSDMX is a library to retrieve and acquire statistical data and
-metadata disseminated in [SDMX](https://www.sdmx.org) 2.1, an
+metadata disseminated in [SDMX](https://sdmx.org) 2.1, an
 ISO-standard widely used by institutions such as statistics offices,
 central banks, and international organisations. pandaSDMX can expose
 datasets and related structural metadata including data flows,
@@ -254,7 +254,7 @@ you can obtain for free on the FRED website.
 
 ## Domain specific
 
-### [Geopandas](https://github.com/kjordahl/geopandas)
+### [Geopandas](https://github.com/geopandas/geopandas)
 
 Geopandas extends pandas data objects to include geographic information
 which support geometric operations. If your work entails maps and
@@ -277,13 +277,13 @@ Blaze provides a standard API for doing computations with various
 in-memory and on-disk backends: NumPy, Pandas, SQLAlchemy, MongoDB,
 PyTables, PySpark.
 
-### [Dask](https://dask.readthedocs.io/en/latest/)
+### [Dask](https://docs.dask.org)
 
 Dask is a flexible parallel computing library for analytics. Dask
 provides a familiar `DataFrame` interface for out-of-core, parallel and
 distributed computing.
 
-### [Dask-ML](https://dask-ml.readthedocs.io/en/latest/)
+### [Dask-ML](https://ml.dask.org)
 
 Dask-ML enables parallel and distributed machine learning using Dask
 alongside existing machine learning libraries like Scikit-Learn,
@@ -303,7 +303,7 @@ packages such as PyTables, h5py, and pymongo to move data between non
 pandas formats. Its graph based approach is also extensible by end users
 for custom formats that may be too specific for the core of odo.
 
-### [Ray](https://ray.readthedocs.io/en/latest/pandas_on_ray.html)
+### [Ray](https://docs.ray.io/en/latest/data/modin/index.html)
 
 Pandas on Ray is an early stage DataFrame library that wraps Pandas and
 transparently distributes the data and computation. The user does not
@@ -320,14 +320,14 @@ Ray just like you would Pandas.
 import ray.dataframe as pd
 ```
 
-### [Vaex](https://docs.vaex.io/)
+### [Vaex](https://vaex.io/docs/)
 
 Increasingly, packages are being built on top of pandas to address
 specific needs in data preparation, analysis and visualization. Vaex is
 a python library for Out-of-Core DataFrames (similar to Pandas), to
 visualize and explore big tabular datasets. It can calculate statistics
 such as mean, sum, count, standard deviation etc, on an N-dimensional
-grid up to a billion (10^9^) objects/rows per second. Visualization is
+grid up to a billion (10^9) objects/rows per second. Visualization is
 done using histograms, density plots and 3d volume rendering, allowing
 interactive exploration of big data. Vaex uses memory mapping, zero
 memory copy policy and lazy computations for best performance (no memory
@@ -338,7 +338,7 @@ wasted).
 
 ## Data cleaning and validation
 
-### [pyjanitor](https://github.com/ericmjl/pyjanitor/)
+### [pyjanitor](https://github.com/pyjanitor-devs/pyjanitor)
 
 Pyjanitor provides a clean API for cleaning data, using method chaining.
 
@@ -379,8 +379,8 @@ A directory of projects providing
 `extension accessors <extending.register-accessors>`. This is for users to discover new accessors and for library
 authors to coordinate on the namespace.
 
-  | Library                                                              | Accessor   |  Classes              |
-  | ---------------------------------------------------------------------|------------|-----------------------|
+  | Library                                                              | Accessor   | Classes               |
+  | -------------------------------------------------------------------- | ---------- | --------------------- |
   | [cyberpandas](https://cyberpandas.readthedocs.io/en/latest)          | `ip`       | `Series`              |
   | [pdvega](https://altair-viz.github.io/pdvega/)                       | `vgplot`   | `Series`, `DataFrame` |
   | [pandas-genomics](https://pandas-genomics.readthedocs.io/en/latest/) | `genomics` | `Series`, `DataFrame` |
@@ -388,6 +388,7 @@ authors to coordinate on the namespace.
   | [pint-pandas](https://github.com/hgrecco/pint-pandas)                | `pint`     | `Series`, `DataFrame` |
   | [composeml](https://github.com/alteryx/compose)                      | `slice`    | `DataFrame`           |
   | [woodwork](https://github.com/alteryx/woodwork)                      | `slice`    | `Series`, `DataFrame` |
+
 ## Development tools
 
 ### [pandas-stubs](https://github.com/VirtusLab/pandas-stubs)
@@ -399,3 +400,20 @@ Learn more by reading through these issues [14468](https://github.com/pandas-dev
 [26766](https://github.com/pandas-dev/pandas/issues/26766), [28142](https://github.com/pandas-dev/pandas/issues/28142).
 
 See installation and usage instructions on the [github page](https://github.com/VirtusLab/pandas-stubs).
+
+### [Hamilton](https://github.com/stitchfix/hamilton)
+
+Hamilton is a declarative dataflow framework that came out of Stitch Fix. It was designed to help one manage a
+Pandas code base, specifically with respect to feature engineering for machine learning models.
+
+It prescibes an opinionated paradigm, that ensures all code is:
+
+* unit testable
+* integration testing friendly
+* documentation friendly
+* transformation logic is reuseable, as it is decoupled from the context of where it is used.
+* integrateable with runtime data quality checks.
+
+This helps one to scale your pandas code base, at the same time, keeping maintenance costs low.
+
+For more information, see [documentation](https://hamilton-docs.gitbook.io/).
diff --git a/web/pandas/config.yml b/web/pandas/config.yml
index 9165456d55897..85dee1d114800 100644
--- a/web/pandas/config.yml
+++ b/web/pandas/config.yml
@@ -1,16 +1,18 @@
 main:
   templates_path: _templates
   base_template: "layout.html"
+  production_url: "https://pandas.pydata.org/"
   ignore:
   - _templates/layout.html
   - config.yml
-  - try.md  # the binder page will be added later
   github_repo_url: pandas-dev/pandas
   context_preprocessors:
+  - pandas_web.Preprocessors.current_year
   - pandas_web.Preprocessors.navbar_add_info
   - pandas_web.Preprocessors.blog_add_posts
   - pandas_web.Preprocessors.maintainers_add_info
   - pandas_web.Preprocessors.home_add_releases
+  - pandas_web.Preprocessors.roadmap_pdeps
   markdown_extensions:
   - toc
   - tables
@@ -27,6 +29,8 @@ navbar:
       target: /about/
     - name: "Project roadmap"
       target: /about/roadmap.html
+    - name: "Governance"
+      target: /about/governance.html
     - name: "Team"
       target: /about/team.html
     - name: "Sponsors"
@@ -58,42 +62,45 @@ blog:
   - https://wesmckinney.com/feeds/pandas.atom.xml
   - https://tomaugspurger.github.io/feed
   - https://jorisvandenbossche.github.io/feeds/pandas.atom.xml
-  - https://datapythonista.github.io/blog/feeds/pandas.atom.xml
+  - https://datapythonista.me/blog/feeds/pandas.atom.xml
   - https://numfocus.org/tag/pandas/feed/
 maintainers:
   active:
   - wesm
   - jorisvandenbossche
   - TomAugspurger
-  - shoyer
   - jreback
-  - chris-b1
-  - sinhrks
-  - cpcloud
   - gfyoung
-  - toobaz
   - WillAyd
   - mroeschke
-  - jschendel
   - jbrockmendel
   - datapythonista
   - simonjayhawkins
   - topper-123
   - alimcmaster1
   - bashtage
-  - charlesdong1991
   - Dr-Irv
-  - dsaxton
   - MarcoGorelli
   - rhshadrach
   - phofl
   - attack68
   - fangchenli
   - twoertwein
-  emeritus:
-  - Wouter Overmeire
-  - Skipper Seabold
-  - Jeff Tratner
+  - lithomas1
+  - mzeitlin11
+  - lukemanley
+  inactive:
+  - lodagro
+  - jseabold
+  - jtratner
+  - shoyer
+  - chris-b1
+  - sinhrks
+  - cpcloud
+  - toobaz
+  - jschendel
+  - charlesdong1991
+  - dsaxton
   coc:
   - Safia Abdalla
   - Tom Augspurger
@@ -101,11 +108,11 @@ maintainers:
   - Camille Scott
   - Nathaniel Smith
   numfocus:
-  - Phillip Cloud
-  - Stephan Hoyer
   - Wes McKinney
   - Jeff Reback
   - Joris Van den Bossche
+  - Tom Augspurger
+  - Matthew Roeschke
 sponsors:
   active:
   - name: "NumFOCUS"
@@ -116,17 +123,27 @@ sponsors:
     url: https://www.twosigma.com/
     logo: /static/img/partners/two_sigma.svg
     kind: partner
-    description: "Phillip Cloud, Jeff Reback"
-  - name: "Ursa Labs"
-    url: https://ursalabs.org/
-    logo: /static/img/partners/ursa_labs.svg
+    description: "Jeff Reback"
+  - name: "Voltron Data"
+    url: https://voltrondata.com/
+    logo: /static/img/partners/voltron_data.svg
     kind: partner
-    description: "Wes McKinney, Joris Van den Bossche"
+    description: "Joris Van den Bossche"
   - name: "d-fine GmbH"
     url: https://www.d-fine.com/en/
     logo: /static/img/partners/dfine.svg
     kind: partner
     description: "Patrick Hoefler"
+  - name: "Quansight"
+    url: https://quansight.com/
+    logo: /static/img/partners/quansight_labs.svg
+    kind: partner
+    description: "Marco Gorelli"
+  - name: "Nvidia"
+    url: https://www.nvidia.com
+    logo: /static/img/partners/nvidia.svg
+    kind: partner
+    description: "Matthew Roeschke"
   - name: "Tidelift"
     url: https://tidelift.com
     logo: /static/img/partners/tidelift.svg
@@ -137,6 +154,11 @@ sponsors:
     logo: /static/img/partners/czi.svg
     kind: regular
     description: "<i>pandas</i> is funded by the Essential Open Source Software for Science program of the Chan Zuckerberg Initiative. The funding is used for general maintenance, improve extension types, and a efficient string type."
+  - name: "Bodo"
+    url: https://www.bodo.ai/
+    logo: /static/img/partners/bodo.svg
+    kind: regular
+    description: "Bodo's parallel computing platform uses pandas API, and Bodo financially supports pandas development to help improve pandas, in particular the pandas API"
   inkind:  # not included in active so they don't appear in the home page
   - name: "OVH"
     url: https://us.ovhcloud.com/
@@ -150,10 +172,15 @@ sponsors:
     kind: partner
   - name: "Anaconda"
     url: https://www.anaconda.com/
-    logo: /static/img/partners/anaconda.svg
     kind: partner
   - name: "RStudio"
     url: https://www.rstudio.com/
-    logo: /static/img/partners/r_studio.svg
     kind: partner
-    description: "Wes McKinney"
+  - name: "Ursa Labs"
+    url: https://ursalabs.org/
+    kind: partner
+  - name: "Gousto"
+    url: https://www.gousto.co.uk/
+    kind: partner
+roadmap:
+  pdeps_path: pdeps
diff --git a/web/pandas/getting_started.md b/web/pandas/getting_started.md
index d4f40a1153fb4..dc43a6a273832 100644
--- a/web/pandas/getting_started.md
+++ b/web/pandas/getting_started.md
@@ -1,5 +1,18 @@
 # Getting started
 
+## Try it in your browser
+
+You can try `pandas` in your browser with the following interactive shell
+without installing anything on your computer.
+
+*Note it can take up to 30 seconds before the shell finishes loading and is ready to run commands.*
+
+<iframe
+  src="https://github.com/lite/repl/index.html?toolbar=1&kernel=python&code=import%20pandas%20as%20pd&code=df%20=%20pd.DataFrame(%7B'num_legs':%20%5B2,%204%5D,%20'num_wings':%20%5B2,%200%5D%7D,%20index=%5B'falcon',%20'dog'%5D)"
+  width="100%"
+  height="500px"
+></iframe>
+
 ## Installation instructions
 
 The next steps provides the easiest and recommended way to set up your
diff --git a/web/pandas/index.html b/web/pandas/index.html
index 930f6caa59cb9..2d5e44d725138 100644
--- a/web/pandas/index.html
+++ b/web/pandas/index.html
@@ -44,12 +44,12 @@ <h5>Community</h5>
                 <section>
                     <h5>With the support of:</h5>
                     {% for row in sponsors.active | batch(6, "") %}
-                        <div class="row h-100">
+                        <div class="row mx-auto h-100">
                             {% for company in row %}
-                                <div class="col-sm-6 col-md-2 my-auto">
+                                <div class="col-6 col-md-2">
                                     {% if company %}
                                         <a href="https://github.com/%7B%7B%20company.url%20%7D%7D" target="_blank">
-                                            <img class="img-fluid" alt="{{ company.name }}" src="https://github.com/%7B%7B%20base_url%20%7D%7D%7B%7B%20company.logo%20%7D%7D"/>
+                                            <img class="img-fluid img-thumnail py-5 mx-auto" alt="{{ company.name }}" src="https://github.com/%7B%7B%20base_url%20%7D%7D%7B%7B%20company.logo%20%7D%7D"/>
                                         </a>
                                     {% endif %}
                                 </div>
@@ -66,15 +66,24 @@ <h4>Latest version: {{ releases[0].name }}</h4>
                         <li><a href="https://github.com/docs/whatsnew/v%7B%7B%20releases[0].name%20%7D%7D.html">What's new in {{ releases[0].name }}</a></li>
                         <li>Release date:<br/>{{ releases[0].published.strftime("%b %d, %Y") }}</li>
                         <li><a href="https://github.com/%7B%7B%20base_url%7D%7D/docs/">Documentation (web)</a></li>
-                        <li><a href="https://github.com/%7B%7B%20base_url%20%7D%7D/docs/pandas.pdf">Documentation (pdf)</a></li>
                         <li><a href="https://github.com/%7B%7B%20releases[0].url%20%7D%7D">Download source code</a></li>
                     </ul>
                 {% endif %}
                 <h4>Follow us</h4>
                 <div class="text-center">
-                    <p>
-                        <a href="https://twitter.com/pandas_dev?ref_src=twsrc%5Etfw" class="twitter-follow-button" data-show-count="false">Follow @pandas_dev</a><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
-                    </p>
+                    <ul class="list-inline social-buttons">
+                        <li class="list-inline-item">
+                            <a href="https://t.me/s/pandas_dev">
+                                <i class="follow-us-button fab fa-telegram"></i>
+                            </a>
+                        </li>
+                        <li class="list-inline-item">
+                            <a href="https://twitter.com/pandas_dev/">
+                                <i class="follow-us-button fab fa-twitter"></i>
+                            </a>
+                        </li>
+                    </ul>
+
                 </div>
 				<h4>Get the book</h4>
 				<p class="book">
@@ -90,7 +99,6 @@ <h4>Previous versions</h4>
                                 {{ release.name }} ({{ release.published.strftime("%b %d, %Y") }})<br/>
                                 <a href="https://pandas.pydata.org/pandas-docs/stable/whatsnew/%7B%7B%20release.tag%20%7D%7D.html">changelog</a> |
                                 <a href="https://pandas.pydata.org/pandas-docs/version/%7B%7B%20release.name%20%7D%7D/">docs</a> |
-                                <a href="https://pandas.pydata.org/pandas-docs/version/%7B%7B%20release.name%20%7D%7D/pandas.pdf">pdf</a> |
                                 <a href="https://github.com/%7B%7B%20release.url%20%7D%7D">code</a>
                             </li>
                         {% endfor %}
@@ -106,7 +114,6 @@ <h4>Previous versions</h4>
                                 {{ release.name }} ({{ release.published.strftime("%Y-%m-%d") }})<br/>
                                 <a href="https://pandas.pydata.org/pandas-docs/stable/whatsnew/%7B%7B%20release.tag%20%7D%7D.html">changelog</a> |
                                 <a href="https://pandas.pydata.org/pandas-docs/version/%7B%7B%20release.name%20%7D%7D/">docs</a> |
-                                <a href="https://pandas.pydata.org/pandas-docs/version/%7B%7B%20release.name%20%7D%7D/pandas.pdf">pdf</a> |
                                 <a href="https://github.com/%7B%7B%20release.url%20%7D%7D">code</a>
                             </li>
                         {% endfor %}
diff --git a/web/pandas/pdeps/0001-purpose-and-guidelines.md b/web/pandas/pdeps/0001-purpose-and-guidelines.md
new file mode 100644
index 0000000000000..e09c5bd01204f
--- /dev/null
+++ b/web/pandas/pdeps/0001-purpose-and-guidelines.md
@@ -0,0 +1,128 @@
+# PDEP-1: Purpose and guidelines
+
+- Created: 3 August 2022
+- Status: Accepted
+- Discussion: [#47444](https://github.com/pandas-dev/pandas/pull/47444)
+- Author: [Marc Garcia](https://github.com/datapythonista)
+- Revision: 1
+
+## PDEP definition, purpose and scope
+
+A PDEP (pandas enhancement proposal) is a proposal for a **major** change in
+pandas, in a similar way as a Python [PEP](https://peps.python.org/pep-0001/)
+or a NumPy [NEP](https://numpy.org/neps/nep-0000.html).
+
+Bug fixes and conceptually minor changes (e.g. adding a parameter to a function)
+are out of the scope of PDEPs. A PDEP should be used for changes that are not
+immediate and not obvious, and are expected to require a significant amount of
+discussion and require detailed documentation before being implemented.
+
+PDEP are appropriate for user facing changes, internal changes and organizational
+discussions. Examples of topics worth a PDEP could include moving a module from
+pandas to a separate repository, a refactoring of the pandas block manager or
+a proposal of a new code of conduct.
+
+## PDEP guidelines
+
+### Target audience
+
+A PDEP is a public document available to anyone, but the main stakeholders to
+consider when writing a PDEP are:
+
+- The core development team, who will have the final decision on whether a PDEP
+  is approved or not
+- Contributors to pandas and other related projects, and experienced users. Their
+  feedback is highly encouraged and appreciated, to make sure all points of views
+  are taken into consideration
+- The wider pandas community, in particular users, who may or may not have feedback
+  on the proposal, but should know and be able to understand the future direction of
+  the project
+
+### PDEP authors
+
+Anyone can propose a PDEP, but in most cases developers of pandas itself and related
+projects are expected to author PDEPs. If you are unsure if you should be opening
+an issue or creating a PDEP, it's probably safe to start by
+[opening an issue](https://github.com/pandas-dev/pandas/issues/new/choose), which can
+be eventually moved to a PDEP.
+
+### Workflow
+
+The possible states of a PDEP are:
+
+- Under discussion
+- Accepted
+- Implemented
+- Rejected
+
+Next is described the workflow that PDEPs can follow.
+
+#### Submitting a PDEP
+
+Proposing a PDEP is done by creating a PR adding a new file to `web/pdeps/`.
+The file is a markdown file, you can use `web/pdeps/0001.md` as a reference
+for the expected format.
+
+The initial status of a PDEP will be `Status: Under discussion`. This will be changed
+to `Status: Accepted` when the PDEP is ready and have the approval of the core team.
+
+#### Accepted PDEP
+
+A PDEP can only be accepted by the core development team, if the proposal is considered
+worth implementing. Decisions will be made based on the process detailed in the
+[pandas governance document](https://github.com/pandas-dev/pandas-governance/blob/master/governance.md).
+In general, more than one approval will be needed before the PR is merged. And
+there should not be any `Request changes` review at the time of merging.
+
+Once a PDEP is accepted, any contributions can be made toward the implementation of the PDEP,
+with an open-ended completion timeline. Development of pandas is difficult to understand and
+forecast, being that the contributors to pandas are a mix of volunteers and developers paid from different sources,
+with different priorities. For companies, institutions or individuals with interest in seeing a
+PDEP being implemented, or to in general see progress to the pandas roadmap, please check how
+you can help in the [contributing page](/contribute.html).
+
+#### Implemented PDEP
+
+Once a PDEP is implemented and available in the main branch of pandas, its
+status will be changed to `Status: Implemented`, so there is visibility that the PDEP
+is not part of the roadmap and future plans, but a change that has already
+happened. The first pandas version in which the PDEP implementation is
+available will also be included in the PDEP header with for example
+`Implemented: v2.0.0`.
+
+#### Rejected PDEP
+
+A PDEP can be rejected when the final decision is that its implementation is
+not in the best interests of the project. Rejected PDEPs are as useful as accepted
+PDEPs, since there are discussions that are worth having, and decisions about
+changes to pandas being made. They will be merged with `Status: Rejected`, so
+there is visibility on what was discussed and what was the outcome of the
+discussion. A PDEP can be rejected for different reasons, for example good ideas
+that aren't backward-compatible, and the breaking changes aren't considered worth
+implementing.
+
+#### Invalid PDEP
+
+For submitted PDEPs that do not contain proper documentation, are out of scope, or
+are not useful to the community for any other reason, the PR will be closed after
+discussion with the author, instead of merging them as rejected. This is to avoid
+adding noise to the list of rejected PDEPs, which should contain documentation as
+good as an accepted PDEP, but where the final decision was to not implement the changes.
+
+## Evolution of PDEPs
+
+Most PDEPs aren't expected to change after accepted. Once there is agreement in the changes,
+and they are implemented, the PDEP will be only useful to understand why the development happened,
+and the details of the discussion.
+
+But in some cases, a PDEP can be updated. For example, a PDEP defining a procedure or
+a policy, like this one (PDEP-1). Or cases when after attempting the implementation,
+new knowledge is obtained that makes the original PDEP obsolete, and changes are
+required. When there are specific changes to be made to the original PDEP, this will
+be edited, its `Revision: X` label will be increased by one, and a note will be added
+to the `PDEP-N history` section. This will let readers understand that the PDEP has
+changed and avoid confusion.
+
+### PDEP-1 History
+
+- 3 August 2022: Initial version
diff --git a/web/pandas/static/css/pandas.css b/web/pandas/static/css/pandas.css
index 67955dd35587c..ec9a4bd502dd1 100644
--- a/web/pandas/static/css/pandas.css
+++ b/web/pandas/static/css/pandas.css
@@ -8,15 +8,19 @@ h1 {
     color: #130654;
 }
 h2 {
-    font-size: 1.45rem;
+    font-size: 1.8rem;
     font-weight: 700;
-    color: black;
+    color: #130654;
 }
 h3 {
     font-size: 1.3rem;
     font-weight: 600;
     color: black;
 }
+h3 a {
+    color: black;
+    text-decoration: underline dotted !important;
+}
 a {
     color: #130654;
 }
@@ -32,6 +36,13 @@ ol ol, ol ul, ul ol, ul ul {
 .pink {
     color: #e70488;
 }
+.follow-us-button {
+    font-size: 2.4rem !important;
+    color: #0d6efd !important;
+}
+.follow-us-button:hover {
+    color: #0b5ed7 !important;
+}
 .fab {
     font-size: 1.2rem;
     color: #666;
@@ -85,3 +96,10 @@ table.logo td {
 table.logo img {
     height: 4rem;
 }
+blockquote {
+    background: #f9f9f9;
+    border-left: 5px solid #ccc;
+    padding-left:15px;
+    color: #787878;
+    font-size: 18px;
+ }
diff --git a/web/pandas/static/img/partners/anaconda.svg b/web/pandas/static/img/partners/anaconda.svg
deleted file mode 100644
index fcddf72ebaa28..0000000000000
--- a/web/pandas/static/img/partners/anaconda.svg
+++ /dev/null
@@ -1,99 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   viewBox="0 0 530.44 90.053329"
-   height="90.053329"
-   width="530.44"
-   xml:space="preserve"
-   id="svg2"
-   version="1.1"><metadata
-     id="metadata8"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /></cc:Work></rdf:RDF></metadata><defs
-     id="defs6" /><g
-     transform="matrix(1.3333333,0,0,-1.3333333,0,90.053333)"
-     id="g10"><g
-       transform="scale(0.1)"
-       id="g12"><path
-         id="path14"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 958.313,274.5 53.637,120.406 h 1.64 L 1068.32,274.5 Z m 67.867,251.754 c -1.65,3.285 -3.83,6.027 -9.31,6.027 h -5.47 c -4.93,0 -7.66,-2.742 -9.31,-6.027 L 831.887,157.93 c -3.282,-7.117 1.097,-14.231 9.304,-14.231 h 47.618 c 8.754,0 13.679,5.473 15.867,10.942 l 26.82,59.113 h 163.644 l 26.81,-59.113 c 3.83,-7.657 7.66,-10.942 15.88,-10.942 h 47.61 c 8.21,0 12.59,7.114 9.3,14.231 l -168.56,368.324" /><path
-         id="path16"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 1547.94,526.801 h -50.35 c -6.03,0 -10.4,-4.922 -10.4,-10.395 V 290.371 h -0.55 l -227.67,241.91 h -13.68 c -5.48,0 -10.4,-4.383 -10.4,-9.855 V 154.102 c 0,-5.481 4.92,-10.403 10.4,-10.403 h 49.8 c 6.02,0 10.4,4.922 10.4,10.403 v 235.332 h 0.54 L 1534.8,138.227 h 13.14 c 5.47,0 10.4,4.378 10.4,9.847 v 368.332 c 0,5.473 -4.93,10.395 -10.4,10.395" /><path
-         id="path18"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 1725.97,274.5 53.64,120.406 h 1.64 L 1835.98,274.5 Z m 67.87,251.754 c -1.64,3.285 -3.83,6.027 -9.31,6.027 h -5.47 c -4.93,0 -7.66,-2.742 -9.31,-6.027 L 1599.55,157.93 c -3.29,-7.117 1.09,-14.231 9.3,-14.231 h 47.62 c 8.75,0 13.68,5.473 15.87,10.942 l 26.82,59.113 h 163.64 l 26.81,-59.113 c 3.83,-7.657 7.67,-10.942 15.88,-10.942 h 47.61 c 8.21,0 12.59,7.114 9.3,14.231 l -168.56,368.324" /><path
-         id="path20"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 2261.6,241.117 c -3.29,3.285 -9.31,3.836 -13.69,0 -22.98,-18.605 -50.9,-31.191 -83.73,-31.191 -70.06,0 -122.6,58.008 -122.6,126.418 0,68.965 51.99,127.519 122.05,127.519 30.64,0 61.3,-12.039 84.28,-32.285 4.38,-4.379 9.85,-4.379 13.69,0 l 33.38,34.477 c 4.38,4.375 4.38,10.941 -0.55,15.328 -37.21,33.383 -77.17,50.898 -132.45,50.898 -109.45,0 -197.57,-88.117 -197.57,-197.574 0,-109.465 88.12,-196.48 197.57,-196.48 48.72,0 95.78,16.964 133,53.086 3.83,3.835 4.92,10.949 0.55,14.777 l -33.93,35.027" /><path
-         id="path22"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 2520.21,209.379 c -68.95,0 -125.33,56.371 -125.33,125.328 0,68.957 56.38,126.426 125.33,126.426 68.96,0 125.88,-57.469 125.88,-126.426 0,-68.957 -56.92,-125.328 -125.88,-125.328 z m 0,322.902 c -109.46,0 -196.48,-88.117 -196.48,-197.574 0,-109.465 87.02,-196.48 196.48,-196.48 109.46,0 197.03,87.015 197.03,196.48 0,109.457 -87.57,197.574 -197.03,197.574" /><path
-         id="path24"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 3090.17,526.801 h -50.35 c -6.02,0 -10.4,-4.922 -10.4,-10.395 V 290.371 h -0.54 l -227.68,241.91 h -13.68 c -5.47,0 -10.4,-4.383 -10.4,-9.855 V 154.102 c 0,-5.481 4.93,-10.403 10.4,-10.403 h 49.8 c 6.02,0 10.4,4.922 10.4,10.403 v 235.332 h 0.55 l 228.77,-251.207 h 13.13 c 5.47,0 10.4,4.378 10.4,9.847 v 368.332 c 0,5.473 -4.93,10.395 -10.4,10.395" /><path
-         id="path26"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 3303.16,210.465 h -62.39 v 250.121 h 62.39 c 71.15,0 123.14,-53.641 123.14,-124.785 0,-71.696 -51.99,-125.336 -123.14,-125.336 z m 6.57,316.336 h -129.71 c -5.47,0 -9.85,-4.922 -9.85,-10.395 V 154.102 c 0,-5.481 4.38,-10.403 9.85,-10.403 h 129.71 c 105.63,0 192.1,85.926 192.1,192.102 0,105.082 -86.47,191 -192.1,191" /><path
-         id="path28"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 3631.32,274.5 53.64,120.406 h 1.64 L 3741.33,274.5 Z m 236.43,-116.57 -168.57,368.324 c -1.64,3.285 -3.82,6.027 -9.29,6.027 h -5.48 c -4.93,0 -7.67,-2.742 -9.3,-6.027 L 3504.9,157.93 c -3.29,-7.117 1.09,-14.231 9.3,-14.231 h 47.62 c 8.76,0 13.68,5.473 15.87,10.942 l 26.82,59.113 h 163.63 l 26.83,-59.113 c 3.82,-7.657 7.66,-10.942 15.86,-10.942 h 47.62 c 8.21,0 12.59,7.114 9.3,14.231" /><path
-         id="path30"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 3940.9,176.27 h 7.99 c 2.7,0 4.5,-1.793 4.5,-4.403 0,-2.422 -1.8,-4.394 -4.5,-4.394 h -7.99 z m -4.85,-26.582 h 3.33 c 0.99,0 1.7,0.808 1.7,1.707 v 10.148 h 5.57 l 4.49,-10.598 c 0.27,-0.629 0.9,-1.257 1.62,-1.257 h 4.04 c 1.26,0 2.16,1.257 1.53,2.425 -1.53,3.235 -3.15,6.645 -4.76,9.969 2.69,0.984 6.82,3.5 6.82,9.879 0,6.824 -5.48,10.594 -11.04,10.594 h -13.3 c -0.98,0 -1.7,-0.809 -1.7,-1.703 v -29.457 c 0,-0.899 0.72,-1.707 1.7,-1.707" /><path
-         id="path32"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 3945.93,192.078 c 14.46,0 26.05,-11.586 26.05,-26.043 0,-14.371 -11.59,-26.047 -26.05,-26.047 -14.37,0 -26.04,11.676 -26.04,26.047 0,14.457 11.67,26.043 26.04,26.043 z m 0,-58.285 c 17.79,0 32.33,14.461 32.33,32.242 0,17.781 -14.54,32.328 -32.33,32.328 -17.78,0 -32.24,-14.547 -32.24,-32.328 0,-17.781 14.46,-32.242 32.24,-32.242" /><path
-         id="path34"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 125.527,158.422 0.051,2.484 c 0.414,19.649 1.977,39.149 4.684,57.961 l 0.254,1.77 -1.668,0.679 c -17.871,7.305 -35.4574,15.782 -52.2699,25.219 l -2.1172,1.184 -1.0742,-2.16 C 62.3164,223.238 52.9844,199.707 45.6836,175.602 l -0.7031,-2.254 2.2812,-0.629 C 72.0234,165.91 97.5195,161.184 123.051,158.66 l 2.476,-0.238" /><path
-         id="path36"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 177.781,500.941 c 0.032,0.196 0.063,0.395 0.094,0.59 -14.668,-0.258 -29.324,-1.265 -43.926,-2.965 1.891,-14.777 4.481,-29.437 7.828,-43.925 10.02,16.949 22.121,32.511 36.004,46.3" /><path
-         id="path38"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 125.527,140.855 -0.039,2.051 -2.043,0.199 c -21.406,2.02 -43.2223,5.661 -64.8278,10.821 l -5.668,1.355 3.211,-4.855 C 75.5742,121.098 99.3125,95.0195 126.73,72.9258 l 4.43,-3.5899 -0.719,5.668 c -2.906,22.6719 -4.554,44.8321 -4.914,65.8511" /><path
-         id="path40"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 230.566,657.227 c -26.32,-9.008 -51.164,-21.161 -74.101,-36.036 17.359,-3.07 34.469,-7.097 51.273,-12.027 6.696,16.375 14.297,32.426 22.828,48.063" /><path
-         id="path42"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 339.918,675.43 c -13.023,0 -25.848,-0.813 -38.488,-2.25 17.925,-12.489 35.066,-26.145 51.238,-41.051 l 13.43,-12.391 -13.168,-12.672 c -10.899,-10.488 -21.559,-21.898 -31.688,-33.918 l -0.512,-0.585 c -0.117,-0.125 -2.003,-2.219 -5.152,-6.055 8,0.84 16.117,1.293 24.34,1.293 127.07,0 230.086,-103.016 230.086,-230.086 0,-127.074 -103.016,-230.086 -230.086,-230.086 -44.094,0 -85.277,12.426 -120.277,33.934 -17.27,-1.918 -34.629,-2.922 -52.012,-2.922 -8.074,0 -16.152,0.211 -24.227,0.629 0.524,-26.172 3.016,-53.3052 7.477,-81.438 C 204.82,21.3242 269.879,0 339.918,0 c 186.516,0 337.715,151.199 337.715,337.715 0,186.512 -151.199,337.715 -337.715,337.715" /><path
-         id="path44"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 295.145,595.602 c 6.726,7.968 13.671,15.695 20.765,23.101 -15.824,13.469 -32.531,25.758 -50.004,36.856 -10.742,-18.161 -20.09,-36.977 -28.093,-56.282 15.195,-5.574 30.066,-11.953 44.589,-19.031 6.711,8.617 11.399,13.883 12.743,15.356" /><path
-         id="path46"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 65.9219,402.934 1.289,-2.09 2.0118,1.433 c 15.6289,11.235 32.0823,21.594 48.9103,30.789 l 1.582,0.864 -0.449,1.738 c -5.028,19.227 -8.868,39.055 -11.414,58.941 l -0.305,2.399 -2.387,-0.434 C 80.168,492.027 55.4609,485.344 31.7383,476.703 l -2.2227,-0.816 0.8789,-2.188 c 9.7422,-24.562 21.6914,-48.363 35.5274,-70.765" /><path
-         id="path48"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="M 62.0469,370.18 60.125,368.629 C 41.9492,353.844 24.7266,337.414 8.93359,319.797 L 7.375,318.066 9.13281,316.531 C 26.6641,301.188 45.5547,287.094 65.2734,274.645 l 2.0274,-1.293 1.2031,2.097 c 8.8828,15.781 18.8945,31.356 29.7695,46.278 l 1.0938,1.503 -1.2383,1.383 c -12.3281,13.746 -23.9883,28.395 -34.668,43.547 l -1.414,2.02" /><path
-         id="path50"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 194.48,157.273 5.868,0.348 -4.559,3.723 c -17.976,14.715 -33.625,32.09 -46.453,51.656 l -0.106,0.621 -3.75,1.649 -0.433,-3.184 c -2.262,-16.856 -3.586,-34.566 -3.945,-52.625 l -0.039,-2.215 2.207,-0.129 c 8.003,-0.429 16.078,-0.644 24.171,-0.644 9.004,0 18.032,0.269 27.039,0.8" /><path
-         id="path52"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 183.219,530.238 c 3.633,16.649 8.109,33.121 13.511,49.317 -21.125,6.078 -42.769,10.617 -64.789,13.523 -1.867,-22.047 -2.082,-44.082 -0.707,-65.941 17.278,1.988 34.629,3.011 51.985,3.101" /><path
-         id="path54"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 215.813,531.414 c 14.707,9.441 30.539,17.266 47.281,23.195 -11.875,5.59 -24,10.661 -36.348,15.184 -4.219,-12.633 -7.863,-25.441 -10.933,-38.379" /><path
-         id="path56"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 58.6914,257.121 -1.7773,1.113 C 39.4922,269.16 22.6055,281.363 6.74609,294.496 l -4.51953,3.742 0.76953,-5.812 C 7.30078,260.039 16.2734,228.496 29.6406,198.684 l 2.3672,-5.278 1.9024,5.465 c 6.6406,19.125 14.6601,38.102 23.8281,56.387 l 0.9531,1.863" /><path
-         id="path58"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="M 102.133,577.48 C 81.9766,557.492 64.3555,534.969 49.7266,510.445 c 17.4804,5.215 35.1836,9.371 53.0194,12.528 -1.23,18.082 -1.465,36.273 -0.613,54.507" /><path
-         id="path60"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 112.121,340.762 0.234,5.824 c 0.79,20.598 4.309,40.855 10.461,60.195 l 1.793,5.653 -5.129,-2.961 c -13.152,-7.59 -26.1792,-16.012 -38.7222,-25.047 l -1.8281,-1.328 1.293,-1.86 c 8.6992,-12.406 18.1562,-24.535 28.0973,-36.062 l 3.801,-4.414" /><path
-         id="path62"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 114.383,305.906 -0.805,5.707 -3.34,-4.691 C 100.836,293.727 92.082,279.945 84.2227,265.961 l -1.1133,-1.992 1.9922,-1.133 c 14.1562,-7.984 29.0114,-15.305 44.1564,-21.762 l 5.402,-2.316 -2.406,5.363 c -8.863,19.668 -14.875,40.453 -17.871,61.785" /><path
-         id="path64"
-         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         d="m 48.6602,386.676 1.5976,1.273 -1.0781,1.735 c -10.5859,16.918 -20.1836,34.707 -28.5469,52.867 l -2.457,5.355 -1.8125,-5.605 C 6.51172,411.789 1.05859,379.887 0.160156,347.473 L 0,341.523 4.10938,345.82 c 14.01172,14.598 28.99612,28.34 44.55082,40.856" /></g></g></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/bodo.svg b/web/pandas/static/img/partners/bodo.svg
new file mode 100644
index 0000000000000..9dc6cb47505a3
--- /dev/null
+++ b/web/pandas/static/img/partners/bodo.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" width="930.84" height="267.43" viewBox="0 0 930.84 267.43"><defs><style>.cls-1{fill:#5e5e5e;}.cls-2{fill:#1db100;}</style></defs><title>bodo-grey-green</title><path class="cls-1" d="M85.73,93a83.24,83.24,0,0,1,33.14,6.64,85.67,85.67,0,0,1,0,158.11,83.45,83.45,0,0,1-33.14,6.67,83.06,83.06,0,0,1-33.34-6.67A87.46,87.46,0,0,1,6.67,212,83.23,83.23,0,0,1,0,178.67V11.44A10.82,10.82,0,0,1,3.43,3.25a11.3,11.3,0,0,1,8-3.24,10.66,10.66,0,0,1,7.81,3.24,11,11,0,0,1,3.24,8.19V121.17a85.33,85.33,0,0,1,23.24-17.91,86.89,86.89,0,0,1,19.47-7.64A81.71,81.71,0,0,1,85.77,93m0,149a62.21,62.21,0,0,0,24.57-5,63.2,63.2,0,0,0,33.72-33.53,64,64,0,0,0,0-49.34,62.65,62.65,0,0,0-33.72-33.72,63.48,63.48,0,0,0-49.15,0,62.72,62.72,0,0,0-33.72,33.72,64,64,0,0,0,0,49.34A63.25,63.25,0,0,0,61.19,237,62.19,62.19,0,0,0,85.77,242"/><path class="cls-1" d="M264.79,264.43a83.15,83.15,0,0,1-33.33-6.67,88.56,88.56,0,0,1-27.27-18.29,84.93,84.93,0,0,1-18.48-27.05,85.76,85.76,0,1,1,158.12,0,84.61,84.61,0,0,1-18.48,27.05,87.75,87.75,0,0,1-27.43,18.29,83.53,83.53,0,0,1-33.15,6.67m0-148.59a61.81,61.81,0,0,0-24.58,5,62.65,62.65,0,0,0-33.72,33.72,63.48,63.48,0,0,0,0,49.15,62.72,62.72,0,0,0,33.72,33.72,63.48,63.48,0,0,0,49.15,0,62.74,62.74,0,0,0,33.75-33.76,63.48,63.48,0,0,0,0-49.15,62.65,62.65,0,0,0-33.72-33.72,62,62,0,0,0-24.58-5"/><path class="cls-1" d="M443.48,93a85.82,85.82,0,0,1,63.24,28.19V11.06A10.66,10.66,0,0,1,510,3.25,11.31,11.31,0,0,1,529.19,11V178.7A83.06,83.06,0,0,1,522.52,212,85.76,85.76,0,1,1,410.19,99.62,82.89,82.89,0,0,1,443.53,93m63.24,85.72a61.86,61.86,0,0,0-4.95-24.57,62.65,62.65,0,0,0-33.72-33.72,63.48,63.48,0,0,0-49.15,0,62.74,62.74,0,0,0-33.76,33.75,64,64,0,0,0,0,49.34,63.39,63.39,0,0,0,116.59,0,61.48,61.48,0,0,0,5-24.77"/><path class="cls-1" d="M622.94,264.43a83.06,83.06,0,0,1-33.34-6.67,88.6,88.6,0,0,1-27.24-18.29,84.77,84.77,0,0,1-18.48-27.05,85.76,85.76,0,1,1,158.11,0,84.42,84.42,0,0,1-18.47,27.05,87.91,87.91,0,0,1-27.44,18.29,83.45,83.45,0,0,1-33.14,6.67m0-148.59a62,62,0,0,0-24.58,5,62.72,62.72,0,0,0-33.72,33.72,63.48,63.48,0,0,0,0,49.15,62.78,62.78,0,0,0,33.72,33.72,63.48,63.48,0,0,0,49.15,0,62.72,62.72,0,0,0,33.68-33.76,63.48,63.48,0,0,0,0-49.15,62.65,62.65,0,0,0-33.72-33.72,61.86,61.86,0,0,0-24.57-5"/><path class="cls-2" d="M850.77,254.14a86.3,86.3,0,0,1-19.24,7.62,81.2,81.2,0,0,1-20.76,2.67,83.23,83.23,0,0,1-33.34-6.67A87.46,87.46,0,0,1,731.71,212a85.77,85.77,0,1,1,158.12-66.51,83.44,83.44,0,0,1,6.66,33.14V253a11.31,11.31,0,0,1-3.23,8,10.84,10.84,0,0,1-8.2,3.43,10.38,10.38,0,0,1-7.81-3.43,11.34,11.34,0,0,1-3.24-8V236.23a81.85,81.85,0,0,1-23.24,17.91M747.52,178.7A63.44,63.44,0,0,0,786.19,237a63.45,63.45,0,0,0,49.14,0,62.65,62.65,0,0,0,33.72-33.72,63.48,63.48,0,0,0,0-49.15,62.59,62.59,0,0,0-33.72-33.72,63.45,63.45,0,0,0-49.14,0,63.4,63.4,0,0,0-38.72,58.29"/><path class="cls-2" d="M919.35,78.12a11.07,11.07,0,0,1-11-11V62.93a11.33,11.33,0,0,1,3.24-8,10.31,10.31,0,0,1,7.81-3.43,11.71,11.71,0,0,1,11.43,11.43v4.19a10.31,10.31,0,0,1-3.43,7.81,11.31,11.31,0,0,1-8,3.24m0,186.31a10.68,10.68,0,0,1-7.81-3.24,11.14,11.14,0,0,1-3.24-8.19V104.41a11.12,11.12,0,0,1,3.24-8.19A10.6,10.6,0,0,1,919.4,93a11.22,11.22,0,0,1,8,3.24,10.75,10.75,0,0,1,3.43,8.19V253a10.76,10.76,0,0,1-3.43,8.19,11.31,11.31,0,0,1-8,3.24"/><path class="cls-2" d="M731.81,234.54a19.27,19.27,0,1,1-27.25,0h0a19.26,19.26,0,0,1,27.25,0"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/dfine.svg b/web/pandas/static/img/partners/dfine.svg
old mode 100755
new mode 100644
diff --git a/web/pandas/static/img/partners/nvidia.svg b/web/pandas/static/img/partners/nvidia.svg
new file mode 100644
index 0000000000000..59f9e19cf00ad
--- /dev/null
+++ b/web/pandas/static/img/partners/nvidia.svg
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="svg2"
+   x="0px"
+   y="0px"
+   width="450"
+   height="340"
+   viewBox="35.188 31.512 450.00001 340"
+   enable-background="new 35.188 31.512 351.46 258.785"
+   xml:space="preserve"
+   sodipodi:docname="nvidia.svg"
+   inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"><metadata
+   id="metadata11"><rdf:RDF><cc:Work
+       rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+         rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title>generated by pstoedit version:3.44 from NVBadge_2D.eps</dc:title></cc:Work></rdf:RDF></metadata><defs
+   id="defs9" /><sodipodi:namedview
+   pagecolor="#ffffff"
+   bordercolor="#666666"
+   borderopacity="1"
+   objecttolerance="10"
+   gridtolerance="10"
+   guidetolerance="10"
+   inkscape:pageopacity="0"
+   inkscape:pageshadow="2"
+   inkscape:window-width="1920"
+   inkscape:window-height="1051"
+   id="namedview7"
+   showgrid="false"
+   inkscape:zoom="2.2870273"
+   inkscape:cx="163.94912"
+   inkscape:cy="154.68953"
+   inkscape:window-x="0"
+   inkscape:window-y="0"
+   inkscape:window-maximized="1"
+   inkscape:current-layer="svg2" />
+<title
+   id="title4">generated by pstoedit version:3.44 from NVBadge_2D.eps</title>
+
+
+<path
+   id="path17"
+   d="m 433.465,322.7165 c 0,3.771 -2.769,6.302 -6.047,6.302 v -0.023 c -3.371,0.023 -6.089,-2.508 -6.089,-6.278 0,-3.769 2.718,-6.293 6.089,-6.293 3.279,-0.001 6.047,2.523 6.047,6.292 z m 2.453,0 c 0,-5.175 -4.02,-8.179 -8.5,-8.179 -4.511,0 -8.531,3.004 -8.531,8.179 0,5.172 4.021,8.188 8.531,8.188 4.481,0 8.5,-3.016 8.5,-8.188 m -9.91,0.692 h 0.91 l 2.109,3.703 h 2.316 l -2.336,-3.859 c 1.207,-0.086 2.2,-0.661 2.2,-2.286 0,-2.019 -1.392,-2.668 -3.75,-2.668 h -3.411 v 8.813 h 1.961 v -3.703 m 10e-4,-1.492 v -2.122 h 1.364 c 0.742,0 1.753,0.06 1.753,0.965 0,0.985 -0.523,1.157 -1.398,1.157 h -1.719" /><path
+   id="path19"
+   d="m 378.676,277.6345 10.598,28.993 H 367.75 Z m -11.35,-11.289 -24.423,61.88 h 17.246 l 3.863,-10.934 h 28.903 l 3.656,10.934 h 18.722 l -24.605,-61.888 z m -49.033,61.903 h 17.497 v -61.922 l -17.5,-0.004 z m -121.467,-61.926 -14.598,49.078 -13.984,-49.074 -18.879,-0.004 19.972,61.926 h 25.207 l 20.133,-61.926 z m 70.725,13.484 h 7.52 c 10.91,0 17.966,4.898 17.966,17.609 0,12.714 -7.056,17.613 -17.966,17.613 h -7.52 z m -17.35,-13.484 v 61.926 h 28.366 c 15.113,0 20.048,-2.512 25.384,-8.148 3.769,-3.957 6.207,-12.641 6.207,-22.134 0,-8.707 -2.063,-16.468 -5.66,-21.304 -6.481,-8.649 -15.817,-10.34 -29.75,-10.34 z m -165.743,-0.086 v 62.012 h 17.645 v -47.086 l 13.672,0.004 c 4.527,0 7.754,1.128 9.934,3.457 2.765,2.945 3.894,7.699 3.894,16.395 v 27.23 h 17.098 v -34.262 c 0,-24.453 -15.586,-27.75 -30.836,-27.75 z m 137.583,0.086 0.007,61.926 h 17.489 v -61.926 z" /><path
+   id="path21"
+   fill="#77b900"
+   d="m 131.481,143.0215 c 0,0 22.504,-33.203 67.437,-36.638 v -12.046 c -49.769,3.997 -92.867,46.149 -92.867,46.149 0,0 24.41,70.565 92.867,77.026 v -12.804 c -50.237,-6.32 -67.437,-61.687 -67.437,-61.687 z m 67.437,36.223 v 11.726 c -37.968,-6.769 -48.507,-46.237 -48.507,-46.237 0,0 18.23,-20.195 48.507,-23.47 v 12.867 c -0.023,0 -0.039,-0.007 -0.058,-0.007 -15.891,-1.907 -28.305,12.938 -28.305,12.938 0,0 6.958,24.991 28.363,32.183 m 0,-107.125 v 22.218 c 1.461,-0.112 2.922,-0.207 4.391,-0.257 56.582,-1.907 93.449,46.406 93.449,46.406 0,0 -42.343,51.488 -86.457,51.488 -4.043,0 -7.828,-0.375 -11.383,-1.005 v 13.739 c 3.04,0.386 6.192,0.613 9.481,0.613 41.051,0 70.738,-20.965 99.484,-45.778 4.766,3.817 24.278,13.103 28.289,17.168 -27.332,22.883 -91.031,41.329 -127.144,41.329 -3.481,0 -6.824,-0.211 -10.11,-0.528 v 19.306 H 354.95 V 72.1195 Z m 0,49.144 v -14.879 c 1.446,-0.101 2.903,-0.179 4.391,-0.226 40.688,-1.278 67.382,34.965 67.382,34.965 0,0 -28.832,40.043 -59.746,40.043 -4.449,0 -8.438,-0.715 -12.028,-1.922 v -45.114 c 15.84,1.914 19.028,8.911 28.551,24.786 l 21.18,-17.859 c 0,0 -15.461,-20.277 -41.524,-20.277 -2.833,-0.001 -5.544,0.198 -8.206,0.483" />
+</svg>
diff --git a/web/pandas/static/img/partners/quansight_labs.svg b/web/pandas/static/img/partners/quansight_labs.svg
new file mode 100644
index 0000000000000..d49ab1b7d39ec
--- /dev/null
+++ b/web/pandas/static/img/partners/quansight_labs.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 511.28 230.68"><defs><style>.cls-1{fill:#452391;}.cls-2{fill:#99c941;}.cls-3{fill:#973896;}</style></defs><path class="cls-1" d="M41.94,188.52c-2.37.51-7.48,2.71-12.51,5.54h3.46c5-2.71,10-5,14.08-6a15,15,0,0,0,1.62-.46Z"/><path class="cls-1" d="M21.51,200.85s9.82-6.64,19.13-6.73C52.76,194,64,212.43,78.34,212.43c13.42,0,19.3-9.22,22.1-16.83l-.58-.26c-5.22,7.72-10.57,10.32-19.14,10.32-15,0-20-15-40.06-14.73C30.05,191.06,21.41,199.35,21.51,200.85Z"/><path class="cls-1" d="M62.94,178.35c.13-.15.25-.31.37-.46a30.46,30.46,0,0,0,6.35-18.57,27.52,27.52,0,0,0-.42-4.5,30.27,30.27,0,0,0-3.75-10.91l.21.25C61,135.79,52.5,130.1,42.82,129.88h-1.3c-9.69.22-18.18,5.91-22.89,14.28l.21-.25A30.48,30.48,0,0,0,15,155.57a29.28,29.28,0,0,0-.31,3.85c.08,16.05,12.4,29.22,27.41,29.22A26.8,26.8,0,0,0,62.9,178.41ZM39.15,133.72l.38-.05.41,0,.69-.07.35,0,.44,0h1.5l.44,0,.34,0,.69.07.41,0,.38.05.43.08c11.63,2.15,16.16,15,16.16,25.45,0,6.22-1.59,13.22-5.3,18.35h0l-.33.45a16.86,16.86,0,0,1-13.87,6.76,18.31,18.31,0,0,1-2.76-.2c-.63-.05-1.26-.13-1.88-.22A16.13,16.13,0,0,1,32.19,182l.14,0c-6.93-4.77-9.77-14.46-9.77-22.76,0-10.48,4.53-23.3,16.16-25.45Z"/><path class="cls-1" d="M113.62,185.14c0,.43-.44.65-1.32.65H104a1.38,1.38,0,0,1-1.32-.9L101.38,182c-.28-.54-.55-.57-.82-.08q-3.54,4.68-10.27,4.68a10.93,10.93,0,0,1-8.42-3.4c-2.11-2.28-3.16-5.49-3.16-9.66v-16.5a3.43,3.43,0,0,0-2.71-3.7l-1.73-.49c-.87-.28-1.31-.58-1.31-.91s.44-.65,1.31-.65H85.61c.71,0,1.07.19,1.07.57a7.93,7.93,0,0,1-1,1.11c-.69.69-1,2.31-1,4.89v17q0,7.4,7.64,7.39A11.09,11.09,0,0,0,98,180.54c2.14-1.32,3.2-2.88,3.2-4.69v-18.8a3.43,3.43,0,0,0-2.71-3.7l-1.72-.49c-.88-.28-1.32-.58-1.32-.91s.44-.65,1.32-.65h9.61c.76,0,1.12.32,1.07,1l-.33,5.42v22.43a3.27,3.27,0,0,0,2.79,3.61l2.3.49C113.15,184.45,113.62,184.75,113.62,185.14Z"/><path class="cls-1" d="M149.59,185.14c0,.43-.44.65-1.31.65h-8.14a1.52,1.52,0,0,1-1.39-.9l-.66-1.15a1,1,0,0,0-.82-.58,1.9,1.9,0,0,0-1.07.41,17.43,17.43,0,0,1-10.26,3,11,11,0,0,1-7.15-2.21,8.23,8.23,0,0,1-3-6.66q0-5.91,5.67-8.37a31.87,31.87,0,0,1,5.42-1.56c3.07-.72,5.06-1.21,6-1.48,2.9-.88,4.35-2.27,4.35-4.19v-3.21a4.59,4.59,0,0,0-2.63-4.18,10,10,0,0,0-4.84-1.15c-3,0-5.25.65-6.7,2s-2.5,3.53-3.16,6.65a.59.59,0,0,1-.58.41.43.43,0,0,1-.49-.49l-.08-9.86c0-.49.27-.76.82-.82.88-.05,2.6-.25,5.18-.57a41.59,41.59,0,0,1,5.17-.42q6.57,0,9.69,2.55,3.54,3,3.53,9.69V180q0,3.21,2.63,3.7l2.47.49C149.15,184.4,149.59,184.7,149.59,185.14Zm-12.32-7.89v-8.13q0-1.06-.9-.66l-10.76,3.12q-4,1.15-4,4.77,0,7.14,6.41,7.14a11.85,11.85,0,0,0,6.57-1.76A5.21,5.21,0,0,0,137.27,177.25Z"/><path class="cls-1" d="M189.92,185.14c0,.43-.44.65-1.32.65H177.27c-.71,0-1.07-.19-1.07-.57a7.21,7.21,0,0,1,1-1.11c.68-.69,1-2.31,1-4.89v-17q0-7.4-7.63-7.39a11.26,11.26,0,0,0-5.67,1.72q-3.28,2.05-3.29,4.68V180a3.45,3.45,0,0,0,2.71,3.7l1.73.49c.87.28,1.31.58,1.31.91s-.44.65-1.31.65H151.4q-1.32,0-1.32-.57t1.32-1l1.72-.49a3.43,3.43,0,0,0,2.63-3.7V157c0-2.13-.93-3.34-2.79-3.61l-3.37-.49c-.88-.11-1.32-.41-1.32-.91s.44-.65,1.32-.65h9.28a1.36,1.36,0,0,1,1.31.9l1.32,2.87c.27.55.55.58.82.09q3.52-4.68,10.27-4.69a11,11,0,0,1,8.42,3.41q3.15,3.42,3.16,9.65V180a3.44,3.44,0,0,0,2.71,3.7l1.72.49C189.48,184.51,189.92,184.81,189.92,185.14Z"/><path class="cls-1" d="M218.58,176.18q0,10.44-12.73,10.43A43.59,43.59,0,0,1,194.27,185c-.71-.22-1.15-1-1.31-2.38,0-1,0-2-.09-3.08s-.19-2.51-.41-4.31c-.11-.66.08-1,.58-1s.79.3.9.91c1.15,3.28,2.77,5.53,4.85,6.73,1.8,1.1,4.49,1.64,8.05,1.64a8.34,8.34,0,0,0,4.6-1.31,4.68,4.68,0,0,0,2.38-4q0-3.53-5.34-5.83-4.84-2.06-9.78-4.19-5.34-3-5.33-8,0-9.69,11.41-9.7a86.77,86.77,0,0,1,11.17,1c.55.06.82.33.82.82l.17,8.13c0,.66-.17,1-.49,1s-.5-.25-.66-.74q-1.48-4.44-4.11-5.91c-1.53-.88-4-1.32-7.39-1.32q-6.4,0-6.41,4.93,0,2.79,5.34,5.09,9.45,4,10,4.36Q218.58,171,218.58,176.18Z"/><path class="cls-1" d="M242.07,185.22c0,.38-.44.57-1.31.57H223.51q-1.32,0-1.32-.57c0-.5.44-.82,1.32-1l2.54-.49q2.72-.5,2.71-3.7V157q0-3.12-2.71-3.61l-2.79-.49c-.87-.17-1.31-.47-1.31-.91s.44-.65,1.31-.65h10.6c.82,0,1.2.32,1.15,1l-.33,5.42V180c0,2.19.9,3.43,2.71,3.7l3.37.49C241.63,184.34,242.07,184.67,242.07,185.22ZM235,137.74a4.15,4.15,0,0,1-1.43,3.08,4.49,4.49,0,0,1-3.21,1.36,3.42,3.42,0,0,1-2.4-1,3.06,3.06,0,0,1-1-2.34,4.18,4.18,0,0,1,1.38-3.12,4.49,4.49,0,0,1,3.17-1.31Q235,134.46,235,137.74Z"/><path class="cls-1" d="M280.67,154c0,.54-.3.82-.9.82l-8.95.25a11.67,11.67,0,0,1-1.4,16.53A16,16,0,0,1,259,175h-2.38c-3.29,0-4.93,1.06-4.93,3.16q0,2.76,3.45,2.76c.33,0,1.67-.06,4-.17s4.25-.16,5.67-.16c4,0,6.95.63,8.87,1.89q3.38,2.3,3.37,7.8,0,6.74-6.74,10.18a27.43,27.43,0,0,1-12.73,2.72,17.13,17.13,0,0,1-9.11-2.22,8.74,8.74,0,0,1-4.36-7.89q0-5.74,5.42-8.7a4.85,4.85,0,0,1-2-4,5.83,5.83,0,0,1,3.78-5.91c.38-.16.58-.36.58-.57s-.17-.42-.51-.58c-4.86-2.14-7.3-5.69-7.3-10.68a10.82,10.82,0,0,1,4.25-8.83,16.31,16.31,0,0,1,10.52-3.41,18.24,18.24,0,0,1,7.18,1.4l13.7-.57c.6,0,.9.22.9.65Zm-8.21,37.61c0-2.13-.71-3.64-2.14-4.51s-3.86-1.32-7.31-1.32c-1.58,0-3.87,0-6.85.13l-5,.12q-2.55.83-2.55,5,0,3.85,4.35,5.91a18.64,18.64,0,0,0,7.89,1.56Q272.46,198.52,272.46,191.62Zm-4.76-28q0-9.94-9.33-9.94-8.09,0-8.09,8.13a11.06,11.06,0,0,0,2.4,7.47q2.38,2.81,7,2.8a7.56,7.56,0,0,0,5.94-2.3A8.88,8.88,0,0,0,267.7,163.62Z"/><path class="cls-1" d="M319.28,185.14c0,.43-.44.65-1.32.65H306.63c-.72,0-1.07-.19-1.07-.57a7.21,7.21,0,0,1,1-1.11q1-1,1-4.23V162.22q0-7.4-7.64-7.39a10.82,10.82,0,0,0-5.75,1.72q-3.2,2-3.2,4.68V180a3.44,3.44,0,0,0,2.71,3.7l1.73.49c.87.28,1.31.58,1.31.91s-.44.65-1.31.65H280.75c-.87,0-1.31-.19-1.31-.57s.44-.71,1.31-1l1.73-.49a3.43,3.43,0,0,0,2.63-3.7v-42c0-2.13-.91-3.34-2.71-3.61L279,134c-.88-.11-1.31-.41-1.31-.91s.43-.65,1.31-.65H290.2c.82,0,1.2.32,1.15,1l-.33,5.42v16a.39.39,0,0,0,.66.33q3.52-4.68,10.27-4.69a10.92,10.92,0,0,1,8.41,3.41q3.17,3.42,3.17,9.65V180a3.44,3.44,0,0,0,2.71,3.7l1.8.49C318.86,184.56,319.28,184.86,319.28,185.14Z"/><path class="cls-1" d="M343.34,183.71a.51.51,0,0,1-.16.65,11.25,11.25,0,0,1-6.74,1.84q-10.1,0-10.1-7.41V155.4h-6.49c-.55,0-.82-.25-.82-.77v-2.48c0-.57.27-.85.82-.85h4.76q1.39,0,2.22-1.89l3.86-9.2c.22-.49.49-.74.82-.74.5,0,.74.33.74,1V151.3h9.36c.55,0,.83.22.83.65v2.8c0,.43-.25.65-.74.65h-9.45v21.82q0,6.53,5.09,6.52a9.31,9.31,0,0,0,4.77-1.15c.33-.33.6-.3.82.08Z"/><path class="cls-1" d="M396,172.82l-2,12.07a1,1,0,0,1-1.15.9H360.92q-1.32,0-1.32-.57t1.32-1q2.54-.57,2.54-3.69V142.18q0-3.21-2.71-3.61l-3.37-.5c-.87-.11-1.31-.41-1.31-.9s.44-.66,1.31-.66h18.48q1.32,0,1.32.57c0,.5-.44.82-1.32,1l-2.71.49c-1.86.33-2.79,1.55-2.79,3.68v38.63c0,1,.58,1.47,1.73,1.47h10.26c3.95-.05,6.76-1,8.46-2.87q1.89-2,3.37-7.48c.22-.71.6-1.06,1.15-1.06S396.21,171.56,396,172.82Z"/><path class="cls-1" d="M431.47,185.14c0,.43-.44.65-1.32.65H422a1.52,1.52,0,0,1-1.39-.9l-.66-1.15a1,1,0,0,0-.82-.58,1.9,1.9,0,0,0-1.07.41,17.44,17.44,0,0,1-10.27,3,11,11,0,0,1-7.14-2.21,8.23,8.23,0,0,1-3-6.66q0-5.91,5.67-8.37a31.58,31.58,0,0,1,5.42-1.56q4.59-1.08,6-1.48c2.91-.88,4.36-2.27,4.36-4.19v-3.21a4.59,4.59,0,0,0-2.63-4.18,10,10,0,0,0-4.85-1.15c-3,0-5.24.65-6.69,2s-2.51,3.53-3.16,6.65a.59.59,0,0,1-.58.41.43.43,0,0,1-.49-.49l-.08-9.86c0-.49.27-.76.82-.82.87-.05,2.6-.25,5.17-.57a41.72,41.72,0,0,1,5.18-.42q6.57,0,9.69,2.55,3.53,3,3.53,9.69V180q0,3.21,2.63,3.7l2.46.49C431,184.4,431.47,184.7,431.47,185.14Zm-12.32-7.89v-8.13c0-.71-.3-.93-.91-.66l-10.75,3.12q-4,1.15-4,4.77,0,7.14,6.41,7.14a11.85,11.85,0,0,0,6.57-1.76A5.23,5.23,0,0,0,419.15,177.25Z"/><path class="cls-1" d="M465.88,168.79q0,8-4.35,12.9a13.71,13.71,0,0,1-10.68,4.92,26.07,26.07,0,0,1-6.82-.82,23.07,23.07,0,0,0-3.69-.82,5.45,5.45,0,0,0-2.47.44,14.15,14.15,0,0,1-1.56.79c-.65,0-1-.3-1-.9a2,2,0,0,1,.45-.86,2.8,2.8,0,0,0,.45-1.69V138.07c0-2.13-.9-3.34-2.71-3.61l-3.37-.49c-.87-.11-1.31-.41-1.31-.91s.44-.65,1.31-.65h11.17c.83,0,1.21.32,1.15,1l-.32,5.42v15.44c0,.28.1.44.32.5a.58.58,0,0,0,.58-.17,11.68,11.68,0,0,1,8.7-4.11,12.5,12.5,0,0,1,9.86,4.19Q465.89,159.52,465.88,168.79Zm-6.24,0q0-14.08-9.28-14.09-4.61,0-7.64,4.67a3.25,3.25,0,0,0-.57,1.72v14.17q0,4.42,1.8,6.31,1.89,2.13,6.57,2.13a7.52,7.52,0,0,0,6.66-4Q459.64,175.64,459.64,168.75Z"/><path class="cls-1" d="M496.6,176.18q0,10.44-12.73,10.43A43.48,43.48,0,0,1,472.29,185c-.71-.22-1.15-1-1.32-2.38,0-1,0-2-.08-3.08s-.19-2.51-.41-4.31c-.11-.66.08-1,.58-1s.79.3.9.91c1.15,3.28,2.76,5.53,4.85,6.73,1.8,1.1,4.48,1.64,8,1.64a8.31,8.31,0,0,0,4.6-1.31,4.67,4.67,0,0,0,2.39-4q0-3.53-5.34-5.83-4.85-2.06-9.78-4.19-5.34-3-5.34-8,0-9.69,11.42-9.7a86.77,86.77,0,0,1,11.17,1c.55.06.82.33.82.82l.17,8.13c0,.66-.17,1-.5,1s-.49-.25-.65-.74q-1.49-4.44-4.11-5.91c-1.53-.88-4-1.32-7.39-1.32q-6.4,0-6.41,4.93,0,2.79,5.34,5.09,9.45,4,10,4.36Q496.6,171,496.6,176.18Z"/><rect class="cls-1" x="179.9" y="34" width="154.24" height="4.36"/><path class="cls-1" d="M270.14,85.37,270.06,81c1.24,0,3.05,0,5.14,0,4.63,0,11,0,13.71-.28a14.89,14.89,0,0,0,8.51-4c3.41-3.08,5.1-7.06,5.16-12.18,0-1.64,0-3.28,0-4.92,0-2.58,0-5.25.09-7.9a17.67,17.67,0,0,1,17.56-17.56c3.14-.09,6.32-.08,9.4-.07h4v4.36c-1.33,0-2.66,0-4,0-3,0-6.19,0-9.27.07a13.26,13.26,0,0,0-13.32,13.33c-.08,2.58-.08,5.23-.09,7.78,0,1.66,0,3.31,0,5A20.12,20.12,0,0,1,300.34,80a19.34,19.34,0,0,1-10.94,5.06c-3,.34-9.21.33-14.21.31C273.12,85.36,271.33,85.35,270.14,85.37Z"/><path class="cls-1" d="M242.35,85.37c-1.22,0-2.51,0-3.89,0a82.68,82.68,0,0,1-9.55-.31A19.37,19.37,0,0,1,218,80c-4.3-3.88-6.52-9-6.6-15.36,0-1.65,0-3.31,0-5,0-2.56,0-5.2-.08-7.79a13.27,13.27,0,0,0-13.33-13.33c-3.13-.08-8.74-.08-13.24-.07-1.85,0-3.52,0-4.8,0l0-4.36h4.77c4.54,0,10.18,0,13.38.07a17.67,17.67,0,0,1,17.56,17.56c.07,2.65.08,5.32.09,7.91,0,1.64,0,3.28,0,4.91.07,5.12,1.76,9.1,5.17,12.18a14.86,14.86,0,0,0,8.51,4,84.4,84.4,0,0,0,9,.28c1.4,0,2.72,0,4,0Z"/><path class="cls-2" d="M256.86,97.52A14.47,14.47,0,0,1,242.39,82.9a14.26,14.26,0,0,1,14.67-14.32A14.46,14.46,0,0,1,271.33,83.1,14.69,14.69,0,0,1,256.86,97.52Z"/><path class="cls-1" d="M348.8,21.45A14.45,14.45,0,0,1,363.08,36a14.66,14.66,0,0,1-14.45,14.43,14.45,14.45,0,0,1-14.49-14.6A14.27,14.27,0,0,1,348.8,21.45Z"/><path class="cls-3" d="M164.39,20.16A15.75,15.75,0,0,1,179.9,36a16,16,0,0,1-15.78,15.67,15.75,15.75,0,0,1-15.74-16A15.55,15.55,0,0,1,164.39,20.16Z"/><path class="cls-1" d="M256.72,99.43a16.38,16.38,0,0,1,.08-32.76H257a16.37,16.37,0,0,1,16.16,16.45,16.54,16.54,0,0,1-16.38,16.31Zm.08-28.94a12.41,12.41,0,0,0-12.59,12.42,12.59,12.59,0,0,0,3.67,9,12.4,12.4,0,0,0,8.84,3.68v1.91l0-1.91a12.71,12.71,0,0,0,12.57-12.53A12.55,12.55,0,0,0,257,70.49Z"/><path class="cls-1" d="M348.46,52.3a16.13,16.13,0,0,1-11.53-4.8,16.38,16.38,0,0,1-4.79-11.72,16.19,16.19,0,0,1,16.39-16.24h.2A16.34,16.34,0,0,1,364.9,36,16.54,16.54,0,0,1,348.55,52.3Zm.07-28.94A12.41,12.41,0,0,0,336,35.8a12.57,12.57,0,0,0,3.68,9,12.34,12.34,0,0,0,8.82,3.67h.07a12.7,12.7,0,0,0,12.55-12.54,12.51,12.51,0,0,0-12.4-12.58Z"/><path class="cls-1" d="M164,53.59a17.44,17.44,0,0,1-12.46-5.18,17.71,17.71,0,0,1-5.16-12.69,17.49,17.49,0,0,1,17.7-17.47h.24A17.67,17.67,0,0,1,181.72,36,17.85,17.85,0,0,1,164,53.59Zm.08-31.52A13.7,13.7,0,0,0,150.2,35.75a13.89,13.89,0,0,0,4.05,10A13.63,13.63,0,0,0,164,49.77v1.91l0-1.91A14,14,0,0,0,177.9,36,13.59,13.59,0,0,0,174,26.27a13.74,13.74,0,0,0-9.72-4.2Z"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/r_studio.svg b/web/pandas/static/img/partners/r_studio.svg
deleted file mode 100644
index 15a1d2a30ff30..0000000000000
--- a/web/pandas/static/img/partners/r_studio.svg
+++ /dev/null
@@ -1,50 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generator: Adobe Illustrator 22.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 1784.1 625.9" style="enable-background:new 0 0 1784.1 625.9;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#75AADB;}
-	.st1{fill:#4D4D4D;}
-	.st2{fill:#FFFFFF;}
-	.st3{fill:url(#SVGID_1_);}
-	.st4{fill:url(#SVGID_2_);}
-	.st5{fill:url(#SVGID_3_);}
-	.st6{fill:url(#SVGID_4_);}
-	.st7{fill:url(#SVGID_5_);}
-	.st8{fill:url(#SVGID_6_);}
-	.st9{fill:url(#SVGID_7_);}
-	.st10{fill:url(#SVGID_8_);}
-	.st11{fill:url(#SVGID_9_);}
-	.st12{fill:url(#SVGID_10_);}
-	.st13{opacity:0.18;fill:url(#SVGID_11_);}
-	.st14{opacity:0.3;}
-</style>
-<g id="Gray_Logo">
-</g>
-<g id="Black_Letters">
-</g>
-<g id="Blue_Gradient_Letters">
-	<g>
-		
-			<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 -127.9265 317.0317)" class="st0" cx="318.7" cy="312.9" rx="309.8" ry="309.8"/>
-		<g>
-			<path class="st1" d="M694.4,404.8c16.1,10.3,39.1,18.1,63.9,18.1c36.7,0,58.1-19.4,58.1-47.4c0-25.5-14.8-40.8-52.3-54.8     c-45.3-16.5-73.3-40.4-73.3-79.1c0-43.3,35.8-75.4,89.8-75.4c28,0,49,6.6,61,13.6l-9.9,29.3c-8.7-5.4-27.2-13.2-52.3-13.2     c-37.9,0-52.3,22.7-52.3,41.6c0,26,16.9,38.7,55.2,53.6c47,18.1,70.5,40.8,70.5,81.6c0,42.8-31.3,80.3-96.8,80.3     c-26.8,0-56-8.2-70.9-18.1L694.4,404.8z"/>
-			<path class="st1" d="M943.3,201.3v47.8h51.9v27.6h-51.9v107.5c0,24.7,7,38.7,27.2,38.7c9.9,0,15.7-0.8,21-2.5l1.6,27.6     c-7,2.5-18.1,4.9-32.1,4.9c-16.9,0-30.5-5.8-39.1-15.2c-9.9-11.1-14-28.8-14-52.3V276.7h-30.9v-27.6h30.9V212L943.3,201.3z"/>
-			<path class="st1" d="M1202.8,393.7c0,21,0.4,39.1,1.6,54.8h-32.1l-2.1-32.5h-0.8c-9.1,16.1-30.5,37.1-65.9,37.1     c-31.3,0-68.8-17.7-68.8-87.3V249.1h36.3v110c0,37.9,11.9,63.9,44.5,63.9c24.3,0,41.2-16.9,47.8-33.4c2.1-4.9,3.3-11.5,3.3-18.5     v-122h36.3V393.7z"/>
-			<path class="st1" d="M1434.8,156v241c0,17.7,0.8,37.9,1.6,51.5h-32.1l-1.6-34.6h-1.2c-10.7,22.2-34.6,39.1-67.2,39.1     c-48.2,0-85.7-40.8-85.7-101.4c-0.4-66.3,41.2-106.7,89.4-106.7c30.9,0,51.1,14.4,60.2,30.1h0.8V156H1434.8z M1398.9,330.2     c0-4.5-0.4-10.7-1.6-15.2c-5.4-22.7-25.1-41.6-52.3-41.6c-37.5,0-59.7,33-59.7,76.6c0,40.4,20.2,73.8,58.9,73.8     c24.3,0,46.6-16.5,53.1-43.3c1.2-4.9,1.6-9.9,1.6-15.7V330.2z"/>
-			<path class="st1" d="M1535.7,193c0,12.4-8.7,22.2-23.1,22.2c-13.2,0-21.8-9.9-21.8-22.2c0-12.4,9.1-22.7,22.7-22.7     C1526.6,170.4,1535.7,180.3,1535.7,193z M1495.3,448.5V249.1h36.3v199.4H1495.3z"/>
-			<path class="st1" d="M1772.2,347.1c0,73.7-51.5,105.9-99.3,105.9c-53.6,0-95.6-39.6-95.6-102.6c0-66.3,44.1-105.5,98.9-105.5     C1733.5,245,1772.2,286.6,1772.2,347.1z M1614.4,349.2c0,43.7,24.7,76.6,60.2,76.6c34.6,0,60.6-32.5,60.6-77.5     c0-33.8-16.9-76.2-59.7-76.2C1632.9,272.1,1614.4,311.7,1614.4,349.2z"/>
-		</g>
-		<g>
-			<path class="st2" d="M424.7,411.8h33.6v26.1h-51.3L322,310.5h-45.3v101.3h44.3v26.1H209.5v-26.1h38.3V187.3l-38.3-4.7v-24.7     c14.5,3.3,27.1,5.6,42.9,5.6c23.8,0,48.1-5.6,71.9-5.6c46.2,0,89.1,21,89.1,72.3c0,39.7-23.8,64.9-60.7,75.6L424.7,411.8z      M276.7,285.3l24.3,0.5c59.3,0.9,82.1-21.9,82.1-52.3c0-35.5-25.7-49.5-58.3-49.5c-15.4,0-31.3,1.4-48.1,3.3V285.3z"/>
-		</g>
-		<g>
-			<path class="st1" d="M1751.8,170.4c-12.9,0-23.4,10.5-23.4,23.4c0,12.9,10.5,23.4,23.4,23.4c12.9,0,23.4-10.5,23.4-23.4     C1775.2,180.9,1764.7,170.4,1751.8,170.4z M1771.4,193.8c0,10.8-8.8,19.5-19.5,19.5c-10.8,0-19.5-8.8-19.5-19.5     c0-10.8,8.8-19.5,19.5-19.5C1762.6,174.2,1771.4,183,1771.4,193.8z"/>
-			<path class="st1" d="M1760.1,203.3l-5.8-8.5c3.3-1.2,5-3.6,5-7c0-5.1-4.3-6.9-8.4-6.9c-1.1,0-2.2,0.1-3.2,0.3     c-1,0.1-2.1,0.2-3.1,0.2c-1.4,0-2.5-0.2-3.7-0.5l-0.6-0.1v3.3l3.4,0.4v18.8h-3.4v3.4h10.9v-3.4h-3.9v-7.9h3.2l7.3,11l0.2,0.2h5.3     v-3.4H1760.1z M1755.6,188.1c0,1.2-0.5,2.2-1.4,2.9c-1.1,0.8-2.8,1.2-5,1.2l-1.9,0v-7.7c1.4-0.1,2.6-0.2,3.7-0.2     C1753.1,184.3,1755.6,185,1755.6,188.1z"/>
-		</g>
-	</g>
-</g>
-<g id="White_Letters">
-</g>
-<g id="R_Ball">
-</g>
-</svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/ursa_labs.svg b/web/pandas/static/img/partners/ursa_labs.svg
deleted file mode 100644
index cacc80e337d25..0000000000000
--- a/web/pandas/static/img/partners/ursa_labs.svg
+++ /dev/null
@@ -1,106 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 23.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 359 270" style="enable-background:new 0 0 359 270;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:#404040;}
-	.st1{filter:url(#Adobe_OpacityMaskFilter);}
-	.st2{fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFFF;}
-	.st3{mask:url(#mask-2_1_);}
-</style>
-<title>HOME 1 Copy 8</title>
-<desc>Created with Sketch.</desc>
-<g id="HOME-1-Copy-8">
-	<g id="Group" transform="translate(20.000000, 20.000000)">
-		<path id="URSA-LABS-Copy" class="st0" d="M0,158.4h9.1V214c0,0.3,0,0.7,0.1,1.1c0,0.3,0,0.9,0.1,1.6s0.2,1.5,0.6,2.3
-			c0.3,0.8,0.9,1.5,1.6,2.1c0.7,0.6,1.8,0.9,3.3,0.9c0.3,0,0.9,0,1.6-0.1c0.7-0.1,1.4-0.4,2.1-0.9c1-0.9,1.6-2,1.8-3.3
-			s0.3-3.2,0.4-5.5v-53.8h9.2v54.4c0,0.6,0,1.3-0.1,2.1c-0.1,0.8-0.2,1.7-0.3,2.6s-0.3,1.8-0.5,2.6c-0.7,2.3-1.7,4.1-3,5.4
-			c-1.3,1.3-2.7,2.3-4.2,2.9c-1.5,0.7-2.9,1.1-4.2,1.2c-1.3,0.1-2.3,0.2-3,0.2c-0.6,0-1.5-0.1-2.7-0.2c-1.2-0.1-2.5-0.5-3.8-1
-			s-2.6-1.4-3.8-2.5c-1.2-1.1-2.2-2.7-3-4.6c-0.4-1-0.7-2.1-0.9-3.3c-0.2-1.2-0.3-2.9-0.4-5V158.4z M44,158.4h17
-			c0.6,0,1.2,0,1.7,0.1c0.6,0.1,1.3,0.2,2.2,0.3c0.9,0.1,1.7,0.4,2.6,0.8c0.8,0.4,1.6,1.1,2.3,2c0.7,0.9,1.2,2.1,1.6,3.7
-			c0.4,1.8,0.6,5.1,0.6,10.1c0,1.3,0,2.7-0.1,4.1c0,1.4-0.1,2.8-0.2,4.2c-0.1,0.9-0.3,1.9-0.4,2.9s-0.4,1.9-0.7,2.7
-			c-0.4,0.9-0.9,1.6-1.6,2.1s-1.3,0.8-2,1c-0.7,0.2-1.3,0.3-1.9,0.3H64v0.5c1.3,0.1,2.4,0.3,3.3,0.6c0.9,0.3,1.8,1,2.5,2.1
-			c0.8,1.3,1.3,2.7,1.5,4.3c0.2,1.6,0.3,3.9,0.3,6.8v7.7c0,2,0,3.6,0.1,4.9c0.1,1.3,0.2,2.4,0.3,3.3c0.1,0.9,0.3,1.8,0.5,2.7
-			c0.2,0.9,0.6,1.8,1,2.9h-9.7c-0.3-1.7-0.6-3-0.8-4.1s-0.3-2.2-0.4-3.2c-0.1-1-0.2-2.1-0.2-3.2c0-1.1-0.1-2.5-0.1-4.2v-5
-			c-0.1-1.2-0.1-2.4-0.2-3.6c0-1.2-0.1-2.4-0.3-3.6c-0.1-0.9-0.3-1.7-0.5-2.5c-0.2-0.8-0.6-1.5-1.2-2c-0.5-0.3-1-0.5-1.5-0.6
-			s-1-0.2-1.6-0.2h-3.8v32.4H44V158.4z M53.4,166.9v21.7h4.4c1.2,0,2.2-0.2,2.9-0.6c0.7-0.4,1.2-1.2,1.6-2.5
-			c0.2-0.9,0.3-2.3,0.4-4.2s0.1-4.1,0.1-6.6c0-0.7,0-1.5-0.1-2.2c0-0.8-0.1-1.5-0.2-2.2c-0.1-1.4-0.4-2.3-1-2.8
-			c-0.3-0.3-0.8-0.5-1.3-0.5c-0.5,0-1.2,0-2.2,0H53.4z M110.6,169.1v12.4h-8.5v-12.4c0-0.2,0-0.6-0.1-1.1c0-0.5-0.2-1.1-0.4-1.6
-			c-0.2-0.5-0.6-1-1.1-1.4s-1.3-0.6-2.3-0.6c-1.1,0-2,0.2-2.6,0.6c-0.6,0.4-1.1,1-1.4,1.7c-0.3,0.7-0.5,1.5-0.6,2.3
-			c-0.1,0.9-0.1,1.7-0.1,2.5c0,1.5,0.1,2.8,0.3,4c0.2,1.2,0.5,2.3,0.9,3.4s0.9,2.2,1.5,3.2s1.3,2.2,2.1,3.4c0.7,1.1,1.3,2.1,2,3.1
-			c0.7,1,1.4,2,2.1,3.1c1,1.4,2,2.9,3.1,4.6c1.2,1.9,2.2,3.7,2.9,5.3c0.7,1.6,1.3,3.1,1.7,4.5c0.4,1.4,0.7,2.7,0.8,3.9
-			c0.1,1.2,0.2,2.3,0.2,3.3c0,0.4,0,1.3-0.1,2.6c-0.1,1.3-0.4,2.8-0.9,4.4c-0.5,1.6-1.3,3.3-2.3,4.9c-1,1.6-2.6,2.9-4.6,3.7
-			c-0.6,0.3-1.4,0.5-2.4,0.7c-1,0.2-2.3,0.3-3.8,0.3c-2.9,0-5.1-0.5-6.8-1.4s-2.8-1.9-3.6-2.8c-1.5-1.7-2.3-3.4-2.6-5.3
-			s-0.4-3.8-0.5-5.9V203h8.6v12.8c0,1.7,0.2,3,0.5,3.8c0.3,0.8,0.8,1.5,1.6,2c0.2,0.1,0.5,0.3,1,0.5c0.5,0.2,1.1,0.3,1.8,0.3
-			c1.1,0,2-0.3,2.7-0.8c0.6-0.6,1.1-1.3,1.4-2.1c0.3-0.8,0.4-1.7,0.5-2.7c0-1,0.1-1.8,0.1-2.6c0-2.5-0.3-4.6-0.8-6.4
-			c-0.5-1.7-1.4-3.7-2.7-5.9c-1.3-2.3-2.8-4.5-4.3-6.6s-2.9-4.3-4.3-6.5c-0.4-0.6-0.9-1.4-1.5-2.4c-0.6-1-1.2-2.2-1.8-3.6
-			c-0.6-1.4-1.1-3-1.5-4.7s-0.7-3.7-0.7-5.7c0-3.9,0.7-6.9,2.1-9s2.8-3.7,4.3-4.5c0.7-0.5,1.8-0.9,3.1-1.3c1.3-0.4,3-0.6,5-0.6
-			c0.5,0,1.2,0,2.3,0.1c1,0.1,2.1,0.3,3.3,0.7c1.1,0.4,2.2,1.1,3.3,2c1.1,0.9,1.9,2.3,2.4,4c0.2,0.7,0.4,1.4,0.5,2.1
-			C110.5,166.6,110.5,167.7,110.6,169.1z M140.1,158.4l10.9,70.3h-9.1l-1.8-12.9h-10.6l-1.6,12.9h-9.1l10-70.3H140.1z M133.5,183
-			l-3,24.2h8.4l-3.5-24.4c-0.1-0.6-0.2-1.2-0.3-1.8c0-0.6-0.1-1.2-0.2-1.8c-0.1-1.3-0.1-2.6-0.1-3.8c0-1.3,0-2.5-0.1-3.8H134
-			c-0.1,1.9-0.1,3.8-0.2,5.7C133.7,179.2,133.6,181.1,133.5,183z M190.2,158.4V220h15.4v8.7h-24.7v-70.3H190.2z M232,158.4
-			l10.9,70.3h-9.1l-1.8-12.9h-10.6l-1.6,12.9h-9.1l10-70.3H232z M225.4,183l-3,24.2h8.4l-3.5-24.4c-0.1-0.6-0.2-1.2-0.3-1.8
-			c0-0.6-0.1-1.2-0.2-1.8c-0.1-1.3-0.1-2.6-0.1-3.8c0-1.3,0-2.5-0.1-3.8h-0.8c-0.1,1.9-0.1,3.8-0.2,5.7
-			C225.6,179.2,225.5,181.1,225.4,183z M251.9,158.4h16.5c1.5,0,2.9,0.1,4.4,0.2s2.8,0.8,3.9,1.8c1.3,1.2,2,2.7,2.2,4.5
-			c0.2,1.8,0.3,4.3,0.4,7.4c0,0.6,0,1.2,0.1,1.8c0,0.6,0.1,1.2,0.1,1.8c0,1.1,0,2.2-0.1,3.3c0,1.1-0.1,2.2-0.2,3.3
-			c0,0.2,0,0.9-0.1,2.1c-0.1,1.2-0.3,2.3-0.8,3.3c-0.4,0.7-1,1.3-1.7,1.8c-0.7,0.5-1.4,0.8-2.2,1c-0.4,0.1-0.8,0.2-1.3,0.2
-			c-0.5,0-0.8,0-0.9,0.1v0.5c1.3,0.1,2.4,0.4,3.5,0.7c1,0.4,1.9,1.1,2.6,2.2c0.5,1,0.8,2.2,0.9,3.7c0.1,1.5,0.1,3.4,0.1,5.9
-			c0.1,0.9,0.1,1.9,0.1,2.8v7c0,1.4-0.1,2.8-0.2,4.3c0,0.2,0,0.6-0.1,1.2c0,0.6-0.2,1.3-0.4,2.1c-0.2,0.8-0.5,1.6-0.9,2.5
-			s-1,1.6-1.7,2.3c-1.4,1.1-3,1.8-4.9,1.9s-3.6,0.2-5.3,0.2h-14.2V158.4z M260.9,166.8v21.1h3.6c1.5-0.1,2.7-0.2,3.7-0.5
-			c1-0.3,1.6-1.3,1.8-3c0.2-1.4,0.3-3.8,0.3-7.1c0-2.2-0.1-4.4-0.3-6.6c-0.1-1.7-0.4-2.8-1-3.3c-0.3-0.3-0.8-0.5-1.3-0.5
-			c-0.5,0-1.2,0-2.1,0H260.9z M260.9,195.5V220h4.8c0.5,0,1,0,1.5,0c0.5,0,0.9-0.1,1.3-0.2c0.4-0.1,0.7-0.3,1-0.6
-			c0.3-0.3,0.5-0.8,0.6-1.4c0-0.3,0-0.7,0.1-1.4c0-0.7,0.1-1.5,0.1-2.4c0-0.9,0.1-1.9,0.1-2.9c0-1.1,0.1-2.1,0.1-3.1
-			c0-1.2,0-2.4-0.1-3.5c0-1.2-0.1-2.3-0.2-3.5c-0.1-0.7-0.2-1.4-0.3-2.3c-0.1-0.9-0.4-1.6-1-2.1c-0.4-0.3-0.9-0.5-1.4-0.6
-			s-1-0.1-1.5-0.1H260.9z M318.4,169.1v12.4h-8.5v-12.4c0-0.2,0-0.6-0.1-1.1c0-0.5-0.2-1.1-0.4-1.6c-0.2-0.5-0.6-1-1.1-1.4
-			c-0.5-0.4-1.3-0.6-2.3-0.6c-1.1,0-2,0.2-2.6,0.6s-1.1,1-1.4,1.7s-0.5,1.5-0.6,2.3c-0.1,0.9-0.1,1.7-0.1,2.5c0,1.5,0.1,2.8,0.3,4
-			s0.5,2.3,0.9,3.4s0.9,2.2,1.5,3.2c0.6,1.1,1.3,2.2,2.1,3.4c0.7,1.1,1.3,2.1,2,3.1c0.7,1,1.4,2,2.1,3.1c1,1.4,2,2.9,3.1,4.6
-			c1.2,1.9,2.2,3.7,2.9,5.3c0.7,1.6,1.3,3.1,1.7,4.5c0.4,1.4,0.7,2.7,0.8,3.9c0.1,1.2,0.2,2.3,0.2,3.3c0,0.4,0,1.3-0.1,2.6
-			c-0.1,1.3-0.4,2.8-0.9,4.4c-0.5,1.6-1.3,3.3-2.3,4.9c-1,1.6-2.6,2.9-4.6,3.7c-0.6,0.3-1.4,0.5-2.4,0.7c-1,0.2-2.3,0.3-3.8,0.3
-			c-2.9,0-5.1-0.5-6.8-1.4c-1.6-0.9-2.8-1.9-3.6-2.8c-1.5-1.7-2.3-3.4-2.6-5.3c-0.3-1.9-0.4-3.8-0.5-5.9V203h8.6v12.8
-			c0,1.7,0.2,3,0.5,3.8c0.3,0.8,0.8,1.5,1.6,2c0.2,0.1,0.5,0.3,1,0.5c0.5,0.2,1.1,0.3,1.8,0.3c1.1,0,2-0.3,2.7-0.8
-			c0.6-0.6,1.1-1.3,1.4-2.1c0.3-0.8,0.4-1.7,0.5-2.7c0-1,0.1-1.8,0.1-2.6c0-2.5-0.3-4.6-0.8-6.4c-0.5-1.7-1.4-3.7-2.7-5.9
-			c-1.3-2.3-2.8-4.5-4.3-6.6c-1.5-2.1-2.9-4.3-4.3-6.5c-0.4-0.6-0.9-1.4-1.5-2.4c-0.6-1-1.2-2.2-1.8-3.6c-0.6-1.4-1.1-3-1.5-4.7
-			c-0.4-1.8-0.7-3.7-0.7-5.7c0-3.9,0.7-6.9,2.1-9s2.8-3.7,4.3-4.5c0.7-0.5,1.8-0.9,3.1-1.3c1.3-0.4,3-0.6,5-0.6c0.5,0,1.2,0,2.3,0.1
-			c1,0.1,2.1,0.3,3.3,0.7s2.2,1.1,3.3,2s1.9,2.3,2.4,4c0.2,0.7,0.4,1.4,0.5,2.1C318.2,166.6,318.3,167.7,318.4,169.1z"/>
-		<g id="Group-3-Copy" transform="translate(47.000000, 0.000000)">
-			<g id="Clip-2">
-			</g>
-			<defs>
-				<filter id="Adobe_OpacityMaskFilter" filterUnits="userSpaceOnUse" x="0" y="0" width="225.8" height="123.9">
-					<feColorMatrix  type="matrix" values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 1 0"/>
-				</filter>
-			</defs>
-			<mask maskUnits="userSpaceOnUse" x="0" y="0" width="225.8" height="123.9" id="mask-2_1_">
-				<g class="st1">
-					<polygon id="path-1_1_" class="st2" points="0,0 225.9,0 225.9,123.9 0,123.9 					"/>
-				</g>
-			</mask>
-			<g id="Page-1" class="st3">
-				<g id="Mask">
-					<path class="st0" d="M177.2,54.3c6.1,21.2,19.4,48.5,24,54.7c5.3-1.2,9.1,1.2,12.4,5.1c-1.2,0.9-2.7,1.5-3.4,2.6
-						c-2.7,4.4-6.9,3-10.7,3.2c-2.8,0.2-5.6,0.3-8.4,0.3c-0.9,0-1.8-0.3-2.7-0.5c-1-0.3-1.9-1-2.8-1c-2.5,0.1-4.7,0-7.1-1.1
-						c-1-0.5-2.6,0.9-3.6-0.8c-1.1-1.8-2.2-3.6-3.4-5.5c-1.2,0.2-2.2,0.4-3.4,0.6c-2.4-3-3.4-14.8-6.1-17.7
-						c-0.6-0.7-2.1-2.2-3.8-2.7c-0.3-0.9-5.4-7.2-5.9-8.7c-0.2-0.5-0.3-1.2-0.7-1.4c-3.1-2-4.2-4.9-4-8.5c0-0.4-0.2-0.7-0.4-1.7
-						c-1.2,2.7-2.2,4.8-3.2,7.1c-0.6,1.4-1,2.9-1.8,4.3c-0.5,0.9-1.3,1.6-2,2.3c-2.4,2.2-1.8,0.9-3.2,3.6c-1.1,2-2,4-3,6.1
-						c-0.5,1.1-0.9,2.2-1.1,3.3c-0.7,4.1-3.2,7.6-1.5,11.2c3,0.6,6.3,0.5,8.6,2c2.2,1.5,3.5,4.5,5,6.7c-3.1,0.5-5.9,1.2-8.7,1.4
-						c-3.8,0.3-7.6,0.2-11.3,0.2c-5,0-10.1-0.1-15.1-0.1c-2.6,0-3.9-1.5-5.4-3.7c-2.1-3.1-1.1-6-0.8-9.1c0.1-0.8,0-3.3-0.1-4.2
-						c-0.1-0.9-0.1-1.9,0-2.9c0.2-1.3,0.8-2.6,0.9-3.9c0.1-1.5-0.4-3-0.4-4.5c0-1.5,0.1-3.1,0.5-4.6c0.7-2.7-0.1,0,0.7-2.7
-						c0.1-0.2,0-0.7,0-0.8c-0.9-3.6,1.8-6,2.8-8.8c0-0.1,0-0.1-0.1-0.5c-1.8,1.8-4.1,0.8-6.1,1.2c-2.9,0.6-5.7,2.1-8,3
-						c-1.4-0.1-2.5-0.4-3.5-0.2c-2,0.5-3.9,1.1-6.2,0.9c-2.5-0.2-5.1,0.6-7.7,0.8c-2.2,0.2-4.8,0.9-6.5,0c-1.5-0.7-2.8-0.9-4.4-1
-						c-1.6-0.1-2.4,0.7-2.6,2.1c-1.1,6.3-2.3,12.7-3.1,19.1c-0.4,3.3-0.2,6.6-0.2,9.9c0,1.5,0.6,2.5,1.9,3.5
-						c1.5,1.1,2.6,2.7,3.6,4.3c0.8,1.3,0.6,2.6-1.5,2.7c-7.3,0.2-14.6,0.5-21.9,0.4c-2.1,0-4.2-1.5-6.2-2.5
-						c-0.3-0.2-0.4-1.1-0.4-1.7c0-4.4,0-13.5,0-18.4c-1,0.6-1.3,0.8-1.6,1c-2.5,2.3-4.9,4.1-7.3,6.4c-1.9,1.8-1.6,3.3,0.2,5.4
-						c2.4,2.7,4.4,5.7,4.4,9.5c0,2.5-2.2,3.2-3.8,3.3c-5.7,0.4-11.5,0.4-17.2,0.4c-2.8,0-3.8-1.5-4.4-4.2
-						c-1.2-5.4-2.2-10.8-4.3-16.1c-1.6-4.1-2-8.9,1.5-13c5.1-5.9,9.5-12.3,12.8-19.5c1-2.2,1.4-3.8,0.4-6.1c-4.9-1-7.1-3.7-8.2-8.7
-						c-1-4.6-0.2-8.9,1-13.2c2.3-7.8,4.1-11,8.4-18c5.6-9,13.4-15.5,22.8-20.2c11.3-5.6,23.3-5.5,35.3-4.2
-						c16.2,1.6,32.4,3.6,48.6,5.3c1.3,0.1,2.9-0.2,4.1-0.8c7.7-3.9,15.5-4.2,23.6-1.4c5.6,1.9,11.4,3.6,17.1,5.2
-						c2,0.6,4.1,0.8,6.2,1.1c5.7,0.9,11.5,1.8,17.3,2.4c2.9,0.3,5.9,0.1,8.8,0.3c0.7,0,1.5,0.3,2.1,0.7c2.6,1.8,5.1,3.7,7.5,5.6
-						c1.6,1.2,3.2,2.3,4.5,3.8c0.6,0.7,0.7,1.9,0.9,2.9c0.3,1.1,0.3,2.6,0.9,3.4c2.6,3.1,5.3,6,8.1,8.9c0.9,1,1.1,1.7,0.3,2.9
-						c-1.2,1.6-1.8,3.7-3.3,4.8c-3.1,2.2-6.3,4.3-10.7,3.2c-2.5-0.6-5.5,0.5-8.2,0.8c-2.1,0.3-4.3,0.2-6.2,0.9
-						c-4.1,1.6-8.5,1.1-12.5,2.3c-1.5,0.4-2.8,1.2-4.3,1.6C179.2,54.8,178.3,54.5,177.2,54.3"/>
-				</g>
-			</g>
-		</g>
-	</g>
-</g>
-</svg>
diff --git a/web/pandas/static/img/partners/voltron_data.svg b/web/pandas/static/img/partners/voltron_data.svg
new file mode 100644
index 0000000000000..0fb7dfd850166
--- /dev/null
+++ b/web/pandas/static/img/partners/voltron_data.svg
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 26.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 1887.7 876.4" style="enable-background:new 0 0 1887.7 876.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#005050;}
+</style>
+<g>
+	<g>
+		<g>
+			<path class="st0" d="M943.8,0L943.8,0H791.1H638.5l76.3,132.2l76.3,132.2l76.3,132.2l76.4,132.2l76.3-132.2l76.3-132.2
+				l-76.3-132.2L943.8,0z M1000,385l-56.2,97.4L887.6,385L818,264.4l69.6-120.6l56.2-97.4l56.2,97.4l69.6,120.6L1000,385z"/>
+			<polygon class="st0" points="1082.5,0 1096,23.5 1208.4,23.5 1152.1,121.1 1165.6,144.6 1249.1,0 			"/>
+		</g>
+	</g>
+	<g>
+		<g>
+			<path class="st0" d="M3.2,758.3c-1-2.1-0.3-3.6,1.7-3.6h14.7c1.2-0.2,2.5,0.1,3.5,0.7c1,0.7,1.8,1.7,2.2,2.8l38.2,78.4h0.3
+				l38.3-78.4c0.4-1.2,1.2-2.2,2.2-2.8c1-0.7,2.3-0.9,3.5-0.7h14.7c2.1,0,2.9,1.5,1.7,3.6L66.8,873.9c-0.7,1.5-1.4,2-2.6,2h-1
+				c-1.2,0-1.9-0.5-2.5-2L3.2,758.3z"/>
+			<path class="st0" d="M245.4,752.4c16.2,0.3,31.6,7,43,18.6c11.3,11.6,17.7,27.1,17.7,43.4c0,16.2-6.3,31.8-17.7,43.4
+				c-11.3,11.6-26.8,18.3-43,18.6c-34.5,0-61.1-27.1-61.1-62C184.2,779.6,210.9,752.4,245.4,752.4z M245.4,858.4
+				c24.9,0,41.7-20.6,41.7-44s-16.7-44.1-41.7-44.1c-24.9,0-41.5,20.5-41.5,44.1S220.6,858.5,245.4,858.4L245.4,858.4z"/>
+			<path class="st0" d="M454.2,856.8c2.9,0,3.4,0.7,3.4,3.4v10.4c0,2.9-0.7,3.6-3.4,3.6h-70c-2.6,0-3.4-0.9-3.4-3.6V758.3
+				c0-2.7,0.8-3.6,3.4-3.6h12.6c2.5,0,3.4,0.9,3.4,3.6v98.5H454.2z"/>
+			<path class="st0" d="M593.9,754.7c2.9,0,3.6,0.9,3.6,3.6v10.9c0,2.9-0.9,3.6-3.6,3.6h-34.5v97.8c0,2.9-0.7,3.6-3.4,3.6h-12.6
+				c-2.6,0-3.4-0.9-3.4-3.6v-97.8h-34.7c-2.5,0-3.4-0.9-3.4-3.6v-10.9c0-2.7,0.9-3.6,3.4-3.6H593.9z"/>
+			<path class="st0" d="M686,870.7c0,2.9-0.9,3.6-3.4,3.6H670c-2.6,0-3.4-0.9-3.4-3.6V758.3c0-2.7,0.8-3.6,3.4-3.6h44.6
+				c20,0,42,9.9,42,37.5c0,21.9-13.8,32.6-29.6,36l28.5,41.5c1.9,2.9,0.7,4.5-2.6,4.5h-13.6c-1.2,0-2.4-0.4-3.5-1
+				c-1-0.6-1.9-1.5-2.5-2.6l-28.4-41h-19.1L686,870.7z M712.7,811.8c18.4,0,24.2-8.6,24.2-19.8s-5.7-19.4-24.2-19.4h-26.6v39.3
+				L712.7,811.8L712.7,811.8z"/>
+			<path class="st0" d="M885.7,752.4c16.2,0.3,31.6,7,43,18.6c11.3,11.6,17.7,27.1,17.7,43.4c0,16.2-6.3,31.8-17.7,43.4
+				c-11.3,11.6-26.8,18.3-43,18.6c-34.5,0-61.1-27.1-61.1-62C824.5,779.6,851.2,752.4,885.7,752.4z M885.7,858.4
+				c24.9,0,41.6-20.6,41.6-44s-16.7-44.1-41.6-44.1c-24.9,0-41.4,20.6-41.4,44.1C844.2,838.1,860.9,858.5,885.7,858.4L885.7,858.4z"
+				/>
+			<path class="st0" d="M1040.9,796.4h-0.3v74.2c0,2.9-0.9,3.6-3.4,3.6h-12.5c-2.9,0-3.6-0.9-3.6-3.6V754.7c0-1.2,0.5-1.7,1.9-1.7
+				h0.9c0.6,0,1.1,0.1,1.6,0.4c0.5,0.3,0.9,0.7,1.2,1.1l76.1,78h0.3v-74.2c0-2.7,0.7-3.6,3.4-3.6h12.5c2.9,0,3.6,0.9,3.6,3.6v115.8
+				c0,1.3-0.5,1.9-1.9,1.9h-0.9c-0.6,0-1.1-0.1-1.6-0.4c-0.5-0.3-0.9-0.6-1.2-1.1L1040.9,796.4z"/>
+			<path class="st0" d="M1335.7,754.7c34.5,0,60.3,24.9,60.3,59.8c0,34.8-25.7,59.8-60.3,59.8h-42.8c-2.6,0-3.4-0.9-3.4-3.6V758.3
+				c0-2.7,0.8-3.6,3.4-3.6H1335.7z M1309.1,772.5v84h26.6c24.8,0,40.6-18.6,40.6-42s-15.9-42.1-40.6-42.1L1309.1,772.5z"/>
+			<path class="st0" d="M1577,870.7c1,2.1,0.3,3.6-1.7,3.6h-14.7c-1.2,0.1-2.4-0.1-3.5-0.8c-1-0.7-1.8-1.6-2.2-2.8l-10.9-22.5h-55
+				l-10.9,22.5c-0.4,1.2-1.1,2.2-2.2,2.9c-1,0.7-2.3,0.9-3.5,0.7h-14.7c-2.1,0-2.9-1.5-1.7-3.6l57.4-115.6c0.7-1.5,1.4-2.1,2.6-2.1
+				h1c1.2,0,1.9,0.5,2.6,2.1L1577,870.7z M1516.6,790.1l-19.8,40.1h39.6l-19.6-40.1H1516.6z"/>
+			<path class="st0" d="M1714.4,754.7c2.9,0,3.6,0.9,3.6,3.6v10.9c0,2.9-0.9,3.6-3.6,3.6h-34.5v97.8c0,2.9-0.7,3.6-3.4,3.6h-12.7
+				c-2.5,0-3.4-0.9-3.4-3.6v-97.8h-34.7c-2.6,0-3.4-0.9-3.4-3.6v-10.9c0-2.7,0.9-3.6,3.4-3.6H1714.4z"/>
+			<path class="st0" d="M1884.4,870.7c1,2.1,0.3,3.6-1.7,3.6H1868c-1.2,0.1-2.4-0.1-3.5-0.8c-1-0.7-1.8-1.6-2.2-2.8l-10.9-22.5
+				h-54.9l-10.9,22.5c-0.3,1.2-1.1,2.2-2.2,2.9s-2.3,0.9-3.5,0.7h-14.7c-2.1,0-2.9-1.5-1.7-3.6l57.4-115.6c0.7-1.5,1.4-2.1,2.6-2.1
+				h1c1.2,0,1.9,0.5,2.6,2.1L1884.4,870.7z M1823.9,790.1l-19.8,40.1h39.6l-19.6-40.1H1823.9z"/>
+		</g>
+	</g>
+</g>
+</svg>
diff --git a/web/pandas/versions.json b/web/pandas/versions.json
new file mode 100644
index 0000000000000..2b30006db0c4d
--- /dev/null
+++ b/web/pandas/versions.json
@@ -0,0 +1,37 @@
+[
+    {
+        "name": "dev",
+        "version": "dev",
+        "url": "/docs/dev/"
+    },
+    {
+        "name": "1.4 (stable)",
+        "version": "1.4 (stable)",
+        "url": "/docs/"
+    },
+    {
+        "name": "1.4",
+        "version": "1.4",
+        "url": "/pandas-docs/version/1.4/"
+    },
+    {
+        "name": "1.3",
+        "version": "1.3",
+        "url": "/pandas-docs/version/1.3/"
+    },
+    {
+        "name": "1.2",
+        "version": "1.2",
+        "url": "/pandas-docs/version/1.2/"
+    },
+    {
+        "name": "1.1",
+        "version": "1.1",
+        "url": "/pandas-docs/version/1.1/"
+    },
+    {
+        "name": "1.0",
+        "version": "1.0",
+        "url": "/pandas-docs/version/1.0/"
+    }
+]
diff --git a/web/pandas_web.py b/web/pandas_web.py
index 7dd63175e69ac..1a2bc45bd87e0 100755
--- a/web/pandas_web.py
+++ b/web/pandas_web.py
@@ -24,10 +24,13 @@
 The rest of the items in the file will be added directly to the context.
 """
 import argparse
+import collections
 import datetime
 import importlib
+import json
 import operator
 import os
+import pathlib
 import re
 import shutil
 import sys
@@ -52,6 +55,15 @@ class Preprocessors:
     anything else needed just be added with context preprocessors.
     """
 
+    @staticmethod
+    def current_year(context):
+        """
+        Add the current year to the context, so it can be used for the copyright
+        note, or other places where it is needed.
+        """
+        context["current_year"] = datetime.datetime.now().year
+        return context
+
     @staticmethod
     def navbar_add_info(context):
         """
@@ -146,13 +158,40 @@ def maintainers_add_info(context):
         Given the active maintainers defined in the yaml file, it fetches
         the GitHub user information for them.
         """
-        context["maintainers"]["people"] = []
-        for user in context["maintainers"]["active"]:
+        repeated = set(context["maintainers"]["active"]) & set(
+            context["maintainers"]["inactive"]
+        )
+        if repeated:
+            raise ValueError(f"Maintainers {repeated} are both active and inactive")
+
+        maintainers_info = {}
+        for user in (
+            context["maintainers"]["active"] + context["maintainers"]["inactive"]
+        ):
             resp = requests.get(f"https://api.github.com/users/%7Buser%7D")
-            if context["ignore_io_errors"] and resp.status_code == 403:
-                return context
+            if resp.status_code == 403:
+                sys.stderr.write(
+                    "WARN: GitHub API quota exceeded when fetching maintainers\n"
+                )
+                # if we exceed github api quota, we use the github info
+                # of maintainers saved with the website
+                resp_bkp = requests.get(
+                    context["main"]["production_url"] + "maintainers.json"
+                )
+                resp_bkp.raise_for_status()
+                maintainers_info = resp_bkp.json()
+                break
+
             resp.raise_for_status()
-            context["maintainers"]["people"].append(resp.json())
+            maintainers_info[user] = resp.json()
+
+        context["maintainers"]["github_info"] = maintainers_info
+
+        # save the data fetched from github to use it in case we exceed
+        # git github api quota in the future
+        with open(pathlib.Path(context["target_path"]) / "maintainers.json", "w") as f:
+            json.dump(maintainers_info, f)
+
         return context
 
     @staticmethod
@@ -161,11 +200,19 @@ def home_add_releases(context):
 
         github_repo_url = context["main"]["github_repo_url"]
         resp = requests.get(f"https://api.github.com/repos/%7Bgithub_repo_url%7D/releases")
-        if context["ignore_io_errors"] and resp.status_code == 403:
-            return context
-        resp.raise_for_status()
+        if resp.status_code == 403:
+            sys.stderr.write("WARN: GitHub API quota exceeded when fetching releases\n")
+            resp_bkp = requests.get(context["main"]["production_url"] + "releases.json")
+            resp_bkp.raise_for_status()
+            releases = resp_bkp.json()
+        else:
+            resp.raise_for_status()
+            releases = resp.json()
+
+        with open(pathlib.Path(context["target_path"]) / "releases.json", "w") as f:
+            json.dump(releases, f, default=datetime.datetime.isoformat)
 
-        for release in resp.json():
+        for release in releases:
             if release["prerelease"]:
                 continue
             published = datetime.datetime.strptime(
@@ -183,6 +230,70 @@ def home_add_releases(context):
                     ),
                 }
             )
+
+        return context
+
+    @staticmethod
+    def roadmap_pdeps(context):
+        """
+        PDEP's (pandas enhancement proposals) are not part of the bar
+        navigation. They are included as lists in the "Roadmap" page
+        and linked from there. This preprocessor obtains the list of
+        PDEP's in different status from the directory tree and GitHub.
+        """
+        KNOWN_STATUS = {"Under discussion", "Accepted", "Implemented", "Rejected"}
+        context["pdeps"] = collections.defaultdict(list)
+
+        # accepted, rejected and implemented
+        pdeps_path = (
+            pathlib.Path(context["source_path"]) / context["roadmap"]["pdeps_path"]
+        )
+        for pdep in sorted(pdeps_path.iterdir()):
+            if pdep.suffix != ".md":
+                continue
+            with pdep.open() as f:
+                title = f.readline()[2:]  # removing markdown title "# "
+                status = None
+                for line in f:
+                    if line.startswith("- Status: "):
+                        status = line.strip().split(": ", 1)[1]
+                        break
+                if status not in KNOWN_STATUS:
+                    raise RuntimeError(
+                        f'PDEP "{pdep}" status "{status}" is unknown. '
+                        f"Should be one of: {KNOWN_STATUS}"
+                    )
+            html_file = pdep.with_suffix(".html").name
+            context["pdeps"][status].append(
+                {
+                    "title": title,
+                    "url": f"/pdeps/{html_file}",
+                }
+            )
+
+        # under discussion
+        github_repo_url = context["main"]["github_repo_url"]
+        resp = requests.get(
+            "https://api.github.com/search/issues?"
+            f"q=is:pr is:open label:PDEP repo:{github_repo_url}"
+        )
+        if resp.status_code == 403:
+            sys.stderr.write("WARN: GitHub API quota exceeded when fetching pdeps\n")
+            resp_bkp = requests.get(context["main"]["production_url"] + "pdeps.json")
+            resp_bkp.raise_for_status()
+            pdeps = resp_bkp.json()
+        else:
+            resp.raise_for_status()
+            pdeps = resp.json()
+
+        with open(pathlib.Path(context["target_path"]) / "pdeps.json", "w") as f:
+            json.dump(pdeps, f)
+
+        for pdep in pdeps["items"]:
+            context["pdeps"]["Under discussion"].append(
+                {"title": pdep["title"], "url": pdep["url"]}
+            )
+
         return context
 
 
@@ -212,7 +323,7 @@ def get_callable(obj_as_str: str) -> object:
     return obj
 
 
-def get_context(config_fname: str, ignore_io_errors: bool, **kwargs):
+def get_context(config_fname: str, **kwargs):
     """
     Load the config yaml as the base context, and enrich it with the
     information added by the context preprocessors defined in the file.
@@ -221,7 +332,6 @@ def get_context(config_fname: str, ignore_io_errors: bool, **kwargs):
         context = yaml.safe_load(f)
 
     context["source_path"] = os.path.dirname(config_fname)
-    context["ignore_io_errors"] = ignore_io_errors
     context.update(kwargs)
 
     preprocessors = (
@@ -259,7 +369,9 @@ def extend_base_template(content: str, base_template: str) -> str:
 
 
 def main(
-    source_path: str, target_path: str, base_url: str, ignore_io_errors: bool
+    source_path: str,
+    target_path: str,
+    base_url: str,
 ) -> int:
     """
     Copy every file in the source directory to the target directory.
@@ -273,7 +385,7 @@ def main(
     os.makedirs(target_path, exist_ok=True)
 
     sys.stderr.write("Generating context...\n")
-    context = get_context(config_fname, ignore_io_errors, base_url=base_url)
+    context = get_context(config_fname, base_url=base_url, target_path=target_path)
     sys.stderr.write("Context generated\n")
 
     templates_path = os.path.join(source_path, context["main"]["templates_path"])
@@ -317,15 +429,5 @@ def main(
     parser.add_argument(
         "--base-url", default="", help="base url where the website is served from"
     )
-    parser.add_argument(
-        "--ignore-io-errors",
-        action="https://github.com/store_true",
-        help="do not fail if errors happen when fetching "
-        "data from http sources, and those fail "
-        "(mostly useful to allow github quota errors "
-        "when running the script locally)",
-    )
     args = parser.parse_args()
-    sys.exit(
-        main(args.source_path, args.target_path, args.base_url, args.ignore_io_errors)
-    )
+    sys.exit(main(args.source_path, args.target_path, args.base_url))